s3-auth Change struct nt_user_token -> struct security_token
[abartlet/samba.git/.git] / source3 / auth / token_util.c
index d60d929482317db98ceee364aaa86fd421c0f680..e9eee90d707b7831c5e8a6245529f9df31465af4 100644 (file)
 /* functions moved from auth/auth_util.c to minimize linker deps */
 
 #include "includes.h"
+#include "secrets.h"
+#include "memcache.h"
+
+#include "../librpc/gen_ndr/netlogon.h"
 
 /****************************************************************************
  Check for a SID in an NT_USER_TOKEN
 ****************************************************************************/
 
-bool nt_token_check_sid ( const DOM_SID *sid, const NT_USER_TOKEN *token )
+bool nt_token_check_sid ( const struct dom_sid *sid, const NT_USER_TOKEN *token )
 {
        int i;
 
@@ -38,7 +42,7 @@ bool nt_token_check_sid ( const DOM_SID *sid, const NT_USER_TOKEN *token )
                return False;
 
        for ( i=0; i<token->num_sids; i++ ) {
-               if ( sid_equal( sid, &token->user_sids[i] ) )
+               if ( sid_equal( sid, &token->sids[i] ) )
                        return True;
        }
 
@@ -47,7 +51,7 @@ bool nt_token_check_sid ( const DOM_SID *sid, const NT_USER_TOKEN *token )
 
 bool nt_token_check_domain_rid( NT_USER_TOKEN *token, uint32 rid )
 {
-       DOM_SID domain_sid;
+       struct 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 */
@@ -77,8 +81,8 @@ bool nt_token_check_domain_rid( NT_USER_TOKEN *token, uint32 rid )
 
 NT_USER_TOKEN *get_root_nt_token( void )
 {
-       struct nt_user_token *token, *for_cache;
-       DOM_SID u_sid, g_sid;
+       struct security_token *token, *for_cache;
+       struct dom_sid u_sid, g_sid;
        struct passwd *pw;
        void *cache_data;
 
@@ -88,7 +92,7 @@ NT_USER_TOKEN *get_root_nt_token( void )
 
        if (cache_data != NULL) {
                return talloc_get_type_abort(
-                       cache_data, struct nt_user_token);
+                       cache_data, struct security_token);
        }
 
        if ( !(pw = sys_getpwuid(0)) ) {
@@ -108,7 +112,7 @@ NT_USER_TOKEN *get_root_nt_token( void )
        token = create_local_nt_token(talloc_autofree_context(), &u_sid, False,
                                      1, &global_sid_Builtin_Administrators);
 
-       token->privileges = se_disk_operators;
+       token->privilege_mask = se_disk_operators;
 
        for_cache = token;
 
@@ -124,8 +128,8 @@ NT_USER_TOKEN *get_root_nt_token( void )
  * Add alias SIDs from memberships within the partially created token SID list
  */
 
-NTSTATUS add_aliases(const DOM_SID *domain_sid,
-                    struct nt_user_token *token)
+NTSTATUS add_aliases(const struct dom_sid *domain_sid,
+                    struct security_token *token)
 {
        uint32 *aliases;
        size_t i, num_aliases;
@@ -140,7 +144,7 @@ NTSTATUS add_aliases(const DOM_SID *domain_sid,
        num_aliases = 0;
 
        status = pdb_enum_alias_memberships(tmp_ctx, domain_sid,
-                                           token->user_sids,
+                                           token->sids,
                                            token->num_sids,
                                            &aliases, &num_aliases);
 
@@ -151,10 +155,10 @@ NTSTATUS add_aliases(const DOM_SID *domain_sid,
        }
 
        for (i=0; i<num_aliases; i++) {
-               DOM_SID alias_sid;
+               struct dom_sid alias_sid;
                sid_compose(&alias_sid, domain_sid, aliases[i]);
                status = add_sid_to_array_unique(token, &alias_sid,
-                                                &token->user_sids,
+                                                &token->sids,
                                                 &token->num_sids);
                if (!NT_STATUS_IS_OK(status)) {
                        DEBUG(0, ("add_sid_to_array failed\n"));
@@ -170,10 +174,10 @@ done:
 /*******************************************************************
 *******************************************************************/
 
-static NTSTATUS add_builtin_administrators(struct nt_user_token *token,
-                                          const DOM_SID *dom_sid)
+static NTSTATUS add_builtin_administrators(struct security_token *token,
+                                          const struct dom_sid *dom_sid)
 {
-       DOM_SID domadm;
+       struct dom_sid domadm;
        NTSTATUS status;
 
        /* nothing to do if we aren't in a domain */
@@ -196,7 +200,7 @@ static NTSTATUS add_builtin_administrators(struct nt_user_token *token,
        if ( nt_token_check_sid( &domadm, token ) ) {
                status = add_sid_to_array(token,
                                          &global_sid_Builtin_Administrators,
-                                         &token->user_sids, &token->num_sids);
+                                         &token->sids, &token->num_sids);
        if (!NT_STATUS_IS_OK(status)) {
                        return status;
                }
@@ -215,7 +219,7 @@ static NTSTATUS add_builtin_administrators(struct nt_user_token *token,
 static NTSTATUS create_builtin(uint32 rid)
 {
        NTSTATUS status = NT_STATUS_OK;
-       DOM_SID sid;
+       struct dom_sid sid;
        gid_t gid;
 
        if (!sid_compose(&sid, &global_sid_Builtin, rid)) {
@@ -238,8 +242,8 @@ static NTSTATUS create_builtin(uint32 rid)
  * @param[in] dom_sid          sid to add as a member of builtin_sid.
  * @return Normal NTSTATUS return
  */
-static NTSTATUS add_sid_to_builtin(const DOM_SID *builtin_sid,
-                                  const DOM_SID *dom_sid)
+static NTSTATUS add_sid_to_builtin(const struct dom_sid *builtin_sid,
+                                  const struct dom_sid *dom_sid)
 {
        NTSTATUS status = NT_STATUS_OK;
 
@@ -267,12 +271,12 @@ static NTSTATUS add_sid_to_builtin(const DOM_SID *builtin_sid,
 /*******************************************************************
 *******************************************************************/
 
-NTSTATUS create_builtin_users(const DOM_SID *dom_sid)
+NTSTATUS create_builtin_users(const struct dom_sid *dom_sid)
 {
        NTSTATUS status;
-       DOM_SID dom_users;
+       struct dom_sid dom_users;
 
-       status = create_builtin(BUILTIN_ALIAS_RID_USERS);
+       status = create_builtin(BUILTIN_RID_USERS);
        if ( !NT_STATUS_IS_OK(status) ) {
                DEBUG(5,("create_builtin_users: Failed to create Users\n"));
                return status;
@@ -292,16 +296,16 @@ NTSTATUS create_builtin_users(const DOM_SID *dom_sid)
 /*******************************************************************
 *******************************************************************/
 
-NTSTATUS create_builtin_administrators(const DOM_SID *dom_sid)
+NTSTATUS create_builtin_administrators(const struct dom_sid *dom_sid)
 {
        NTSTATUS status;
-       DOM_SID dom_admins, root_sid;
+       struct dom_sid dom_admins, root_sid;
        fstring root_name;
        enum lsa_SidType type;
        TALLOC_CTX *ctx;
        bool ret;
 
-       status = create_builtin(BUILTIN_ALIAS_RID_ADMINS);
+       status = create_builtin(BUILTIN_RID_ADMINISTRATORS);
        if ( !NT_STATUS_IS_OK(status) ) {
                DEBUG(5,("create_builtin_administrators: Failed to create Administrators\n"));
                return status;
@@ -335,27 +339,139 @@ NTSTATUS create_builtin_administrators(const DOM_SID *dom_sid)
        return status;
 }
 
+static NTSTATUS finalize_local_nt_token(struct security_token *result,
+                                       bool is_guest);
+
+NTSTATUS create_local_nt_token_from_info3(TALLOC_CTX *mem_ctx,
+                                         bool is_guest,
+                                         struct netr_SamInfo3 *info3,
+                                         struct extra_auth_info *extra,
+                                         struct security_token **ntok)
+{
+       struct security_token *usrtok = NULL;
+       NTSTATUS status;
+       int i;
+
+       DEBUG(10, ("Create local NT token for %s\n",
+                  info3->base.account_name.string));
+
+       usrtok = talloc_zero(mem_ctx, struct security_token);
+       if (!usrtok) {
+               DEBUG(0, ("talloc failed\n"));
+               return NT_STATUS_NO_MEMORY;
+       }
+
+       /* Add the user and primary group sid FIRST */
+       /* check if the user rid is the special "Domain Guests" rid.
+        * If so pick the first sid for the extra sids instead as it
+        * is a local fake account */
+       usrtok->sids = talloc_array(usrtok, struct dom_sid, 2);
+       if (!usrtok->sids) {
+               TALLOC_FREE(usrtok);
+               return NT_STATUS_NO_MEMORY;
+       }
+       usrtok->num_sids = 2;
+
+       /* USER SID */
+       if (info3->base.rid == (uint32_t)(-1)) {
+               /* this is a signal the user was fake and generated,
+                * the actual SID we want to use is stored in the extra
+                * sids */
+               if (is_null_sid(&extra->user_sid)) {
+                       /* we couldn't find the user sid, bail out */
+                       DEBUG(3, ("Invalid user SID\n"));
+                       TALLOC_FREE(usrtok);
+                       return NT_STATUS_UNSUCCESSFUL;
+               }
+               sid_copy(&usrtok->sids[0], &extra->user_sid);
+       } else {
+               sid_copy(&usrtok->sids[0], info3->base.domain_sid);
+               sid_append_rid(&usrtok->sids[0], info3->base.rid);
+       }
+
+       /* GROUP SID */
+       if (info3->base.primary_gid == (uint32_t)(-1)) {
+               /* this is a signal the user was fake and generated,
+                * the actual SID we want to use is stored in the extra
+                * sids */
+               if (is_null_sid(&extra->pgid_sid)) {
+                       /* we couldn't find the user sid, bail out */
+                       DEBUG(3, ("Invalid group SID\n"));
+                       TALLOC_FREE(usrtok);
+                       return NT_STATUS_UNSUCCESSFUL;
+               }
+               sid_copy(&usrtok->sids[1], &extra->pgid_sid);
+       } else {
+               sid_copy(&usrtok->sids[1], info3->base.domain_sid);
+               sid_append_rid(&usrtok->sids[1],
+                               info3->base.primary_gid);
+       }
+
+       /* 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 = 0; i < info3->base.groups.count; i++) {
+               struct dom_sid tmp_sid;
+
+               sid_copy(&tmp_sid, info3->base.domain_sid);
+               sid_append_rid(&tmp_sid, info3->base.groups.rids[i].rid);
+
+               status = add_sid_to_array_unique(usrtok, &tmp_sid,
+                                                &usrtok->sids,
+                                                &usrtok->num_sids);
+               if (!NT_STATUS_IS_OK(status)) {
+                       DEBUG(3, ("Failed to add SID to nt token\n"));
+                       TALLOC_FREE(usrtok);
+                       return status;
+               }
+       }
+
+       /* now also add extra sids if they are not the special user/group
+        * sids */
+       for (i = 0; i < info3->sidcount; i++) {
+               status = add_sid_to_array_unique(usrtok,
+                                                info3->sids[i].sid,
+                                                &usrtok->sids,
+                                                &usrtok->num_sids);
+               if (!NT_STATUS_IS_OK(status)) {
+                       DEBUG(3, ("Failed to add SID to nt token\n"));
+                       TALLOC_FREE(usrtok);
+                       return status;
+               }
+       }
+
+       status = finalize_local_nt_token(usrtok, is_guest);
+       if (!NT_STATUS_IS_OK(status)) {
+               DEBUG(3, ("Failed to finalize nt token\n"));
+               TALLOC_FREE(usrtok);
+               return status;
+       }
+
+       *ntok = usrtok;
+       return NT_STATUS_OK;
+}
 
 /*******************************************************************
  Create a NT token for the user, expanding local aliases
 *******************************************************************/
 
-struct nt_user_token *create_local_nt_token(TALLOC_CTX *mem_ctx,
-                                           const DOM_SID *user_sid,
+struct security_token *create_local_nt_token(TALLOC_CTX *mem_ctx,
+                                           const struct dom_sid *user_sid,
                                            bool is_guest,
                                            int num_groupsids,
-                                           const DOM_SID *groupsids)
+                                           const struct dom_sid *groupsids)
 {
-       struct nt_user_token *result = NULL;
+       struct security_token *result = NULL;
        int i;
        NTSTATUS status;
-       gid_t gid;
-       DOM_SID dom_sid;
 
        DEBUG(10, ("Create local NT token for %s\n",
                   sid_string_dbg(user_sid)));
 
-       if (!(result = TALLOC_ZERO_P(mem_ctx, struct nt_user_token))) {
+       if (!(result = TALLOC_ZERO_P(mem_ctx, struct security_token))) {
                DEBUG(0, ("talloc failed\n"));
                return NULL;
        }
@@ -363,63 +479,82 @@ struct nt_user_token *create_local_nt_token(TALLOC_CTX *mem_ctx,
        /* Add the user and primary group sid */
 
        status = add_sid_to_array(result, user_sid,
-                                 &result->user_sids, &result->num_sids);
+                                 &result->sids, &result->num_sids);
        if (!NT_STATUS_IS_OK(status)) {
+               TALLOC_FREE(result);
                return NULL;
        }
 
        /* For guest, num_groupsids may be zero. */
        if (num_groupsids) {
                status = add_sid_to_array(result, &groupsids[0],
-                                         &result->user_sids,
+                                         &result->sids,
                                          &result->num_sids);
                if (!NT_STATUS_IS_OK(status)) {
+                       TALLOC_FREE(result);
+                       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++) {
+               status = add_sid_to_array_unique(result, &groupsids[i],
+                                                &result->sids,
+                                                &result->num_sids);
+               if (!NT_STATUS_IS_OK(status)) {
+                       TALLOC_FREE(result);
                        return NULL;
                }
        }
 
+       status = finalize_local_nt_token(result, is_guest);
+       if (!NT_STATUS_IS_OK(status)) {
+               TALLOC_FREE(result);
+               return NULL;
+       }
+
+       return result;
+}
+
+static NTSTATUS finalize_local_nt_token(struct security_token *result,
+                                       bool is_guest)
+{
+       struct dom_sid dom_sid;
+       gid_t gid;
+       NTSTATUS status;
+
        /* Add in BUILTIN sids */
 
        status = add_sid_to_array(result, &global_sid_World,
-                                 &result->user_sids, &result->num_sids);
+                                 &result->sids, &result->num_sids);
        if (!NT_STATUS_IS_OK(status)) {
-               return NULL;
+               return status;
        }
        status = add_sid_to_array(result, &global_sid_Network,
-                                 &result->user_sids, &result->num_sids);
+                                 &result->sids, &result->num_sids);
        if (!NT_STATUS_IS_OK(status)) {
-               return NULL;
+               return status;
        }
 
        if (is_guest) {
                status = add_sid_to_array(result, &global_sid_Builtin_Guests,
-                                         &result->user_sids,
+                                         &result->sids,
                                          &result->num_sids);
                if (!NT_STATUS_IS_OK(status)) {
-                       return NULL;
+                       return status;
                }
        } else {
                status = add_sid_to_array(result,
                                          &global_sid_Authenticated_Users,
-                                         &result->user_sids,
+                                         &result->sids,
                                          &result->num_sids);
                if (!NT_STATUS_IS_OK(status)) {
-                       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++) {
-               status = add_sid_to_array_unique(result, &groupsids[i],
-                                                &result->user_sids,
-                                                &result->num_sids);
-               if (!NT_STATUS_IS_OK(status)) {
-                       return NULL;
+                       return status;
                }
        }
 
@@ -490,8 +625,7 @@ struct nt_user_token *create_local_nt_token(TALLOC_CTX *mem_ctx,
 
                if (!NT_STATUS_IS_OK(status)) {
                        unbecome_root();
-                       TALLOC_FREE(result);
-                       return NULL;
+                       return status;
                }
 
                /* Finally the builtin ones */
@@ -500,17 +634,18 @@ struct nt_user_token *create_local_nt_token(TALLOC_CTX *mem_ctx,
 
                if (!NT_STATUS_IS_OK(status)) {
                        unbecome_root();
-                       TALLOC_FREE(result);
-                       return NULL;
+                       return status;
                }
 
                unbecome_root();
        }
 
+       /* Add privileges based on current user sids */
 
-       get_privileges_for_sids(&result->privileges, result->user_sids,
+       get_privileges_for_sids(&result->privilege_mask, result->sids,
                                result->num_sids);
-       return result;
+
+       return NT_STATUS_OK;
 }
 
 /****************************************************************************
@@ -528,15 +663,15 @@ void debug_nt_user_token(int dbg_class, int dbg_lev, NT_USER_TOKEN *token)
 
        DEBUGC(dbg_class, dbg_lev,
               ("NT user token of user %s\n",
-               sid_string_dbg(&token->user_sids[0]) ));
+               sid_string_dbg(&token->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_dbg(&token->user_sids[i])));
+                          sid_string_dbg(&token->sids[i])));
 
-       dump_se_priv( dbg_class, dbg_lev, &token->privileges );
+       dump_se_priv( dbg_class, dbg_lev, &token->privilege_mask );
 }
 
 /****************************************************************************
@@ -581,16 +716,16 @@ NTSTATUS create_token_from_username(TALLOC_CTX *mem_ctx, const char *username,
                                    bool is_guest,
                                    uid_t *uid, gid_t *gid,
                                    char **found_username,
-                                   struct nt_user_token **token)
+                                   struct security_token **token)
 {
        NTSTATUS result = NT_STATUS_NO_SUCH_USER;
        TALLOC_CTX *tmp_ctx = talloc_stackframe();
-       DOM_SID user_sid;
+       struct dom_sid user_sid;
        enum lsa_SidType type;
        gid_t *gids;
-       DOM_SID *group_sids;
-       DOM_SID unix_group_sid;
-       size_t num_group_sids;
+       struct dom_sid *group_sids;
+       struct dom_sid unix_group_sid;
+       uint32_t num_group_sids;
        size_t num_gids;
        size_t i;
 
@@ -608,7 +743,7 @@ NTSTATUS create_token_from_username(TALLOC_CTX *mem_ctx, const char *username,
 
        if (sid_check_is_in_our_domain(&user_sid)) {
                bool ret;
-
+               size_t pdb_num_group_sids;
                /* This is a passdb user, so ask passdb */
 
                struct samu *sam_acct = NULL;
@@ -631,7 +766,7 @@ NTSTATUS create_token_from_username(TALLOC_CTX *mem_ctx, const char *username,
 
                result = pdb_enum_group_memberships(tmp_ctx, sam_acct,
                                                    &group_sids, &gids,
-                                                   &num_group_sids);
+                                                   &pdb_num_group_sids);
                if (!NT_STATUS_IS_OK(result)) {
                        DEBUG(1, ("enum_group_memberships failed for %s (%s): "
                                  "%s\n", username, sid_string_dbg(&user_sid),
@@ -639,6 +774,7 @@ NTSTATUS create_token_from_username(TALLOC_CTX *mem_ctx, const char *username,
                        DEBUGADD(1, ("Fall back to unix user %s\n", username));
                        goto unix_user;
                }
+               num_group_sids = pdb_num_group_sids;
 
                /* see the smb_panic() in pdb_default_enum_group_memberships */
                SMB_ASSERT(num_group_sids > 0);
@@ -677,7 +813,7 @@ NTSTATUS create_token_from_username(TALLOC_CTX *mem_ctx, const char *username,
                *uid = sam_acct->unix_pw->pw_uid;
 
        } else  if (sid_check_is_in_unix_users(&user_sid)) {
-
+               size_t getgroups_num_group_sids;
                /* This is a unix user not in passdb. We need to ask nss
                 * directly, without consulting passdb */
 
@@ -708,14 +844,15 @@ NTSTATUS create_token_from_username(TALLOC_CTX *mem_ctx, const char *username,
                }
 
                if (!getgroups_unix_user(tmp_ctx, username, pass->pw_gid,
-                                        &gids, &num_group_sids)) {
+                                        &gids, &getgroups_num_group_sids)) {
                        DEBUG(1, ("getgroups_unix_user for user %s failed\n",
                                  username));
                        goto done;
                }
+               num_group_sids = getgroups_num_group_sids;
 
                if (num_group_sids) {
-                       group_sids = TALLOC_ARRAY(tmp_ctx, DOM_SID, num_group_sids);
+                       group_sids = TALLOC_ARRAY(tmp_ctx, struct dom_sid, num_group_sids);
                        if (group_sids == NULL) {
                                DEBUG(1, ("TALLOC_ARRAY failed\n"));
                                result = NT_STATUS_NO_MEMORY;
@@ -756,7 +893,7 @@ NTSTATUS create_token_from_username(TALLOC_CTX *mem_ctx, const char *username,
                }
 
                num_group_sids = 1;
-               group_sids = TALLOC_ARRAY(tmp_ctx, DOM_SID, num_group_sids);
+               group_sids = TALLOC_ARRAY(tmp_ctx, struct dom_sid, num_group_sids);
                if (group_sids == NULL) {
                        DEBUG(1, ("TALLOC_ARRAY failed\n"));
                        result = NT_STATUS_NO_MEMORY;
@@ -795,11 +932,8 @@ NTSTATUS create_token_from_username(TALLOC_CTX *mem_ctx, const char *username,
                if ( lp_idmap_gid(&low, &high) && (gids[i] >= low) && (gids[i] <= high) )
                        continue;
 
-               if ( !gid_to_unix_groups_sid( gids[i], &unix_group_sid ) ) {
-                       DEBUG(1,("create_token_from_username: Failed to create SID "
-                               "for gid %u!\n", (unsigned int)gids[i]));
-                       continue;
-               }
+               gid_to_unix_groups_sid(gids[i], &unix_group_sid);
+
                result = add_sid_to_array_unique(tmp_ctx, &unix_group_sid,
                                                 &group_sids, &num_group_sids);
                if (!NT_STATUS_IS_OK(result)) {
@@ -829,13 +963,13 @@ NTSTATUS create_token_from_username(TALLOC_CTX *mem_ctx, const char *username,
  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 struct dom_sid *group_sid)
 {
        NTSTATUS status;
        uid_t uid;
        gid_t gid;
        char *found_username;
-       struct nt_user_token *token;
+       struct security_token *token;
        bool result;
        TALLOC_CTX *mem_ctx = talloc_stackframe();
 
@@ -858,7 +992,7 @@ bool user_in_group_sid(const char *username, const DOM_SID *group_sid)
 bool user_in_group(const char *username, const char *groupname)
 {
        TALLOC_CTX *mem_ctx = talloc_stackframe();
-       DOM_SID group_sid;
+       struct dom_sid group_sid;
        bool ret;
 
        ret = lookup_name(mem_ctx, groupname, LOOKUP_NAME_ALL,