source3/auth/token_util.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  Authentication utility functions
   4  *  Copyright (C) Andrew Tridgell 1992-1998
   5  *  Copyright (C) Andrew Bartlett 2001
   6  *  Copyright (C) Jeremy Allison 2000-2001
   7  *  Copyright (C) Rafal Szczesniak 2002
   8  *  Copyright (C) Volker Lendecke 2006
   9  *  Copyright (C) Michael Adam 2007
  10  *
  11  *  This program is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 3 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This program is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  23  */
  24
  25 /* functions moved from auth/auth_util.c to minimize linker deps */
  26
  27 #include "includes.h"
  28 #include "lib/util_unixsids.h"
  29 #include "system/passwd.h"
  30 #include "auth.h"
  31 #include "secrets.h"
  32 #include "../lib/util/memcache.h"
  33 #include "../librpc/gen_ndr/netlogon.h"
  34 #include "../libcli/security/security.h"
  35 #include "../lib/util/util_pw.h"
  36 #include "passdb.h"
  37 #include "lib/privileges.h"
  38
  39 /****************************************************************************
  40  Check for a SID in an struct security_token
  41 ****************************************************************************/
  42
  43 bool nt_token_check_sid ( const struct dom_sid *sid, const struct security_token *token )
  44 {
  45         if ( !sid || !token )
  46                 return False;
  47
  48         return security_token_has_sid(token, sid);
  49 }
  50
  51 bool nt_token_check_domain_rid( struct security_token *token, uint32_t rid )
  52 {
  53         struct dom_sid domain_sid;
  54
  55         /* if we are a domain member, the get the domain SID, else for
  56            a DC or standalone server, use our own SID */
  57
  58         if ( lp_server_role() == ROLE_DOMAIN_MEMBER ) {
  59                 if ( !secrets_fetch_domain_sid( lp_workgroup(),
  60                                                 &domain_sid ) ) {
  61                         DEBUG(1,("nt_token_check_domain_rid: Cannot lookup "
  62                                  "SID for domain [%s]\n", lp_workgroup()));
  63                         return False;
  64                 }
  65         }
  66         else
  67                 sid_copy( &domain_sid, get_global_sam_sid() );
  68
  69         sid_append_rid( &domain_sid, rid );
  70
  71         return nt_token_check_sid( &domain_sid, token );\
  72 }
  73
  74 /******************************************************************************
  75  Create a token for the root user to be used internally by smbd.
  76  This is similar to running under the context of the LOCAL_SYSTEM account
  77  in Windows.  This is a read-only token.  Do not modify it or free() it.
  78  Create a copy if you need to change it.
  79 ******************************************************************************/
  80
  81 NTSTATUS get_root_nt_token( struct security_token **token )
  82 {
  83         struct security_token *for_cache;
  84         struct dom_sid u_sid, g_sid;
  85         struct passwd *pw;
  86         void *cache_data;
  87         NTSTATUS status = NT_STATUS_OK;
  88
  89         cache_data = memcache_lookup_talloc(
  90                 NULL, SINGLETON_CACHE_TALLOC,
  91                 data_blob_string_const_null("root_nt_token"));
  92
  93         if (cache_data != NULL) {
  94                 *token = talloc_get_type_abort(
  95                         cache_data, struct security_token);
  96                 return NT_STATUS_OK;
  97         }
  98
  99         if ( !(pw = getpwuid(0)) ) {
 100                 if ( !(pw = getpwnam("root")) ) {
 101                         DBG_ERR("get_root_nt_token: both getpwuid(0) "
 102                                 "and getpwnam(\"root\") failed!\n");
 103                         return NT_STATUS_NO_SUCH_USER;
 104                 }
 105         }
 106
 107         /* get the user and primary group SIDs; although the
 108            BUILTIN\Administrators SId is really the one that matters here */
 109
 110         uid_to_sid(&u_sid, pw->pw_uid);
 111         gid_to_sid(&g_sid, pw->pw_gid);
 112
 113         status = create_local_nt_token(talloc_tos(), &u_sid, False,
 114                                       1, &global_sid_Builtin_Administrators, token);
 115         if (!NT_STATUS_IS_OK(status)) {
 116                 return status;
 117         }
 118
 119         security_token_set_privilege(*token, SEC_PRIV_DISK_OPERATOR);
 120
 121         for_cache = *token;
 122
 123         memcache_add_talloc(
 124                 NULL, SINGLETON_CACHE_TALLOC,
 125                 data_blob_string_const_null("root_nt_token"), &for_cache);
 126
 127         return status;
 128 }
 129
 130
 131 /*
 132  * Add alias SIDs from memberships within the partially created token SID list
 133  */
 134
 135 NTSTATUS add_aliases(const struct dom_sid *domain_sid,
 136                      struct security_token *token)
 137 {
 138         uint32_t *aliases;
 139         size_t i, num_aliases;
 140         NTSTATUS status;
 141         TALLOC_CTX *tmp_ctx;
 142
 143         if (!(tmp_ctx = talloc_init("add_aliases"))) {
 144                 return NT_STATUS_NO_MEMORY;
 145         }
 146
 147         aliases = NULL;
 148         num_aliases = 0;
 149
 150         status = pdb_enum_alias_memberships(tmp_ctx, domain_sid,
 151                                             token->sids,
 152                                             token->num_sids,
 153                                             &aliases, &num_aliases);
 154
 155         if (!NT_STATUS_IS_OK(status)) {
 156                 DEBUG(10, ("pdb_enum_alias_memberships failed: %s\n",
 157                            nt_errstr(status)));
 158                 goto done;
 159         }
 160
 161         for (i=0; i<num_aliases; i++) {
 162                 struct dom_sid alias_sid;
 163                 sid_compose(&alias_sid, domain_sid, aliases[i]);
 164                 status = add_sid_to_array_unique(token, &alias_sid,
 165                                                  &token->sids,
 166                                                  &token->num_sids);
 167                 if (!NT_STATUS_IS_OK(status)) {
 168                         DEBUG(0, ("add_sid_to_array failed\n"));
 169                         goto done;
 170                 }
 171         }
 172
 173 done:
 174         TALLOC_FREE(tmp_ctx);
 175         return NT_STATUS_OK;
 176 }
 177
 178 /*******************************************************************
 179 *******************************************************************/
 180
 181 static NTSTATUS add_builtin_administrators(struct security_token *token,
 182                                            const struct dom_sid *dom_sid)
 183 {
 184         struct dom_sid domadm;
 185         NTSTATUS status;
 186
 187         /* nothing to do if we aren't in a domain */
 188
 189         if ( !(IS_DC || lp_server_role()==ROLE_DOMAIN_MEMBER) ) {
 190                 return NT_STATUS_OK;
 191         }
 192
 193         /* Find the Domain Admins SID */
 194
 195         if ( IS_DC ) {
 196                 sid_copy( &domadm, get_global_sam_sid() );
 197         } else {
 198                 if (dom_sid == NULL) {
 199                         return NT_STATUS_INVALID_PARAMETER_MIX;
 200                 }
 201                 sid_copy(&domadm, dom_sid);
 202         }
 203         sid_append_rid( &domadm, DOMAIN_RID_ADMINS );
 204
 205         /* Add Administrators if the user beloongs to Domain Admins */
 206
 207         if ( nt_token_check_sid( &domadm, token ) ) {
 208                 status = add_sid_to_array(token,
 209                                           &global_sid_Builtin_Administrators,
 210                                           &token->sids, &token->num_sids);
 211         if (!NT_STATUS_IS_OK(status)) {
 212                         return status;
 213                 }
 214         }
 215
 216         return NT_STATUS_OK;
 217 }
 218
 219 static NTSTATUS add_builtin_guests(struct security_token *token,
 220                                    const struct dom_sid *dom_sid)
 221 {
 222         struct dom_sid tmp_sid;
 223         NTSTATUS status;
 224
 225         /*
 226          * First check the local GUEST account.
 227          */
 228         sid_compose(&tmp_sid, get_global_sam_sid(), DOMAIN_RID_GUEST);
 229
 230         if (nt_token_check_sid(&tmp_sid, token)) {
 231                 status = add_sid_to_array_unique(token,
 232                                         &global_sid_Builtin_Guests,
 233                                         &token->sids, &token->num_sids);
 234                 if (!NT_STATUS_IS_OK(status)) {
 235                         return status;
 236                 }
 237
 238                 return NT_STATUS_OK;
 239         }
 240
 241         /*
 242          * First check the local GUESTS group.
 243          */
 244         sid_compose(&tmp_sid, get_global_sam_sid(), DOMAIN_RID_GUESTS);
 245
 246         if (nt_token_check_sid(&tmp_sid, token)) {
 247                 status = add_sid_to_array_unique(token,
 248                                         &global_sid_Builtin_Guests,
 249                                         &token->sids, &token->num_sids);
 250                 if (!NT_STATUS_IS_OK(status)) {
 251                         return status;
 252                 }
 253
 254                 return NT_STATUS_OK;
 255         }
 256
 257         if (lp_server_role() != ROLE_DOMAIN_MEMBER) {
 258                 return NT_STATUS_OK;
 259         }
 260
 261         if (dom_sid == NULL) {
 262                 return NT_STATUS_INVALID_PARAMETER_MIX;
 263         }
 264
 265         /*
 266          * First check the domain GUESTS group.
 267          */
 268         sid_copy(&tmp_sid, dom_sid);
 269         sid_append_rid(&tmp_sid, DOMAIN_RID_GUESTS);
 270
 271         if (nt_token_check_sid(&tmp_sid, token)) {
 272                 status = add_sid_to_array_unique(token,
 273                                         &global_sid_Builtin_Guests,
 274                                         &token->sids, &token->num_sids);
 275                 if (!NT_STATUS_IS_OK(status)) {
 276                         return status;
 277                 }
 278
 279                 return NT_STATUS_OK;
 280         }
 281
 282         return NT_STATUS_OK;
 283 }
 284
 285 static NTSTATUS add_local_groups(struct security_token *result,
 286                                  bool is_guest);
 287
 288 NTSTATUS get_user_sid_info3_and_extra(const struct netr_SamInfo3 *info3,
 289                                       const struct extra_auth_info *extra,
 290                                       struct dom_sid *sid)
 291 {
 292         /* USER SID */
 293         if (info3->base.rid == (uint32_t)(-1)) {
 294                 /* this is a signal the user was fake and generated,
 295                  * the actual SID we want to use is stored in the extra
 296                  * sids */
 297                 if (is_null_sid(&extra->user_sid)) {
 298                         /* we couldn't find the user sid, bail out */
 299                         DEBUG(3, ("Invalid user SID\n"));
 300                         return NT_STATUS_UNSUCCESSFUL;
 301                 }
 302                 sid_copy(sid, &extra->user_sid);
 303         } else {
 304                 sid_copy(sid, info3->base.domain_sid);
 305                 sid_append_rid(sid, info3->base.rid);
 306         }
 307         return NT_STATUS_OK;
 308 }
 309
 310 NTSTATUS create_local_nt_token_from_info3(TALLOC_CTX *mem_ctx,
 311                                           bool is_guest,
 312                                           const struct netr_SamInfo3 *info3,
 313                                           const struct extra_auth_info *extra,
 314                                           struct security_token **ntok)
 315 {
 316         struct security_token *usrtok = NULL;
 317         uint32_t session_info_flags = 0;
 318         NTSTATUS status;
 319         int i;
 320
 321         DEBUG(10, ("Create local NT token for %s\n",
 322                    info3->base.account_name.string));
 323
 324         usrtok = talloc_zero(mem_ctx, struct security_token);
 325         if (!usrtok) {
 326                 DEBUG(0, ("talloc failed\n"));
 327                 return NT_STATUS_NO_MEMORY;
 328         }
 329
 330         /* Add the user and primary group sid FIRST */
 331         /* check if the user rid is the special "Domain Guests" rid.
 332          * If so pick the first sid for the extra sids instead as it
 333          * is a local fake account */
 334         usrtok->sids = talloc_array(usrtok, struct dom_sid, 2);
 335         if (!usrtok->sids) {
 336                 TALLOC_FREE(usrtok);
 337                 return NT_STATUS_NO_MEMORY;
 338         }
 339         usrtok->num_sids = 2;
 340
 341         status = get_user_sid_info3_and_extra(info3, extra, &usrtok->sids[0]);
 342         if (!NT_STATUS_IS_OK(status)) {
 343                 TALLOC_FREE(usrtok);
 344                 return status;
 345         }
 346
 347         /* GROUP SID */
 348         if (info3->base.primary_gid == (uint32_t)(-1)) {
 349                 /* this is a signal the user was fake and generated,
 350                  * the actual SID we want to use is stored in the extra
 351                  * sids */
 352                 if (is_null_sid(&extra->pgid_sid)) {
 353                         /* we couldn't find the user sid, bail out */
 354                         DEBUG(3, ("Invalid group SID\n"));
 355                         TALLOC_FREE(usrtok);
 356                         return NT_STATUS_UNSUCCESSFUL;
 357                 }
 358                 sid_copy(&usrtok->sids[1], &extra->pgid_sid);
 359         } else {
 360                 sid_copy(&usrtok->sids[1], info3->base.domain_sid);
 361                 sid_append_rid(&usrtok->sids[1],
 362                                 info3->base.primary_gid);
 363         }
 364
 365         /* Now the SIDs we got from authentication. These are the ones from
 366          * the info3 struct or from the pdb_enum_group_memberships, depending
 367          * on who authenticated the user.
 368          * Note that we start the for loop at "1" here, we already added the
 369          * first group sid as primary above. */
 370
 371         for (i = 0; i < info3->base.groups.count; i++) {
 372                 struct dom_sid tmp_sid;
 373
 374                 sid_copy(&tmp_sid, info3->base.domain_sid);
 375                 sid_append_rid(&tmp_sid, info3->base.groups.rids[i].rid);
 376
 377                 status = add_sid_to_array_unique(usrtok, &tmp_sid,
 378                                                  &usrtok->sids,
 379                                                  &usrtok->num_sids);
 380                 if (!NT_STATUS_IS_OK(status)) {
 381                         DEBUG(3, ("Failed to add SID to nt token\n"));
 382                         TALLOC_FREE(usrtok);
 383                         return status;
 384                 }
 385         }
 386
 387         /* now also add extra sids if they are not the special user/group
 388          * sids */
 389         for (i = 0; i < info3->sidcount; i++) {
 390                 status = add_sid_to_array_unique(usrtok,
 391                                                  info3->sids[i].sid,
 392                                                  &usrtok->sids,
 393                                                  &usrtok->num_sids);
 394                 if (!NT_STATUS_IS_OK(status)) {
 395                         DEBUG(3, ("Failed to add SID to nt token\n"));
 396                         TALLOC_FREE(usrtok);
 397                         return status;
 398                 }
 399         }
 400
 401         status = add_local_groups(usrtok, is_guest);
 402         if (!NT_STATUS_IS_OK(status)) {
 403                 DEBUG(3, ("Failed to add local groups\n"));
 404                 TALLOC_FREE(usrtok);
 405                 return status;
 406         }
 407
 408         session_info_flags |= AUTH_SESSION_INFO_DEFAULT_GROUPS;
 409         if (!is_guest) {
 410                 session_info_flags |= AUTH_SESSION_INFO_AUTHENTICATED;
 411         }
 412
 413         status = finalize_local_nt_token(usrtok, session_info_flags);
 414         if (!NT_STATUS_IS_OK(status)) {
 415                 DEBUG(3, ("Failed to finalize nt token\n"));
 416                 TALLOC_FREE(usrtok);
 417                 return status;
 418         }
 419
 420         *ntok = usrtok;
 421         return NT_STATUS_OK;
 422 }
 423
 424 /*******************************************************************
 425  Create a NT token for the user, expanding local aliases
 426 *******************************************************************/
 427
 428 NTSTATUS create_local_nt_token(TALLOC_CTX *mem_ctx,
 429                                             const struct dom_sid *user_sid,
 430                                             bool is_guest,
 431                                             int num_groupsids,
 432                                             const struct dom_sid *groupsids,
 433                                             struct security_token **token)
 434 {
 435         struct security_token *result = NULL;
 436         int i;
 437         NTSTATUS status;
 438         uint32_t session_info_flags = 0;
 439         struct dom_sid_buf buf;
 440
 441         DEBUG(10, ("Create local NT token for %s\n",
 442                    dom_sid_str_buf(user_sid, &buf)));
 443
 444         if (!(result = talloc_zero(mem_ctx, struct security_token))) {
 445                 DEBUG(0, ("talloc failed\n"));
 446                 status = NT_STATUS_NO_MEMORY;
 447                 goto err;
 448         }
 449
 450         /* Add the user and primary group sid */
 451
 452         status = add_sid_to_array(result, user_sid,
 453                                   &result->sids, &result->num_sids);
 454         if (!NT_STATUS_IS_OK(status)) {
 455                 goto err;
 456         }
 457
 458         /* For guest, num_groupsids may be zero. */
 459         if (num_groupsids) {
 460                 status = add_sid_to_array(result, &groupsids[0],
 461                                           &result->sids,
 462                                           &result->num_sids);
 463                 if (!NT_STATUS_IS_OK(status)) {
 464                         goto err;
 465                 }
 466         }
 467
 468         /* Now the SIDs we got from authentication. These are the ones from
 469          * the info3 struct or from the pdb_enum_group_memberships, depending
 470          * on who authenticated the user.
 471          * Note that we start the for loop at "1" here, we already added the
 472          * first group sid as primary above. */
 473
 474         for (i=1; i<num_groupsids; i++) {
 475                 status = add_sid_to_array_unique(result, &groupsids[i],
 476                                                  &result->sids,
 477                                                  &result->num_sids);
 478                 if (!NT_STATUS_IS_OK(status)) {
 479                         goto err;
 480                 }
 481         }
 482
 483         status = add_local_groups(result, is_guest);
 484         if (!NT_STATUS_IS_OK(status)) {
 485                 goto err;
 486         }
 487
 488         session_info_flags |= AUTH_SESSION_INFO_DEFAULT_GROUPS;
 489         if (!is_guest) {
 490                 session_info_flags |= AUTH_SESSION_INFO_AUTHENTICATED;
 491         }
 492
 493         status = finalize_local_nt_token(result, session_info_flags);
 494         if (!NT_STATUS_IS_OK(status)) {
 495                 goto err;
 496         }
 497
 498         if (is_guest) {
 499                 /*
 500                  * It's ugly, but for now it's
 501                  * needed to add Builtin_Guests
 502                  * here, the "local" token only
 503                  * consist of S-1-22-* SIDs
 504                  * and finalize_local_nt_token()
 505                  * doesn't have the chance to
 506                  * to detect it need to
 507                  * add Builtin_Guests via
 508                  * add_builtin_guests().
 509                  */
 510                 status = add_sid_to_array_unique(result,
 511                                                  &global_sid_Builtin_Guests,
 512                                                  &result->sids,
 513                                                  &result->num_sids);
 514                 if (!NT_STATUS_IS_OK(status)) {
 515                         DEBUG(3, ("Failed to add SID to nt token\n"));
 516                         goto err;
 517                 }
 518         }
 519
 520         *token = result;
 521         return NT_STATUS_SUCCESS;
 522
 523 err:
 524         TALLOC_FREE(result);
 525         return status;
 526 }
 527
 528 /***************************************************
 529  Merge in any groups from /etc/group.
 530 ***************************************************/
 531
 532 static NTSTATUS add_local_groups(struct security_token *result,
 533                                  bool is_guest)
 534 {
 535         gid_t *gids = NULL;
 536         uint32_t getgroups_num_group_sids = 0;
 537         struct passwd *pass = NULL;
 538         TALLOC_CTX *tmp_ctx = talloc_stackframe();
 539         int i;
 540
 541         if (is_guest) {
 542                 /*
 543                  * Guest is a special case. It's always
 544                  * a user that can be looked up, but
 545                  * result->sids[0] is set to DOMAIN\Guest.
 546                  * Lookup by account name instead.
 547                  */
 548                 pass = Get_Pwnam_alloc(tmp_ctx, lp_guest_account());
 549         } else {
 550                 uid_t uid;
 551
 552                 /* For non-guest result->sids[0] is always the user sid. */
 553                 if (!sid_to_uid(&result->sids[0], &uid)) {
 554                         /*
 555                          * Non-mappable SID like SYSTEM.
 556                          * Can't be in any /etc/group groups.
 557                          */
 558                         TALLOC_FREE(tmp_ctx);
 559                         return NT_STATUS_OK;
 560                 }
 561
 562                 pass = getpwuid_alloc(tmp_ctx, uid);
 563                 if (pass == NULL) {
 564                         struct dom_sid_buf buf;
 565                         DBG_ERR("SID %s -> getpwuid(%u) failed, is nsswitch configured?\n",
 566                                 dom_sid_str_buf(&result->sids[0], &buf),
 567                                 (unsigned int)uid);
 568                         TALLOC_FREE(tmp_ctx);
 569                         return NT_STATUS_NO_SUCH_USER;
 570                 }
 571         }
 572
 573         if (!pass) {
 574                 TALLOC_FREE(tmp_ctx);
 575                 return NT_STATUS_UNSUCCESSFUL;
 576         }
 577
 578         /*
 579          * Now we must get any groups this user has been
 580          * added to in /etc/group and merge them in.
 581          * This has to be done in every code path
 582          * that creates an NT token, as remote users
 583          * may have been added to the local /etc/group
 584          * database. Tokens created merely from the
 585          * info3 structs (via the DC or via the krb5 PAC)
 586          * won't have these local groups. Note the
 587          * groups added here will only be UNIX groups
 588          * (S-1-22-2-XXXX groups) as getgroups_unix_user()
 589          * turns off winbindd before calling getgroups().
 590          *
 591          * NB. This is duplicating work already
 592          * done in the 'unix_user:' case of
 593          * create_token_from_sid() but won't
 594          * do anything other than be inefficient
 595          * in that case.
 596          */
 597
 598         if (!getgroups_unix_user(tmp_ctx, pass->pw_name, pass->pw_gid,
 599                         &gids, &getgroups_num_group_sids)) {
 600                 DEBUG(1, ("getgroups_unix_user for user %s failed\n",
 601                         pass->pw_name));
 602                 TALLOC_FREE(tmp_ctx);
 603                 return NT_STATUS_UNSUCCESSFUL;
 604         }
 605
 606         for (i=0; i<getgroups_num_group_sids; i++) {
 607                 NTSTATUS status;
 608                 struct dom_sid grp_sid;
 609                 gid_to_sid(&grp_sid, gids[i]);
 610
 611                 status = add_sid_to_array_unique(result,
 612                                          &grp_sid,
 613                                          &result->sids,
 614                                          &result->num_sids);
 615                 if (!NT_STATUS_IS_OK(status)) {
 616                         DEBUG(3, ("Failed to add UNIX SID to nt token\n"));
 617                         TALLOC_FREE(tmp_ctx);
 618                         return status;
 619                 }
 620         }
 621         TALLOC_FREE(tmp_ctx);
 622         return NT_STATUS_OK;
 623 }
 624
 625 NTSTATUS finalize_local_nt_token(struct security_token *result,
 626                                  uint32_t session_info_flags)
 627 {
 628         struct dom_sid _dom_sid = { 0, };
 629         struct dom_sid *domain_sid = NULL;
 630         NTSTATUS status;
 631         struct acct_info *info;
 632         bool ok;
 633
 634         result->privilege_mask = 0;
 635         result->rights_mask = 0;
 636
 637         if (result->num_sids == 0) {
 638                 return NT_STATUS_INVALID_TOKEN;
 639         }
 640
 641         if (session_info_flags & AUTH_SESSION_INFO_DEFAULT_GROUPS) {
 642                 status = add_sid_to_array(result, &global_sid_World,
 643                                           &result->sids, &result->num_sids);
 644                 if (!NT_STATUS_IS_OK(status)) {
 645                         return status;
 646                 }
 647                 status = add_sid_to_array(result, &global_sid_Network,
 648                                           &result->sids, &result->num_sids);
 649                 if (!NT_STATUS_IS_OK(status)) {
 650                         return status;
 651                 }
 652         }
 653
 654         /*
 655          * Don't expand nested groups of system, anonymous etc
 656          *
 657          * Note that they still get SID_WORLD and SID_NETWORK
 658          * for now in order let existing tests pass.
 659          *
 660          * But SYSTEM doesn't get AUTHENTICATED_USERS
 661          * and ANONYMOUS doesn't get BUILTIN GUESTS anymore.
 662          */
 663         if (security_token_is_anonymous(result)) {
 664                 return NT_STATUS_OK;
 665         }
 666         if (security_token_is_system(result)) {
 667                 result->privilege_mask = ~0;
 668                 return NT_STATUS_OK;
 669         }
 670
 671         if (session_info_flags & AUTH_SESSION_INFO_AUTHENTICATED) {
 672                 status = add_sid_to_array(result,
 673                                           &global_sid_Authenticated_Users,
 674                                           &result->sids,
 675                                           &result->num_sids);
 676                 if (!NT_STATUS_IS_OK(status)) {
 677                         return status;
 678                 }
 679         }
 680
 681         /* Add in BUILTIN sids */
 682
 683         become_root();
 684         ok = secrets_fetch_domain_sid(lp_workgroup(), &_dom_sid);
 685         if (ok) {
 686                 domain_sid = &_dom_sid;
 687         } else {
 688                 DEBUG(3, ("Failed to fetch domain sid for %s\n",
 689                           lp_workgroup()));
 690         }
 691         unbecome_root();
 692
 693         info = talloc_zero(talloc_tos(), struct acct_info);
 694         if (info == NULL) {
 695                 DEBUG(0, ("talloc failed!\n"));
 696                 return NT_STATUS_NO_MEMORY;
 697         }
 698
 699         /* Deal with the BUILTIN\Administrators group.  If the SID can
 700            be resolved then assume that the add_aliasmem( S-1-5-32 )
 701            handled it. */
 702
 703         status = pdb_get_aliasinfo(&global_sid_Builtin_Administrators, info);
 704         if (!NT_STATUS_IS_OK(status)) {
 705
 706                 become_root();
 707                 status = create_builtin_administrators(domain_sid);
 708                 unbecome_root();
 709
 710                 if (NT_STATUS_EQUAL(status, NT_STATUS_PROTOCOL_UNREACHABLE)) {
 711                         /* Add BUILTIN\Administrators directly to token. */
 712                         status = add_builtin_administrators(result, domain_sid);
 713                         if ( !NT_STATUS_IS_OK(status) ) {
 714                                 DEBUG(3, ("Failed to check for local "
 715                                           "Administrators membership (%s)\n",
 716                                           nt_errstr(status)));
 717                         }
 718                 } else if (!NT_STATUS_IS_OK(status)) {
 719                         DEBUG(2, ("WARNING: Failed to create "
 720                                   "BUILTIN\\Administrators group!  Can "
 721                                   "Winbind allocate gids?\n"));
 722                 }
 723         }
 724
 725         /* Deal with the BUILTIN\Users group.  If the SID can
 726            be resolved then assume that the add_aliasmem( S-1-5-32 )
 727            handled it. */
 728
 729         status = pdb_get_aliasinfo(&global_sid_Builtin_Users, info);
 730         if (!NT_STATUS_IS_OK(status)) {
 731
 732                 become_root();
 733                 status = create_builtin_users(domain_sid);
 734                 unbecome_root();
 735
 736                 if (!NT_STATUS_EQUAL(status, NT_STATUS_PROTOCOL_UNREACHABLE) &&
 737                     !NT_STATUS_IS_OK(status))
 738                 {
 739                         DEBUG(2, ("WARNING: Failed to create BUILTIN\\Users group! "
 740                                   "Can Winbind allocate gids?\n"));
 741                 }
 742         }
 743
 744         /*
 745          * Deal with the BUILTIN\Guests group.  If the SID can
 746          * be resolved then assume that the add_aliasmem( S-1-5-32 )
 747          * handled it.
 748          */
 749         status = pdb_get_aliasinfo(&global_sid_Builtin_Guests, info);
 750         if (!NT_STATUS_IS_OK(status)) {
 751
 752                 become_root();
 753                 status = create_builtin_guests(domain_sid);
 754                 unbecome_root();
 755
 756                 /*
 757                  * NT_STATUS_PROTOCOL_UNREACHABLE:
 758                  * => winbindd is not running.
 759                  *
 760                  * NT_STATUS_ACCESS_DENIED:
 761                  * => no idmap config at all
 762                  * and wbint_AllocateGid()/winbind_allocate_gid()
 763                  * failed.
 764                  *
 765                  * NT_STATUS_NO_SUCH_GROUP:
 766                  * => no idmap config at all and
 767                  * "tdbsam:map builtin = no" means
 768                  * wbint_Sids2UnixIDs() fails.
 769                  */
 770                 if (NT_STATUS_EQUAL(status, NT_STATUS_PROTOCOL_UNREACHABLE) ||
 771                     NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED) ||
 772                     NT_STATUS_EQUAL(status, NT_STATUS_NO_SUCH_GROUP)) {
 773                         /*
 774                          * Add BUILTIN\Guests directly to token.
 775                          * But only if the token already indicates
 776                          * real guest access by:
 777                          * - local GUEST account
 778                          * - local GUESTS group
 779                          * - domain GUESTS group
 780                          *
 781                          * Even if a user was authenticated, it
 782                          * can be member of a guest related group.
 783                          */
 784                         status = add_builtin_guests(result, domain_sid);
 785                         if (!NT_STATUS_IS_OK(status)) {
 786                                 DEBUG(3, ("Failed to check for local "
 787                                           "Guests membership (%s)\n",
 788                                           nt_errstr(status)));
 789                                 /*
 790                                  * This is a hard error.
 791                                  */
 792                                 return status;
 793                         }
 794                 } else if (!NT_STATUS_IS_OK(status)) {
 795                         DEBUG(2, ("Failed to create "
 796                                   "BUILTIN\\Guests group %s!  Can "
 797                                   "Winbind allocate gids?\n",
 798                                   nt_errstr(status)));
 799                         /*
 800                          * This is a hard error.
 801                          */
 802                         return status;
 803                 }
 804         }
 805
 806         TALLOC_FREE(info);
 807
 808         /* Deal with local groups */
 809
 810         if (lp_winbind_nested_groups()) {
 811
 812                 become_root();
 813
 814                 /* Now add the aliases. First the one from our local SAM */
 815
 816                 status = add_aliases(get_global_sam_sid(), result);
 817
 818                 if (!NT_STATUS_IS_OK(status)) {
 819                         unbecome_root();
 820                         return status;
 821                 }
 822
 823                 /* Finally the builtin ones */
 824
 825                 status = add_aliases(&global_sid_Builtin, result);
 826
 827                 if (!NT_STATUS_IS_OK(status)) {
 828                         unbecome_root();
 829                         return status;
 830                 }
 831
 832                 unbecome_root();
 833         }
 834
 835         if (session_info_flags & AUTH_SESSION_INFO_NTLM) {
 836                 struct dom_sid tmp_sid = { 0, };
 837
 838                 ok = dom_sid_parse(SID_NT_NTLM_AUTHENTICATION, &tmp_sid);
 839                 if (!ok) {
 840                         return NT_STATUS_NO_MEMORY;
 841                 }
 842
 843                 status = add_sid_to_array(result,
 844                                           &tmp_sid,
 845                                           &result->sids,
 846                                           &result->num_sids);
 847                 if (!NT_STATUS_IS_OK(status)) {
 848                         return status;
 849                 }
 850         }
 851
 852         if (session_info_flags & AUTH_SESSION_INFO_SIMPLE_PRIVILEGES) {
 853                 if (security_token_has_builtin_administrators(result)) {
 854                         result->privilege_mask = ~0;
 855                 }
 856         } else {
 857                 /* Add privileges based on current user sids */
 858                 get_privileges_for_sids(&result->privilege_mask, result->sids,
 859                                         result->num_sids);
 860         }
 861
 862         return NT_STATUS_OK;
 863 }
 864
 865 /****************************************************************************
 866  prints a UNIX 'token' to debug output.
 867 ****************************************************************************/
 868
 869 void debug_unix_user_token(int dbg_class, int dbg_lev, uid_t uid, gid_t gid,
 870                            int n_groups, gid_t *groups)
 871 {
 872         int     i;
 873         DEBUGC(dbg_class, dbg_lev,
 874                ("UNIX token of user %ld\n", (long int)uid));
 875
 876         DEBUGADDC(dbg_class, dbg_lev,
 877                   ("Primary group is %ld and contains %i supplementary "
 878                    "groups\n", (long int)gid, n_groups));
 879         for (i = 0; i < n_groups; i++)
 880                 DEBUGADDC(dbg_class, dbg_lev, ("Group[%3i]: %ld\n", i,
 881                         (long int)groups[i]));
 882 }
 883
 884 /*
 885  * Create an artificial NT token given just a domain SID.
 886  *
 887  * We have 3 cases:
 888  *
 889  * unmapped unix users: Go directly to nss to find the user's group.
 890  *
 891  * A passdb user: The list of groups is provided by pdb_enum_group_memberships.
 892  *
 893  * If the user is provided by winbind, the primary gid is set to "domain
 894  * users" of the user's domain. For an explanation why this is necessary, see
 895  * the thread starting at
 896  * http://lists.samba.org/archive/samba-technical/2006-January/044803.html.
 897  */
 898
 899 static NTSTATUS create_token_from_sid(TALLOC_CTX *mem_ctx,
 900                                       const struct dom_sid *user_sid,
 901                                       bool is_guest,
 902                                       uid_t *uid, gid_t *gid,
 903                                       char **found_username,
 904                                       struct security_token **token)
 905 {
 906         NTSTATUS result = NT_STATUS_NO_SUCH_USER;
 907         TALLOC_CTX *tmp_ctx = talloc_stackframe();
 908         gid_t *gids;
 909         struct dom_sid *group_sids;
 910         struct dom_sid tmp_sid;
 911         uint32_t num_group_sids;
 912         uint32_t num_gids;
 913         uint32_t i;
 914         uint32_t high, low;
 915         bool range_ok;
 916         struct dom_sid_buf buf;
 917
 918         if (sid_check_is_in_our_sam(user_sid)) {
 919                 bool ret;
 920                 uint32_t pdb_num_group_sids;
 921                 /* This is a passdb user, so ask passdb */
 922
 923                 struct samu *sam_acct = NULL;
 924
 925                 if ( !(sam_acct = samu_new( tmp_ctx )) ) {
 926                         result = NT_STATUS_NO_MEMORY;
 927                         goto done;
 928                 }
 929
 930                 become_root();
 931                 ret = pdb_getsampwsid(sam_acct, user_sid);
 932                 unbecome_root();
 933
 934                 if (!ret) {
 935                         DEBUG(1, ("pdb_getsampwsid(%s) failed\n",
 936                                   dom_sid_str_buf(user_sid, &buf)));
 937                         DEBUGADD(1, ("Fall back to unix user\n"));
 938                         goto unix_user;
 939                 }
 940
 941                 result = pdb_enum_group_memberships(tmp_ctx, sam_acct,
 942                                                     &group_sids, &gids,
 943                                                     &pdb_num_group_sids);
 944                 if (!NT_STATUS_IS_OK(result)) {
 945                         DEBUG(1, ("enum_group_memberships failed for %s: "
 946                                   "%s\n",
 947                                   dom_sid_str_buf(user_sid, &buf),
 948                                   nt_errstr(result)));
 949                         DEBUGADD(1, ("Fall back to unix uid lookup\n"));
 950                         goto unix_user;
 951                 }
 952                 num_group_sids = pdb_num_group_sids;
 953
 954                 /* see the smb_panic() in pdb_default_enum_group_memberships */
 955                 SMB_ASSERT(num_group_sids > 0);
 956
 957                 /* Ensure we're returning the found_username on the right context. */
 958                 *found_username = talloc_strdup(mem_ctx,
 959                                                 pdb_get_username(sam_acct));
 960
 961                 if (*found_username == NULL) {
 962                         result = NT_STATUS_NO_MEMORY;
 963                         goto done;
 964                 }
 965
 966                 /*
 967                  * If the SID from lookup_name() was the guest sid, passdb knows
 968                  * about the mapping of guest sid to lp_guest_account()
 969                  * username and will return the unix_pw info for a guest
 970                  * user. Use it if it's there, else lookup the *uid details
 971                  * using Get_Pwnam_alloc(). See bug #6291 for details. JRA.
 972                  */
 973
 974                 /* We must always assign the *uid. */
 975                 if (sam_acct->unix_pw == NULL) {
 976                         struct passwd *pwd = Get_Pwnam_alloc(sam_acct, *found_username );
 977                         if (!pwd) {
 978                                 DEBUG(10, ("Get_Pwnam_alloc failed for %s\n",
 979                                         *found_username));
 980                                 result = NT_STATUS_NO_SUCH_USER;
 981                                 goto done;
 982                         }
 983                         result = samu_set_unix(sam_acct, pwd );
 984                         if (!NT_STATUS_IS_OK(result)) {
 985                                 DEBUG(10, ("samu_set_unix failed for %s\n",
 986                                         *found_username));
 987                                 result = NT_STATUS_NO_SUCH_USER;
 988                                 goto done;
 989                         }
 990                 }
 991                 *uid = sam_acct->unix_pw->pw_uid;
 992
 993         } else  if (sid_check_is_in_unix_users(user_sid)) {
 994                 uint32_t getgroups_num_group_sids;
 995                 /* This is a unix user not in passdb. We need to ask nss
 996                  * directly, without consulting passdb */
 997
 998                 struct passwd *pass;
 999
1000                 /*
1001                  * This goto target is used as a fallback for the passdb
1002                  * case. The concrete bug report is when passdb gave us an
1003                  * unmapped gid.
1004                  */
1005
1006         unix_user:
1007
1008                 if (!sid_to_uid(user_sid, uid)) {
1009                         DEBUG(1, ("unix_user case, sid_to_uid for %s failed\n",
1010                                   dom_sid_str_buf(user_sid, &buf)));
1011                         result = NT_STATUS_NO_SUCH_USER;
1012                         goto done;
1013                 }
1014
1015                 uid_to_unix_users_sid(*uid, &tmp_sid);
1016                 user_sid = &tmp_sid;
1017
1018                 pass = getpwuid_alloc(tmp_ctx, *uid);
1019                 if (pass == NULL) {
1020                         DEBUG(1, ("getpwuid(%u) failed\n",
1021                                   (unsigned int)*uid));
1022                         goto done;
1023                 }
1024
1025                 if (!getgroups_unix_user(tmp_ctx, pass->pw_name, pass->pw_gid,
1026                                          &gids, &getgroups_num_group_sids)) {
1027                         DEBUG(1, ("getgroups_unix_user for user %s failed\n",
1028                                   pass->pw_name));
1029                         goto done;
1030                 }
1031                 num_group_sids = getgroups_num_group_sids;
1032
1033                 group_sids = talloc_array(tmp_ctx, struct dom_sid, num_group_sids);
1034                 if (group_sids == NULL) {
1035                         DEBUG(1, ("talloc_array failed\n"));
1036                         result = NT_STATUS_NO_MEMORY;
1037                         goto done;
1038                 }
1039
1040                 for (i=0; i<num_group_sids; i++) {
1041                         gid_to_sid(&group_sids[i], gids[i]);
1042                 }
1043
1044                 /* In getgroups_unix_user we always set the primary gid */
1045                 SMB_ASSERT(num_group_sids > 0);
1046
1047                 /* Ensure we're returning the found_username on the right context. */
1048                 *found_username = talloc_strdup(mem_ctx, pass->pw_name);
1049                 if (*found_username == NULL) {
1050                         result = NT_STATUS_NO_MEMORY;
1051                         goto done;
1052                 }
1053         } else {
1054
1055                 /* This user is from winbind, force the primary gid to the
1056                  * user's "domain users" group. Under certain circumstances
1057                  * (user comes from NT4), this might be a loss of
1058                  * information. But we can not rely on winbind getting the
1059                  * correct info. AD might prohibit winbind looking up that
1060                  * information. */
1061
1062                 /* We must always assign the *uid. */
1063                 if (!sid_to_uid(user_sid, uid)) {
1064                         DEBUG(1, ("winbindd case, sid_to_uid for %s failed\n",
1065                                   dom_sid_str_buf(user_sid, &buf)));
1066                         result = NT_STATUS_NO_SUCH_USER;
1067                         goto done;
1068                 }
1069
1070                 num_group_sids = 1;
1071                 group_sids = talloc_array(tmp_ctx, struct dom_sid, num_group_sids);
1072                 if (group_sids == NULL) {
1073                         DEBUG(1, ("talloc_array failed\n"));
1074                         result = NT_STATUS_NO_MEMORY;
1075                         goto done;
1076                 }
1077
1078                 gids = talloc_array(tmp_ctx, gid_t, num_group_sids);
1079                 if (gids == NULL) {
1080                         result = NT_STATUS_NO_MEMORY;
1081                         goto done;
1082                 }
1083
1084                 sid_copy(&group_sids[0], user_sid);
1085                 sid_split_rid(&group_sids[0], NULL);
1086                 sid_append_rid(&group_sids[0], DOMAIN_RID_USERS);
1087
1088                 if (!sid_to_gid(&group_sids[0], &gids[0])) {
1089                         DEBUG(1, ("sid_to_gid(%s) failed\n",
1090                                   dom_sid_str_buf(&group_sids[0], &buf)));
1091                         goto done;
1092                 }
1093
1094                 *found_username = NULL;
1095         }
1096
1097         *gid = gids[0];
1098
1099         /* Add the "Unix Group" SID for each gid to catch mapped groups
1100            and their Unix equivalent.  This is to solve the backwards
1101            compatibility problem of 'valid users = +ntadmin' where
1102            ntadmin has been paired with "Domain Admins" in the group
1103            mapping table.  Otherwise smb.conf would need to be changed
1104            to 'valid user = "Domain Admins"'.  --jerry */
1105
1106         num_gids = num_group_sids;
1107         range_ok = lp_idmap_default_range(&low, &high);
1108         for ( i=0; i<num_gids; i++ ) {
1109                 struct dom_sid unix_group_sid;
1110
1111                 /* don't pickup anything managed by Winbind */
1112                 if (range_ok && (gids[i] >= low) && (gids[i] <= high)) {
1113                         continue;
1114                 }
1115
1116                 gid_to_unix_groups_sid(gids[i], &unix_group_sid);
1117
1118                 result = add_sid_to_array_unique(tmp_ctx, &unix_group_sid,
1119                                                  &group_sids, &num_group_sids);
1120                 if (!NT_STATUS_IS_OK(result)) {
1121                         goto done;
1122                 }
1123         }
1124
1125         /* Ensure we're creating the nt_token on the right context. */
1126         result = create_local_nt_token(mem_ctx, user_sid,
1127                                        is_guest, num_group_sids, group_sids, token);
1128
1129         if (!NT_STATUS_IS_OK(result)) {
1130                 goto done;
1131         }
1132
1133         result = NT_STATUS_OK;
1134  done:
1135         TALLOC_FREE(tmp_ctx);
1136         return result;
1137 }
1138
1139 /*
1140  * Create an artificial NT token given just a username. (Initially intended
1141  * for force user)
1142  *
1143  * We go through lookup_name() to avoid problems we had with 'winbind use
1144  * default domain'.
1145  *
1146  * We have 3 cases:
1147  *
1148  * unmapped unix users: Go directly to nss to find the user's group.
1149  *
1150  * A passdb user: The list of groups is provided by pdb_enum_group_memberships.
1151  *
1152  * If the user is provided by winbind, the primary gid is set to "domain
1153  * users" of the user's domain. For an explanation why this is necessary, see
1154  * the thread starting at
1155  * http://lists.samba.org/archive/samba-technical/2006-January/044803.html.
1156  */
1157
1158 NTSTATUS create_token_from_username(TALLOC_CTX *mem_ctx, const char *username,
1159                                     bool is_guest,
1160                                     uid_t *uid, gid_t *gid,
1161                                     char **found_username,
1162                                     struct security_token **token)
1163 {
1164         NTSTATUS result = NT_STATUS_NO_SUCH_USER;
1165         TALLOC_CTX *tmp_ctx = talloc_stackframe();
1166         struct dom_sid user_sid;
1167         enum lsa_SidType type;
1168
1169         if (!lookup_name_smbconf(tmp_ctx, username, LOOKUP_NAME_ALL,
1170                          NULL, NULL, &user_sid, &type)) {
1171                 DEBUG(1, ("lookup_name_smbconf for %s failed\n", username));
1172                 goto done;
1173         }
1174
1175         if (type != SID_NAME_USER) {
1176                 DEBUG(1, ("%s is a %s, not a user\n", username,
1177                           sid_type_lookup(type)));
1178                 goto done;
1179         }
1180
1181         result = create_token_from_sid(mem_ctx, &user_sid, is_guest, uid, gid, found_username, token);
1182
1183         if (!NT_STATUS_IS_OK(result)) {
1184                 goto done;
1185         }
1186
1187         /*
1188          * If result == NT_STATUS_OK then
1189          * we know we have a valid token. Ensure
1190          * we also have a valid username to match.
1191          */
1192
1193         if (*found_username == NULL) {
1194                 *found_username = talloc_strdup(mem_ctx, username);
1195                 if (*found_username == NULL) {
1196                         result = NT_STATUS_NO_MEMORY;
1197                 }
1198         }
1199
1200 done:
1201         TALLOC_FREE(tmp_ctx);
1202         return result;
1203 }
1204
1205 /***************************************************************************
1206  Build upon create_token_from_sid:
1207
1208  Expensive helper function to figure out whether a user given its sid is
1209  member of a particular group.
1210 ***************************************************************************/
1211
1212 bool user_sid_in_group_sid(const struct dom_sid *sid, const struct dom_sid *group_sid)
1213 {
1214         NTSTATUS status;
1215         uid_t uid;
1216         gid_t gid;
1217         char *found_username;
1218         struct security_token *token;
1219         bool result = false;
1220         enum lsa_SidType type;
1221         TALLOC_CTX *mem_ctx = talloc_stackframe();
1222         struct dom_sid_buf buf;
1223
1224         if (!lookup_sid(mem_ctx, sid,
1225                          NULL, NULL, &type)) {
1226                 DEBUG(1, ("lookup_sid for %s failed\n",
1227                           dom_sid_str_buf(sid, &buf)));
1228                 goto done;
1229         }
1230
1231         if (type != SID_NAME_USER) {
1232                 DEBUG(5, ("%s is a %s, not a user\n",
1233                           dom_sid_str_buf(sid, &buf),
1234                           sid_type_lookup(type)));
1235                 goto done;
1236         }
1237
1238         status = create_token_from_sid(mem_ctx, sid, False,
1239                                        &uid, &gid, &found_username,
1240                                        &token);
1241
1242         if (!NT_STATUS_IS_OK(status)) {
1243                 DEBUG(10, ("could not create token for %s\n",
1244                            dom_sid_str_buf(sid, &buf)));
1245                 goto done;
1246         }
1247
1248         result = security_token_has_sid(token, group_sid);
1249
1250 done:
1251         TALLOC_FREE(mem_ctx);
1252         return result;
1253 }
1254
1255 /***************************************************************************
1256  Build upon create_token_from_username:
1257
1258  Expensive helper function to figure out whether a user given its name is
1259  member of a particular group.
1260 ***************************************************************************/
1261
1262 bool user_in_group_sid(const char *username, const struct dom_sid *group_sid)
1263 {
1264         NTSTATUS status;
1265         uid_t uid;
1266         gid_t gid;
1267         char *found_username;
1268         struct security_token *token;
1269         bool result;
1270         TALLOC_CTX *mem_ctx = talloc_stackframe();
1271
1272         status = create_token_from_username(mem_ctx, username, False,
1273                                             &uid, &gid, &found_username,
1274                                             &token);
1275
1276         if (!NT_STATUS_IS_OK(status)) {
1277                 DEBUG(10, ("could not create token for %s\n", username));
1278                 TALLOC_FREE(mem_ctx);
1279                 return False;
1280         }
1281
1282         result = security_token_has_sid(token, group_sid);
1283
1284         TALLOC_FREE(mem_ctx);
1285         return result;
1286 }
1287
1288 bool user_in_group(const char *username, const char *groupname)
1289 {
1290         TALLOC_CTX *mem_ctx = talloc_stackframe();
1291         struct dom_sid group_sid;
1292         bool ret;
1293
1294         ret = lookup_name(mem_ctx, groupname, LOOKUP_NAME_ALL,
1295                           NULL, NULL, &group_sid, NULL);
1296         TALLOC_FREE(mem_ctx);
1297
1298         if (!ret) {
1299                 DEBUG(10, ("lookup_name for (%s) failed.\n", groupname));
1300                 return False;
1301         }
1302
1303         return user_in_group_sid(username, &group_sid);
1304 }
1305
1306 /* END */