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
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_AUTH
-static struct nt_user_token *create_local_nt_token(TALLOC_CTX *mem_ctx,
- const DOM_SID *user_sid,
- BOOL is_guest,
- int num_groupsids,
- const DOM_SID *groupsids);
-
/****************************************************************************
Create a UNIX user on demand.
****************************************************************************/
DATA_BLOB *lm_pwd, DATA_BLOB *nt_pwd,
DATA_BLOB *lm_interactive_pwd, DATA_BLOB *nt_interactive_pwd,
DATA_BLOB *plaintext,
- BOOL encrypted)
+ bool encrypted)
{
DEBUG(5,("attempting to make a user_info for %s (%s)\n", internal_username, smb_name));
DATA_BLOB *lm_pwd, DATA_BLOB *nt_pwd,
DATA_BLOB *lm_interactive_pwd, DATA_BLOB *nt_interactive_pwd,
DATA_BLOB *plaintext,
- BOOL encrypted)
+ bool encrypted)
{
const char *domain;
NTSTATUS result;
- BOOL was_mapped;
+ bool was_mapped;
fstring internal_username;
fstrcpy(internal_username, smb_name);
was_mapped = map_username(internal_username);
Decrypt and encrypt the passwords.
****************************************************************************/
-BOOL make_user_info_netlogon_network(auth_usersupplied_info **user_info,
+bool make_user_info_netlogon_network(auth_usersupplied_info **user_info,
const char *smb_name,
const char *client_domain,
const char *wksta_name,
const uchar *nt_network_pwd,
int nt_pwd_len)
{
- BOOL ret;
+ bool ret;
NTSTATUS status;
DATA_BLOB lm_blob = data_blob(lm_network_pwd, lm_pwd_len);
DATA_BLOB nt_blob = data_blob(nt_network_pwd, nt_pwd_len);
Decrypt and encrypt the passwords.
****************************************************************************/
-BOOL make_user_info_netlogon_interactive(auth_usersupplied_info **user_info,
+bool make_user_info_netlogon_interactive(auth_usersupplied_info **user_info,
const char *smb_name,
const char *client_domain,
const char *wksta_name,
const uchar nt_interactive_pwd[16],
const uchar *dc_sess_key)
{
- char lm_pwd[16];
- char nt_pwd[16];
+ unsigned char lm_pwd[16];
+ unsigned char nt_pwd[16];
unsigned char local_lm_response[24];
unsigned char local_nt_response[24];
unsigned char key[16];
#ifdef DEBUG_PASSWORD
DEBUG(100,("key:"));
- dump_data(100, (char *)key, sizeof(key));
+ dump_data(100, key, sizeof(key));
DEBUG(100,("lm owf password:"));
dump_data(100, lm_pwd, sizeof(lm_pwd));
#endif
if (lm_interactive_pwd)
- SamOEMhash((uchar *)lm_pwd, key, sizeof(lm_pwd));
+ SamOEMhash(lm_pwd, key, sizeof(lm_pwd));
if (nt_interactive_pwd)
- SamOEMhash((uchar *)nt_pwd, key, sizeof(nt_pwd));
+ SamOEMhash(nt_pwd, key, sizeof(nt_pwd));
#ifdef DEBUG_PASSWORD
DEBUG(100,("decrypt of lm owf password:"));
#endif
if (lm_interactive_pwd)
- SMBOWFencrypt((const unsigned char *)lm_pwd, chal,
+ SMBOWFencrypt(lm_pwd, chal,
local_lm_response);
if (nt_interactive_pwd)
- SMBOWFencrypt((const unsigned char *)nt_pwd, chal,
+ SMBOWFencrypt(nt_pwd, chal,
local_nt_response);
/* Password info paranoia */
ZERO_STRUCT(key);
{
- BOOL ret;
+ bool ret;
NTSTATUS nt_status;
DATA_BLOB local_lm_blob;
DATA_BLOB local_nt_blob;
Create an auth_usersupplied_data structure
****************************************************************************/
-BOOL make_user_info_for_reply(auth_usersupplied_info **user_info,
+bool make_user_info_for_reply(auth_usersupplied_info **user_info,
const char *smb_name,
const char *client_domain,
const uint8 chal[8],
#ifdef DEBUG_PASSWORD
DEBUG(10,("Unencrypted password (len %d):\n",
(int)plaintext_password.length));
- dump_data(100, (const char *)plaintext_password.data,
+ dump_data(100, plaintext_password.data,
plaintext_password.length);
#endif
/* We can't do an NT hash here, as the password needs to be
case insensitive */
- local_nt_blob = data_blob(NULL, 0);
+ local_nt_blob = data_blob_null;
} else {
- local_lm_blob = data_blob(NULL, 0);
- local_nt_blob = data_blob(NULL, 0);
+ local_lm_blob = data_blob_null;
+ local_nt_blob = data_blob_null;
}
ret = make_user_info_map(
Create a guest user_info blob, for anonymous authenticaion.
****************************************************************************/
-BOOL make_user_info_guest(auth_usersupplied_info **user_info)
+bool make_user_info_guest(auth_usersupplied_info **user_info)
{
NTSTATUS nt_status;
return NT_STATUS_IS_OK(nt_status) ? True : False;
}
-/****************************************************************************
- prints a NT_USER_TOKEN to debug output.
-****************************************************************************/
-
-void debug_nt_user_token(int dbg_class, int dbg_lev, NT_USER_TOKEN *token)
-{
- size_t i;
-
- if (!token) {
- DEBUGC(dbg_class, dbg_lev, ("NT user token: (NULL)\n"));
- return;
- }
-
- DEBUGC(dbg_class, dbg_lev,
- ("NT user token of user %s\n",
- sid_string_static(&token->user_sids[0]) ));
- DEBUGADDC(dbg_class, dbg_lev,
- ("contains %lu SIDs\n", (unsigned long)token->num_sids));
- for (i = 0; i < token->num_sids; i++)
- DEBUGADDC(dbg_class, dbg_lev,
- ("SID[%3lu]: %s\n", (unsigned long)i,
- sid_string_static(&token->user_sids[i])));
-
- dump_se_priv( dbg_class, dbg_lev, &token->privileges );
-}
-
-/****************************************************************************
- prints a UNIX 'token' to debug output.
-****************************************************************************/
-
-void debug_unix_user_token(int dbg_class, int dbg_lev, uid_t uid, gid_t gid,
- int n_groups, gid_t *groups)
-{
- int i;
- DEBUGC(dbg_class, dbg_lev,
- ("UNIX token of user %ld\n", (long int)uid));
-
- DEBUGADDC(dbg_class, dbg_lev,
- ("Primary group is %ld and contains %i supplementary "
- "groups\n", (long int)gid, n_groups));
- for (i = 0; i < n_groups; i++)
- DEBUGADDC(dbg_class, dbg_lev, ("Group[%3i]: %ld\n", i,
- (long int)groups[i]));
-}
-
-/******************************************************************************
- Create a token for the root user to be used internally by smbd.
- This is similar to running under the context of the LOCAL_SYSTEM account
- in Windows. This is a read-only token. Do not modify it or free() it.
- Create a copy if your need to change it.
-******************************************************************************/
-
-NT_USER_TOKEN *get_root_nt_token( void )
-{
- static NT_USER_TOKEN *token = NULL;
- DOM_SID u_sid, g_sid;
- struct passwd *pw;
-
- if ( token )
- return token;
-
- if ( !(pw = sys_getpwnam( "root" )) ) {
- DEBUG(0,("get_root_nt_token: getpwnam\"root\") failed!\n"));
- return NULL;
- }
-
- /* get the user and primary group SIDs; although the
- BUILTIN\Administrators SId is really the one that matters here */
-
- uid_to_sid(&u_sid, pw->pw_uid);
- gid_to_sid(&g_sid, pw->pw_gid);
-
- token = create_local_nt_token(NULL, &u_sid, False,
- 1, &global_sid_Builtin_Administrators);
- return token;
-}
-
static int server_info_dtor(auth_serversupplied_info *server_info)
{
TALLOC_FREE(server_info->sam_account);
DOM_SID unix_group_sid;
- if ( !(pwd = getpwnam_alloc(NULL, pdb_get_username(sampass))) ) {
+ if ( !(result = make_server_info(NULL)) ) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ if ( !(pwd = getpwnam_alloc(result, pdb_get_username(sampass))) ) {
DEBUG(1, ("User %s in passdb, but getpwnam() fails!\n",
pdb_get_username(sampass)));
+ TALLOC_FREE(result);
return NT_STATUS_NO_SUCH_USER;
}
- if ( !(result = make_server_info(NULL)) ) {
- TALLOC_FREE(pwd);
- return NT_STATUS_NO_MEMORY;
- }
-
result->sam_account = sampass;
- result->unix_name = talloc_strdup(result, pwd->pw_name);
+ /* Ensure thaat the sampass will be freed with the result */
+ talloc_steal(result, sampass);
+ result->unix_name = pwd->pw_name;
+ /* Ensure that we keep pwd->pw_name, because we will free pwd below */
+ talloc_steal(result, pwd->pw_name);
result->gid = pwd->pw_gid;
result->uid = pwd->pw_uid;
return NT_STATUS_OK;
}
-/*
- * Add alias SIDs from memberships within the partially created token SID list
- */
-
-static NTSTATUS add_aliases(const DOM_SID *domain_sid,
- struct nt_user_token *token)
-{
- uint32 *aliases;
- size_t i, num_aliases;
- NTSTATUS status;
- TALLOC_CTX *tmp_ctx;
-
- if (!(tmp_ctx = talloc_init("add_aliases"))) {
- return NT_STATUS_NO_MEMORY;
- }
-
- aliases = NULL;
- num_aliases = 0;
-
- status = pdb_enum_alias_memberships(tmp_ctx, domain_sid,
- token->user_sids,
- token->num_sids,
- &aliases, &num_aliases);
-
- if (!NT_STATUS_IS_OK(status)) {
- DEBUG(10, ("pdb_enum_alias_memberships failed: %s\n",
- nt_errstr(status)));
- TALLOC_FREE(tmp_ctx);
- return status;
- }
-
- for (i=0; i<num_aliases; i++) {
- DOM_SID alias_sid;
- sid_compose(&alias_sid, domain_sid, aliases[i]);
- if (!add_sid_to_array_unique(token, &alias_sid,
- &token->user_sids,
- &token->num_sids)) {
- DEBUG(0, ("add_sid_to_array failed\n"));
- TALLOC_FREE(tmp_ctx);
- return NT_STATUS_NO_MEMORY;
- }
- }
-
- TALLOC_FREE(tmp_ctx);
- return NT_STATUS_OK;
-}
-
static NTSTATUS log_nt_token(TALLOC_CTX *tmp_ctx, NT_USER_TOKEN *token)
{
char *command;
return NT_STATUS_OK;
}
-/*******************************************************************
-*******************************************************************/
-
-static NTSTATUS add_builtin_administrators( struct nt_user_token *token )
-{
- DOM_SID domadm;
-
- /* nothing to do if we aren't in a domain */
-
- if ( !(IS_DC || lp_server_role()==ROLE_DOMAIN_MEMBER) ) {
- return NT_STATUS_OK;
- }
-
- /* Find the Domain Admins SID */
-
- if ( IS_DC ) {
- sid_copy( &domadm, get_global_sam_sid() );
- } else {
- if ( !secrets_fetch_domain_sid( lp_workgroup(), &domadm ) )
- return NT_STATUS_CANT_ACCESS_DOMAIN_INFO;
- }
- sid_append_rid( &domadm, DOMAIN_GROUP_RID_ADMINS );
-
- /* Add Administrators if the user beloongs to Domain Admins */
-
- if ( nt_token_check_sid( &domadm, token ) ) {
- if (!add_sid_to_array(token, &global_sid_Builtin_Administrators,
- &token->user_sids, &token->num_sids)) {
- return NT_STATUS_NO_MEMORY;
- }
- }
-
- return NT_STATUS_OK;
-}
-
-/*******************************************************************
-*******************************************************************/
-
-static NTSTATUS create_builtin_users( void )
-{
- NTSTATUS status;
- DOM_SID dom_users;
-
- status = pdb_create_builtin_alias( BUILTIN_ALIAS_RID_USERS );
- if ( !NT_STATUS_IS_OK(status) ) {
- DEBUG(0,("create_builtin_users: Failed to create Users\n"));
- return status;
- }
-
- /* add domain users */
- if ((IS_DC || (lp_server_role() == ROLE_DOMAIN_MEMBER))
- && secrets_fetch_domain_sid(lp_workgroup(), &dom_users))
- {
- sid_append_rid(&dom_users, DOMAIN_GROUP_RID_USERS );
- status = pdb_add_aliasmem( &global_sid_Builtin_Users, &dom_users);
- if ( !NT_STATUS_IS_OK(status) ) {
- DEBUG(0,("create_builtin_administrators: Failed to add Domain Users to"
- " Users\n"));
- return status;
- }
- }
-
- return NT_STATUS_OK;
-}
-
-/*******************************************************************
-*******************************************************************/
-
-static NTSTATUS create_builtin_administrators( void )
-{
- NTSTATUS status;
- DOM_SID dom_admins, root_sid;
- fstring root_name;
- enum lsa_SidType type;
- TALLOC_CTX *ctx;
- BOOL ret;
-
- status = pdb_create_builtin_alias( BUILTIN_ALIAS_RID_ADMINS );
- if ( !NT_STATUS_IS_OK(status) ) {
- DEBUG(0,("create_builtin_administrators: Failed to create Administrators\n"));
- return status;
- }
-
- /* add domain admins */
- if ((IS_DC || (lp_server_role() == ROLE_DOMAIN_MEMBER))
- && secrets_fetch_domain_sid(lp_workgroup(), &dom_admins))
- {
- sid_append_rid(&dom_admins, DOMAIN_GROUP_RID_ADMINS);
- status = pdb_add_aliasmem( &global_sid_Builtin_Administrators, &dom_admins );
- if ( !NT_STATUS_IS_OK(status) ) {
- DEBUG(0,("create_builtin_administrators: Failed to add Domain Admins"
- " Administrators\n"));
- return status;
- }
- }
-
- /* add root */
- if ( (ctx = talloc_init("create_builtin_administrators")) == NULL ) {
- return NT_STATUS_NO_MEMORY;
- }
- fstr_sprintf( root_name, "%s\\root", get_global_sam_name() );
- ret = lookup_name( ctx, root_name, 0, NULL, NULL, &root_sid, &type );
- TALLOC_FREE( ctx );
-
- if ( ret ) {
- status = pdb_add_aliasmem( &global_sid_Builtin_Administrators, &root_sid );
- if ( !NT_STATUS_IS_OK(status) ) {
- DEBUG(0,("create_builtin_administrators: Failed to add root"
- " Administrators\n"));
- return status;
- }
- }
-
- return NT_STATUS_OK;
-}
-
-/*******************************************************************
- Create a NT token for the user, expanding local aliases
-*******************************************************************/
-
-static struct nt_user_token *create_local_nt_token(TALLOC_CTX *mem_ctx,
- const DOM_SID *user_sid,
- BOOL is_guest,
- int num_groupsids,
- const DOM_SID *groupsids)
-{
- struct nt_user_token *result = NULL;
- int i;
- NTSTATUS status;
- gid_t gid;
-
- DEBUG(10, ("Create local NT token for %s\n", sid_string_static(user_sid)));
-
- if (!(result = TALLOC_ZERO_P(mem_ctx, NT_USER_TOKEN))) {
- DEBUG(0, ("talloc failed\n"));
- return NULL;
- }
-
- /* Add the user and primary group sid */
-
- if (!add_sid_to_array(result, user_sid,
- &result->user_sids, &result->num_sids)) {
- return NULL;
- }
-
- /* For guest, num_groupsids may be zero. */
- if (num_groupsids) {
- if (!add_sid_to_array(result, &groupsids[0],
- &result->user_sids, &result->num_sids)) {
- return NULL;
- }
- }
-
- /* Add in BUILTIN sids */
-
- if (!add_sid_to_array(result, &global_sid_World,
- &result->user_sids, &result->num_sids)) {
- return NULL;
- }
- if (!add_sid_to_array(result, &global_sid_Network,
- &result->user_sids, &result->num_sids)) {
- return NULL;
- }
-
- if (is_guest) {
- if (!add_sid_to_array(result, &global_sid_Builtin_Guests,
- &result->user_sids, &result->num_sids)) {
- return NULL;
- }
- } else {
- if (!add_sid_to_array(result, &global_sid_Authenticated_Users,
- &result->user_sids, &result->num_sids)) {
- return NULL;
- }
- }
-
- /* Now the SIDs we got from authentication. These are the ones from
- * the info3 struct or from the pdb_enum_group_memberships, depending
- * on who authenticated the user.
- * Note that we start the for loop at "1" here, we already added the
- * first group sid as primary above. */
-
- for (i=1; i<num_groupsids; i++) {
- if (!add_sid_to_array_unique(result, &groupsids[i],
- &result->user_sids, &result->num_sids)) {
- return NULL;
- }
- }
-
- /* Deal with the BUILTIN\Administrators group. If the SID can
- be resolved then assume that the add_aliasmem( S-1-5-32 )
- handled it. */
-
- if ( !sid_to_gid( &global_sid_Builtin_Administrators, &gid ) ) {
- /* We can only create a mapping if winbind is running
- and the nested group functionality has been enabled */
-
- if ( lp_winbind_nested_groups() && winbind_ping() ) {
- become_root();
- status = create_builtin_administrators( );
- if ( !NT_STATUS_IS_OK(status) ) {
- DEBUG(2,("create_local_nt_token: Failed to create BUILTIN\\Administrators group!\n"));
- /* don't fail, just log the message */
- }
- unbecome_root();
- }
- else {
- status = add_builtin_administrators( result );
- if ( !NT_STATUS_IS_OK(status) ) {
- /* just log a complaint but do not fail */
- DEBUG(3,("create_local_nt_token: failed to check for local Administrators"
- " membership (%s)\n", nt_errstr(status)));
- }
- }
- }
-
- /* Deal with the BUILTIN\Users group. If the SID can
- be resolved then assume that the add_aliasmem( S-1-5-32 )
- handled it. */
-
- if ( !sid_to_gid( &global_sid_Builtin_Users, &gid ) ) {
- /* We can only create a mapping if winbind is running
- and the nested group functionality has been enabled */
-
- if ( lp_winbind_nested_groups() && winbind_ping() ) {
- become_root();
- status = create_builtin_users( );
- if ( !NT_STATUS_IS_OK(status) ) {
- DEBUG(2,("create_local_nt_token: Failed to create BUILTIN\\Users group!\n"));
- /* don't fail, just log the message */
- }
- unbecome_root();
- }
- }
-
- /* Deal with local groups */
-
- if (lp_winbind_nested_groups()) {
-
- /* Now add the aliases. First the one from our local SAM */
-
- status = add_aliases(get_global_sam_sid(), result);
-
- if (!NT_STATUS_IS_OK(status)) {
- TALLOC_FREE(result);
- return NULL;
- }
-
- /* Finally the builtin ones */
-
- status = add_aliases(&global_sid_Builtin, result);
-
- if (!NT_STATUS_IS_OK(status)) {
- TALLOC_FREE(result);
- return NULL;
- }
- }
-
-
- get_privileges_for_sids(&result->privileges, result->user_sids,
- result->num_sids);
- return result;
-}
-
/*
* Create the token to use from server_info->sam_account and
* server_info->sids (the info3/sam groups). Find the unix gids.
NTSTATUS create_local_token(auth_serversupplied_info *server_info)
{
TALLOC_CTX *mem_ctx;
- struct id_map *ids;
NTSTATUS status;
- BOOL wb = True;
size_t i;
server_info->groups = NULL;
/* Start at index 1, where the groups start. */
- ids = talloc_zero_array(mem_ctx, struct id_map, server_info->ptok->num_sids);
- for (i = 0; i < server_info->ptok->num_sids-1; i++) {
- ids[i].sid = &server_info->ptok->user_sids[i + 1]; /* store the sids */
- }
- if (!winbind_sids_to_unixids(ids, server_info->ptok->num_sids-1)) {
- DEBUG(2, ("Query to map secondary SIDs failed!\n"));
- if (!winbind_ping()) {
- DEBUG(2, ("Winbindd is not running, will try to map SIDs one by one with legacy code\n"));
- wb = False;
- }
- }
+ for (i=1; i<server_info->ptok->num_sids; i++) {
+ gid_t gid;
+ DOM_SID *sid = &server_info->ptok->user_sids[i];
- for (i = 0; i < server_info->ptok->num_sids-1; i++) {
- gid_t agid;
-
- if (wb) {
- if (ids[i].status != ID_MAPPED) {
- DEBUG(10, ("Could not convert SID %s to gid, "
- "ignoring it\n", sid_string_static(ids[i].sid)));
- continue;
- }
- if (ids[i].xid.type == ID_TYPE_UID) {
- DEBUG(10, ("SID %s is a User ID (%u) not a Group ID, "
- "ignoring it\n", sid_string_static(ids[i].sid), ids[i].xid.id));
- continue;
- }
- agid = (gid_t)ids[i].xid.id;
- } else {
- if (! sid_to_gid(ids[i].sid, &agid)) {
- continue;
- }
- }
- if (!add_gid_to_array_unique(server_info, agid, &server_info->groups,
- &server_info->n_groups)) {
- TALLOC_FREE(mem_ctx);
- return NT_STATUS_NO_MEMORY;
+ if (!sid_to_gid(sid, &gid)) {
+ DEBUG(10, ("Could not convert SID %s to gid, "
+ "ignoring it\n", sid_string_static(sid)));
+ continue;
}
+ add_gid_to_array_unique(server_info, gid, &server_info->groups,
+ &server_info->n_groups);
}
-
+
debug_nt_user_token(DBGC_AUTH, 10, server_info->ptok);
status = log_nt_token(mem_ctx, server_info->ptok);
*/
NTSTATUS create_token_from_username(TALLOC_CTX *mem_ctx, const char *username,
- BOOL is_guest,
+ bool is_guest,
uid_t *uid, gid_t *gid,
char **found_username,
struct nt_user_token **token)
}
if (sid_check_is_in_our_domain(&user_sid)) {
+ bool ret;
/* This is a passdb user, so ask passdb */
goto done;
}
- if (!pdb_getsampwsid(sam_acct, &user_sid)) {
+ become_root();
+ ret = pdb_getsampwsid(sam_acct, &user_sid);
+ unbecome_root();
+
+ if (!ret) {
DEBUG(1, ("pdb_getsampwsid(%s) for user %s failed\n",
sid_string_static(&user_sid), username));
DEBUGADD(1, ("Fall back to unix user %s\n", username));
goto done;
}
- group_sids = talloc_array(tmp_ctx, DOM_SID, num_group_sids);
- if (group_sids == NULL) {
- DEBUG(1, ("talloc_array failed\n"));
- result = NT_STATUS_NO_MEMORY;
- goto done;
+ if (num_group_sids) {
+ group_sids = TALLOC_ARRAY(tmp_ctx, DOM_SID, num_group_sids);
+ if (group_sids == NULL) {
+ DEBUG(1, ("TALLOC_ARRAY failed\n"));
+ result = NT_STATUS_NO_MEMORY;
+ goto done;
+ }
+ } else {
+ group_sids = NULL;
}
for (i=0; i<num_group_sids; i++) {
uint32 dummy;
num_group_sids = 1;
- group_sids = talloc_array(tmp_ctx, DOM_SID, num_group_sids);
+ group_sids = TALLOC_ARRAY(tmp_ctx, DOM_SID, num_group_sids);
if (group_sids == NULL) {
- DEBUG(1, ("talloc_array failed\n"));
+ DEBUG(1, ("TALLOC_ARRAY failed\n"));
result = NT_STATUS_NO_MEMORY;
goto done;
}
member of a particular group.
***************************************************************************/
-BOOL user_in_group_sid(const char *username, const DOM_SID *group_sid)
+bool user_in_group_sid(const char *username, const DOM_SID *group_sid)
{
NTSTATUS status;
uid_t uid;
gid_t gid;
char *found_username;
struct nt_user_token *token;
- BOOL result;
+ bool result;
TALLOC_CTX *mem_ctx;
}
-BOOL user_in_group(const char *username, const char *groupname)
+bool user_in_group(const char *username, const char *groupname)
{
TALLOC_CTX *mem_ctx;
DOM_SID group_sid;
- BOOL ret;
+ bool ret;
mem_ctx = talloc_new(NULL);
if (mem_ctx == NULL) {
NTSTATUS status;
struct samu *sampass = NULL;
gid_t *gids;
+ char *qualified_name = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+ DOM_SID u_sid;
+ enum lsa_SidType type;
auth_serversupplied_info *result;
if ( !(sampass = samu_new( NULL )) ) {
return status;
}
+ /*
+ * The SID returned in server_info->sam_account is based
+ * on our SAM sid even though for a pure UNIX account this should
+ * not be the case as it doesn't really exist in the SAM db.
+ * This causes lookups on "[in]valid users" to fail as they
+ * will lookup this name as a "Unix User" SID to check against
+ * the user token. Fix this by adding the "Unix User"\unix_username
+ * SID to the sid array. The correct fix should probably be
+ * changing the server_info->sam_account user SID to be a
+ * S-1-22 Unix SID, but this might break old configs where
+ * plaintext passwords were used with no SAM backend.
+ */
+
+ mem_ctx = talloc_init("make_server_info_pw_tmp");
+ if (!mem_ctx) {
+ TALLOC_FREE(result);
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ qualified_name = talloc_asprintf(mem_ctx, "%s\\%s",
+ unix_users_domain_name(),
+ unix_username );
+ if (!qualified_name) {
+ TALLOC_FREE(result);
+ TALLOC_FREE(mem_ctx);
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ if (!lookup_name(mem_ctx, qualified_name, LOOKUP_NAME_ALL,
+ NULL, NULL,
+ &u_sid, &type)) {
+ TALLOC_FREE(result);
+ TALLOC_FREE(mem_ctx);
+ return NT_STATUS_NO_SUCH_USER;
+ }
+
+ TALLOC_FREE(mem_ctx);
+
+ if (type != SID_NAME_USER) {
+ TALLOC_FREE(result);
+ return NT_STATUS_NO_SUCH_USER;
+ }
+
+ if (!add_sid_to_array_unique(result, &u_sid,
+ &result->sids,
+ &result->num_sids)) {
+ TALLOC_FREE(result);
+ return NT_STATUS_NO_MEMORY;
+ }
+
/* For now we throw away the gids and convert via sid_to_gid
* later. This needs fixing, but I'd like to get the code straight and
* simple first. */
NTSTATUS status;
struct samu *sampass = NULL;
DOM_SID guest_sid;
- BOOL ret;
+ bool ret;
static const char zeros[16] = { 0, };
if ( !(sampass = samu_new( NULL )) ) {
dst->gid = src->gid;
dst->n_groups = src->n_groups;
if (src->n_groups != 0) {
- dst->groups = (gid_t *)talloc_memdup(
+ dst->groups = (gid_t *)TALLOC_MEMDUP(
dst, src->groups, sizeof(gid_t)*dst->n_groups);
} else {
dst->groups = NULL;
static auth_serversupplied_info *guest_info = NULL;
-BOOL init_guest_info(void)
+bool init_guest_info(void)
{
if (guest_info != NULL)
return True;
return (*server_info != NULL) ? NT_STATUS_OK : NT_STATUS_NO_MEMORY;
}
-BOOL copy_current_user(struct current_user *dst, struct current_user *src)
+bool copy_current_user(struct current_user *dst, struct current_user *src)
{
gid_t *groups;
NT_USER_TOKEN *nt_token;
return True;
}
-BOOL set_current_user_guest(struct current_user *dst)
+bool set_current_user_guest(struct current_user *dst)
{
gid_t *groups;
NT_USER_TOKEN *nt_token;
char **found_username,
uid_t *uid, gid_t *gid,
struct samu *account,
- BOOL *username_was_mapped)
+ bool *username_was_mapped)
{
NTSTATUS nt_status;
fstring dom_user, lower_username;
****************************************************************************/
struct passwd *smb_getpwnam( TALLOC_CTX *mem_ctx, char *domuser,
- fstring save_username, BOOL create )
+ fstring save_username, bool create )
{
struct passwd *pw = NULL;
char *p;
struct samu *sam_account = NULL;
DOM_SID user_sid;
DOM_SID group_sid;
- BOOL username_was_mapped;
+ bool username_was_mapped;
uid_t uid;
gid_t gid;
- size_t i;
-
auth_serversupplied_info *result;
/*
return NT_STATUS_NO_MEMORY;
}
+ if (!pdb_set_pass_last_set_time(
+ sam_account,
+ nt_time_to_unix(info3->pass_last_set_time),
+ PDB_CHANGED)) {
+ TALLOC_FREE(sam_account);
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ if (!pdb_set_pass_can_change_time(
+ sam_account,
+ nt_time_to_unix(info3->pass_can_change_time),
+ PDB_CHANGED)) {
+ TALLOC_FREE(sam_account);
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ if (!pdb_set_pass_must_change_time(
+ sam_account,
+ nt_time_to_unix(info3->pass_must_change_time),
+ PDB_CHANGED)) {
+ TALLOC_FREE(sam_account);
+ return NT_STATUS_NO_MEMORY;
+ }
+
result = make_server_info(NULL);
if (result == NULL) {
DEBUG(4, ("make_server_info failed!\n"));
result->num_sids = 0;
result->sids = NULL;
- /* and create (by appending rids) the 'domain' sids */
-
- for (i = 0; i < info3->num_groups2; i++) {
- DOM_SID sid;
- if (!sid_compose(&sid, &info3->dom_sid.sid,
- info3->gids[i].g_rid)) {
- DEBUG(3,("could not append additional group rid "
- "0x%x\n", info3->gids[i].g_rid));
- TALLOC_FREE(result);
- return NT_STATUS_INVALID_PARAMETER;
- }
- if (!add_sid_to_array(result, &sid, &result->sids,
- &result->num_sids)) {
- TALLOC_FREE(result);
- return NT_STATUS_NO_MEMORY;
- }
- }
-
- /* Copy 'other' sids. We need to do sid filtering here to
- prevent possible elevation of privileges. See:
-
- http://www.microsoft.com/windows2000/techinfo/administration/security/sidfilter.asp
- */
-
- for (i = 0; i < info3->num_other_sids; i++) {
- if (!add_sid_to_array(result, &info3->other_sids[i].sid,
+ nt_status = sid_array_from_info3(result, info3,
&result->sids,
- &result->num_sids)) {
- TALLOC_FREE(result);
- return NT_STATUS_NO_MEMORY;
- }
+ &result->num_sids,
+ False);
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ TALLOC_FREE(result);
+ return nt_status;
}
result->login_server = unistr2_tdup(result,
/* ensure we are never given NULL session keys */
if (memcmp(info3->user_sess_key, zeros, sizeof(zeros)) == 0) {
- result->user_session_key = data_blob(NULL, 0);
+ result->user_session_key = data_blob_null;
} else {
result->user_session_key = data_blob_talloc(
result, info3->user_sess_key,
}
if (memcmp(info3->lm_sess_key, zeros, 8) == 0) {
- result->lm_session_key = data_blob(NULL, 0);
+ result->lm_session_key = data_blob_null;
} else {
result->lm_session_key = data_blob_talloc(
result, info3->lm_sess_key,
Make an auth_methods struct
***************************************************************************/
-BOOL make_auth_methods(struct auth_context *auth_context, auth_methods **auth_method)
+bool make_auth_methods(struct auth_context *auth_context, auth_methods **auth_method)
{
if (!auth_context) {
smb_panic("no auth_context supplied to "
return True;
}
-/****************************************************************************
- Duplicate a SID token.
-****************************************************************************/
-
-NT_USER_TOKEN *dup_nt_token(TALLOC_CTX *mem_ctx, const NT_USER_TOKEN *ptoken)
-{
- NT_USER_TOKEN *token;
-
- if (!ptoken)
- return NULL;
-
- token = TALLOC_P(mem_ctx, NT_USER_TOKEN);
- if (token == NULL) {
- DEBUG(0, ("talloc failed\n"));
- return NULL;
- }
-
- ZERO_STRUCTP(token);
-
- if (ptoken->user_sids && ptoken->num_sids) {
- token->user_sids = (DOM_SID *)talloc_memdup(
- token, ptoken->user_sids, sizeof(DOM_SID) * ptoken->num_sids );
-
- if (token->user_sids == NULL) {
- DEBUG(0, ("talloc_memdup failed\n"));
- TALLOC_FREE(token);
- return NULL;
- }
- token->num_sids = ptoken->num_sids;
- }
-
- /* copy the privileges; don't consider failure to be critical here */
-
- if ( !se_priv_copy( &token->privileges, &ptoken->privileges ) ) {
- DEBUG(0,("dup_nt_token: Failure to copy SE_PRIV!. "
- "Continuing with 0 privileges assigned.\n"));
- }
-
- return token;
-}
-
-/****************************************************************************
- Check for a SID in an NT_USER_TOKEN
-****************************************************************************/
-
-BOOL nt_token_check_sid ( const DOM_SID *sid, const NT_USER_TOKEN *token )
-{
- int i;
-
- if ( !sid || !token )
- return False;
-
- for ( i=0; i<token->num_sids; i++ ) {
- if ( sid_equal( sid, &token->user_sids[i] ) )
- return True;
- }
-
- return False;
-}
-
-BOOL nt_token_check_domain_rid( NT_USER_TOKEN *token, uint32 rid )
-{
- DOM_SID domain_sid;
-
- /* if we are a domain member, the get the domain SID, else for
- a DC or standalone server, use our own SID */
-
- if ( lp_server_role() == ROLE_DOMAIN_MEMBER ) {
- if ( !secrets_fetch_domain_sid( lp_workgroup(),
- &domain_sid ) ) {
- DEBUG(1,("nt_token_check_domain_rid: Cannot lookup "
- "SID for domain [%s]\n", lp_workgroup()));
- return False;
- }
- }
- else
- sid_copy( &domain_sid, get_global_sam_sid() );
-
- sid_append_rid( &domain_sid, rid );
-
- return nt_token_check_sid( &domain_sid, token );\
-}
-
/**
* Verify whether or not given domain is trusted.
*
* false if otherwise
**/
-BOOL is_trusted_domain(const char* dom_name)
+bool is_trusted_domain(const char* dom_name)
{
DOM_SID trustdom_sid;
- BOOL ret;
+ bool ret;
/* no trusted domains for a standalone server */
git.samba.org / nivanova / samba-autobuild / .git / blobdiff