#include "passdb.h"
#include "../librpc/gen_ndr/ndr_auth.h"
#include "../auth/auth_sam_reply.h"
+#include "../librpc/gen_ndr/idmap.h"
+#include "lib/param/loadparm.h"
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_AUTH
char *add_script;
int ret;
- add_script = talloc_strdup(ctx, lp_adduser_script());
+ add_script = lp_adduser_script(ctx);
if (!add_script || !*add_script) {
return -1;
}
const char *client_domain,
const char *workstation_name,
const struct tsocket_address *remote_address,
- DATA_BLOB *lm_pwd,
- DATA_BLOB *nt_pwd,
+ const DATA_BLOB *lm_pwd,
+ const DATA_BLOB *nt_pwd,
const struct samr_Password *lm_interactive_pwd,
const struct samr_Password *nt_interactive_pwd,
const char *plaintext,
return false;
}
- ret = make_user_info_map(
- user_info, smb_name, client_domain,
+ ret = make_user_info(
+ user_info, smb_name, smb_name, client_domain, client_domain,
get_remote_machine_name(),
remote_address,
local_lm_blob.data ? &local_lm_blob : NULL,
const struct tsocket_address *remote_address,
DATA_BLOB lm_resp, DATA_BLOB nt_resp)
{
- return make_user_info_map(user_info, smb_name,
- client_domain,
- get_remote_machine_name(),
- remote_address,
- lm_resp.data && (lm_resp.length > 0) ? &lm_resp : NULL,
- nt_resp.data && (nt_resp.length > 0) ? &nt_resp : NULL,
- NULL, NULL, NULL,
- AUTH_PASSWORD_RESPONSE);
+ return make_user_info(user_info, smb_name, smb_name,
+ client_domain, client_domain,
+ get_remote_machine_name(),
+ remote_address,
+ lm_resp.data && (lm_resp.length > 0) ? &lm_resp : NULL,
+ nt_resp.data && (nt_resp.length > 0) ? &nt_resp : NULL,
+ NULL, NULL, NULL,
+ AUTH_PASSWORD_RESPONSE);
}
/****************************************************************************
char *group_sidstr;
size_t i;
- if ((lp_log_nt_token_command() == NULL) ||
- (strlen(lp_log_nt_token_command()) == 0)) {
+ if ((lp_log_nt_token_command(frame) == NULL) ||
+ (strlen(lp_log_nt_token_command(frame)) == 0)) {
TALLOC_FREE(frame);
return NT_STATUS_OK;
}
}
command = talloc_string_sub(
- frame, lp_log_nt_token_command(),
+ frame, lp_log_nt_token_command(frame),
"%s", sid_string_talloc(frame, &token->sids[0]));
command = talloc_string_sub(frame, command, "%t", group_sidstr);
NTSTATUS create_local_token(TALLOC_CTX *mem_ctx,
const struct auth_serversupplied_info *server_info,
DATA_BLOB *session_key,
+ const char *smb_username, /* for ->sanitized_username, for %U subs */
struct auth_session_info **session_info_out)
{
struct security_token *t;
size_t i;
struct dom_sid tmp_sid;
struct auth_session_info *session_info;
- struct wbcUnixId *ids;
+ struct unixid *ids;
+ fstring tmp;
/* Ensure we can't possible take a code path leading to a
* null defref. */
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;
+ /* This is a potentially untrusted username for use in %U */
+ alpha_strcpy(tmp, smb_username, ". _-$", sizeof(tmp));
+ session_info->unix_info->sanitized_username =
+ talloc_strdup(session_info->unix_info, tmp);
if (session_key) {
data_blob_free(&session_info->session_key);
server_info->session_key.length);
}
- if (session_info->security_token) {
+ /* 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 (server_info->security_token) {
/* Just copy the token, it has already been finalised
- * (nasty hack to support a cached guest session_info,
- * and a possible strategy for auth_samba4 to pass in
- * a finalised session) */
+ * (nasty hack to support a cached guest/system session_info
+ */
session_info->security_token = dup_nt_token(session_info, server_info->security_token);
if (!session_info->security_token) {
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
t = session_info->security_token;
- ids = talloc_array(talloc_tos(), struct wbcUnixId,
+ ids = talloc_array(talloc_tos(), struct unixid,
t->num_sids);
if (ids == NULL) {
return NT_STATUS_NO_MEMORY;
}
- if (!sids_to_unix_ids(t->sids, t->num_sids, ids)) {
+ if (!sids_to_unixids(t->sids, t->num_sids, ids)) {
TALLOC_FREE(ids);
return NT_STATUS_NO_MEMORY;
}
- /* Start at index 1, where the groups start. */
+ for (i=0; i<t->num_sids; i++) {
- for (i=1; i<t->num_sids; i++) {
+ if (i == 0 && ids[i].type != ID_TYPE_BOTH) {
+ continue;
+ }
- if (ids[i].type != WBC_ID_TYPE_GID) {
+ if (ids[i].type != ID_TYPE_GID &&
+ ids[i].type != ID_TYPE_BOTH) {
DEBUG(10, ("Could not convert SID %s to gid, "
"ignoring it\n",
sid_string_dbg(&t->sids[i])));
continue;
}
- if (!add_gid_to_array_unique(session_info, ids[i].id.gid,
+ if (!add_gid_to_array_unique(session_info, ids[i].id,
&session_info->unix_token->groups,
&session_info->unix_token->ngroups)) {
return NT_STATUS_NO_MEMORY;
}
result->unix_name = talloc_strdup(result, unix_username);
- result->sanitized_username = sanitize_username(result, unix_username);
- if ((result->unix_name == NULL)
- || (result->sanitized_username == NULL)) {
+ if (result->unix_name == NULL) {
TALLOC_FREE(result);
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_OK;
}
+static NTSTATUS get_system_info3(TALLOC_CTX *mem_ctx,
+ struct netr_SamInfo3 *info3)
+{
+ NTSTATUS status;
+ struct dom_sid *system_sid;
+
+ /* Set account name */
+ init_lsa_String(&info3->base.account_name, "SYSTEM");
+
+ /* Set domain name */
+ init_lsa_StringLarge(&info3->base.logon_domain, "NT AUTHORITY");
+
+
+ /* The SID set here will be overwirtten anyway, but try and make it SID_NT_SYSTEM anyway */
+ /* Domain sid is NT_AUTHORITY */
+
+ system_sid = dom_sid_parse_talloc(mem_ctx, SID_NT_SYSTEM);
+ if (system_sid == NULL) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ status = dom_sid_split_rid(mem_ctx, system_sid, &info3->base.domain_sid,
+ &info3->base.rid);
+ TALLOC_FREE(system_sid);
+ if (!NT_STATUS_IS_OK(status)) {
+ return status;
+ }
+
+ /* Primary gid is the same */
+ info3->base.primary_gid = info3->base.rid;
+
+ return NT_STATUS_OK;
+}
+
static NTSTATUS get_guest_info3(TALLOC_CTX *mem_ctx,
struct netr_SamInfo3 *info3)
{
if (tmp == NULL) {
return NT_STATUS_NO_MEMORY;
}
- init_lsa_StringLarge(&info3->base.domain, tmp);
+ init_lsa_StringLarge(&info3->base.logon_domain, tmp);
/* Domain sid */
sid_copy(&domain_sid, get_global_sam_sid());
info3->base.rid = DOMAIN_RID_GUEST;
/* Primary gid */
- info3->base.primary_gid = BUILTIN_RID_GUESTS;
+ info3->base.primary_gid = DOMAIN_RID_GUESTS;
/* Set as guest */
info3->base.user_flags = NETLOGON_GUEST;
struct netr_SamInfo3 info3;
TALLOC_CTX *tmp_ctx;
NTSTATUS status;
- fstring tmp;
tmp_ctx = talloc_stackframe();
if (tmp_ctx == NULL) {
/* 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 behavior */
- status = create_local_token(tmp_ctx, *server_info, NULL, session_info);
+ status = create_local_token(tmp_ctx, *server_info, NULL,
+ (*server_info)->info3->base.account_name.string,
+ session_info);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0, ("create_local_token failed: %s\n",
nt_errstr(status)));
all zeros! */
(*session_info)->session_key = data_blob(zeros, sizeof(zeros));
- alpha_strcpy(tmp, (*server_info)->info3->base.account_name.string,
- ". _-$", sizeof(tmp));
- (*session_info)->unix_info->sanitized_username = talloc_strdup(*session_info, tmp);
-
status = NT_STATUS_OK;
done:
TALLOC_FREE(tmp_ctx);
static NTSTATUS make_new_session_info_system(TALLOC_CTX *mem_ctx,
struct auth_session_info **session_info)
{
- struct passwd *pwd;
NTSTATUS status;
+ struct auth_serversupplied_info *server_info;
+ TALLOC_CTX *tmp_ctx;
- pwd = getpwuid_alloc(mem_ctx, sec_initial_uid());
- if (pwd == NULL) {
- return NT_STATUS_NO_SUCH_USER;
+ tmp_ctx = talloc_stackframe();
+ if (tmp_ctx == NULL) {
+ return NT_STATUS_NO_MEMORY;
}
- status = make_session_info_from_username(mem_ctx,
- pwd->pw_name,
- false,
- session_info);
- TALLOC_FREE(pwd);
+ server_info = make_server_info(tmp_ctx);
+ if (!server_info) {
+ status = NT_STATUS_NO_MEMORY;
+ DEBUG(0, ("failed making server_info\n"));
+ goto done;
+ }
+
+ server_info->info3 = talloc_zero(server_info, struct netr_SamInfo3);
+ if (!server_info->info3) {
+ status = NT_STATUS_NO_MEMORY;
+ DEBUG(0, ("talloc failed setting info3\n"));
+ goto done;
+ }
+
+ status = get_system_info3(server_info, server_info->info3);
if (!NT_STATUS_IS_OK(status)) {
- return status;
+ DEBUG(0, ("Failed creating system info3 with %s\n",
+ nt_errstr(status)));
+ goto done;
+ }
+
+ server_info->utok.uid = sec_initial_uid();
+ server_info->utok.gid = sec_initial_gid();
+ server_info->unix_name = talloc_asprintf(server_info,
+ "NT AUTHORITY%cSYSTEM",
+ *lp_winbind_separator());
+
+ if (!server_info->unix_name) {
+ status = NT_STATUS_NO_MEMORY;
+ DEBUG(0, ("talloc_asprintf failed setting unix_name\n"));
+ goto done;
}
- (*session_info)->unix_info->system = true;
+ server_info->security_token = talloc_zero(server_info, struct security_token);
+ if (!server_info->security_token) {
+ status = NT_STATUS_NO_MEMORY;
+ DEBUG(0, ("talloc failed setting security token\n"));
+ goto done;
+ }
- status = add_sid_to_array_unique((*session_info)->security_token->sids,
+ status = add_sid_to_array_unique(server_info->security_token->sids,
&global_sid_System,
- &(*session_info)->security_token->sids,
- &(*session_info)->security_token->num_sids);
+ &server_info->security_token->sids,
+ &server_info->security_token->num_sids);
if (!NT_STATUS_IS_OK(status)) {
- TALLOC_FREE((*session_info));
- return status;
+ goto done;
}
- return NT_STATUS_OK;
+ /* SYSTEM has all privilages */
+ server_info->security_token->privilege_mask = ~0;
+
+ /* Now turn the server_info into a session_info with the full token etc */
+ status = create_local_token(mem_ctx, server_info, NULL, "SYSTEM", session_info);
+ talloc_free(server_info);
+
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(0, ("create_local_token failed: %s\n",
+ nt_errstr(status)));
+ goto done;
+ }
+
+ talloc_steal(mem_ctx, *session_info);
+
+done:
+ TALLOC_FREE(tmp_ctx);
+ return status;
}
/****************************************************************************
bool is_guest,
struct auth_session_info **session_info)
{
- struct auth_serversupplied_info *result;
struct passwd *pwd;
NTSTATUS status;
+ struct auth_serversupplied_info *result;
pwd = Get_Pwnam_alloc(talloc_tos(), username);
if (pwd == NULL) {
status = make_server_info_pw(&result, pwd->pw_name, pwd);
- TALLOC_FREE(pwd);
-
if (!NT_STATUS_IS_OK(status)) {
return status;
}
result->guest = is_guest;
/* Now turn the server_info into a session_info with the full token etc */
- status = create_local_token(mem_ctx, result, NULL, session_info);
- talloc_free(result);
+ status = create_local_token(mem_ctx, result, NULL, pwd->pw_name, session_info);
+ TALLOC_FREE(result);
+ TALLOC_FREE(pwd);
+
return status;
}
return NULL;
}
- dst->sanitized_username = talloc_strdup(dst, src->unix_info->sanitized_username);
- if (!dst->sanitized_username) {
- TALLOC_FREE(dst);
- return NULL;
- }
-
return dst;
}
static struct auth_session_info *system_info = NULL;
-NTSTATUS init_system_info(void)
+NTSTATUS init_system_session_info(void)
{
if (system_info != NULL)
return NT_STATUS_OK;
return system_info;
}
-bool copy_current_user(struct current_user *dst, struct current_user *src)
-{
- gid_t *groups;
- struct security_token *nt_token;
-
- groups = (gid_t *)memdup(src->ut.groups,
- sizeof(gid_t) * src->ut.ngroups);
- if ((src->ut.ngroups != 0) && (groups == NULL)) {
- return false;
- }
-
- nt_token = dup_nt_token(NULL, src->nt_user_token);
- if (nt_token == NULL) {
- SAFE_FREE(groups);
- return false;
- }
-
- dst->conn = src->conn;
- dst->vuid = src->vuid;
- dst->ut.uid = src->ut.uid;
- dst->ut.gid = src->ut.gid;
- dst->ut.ngroups = src->ut.ngroups;
- dst->ut.groups = groups;
- dst->nt_user_token = nt_token;
- return true;
-}
-
/***************************************************************************
Purely internal function for make_server_info_info3
***************************************************************************/
if (!lower_username) {
return NT_STATUS_NO_MEMORY;
}
- strlower_m( lower_username );
+ if (!strlower_m( lower_username )) {
+ return NT_STATUS_INVALID_PARAMETER;
+ }
orig_dom_user = talloc_asprintf(mem_ctx,
"%s%c%s",
/* make sure we get the case of the username correct */
/* work around 'winbind use default domain = yes' */
- if ( !strchr_m( pw->pw_name, *lp_winbind_separator() ) ) {
+ if ( lp_winbind_use_default_domain() &&
+ !strchr_m( pw->pw_name, *lp_winbind_separator() ) ) {
char *domain;
/* split the domain and username into 2 strings */
char *found_username = NULL;
const char *nt_domain;
const char *nt_username;
+ struct dom_sid user_sid;
+ struct dom_sid group_sid;
bool username_was_mapped;
struct passwd *pwd;
struct auth_serversupplied_info *result;
- struct dom_sid *group_sid;
- struct netr_SamInfo3 *i3;
/*
Here is where we should check the list of
matches.
*/
+ if (!sid_compose(&user_sid, info3->base.domain_sid, info3->base.rid)) {
+ return NT_STATUS_INVALID_PARAMETER;
+ }
+
+ if (!sid_compose(&group_sid, info3->base.domain_sid,
+ info3->base.primary_gid)) {
+ return NT_STATUS_INVALID_PARAMETER;
+ }
+
nt_username = talloc_strdup(mem_ctx, info3->base.account_name.string);
if (!nt_username) {
/* If the server didn't give us one, just use the one we sent
nt_username = sent_nt_username;
}
- nt_domain = talloc_strdup(mem_ctx, info3->base.domain.string);
+ nt_domain = talloc_strdup(mem_ctx, info3->base.logon_domain.string);
if (!nt_domain) {
/* If the server didn't give us one, just use the one we sent
* them */
result->unix_name = talloc_strdup(result, found_username);
- result->sanitized_username = sanitize_username(result,
- result->unix_name);
- if (result->sanitized_username == NULL) {
- TALLOC_FREE(result);
- return NT_STATUS_NO_MEMORY;
- }
-
/* copy in the info3 */
- result->info3 = i3 = copy_netr_SamInfo3(result, info3);
+ result->info3 = copy_netr_SamInfo3(result, info3);
if (result->info3 == NULL) {
TALLOC_FREE(result);
return NT_STATUS_NO_MEMORY;
}
/* Fill in the unix info we found on the way */
+
result->utok.uid = pwd->pw_uid;
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 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);
- if (!NT_STATUS_IS_OK(nt_status)) {
- TALLOC_FREE(result);
- return nt_status;
- }
-
- /* store and check if it is the same we got originally */
- sid_peek_rid(group_sid, &i3->base.primary_gid);
- if (i3->base.primary_gid != info3->base.primary_gid) {
- uint32_t n = i3->base.groups.count;
- /* not the same, store the original as an additional group */
- i3->base.groups.rids =
- talloc_realloc(i3, i3->base.groups.rids,
- struct samr_RidWithAttribute, n + 1);
- if (i3->base.groups.rids == NULL) {
- TALLOC_FREE(result);
- return NT_STATUS_NO_MEMORY;
- }
- i3->base.groups.rids[n].rid = info3->base.primary_gid;
- i3->base.groups.rids[n].attributes = SE_GROUP_ENABLED;
- i3->base.groups.count = n + 1;
- }
-
/* ensure we are never given NULL session keys */
if (memcmp(info3->base.key.key, zeros, sizeof(zeros)) == 0) {
(lp_map_to_guest() == MAP_TO_GUEST_ON_BAD_PASSWORD)) {
DEBUG(3,("No such user %s [%s] - using guest account\n",
user, domain));
- status = make_server_info_guest(NULL, server_info);
+ return make_server_info_guest(NULL, server_info);
}
- }
-
- if (NT_STATUS_EQUAL(status, NT_STATUS_WRONG_PASSWORD)) {
+ } else if (NT_STATUS_EQUAL(status, NT_STATUS_WRONG_PASSWORD)) {
if (lp_map_to_guest() == MAP_TO_GUEST_ON_BAD_PASSWORD) {
DEBUG(3,("Registered username %s for guest access\n",
user));
- status = make_server_info_guest(NULL, server_info);
+ return make_server_info_guest(NULL, server_info);
}
}
return status;
}
+
+/*
+ Extract session key from a session info and return it in a blob
+ if intent is KEY_USE_16BYTES, truncate it to 16 bytes
+
+ See sections 3.2.4.15 and 3.3.4.2 of MS-SMB
+ Also see https://lists.samba.org/archive/cifs-protocol/2012-January/002265.html for details
+
+ Note that returned session_key is referencing the original key, it is supposed to be
+ short-lived. If original session_info->session_key is gone, the reference will be broken.
+*/
+NTSTATUS session_extract_session_key(const struct auth_session_info *session_info, DATA_BLOB *session_key, enum session_key_use_intent intent)
+{
+
+ if (session_key == NULL || session_info == NULL) {
+ return NT_STATUS_INVALID_PARAMETER;
+ }
+
+ if (session_info->session_key.length == 0) {
+ return NT_STATUS_NO_USER_SESSION_KEY;
+ }
+
+ *session_key = session_info->session_key;
+ if (intent == KEY_USE_16BYTES) {
+ session_key->length = MIN(session_info->session_key.length, 16);
+ }
+ return NT_STATUS_OK;
+}
git.samba.org / metze / samba / wip.git / blobdiff