source3/lib/util_sid.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Samba utility functions
   4    Copyright (C) Andrew Tridgell                1992-1998
   5    Copyright (C) Luke Kenneth Caseson Leighton  1998-1999
   6    Copyright (C) Jeremy Allison                 1999
   7    Copyright (C) Stefan (metze) Metzmacher      2002
   8    Copyright (C) Simo Sorce                     2002
   9    Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2005
  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 #include "includes.h"
  26 #include "../librpc/gen_ndr/ndr_security.h"
  27 #include "../librpc/gen_ndr/netlogon.h"
  28 #include "../libcli/security/dom_sid.h"
  29
  30 /*
  31  * Some useful sids, more well known sids can be found at
  32  * http://support.microsoft.com/kb/243330/EN-US/
  33  */
  34
  35
  36 const struct dom_sid global_sid_World_Domain =               /* Everyone domain */
  37 { 1, 0, {0,0,0,0,0,1}, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  38 const struct dom_sid global_sid_World =                      /* Everyone */
  39 { 1, 1, {0,0,0,0,0,1}, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  40 const struct dom_sid global_sid_Creator_Owner_Domain =       /* Creator Owner domain */
  41 { 1, 0, {0,0,0,0,0,3}, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  42 const struct dom_sid global_sid_NT_Authority =                  /* NT Authority */
  43 { 1, 0, {0,0,0,0,0,5}, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  44 const struct dom_sid global_sid_System =                        /* System */
  45 { 1, 1, {0,0,0,0,0,5}, {18,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  46 const struct dom_sid global_sid_NULL =                          /* NULL sid */
  47 { 1, 1, {0,0,0,0,0,0}, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  48 const struct dom_sid global_sid_Authenticated_Users =   /* All authenticated rids */
  49 { 1, 1, {0,0,0,0,0,5}, {11,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  50 #if 0
  51 /* for documentation */
  52 const struct dom_sid global_sid_Restriced =                     /* Restriced Code */
  53 { 1, 1, {0,0,0,0,0,5}, {12,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  54 #endif
  55 const struct dom_sid global_sid_Network =                       /* Network rids */
  56 { 1, 1, {0,0,0,0,0,5}, {2,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  57
  58 const struct dom_sid global_sid_Creator_Owner =         /* Creator Owner */
  59 { 1, 1, {0,0,0,0,0,3}, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  60 const struct dom_sid global_sid_Creator_Group =         /* Creator Group */
  61 { 1, 1, {0,0,0,0,0,3}, {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  62 const struct dom_sid global_sid_Anonymous =                     /* Anonymous login */
  63 { 1, 1, {0,0,0,0,0,5}, {7,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  64
  65 const struct dom_sid global_sid_Builtin =                       /* Local well-known domain */
  66 { 1, 1, {0,0,0,0,0,5}, {32,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  67 const struct dom_sid global_sid_Builtin_Administrators =        /* Builtin administrators */
  68 { 1, 2, {0,0,0,0,0,5}, {32,544,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  69 const struct dom_sid global_sid_Builtin_Users =         /* Builtin users */
  70 { 1, 2, {0,0,0,0,0,5}, {32,545,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  71 const struct dom_sid global_sid_Builtin_Guests =                /* Builtin guest users */
  72 { 1, 2, {0,0,0,0,0,5}, {32,546,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  73 const struct dom_sid global_sid_Builtin_Power_Users =   /* Builtin power users */
  74 { 1, 2, {0,0,0,0,0,5}, {32,547,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  75 const struct dom_sid global_sid_Builtin_Account_Operators =     /* Builtin account operators */
  76 { 1, 2, {0,0,0,0,0,5}, {32,548,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  77 const struct dom_sid global_sid_Builtin_Server_Operators =      /* Builtin server operators */
  78 { 1, 2, {0,0,0,0,0,5}, {32,549,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  79 const struct dom_sid global_sid_Builtin_Print_Operators =       /* Builtin print operators */
  80 { 1, 2, {0,0,0,0,0,5}, {32,550,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  81 const struct dom_sid global_sid_Builtin_Backup_Operators =      /* Builtin backup operators */
  82 { 1, 2, {0,0,0,0,0,5}, {32,551,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  83 const struct dom_sid global_sid_Builtin_Replicator =            /* Builtin replicator */
  84 { 1, 2, {0,0,0,0,0,5}, {32,552,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  85 const struct dom_sid global_sid_Builtin_PreWin2kAccess =        /* Builtin pre win2k access */
  86 { 1, 2, {0,0,0,0,0,5}, {32,554,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  87
  88 const struct dom_sid global_sid_Unix_Users =                    /* Unmapped Unix users */
  89 { 1, 1, {0,0,0,0,0,22}, {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  90 const struct dom_sid global_sid_Unix_Groups =                   /* Unmapped Unix groups */
  91 { 1, 1, {0,0,0,0,0,22}, {2,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  92
  93 /* Unused, left here for documentary purposes */
  94 #if 0
  95 #define SECURITY_NULL_SID_AUTHORITY    0
  96 #define SECURITY_WORLD_SID_AUTHORITY   1
  97 #define SECURITY_LOCAL_SID_AUTHORITY   2
  98 #define SECURITY_CREATOR_SID_AUTHORITY 3
  99 #define SECURITY_NT_AUTHORITY          5
 100 #endif
 101
 102 static struct dom_sid system_sid_array[1] =
 103 { { 1, 1, {0,0,0,0,0,5}, {18,0,0,0,0,0,0,0,0,0,0,0,0,0,0}} };
 104 static const struct security_token system_token = {
 105         .num_sids       = ARRAY_SIZE(system_sid_array),
 106         .sids           = system_sid_array,
 107         .privilege_mask = SE_ALL_PRIVS
 108 };
 109
 110 /****************************************************************************
 111  Lookup string names for SID types.
 112 ****************************************************************************/
 113
 114 static const struct {
 115         enum lsa_SidType sid_type;
 116         const char *string;
 117 } sid_name_type[] = {
 118         {SID_NAME_USER, "User"},
 119         {SID_NAME_DOM_GRP, "Domain Group"},
 120         {SID_NAME_DOMAIN, "Domain"},
 121         {SID_NAME_ALIAS, "Local Group"},
 122         {SID_NAME_WKN_GRP, "Well-known Group"},
 123         {SID_NAME_DELETED, "Deleted Account"},
 124         {SID_NAME_INVALID, "Invalid Account"},
 125         {SID_NAME_UNKNOWN, "UNKNOWN"},
 126         {SID_NAME_COMPUTER, "Computer"},
 127
 128         {(enum lsa_SidType)0, NULL}
 129 };
 130
 131 const char *sid_type_lookup(uint32 sid_type)
 132 {
 133         int i = 0;
 134
 135         /* Look through list */
 136         while(sid_name_type[i].sid_type != 0) {
 137                 if (sid_name_type[i].sid_type == sid_type)
 138                         return sid_name_type[i].string;
 139                 i++;
 140         }
 141
 142         /* Default return */
 143         return "SID *TYPE* is INVALID";
 144 }
 145
 146 /**************************************************************************
 147  Create the SYSTEM token.
 148 ***************************************************************************/
 149
 150 const struct security_token *get_system_token(void)
 151 {
 152         return &system_token;
 153 }
 154
 155 /*****************************************************************
 156  Convert a SID to an ascii string.
 157 *****************************************************************/
 158
 159 char *sid_to_fstring(fstring sidstr_out, const struct dom_sid *sid)
 160 {
 161         char *str = sid_string_talloc(talloc_tos(), sid);
 162         fstrcpy(sidstr_out, str);
 163         TALLOC_FREE(str);
 164         return sidstr_out;
 165 }
 166
 167 /*****************************************************************
 168  Essentially a renamed dom_sid_string from
 169  ../libcli/security/dom_sid.c with a panic if it didn't work.
 170 *****************************************************************/
 171
 172 char *sid_string_talloc(TALLOC_CTX *mem_ctx, const struct dom_sid *sid)
 173 {
 174         char *result = dom_sid_string(mem_ctx, sid);
 175         SMB_ASSERT(result != NULL);
 176         return result;
 177 }
 178
 179 /*****************************************************************
 180  Useful function for debug lines.
 181 *****************************************************************/
 182
 183 char *sid_string_dbg(const struct dom_sid *sid)
 184 {
 185         return sid_string_talloc(talloc_tos(), sid);
 186 }
 187
 188 /*****************************************************************
 189  Use with care!
 190 *****************************************************************/
 191
 192 char *sid_string_tos(const struct dom_sid *sid)
 193 {
 194         return sid_string_talloc(talloc_tos(), sid);
 195 }
 196
 197 bool sid_compose(struct dom_sid *dst, const struct dom_sid *domain_sid, uint32 rid)
 198 {
 199         sid_copy(dst, domain_sid);
 200         return sid_append_rid(dst, rid);
 201 }
 202
 203 /*****************************************************************
 204  Removes the last rid from the end of a sid
 205 *****************************************************************/
 206
 207 bool sid_split_rid(struct dom_sid *sid, uint32 *rid)
 208 {
 209         if (sid->num_auths > 0) {
 210                 sid->num_auths--;
 211                 *rid = sid->sub_auths[sid->num_auths];
 212                 return True;
 213         }
 214         return False;
 215 }
 216
 217 /*****************************************************************
 218  Return the last rid from the end of a sid
 219 *****************************************************************/
 220
 221 bool sid_peek_rid(const struct dom_sid *sid, uint32 *rid)
 222 {
 223         if (!sid || !rid)
 224                 return False;
 225
 226         if (sid->num_auths > 0) {
 227                 *rid = sid->sub_auths[sid->num_auths - 1];
 228                 return True;
 229         }
 230         return False;
 231 }
 232
 233 /*****************************************************************
 234  Return the last rid from the end of a sid
 235  and check the sid against the exp_dom_sid
 236 *****************************************************************/
 237
 238 bool sid_peek_check_rid(const struct dom_sid *exp_dom_sid, const struct dom_sid *sid, uint32 *rid)
 239 {
 240         if (!exp_dom_sid || !sid || !rid)
 241                 return False;
 242
 243         if (sid->num_auths != (exp_dom_sid->num_auths+1)) {
 244                 return False;
 245         }
 246
 247         if (dom_sid_compare_domain(exp_dom_sid, sid)!=0){
 248                 *rid=(-1);
 249                 return False;
 250         }
 251
 252         return sid_peek_rid(sid, rid);
 253 }
 254
 255 /*****************************************************************
 256  Copies a sid
 257 *****************************************************************/
 258
 259 void sid_copy(struct dom_sid *dst, const struct dom_sid *src)
 260 {
 261         int i;
 262
 263         ZERO_STRUCTP(dst);
 264
 265         dst->sid_rev_num = src->sid_rev_num;
 266         dst->num_auths = src->num_auths;
 267
 268         memcpy(&dst->id_auth[0], &src->id_auth[0], sizeof(src->id_auth));
 269
 270         for (i = 0; i < src->num_auths; i++)
 271                 dst->sub_auths[i] = src->sub_auths[i];
 272 }
 273
 274 /*****************************************************************
 275  Write a sid out into on-the-wire format.
 276 *****************************************************************/
 277
 278 bool sid_linearize(char *outbuf, size_t len, const struct dom_sid *sid)
 279 {
 280         size_t i;
 281
 282         if (len < ndr_size_dom_sid(sid, 0))
 283                 return False;
 284
 285         SCVAL(outbuf,0,sid->sid_rev_num);
 286         SCVAL(outbuf,1,sid->num_auths);
 287         memcpy(&outbuf[2], sid->id_auth, 6);
 288         for(i = 0; i < sid->num_auths; i++)
 289                 SIVAL(outbuf, 8 + (i*4), sid->sub_auths[i]);
 290
 291         return True;
 292 }
 293
 294 /*****************************************************************
 295  Parse a on-the-wire SID to a struct dom_sid.
 296 *****************************************************************/
 297
 298 bool sid_parse(const char *inbuf, size_t len, struct dom_sid *sid)
 299 {
 300         enum ndr_err_code ndr_err;
 301         DATA_BLOB in = data_blob_const(inbuf, len);
 302         ndr_err = ndr_pull_struct_blob_all(&in, NULL, sid,
 303                                            (ndr_pull_flags_fn_t)ndr_pull_dom_sid);
 304         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 305                 return false;
 306         }
 307         return true;
 308 }
 309
 310 /*****************************************************************
 311  Returns true if SID is internal (and non-mappable).
 312 *****************************************************************/
 313
 314 bool non_mappable_sid(struct dom_sid *sid)
 315 {
 316         struct dom_sid dom;
 317         uint32 rid;
 318
 319         sid_copy(&dom, sid);
 320         sid_split_rid(&dom, &rid);
 321
 322         if (dom_sid_equal(&dom, &global_sid_Builtin))
 323                 return True;
 324
 325         if (dom_sid_equal(&dom, &global_sid_NT_Authority))
 326                 return True;
 327
 328         return False;
 329 }
 330
 331 /*****************************************************************
 332  Return the binary string representation of a struct dom_sid.
 333  Caller must free.
 334 *****************************************************************/
 335
 336 char *sid_binstring(TALLOC_CTX *mem_ctx, const struct dom_sid *sid)
 337 {
 338         uint8_t *buf;
 339         char *s;
 340         int len = ndr_size_dom_sid(sid, 0);
 341         buf = talloc_array(mem_ctx, uint8_t, len);
 342         if (!buf) {
 343                 return NULL;
 344         }
 345         sid_linearize((char *)buf, len, sid);
 346         s = binary_string_rfc2254(mem_ctx, buf, len);
 347         TALLOC_FREE(buf);
 348         return s;
 349 }
 350
 351 /*****************************************************************
 352  Return the binary string representation of a struct dom_sid.
 353  Caller must free.
 354 *****************************************************************/
 355
 356 char *sid_binstring_hex(const struct dom_sid *sid)
 357 {
 358         char *buf, *s;
 359         int len = ndr_size_dom_sid(sid, 0);
 360         buf = (char *)SMB_MALLOC(len);
 361         if (!buf)
 362                 return NULL;
 363         sid_linearize(buf, len, sid);
 364         s = binary_string(buf, len);
 365         free(buf);
 366         return s;
 367 }
 368
 369 /********************************************************************
 370  Add SID to an array SIDs
 371 ********************************************************************/
 372
 373 NTSTATUS add_sid_to_array(TALLOC_CTX *mem_ctx, const struct dom_sid *sid,
 374                           struct dom_sid **sids, uint32_t *num)
 375 {
 376         *sids = TALLOC_REALLOC_ARRAY(mem_ctx, *sids, struct dom_sid,
 377                                              (*num)+1);
 378         if (*sids == NULL) {
 379                 *num = 0;
 380                 return NT_STATUS_NO_MEMORY;
 381         }
 382
 383         sid_copy(&((*sids)[*num]), sid);
 384         *num += 1;
 385
 386         return NT_STATUS_OK;
 387 }
 388
 389
 390 /********************************************************************
 391  Add SID to an array SIDs ensuring that it is not already there
 392 ********************************************************************/
 393
 394 NTSTATUS add_sid_to_array_unique(TALLOC_CTX *mem_ctx, const struct dom_sid *sid,
 395                                  struct dom_sid **sids, uint32_t *num_sids)
 396 {
 397         size_t i;
 398
 399         for (i=0; i<(*num_sids); i++) {
 400                 if (dom_sid_compare(sid, &(*sids)[i]) == 0)
 401                         return NT_STATUS_OK;
 402         }
 403
 404         return add_sid_to_array(mem_ctx, sid, sids, num_sids);
 405 }
 406
 407 /********************************************************************
 408  Remove SID from an array
 409 ********************************************************************/
 410
 411 void del_sid_from_array(const struct dom_sid *sid, struct dom_sid **sids, size_t *num)
 412 {
 413         struct dom_sid *sid_list = *sids;
 414         size_t i;
 415
 416         for ( i=0; i<*num; i++ ) {
 417
 418                 /* if we find the SID, then decrement the count
 419                    and break out of the loop */
 420
 421                 if ( dom_sid_equal(sid, &sid_list[i]) ) {
 422                         *num -= 1;
 423                         break;
 424                 }
 425         }
 426
 427         /* This loop will copy the remainder of the array
 428            if i < num of sids ni the array */
 429
 430         for ( ; i<*num; i++ )
 431                 sid_copy( &sid_list[i], &sid_list[i+1] );
 432
 433         return;
 434 }
 435
 436 bool add_rid_to_array_unique(TALLOC_CTX *mem_ctx,
 437                                     uint32 rid, uint32 **pp_rids, size_t *p_num)
 438 {
 439         size_t i;
 440
 441         for (i=0; i<*p_num; i++) {
 442                 if ((*pp_rids)[i] == rid)
 443                         return True;
 444         }
 445
 446         *pp_rids = TALLOC_REALLOC_ARRAY(mem_ctx, *pp_rids, uint32, *p_num+1);
 447
 448         if (*pp_rids == NULL) {
 449                 *p_num = 0;
 450                 return False;
 451         }
 452
 453         (*pp_rids)[*p_num] = rid;
 454         *p_num += 1;
 455         return True;
 456 }
 457
 458 bool is_null_sid(const struct dom_sid *sid)
 459 {
 460         static const struct dom_sid null_sid = {0};
 461         return dom_sid_equal(sid, &null_sid);
 462 }
 463
 464 bool is_sid_in_token(const struct security_token *token, const struct dom_sid *sid)
 465 {
 466         int i;
 467
 468         for (i=0; i<token->num_sids; i++) {
 469                 if (dom_sid_compare(sid, &token->sids[i]) == 0)
 470                         return true;
 471         }
 472         return false;
 473 }
 474
 475 NTSTATUS sid_array_from_info3(TALLOC_CTX *mem_ctx,
 476                               const struct netr_SamInfo3 *info3,
 477                               struct dom_sid **user_sids,
 478                               uint32_t *num_user_sids,
 479                               bool include_user_group_rid,
 480                               bool skip_ressource_groups)
 481 {
 482         NTSTATUS status;
 483         struct dom_sid sid;
 484         struct dom_sid *sid_array = NULL;
 485         uint32_t num_sids = 0;
 486         int i;
 487
 488         if (include_user_group_rid) {
 489                 if (!sid_compose(&sid, info3->base.domain_sid, info3->base.rid)) {
 490                         DEBUG(3, ("could not compose user SID from rid 0x%x\n",
 491                                   info3->base.rid));
 492                         return NT_STATUS_INVALID_PARAMETER;
 493                 }
 494                 status = add_sid_to_array(mem_ctx, &sid, &sid_array, &num_sids);
 495                 if (!NT_STATUS_IS_OK(status)) {
 496                         DEBUG(3, ("could not append user SID from rid 0x%x\n",
 497                                   info3->base.rid));
 498                         return status;
 499                 }
 500         }
 501
 502         if (!sid_compose(&sid, info3->base.domain_sid, info3->base.primary_gid)) {
 503                 DEBUG(3, ("could not compose group SID from rid 0x%x\n",
 504                           info3->base.primary_gid));
 505                 return NT_STATUS_INVALID_PARAMETER;
 506         }
 507         status = add_sid_to_array(mem_ctx, &sid, &sid_array, &num_sids);
 508         if (!NT_STATUS_IS_OK(status)) {
 509                 DEBUG(3, ("could not append group SID from rid 0x%x\n",
 510                           info3->base.rid));
 511                 return status;
 512         }
 513
 514         for (i = 0; i < info3->base.groups.count; i++) {
 515                 /* Don't add the primary group sid twice. */
 516                 if (info3->base.primary_gid == info3->base.groups.rids[i].rid) {
 517                         continue;
 518                 }
 519                 if (!sid_compose(&sid, info3->base.domain_sid,
 520                                  info3->base.groups.rids[i].rid)) {
 521                         DEBUG(3, ("could not compose SID from additional group "
 522                                   "rid 0x%x\n", info3->base.groups.rids[i].rid));
 523                         return NT_STATUS_INVALID_PARAMETER;
 524                 }
 525                 status = add_sid_to_array(mem_ctx, &sid, &sid_array, &num_sids);
 526                 if (!NT_STATUS_IS_OK(status)) {
 527                         DEBUG(3, ("could not append SID from additional group "
 528                                   "rid 0x%x\n", info3->base.groups.rids[i].rid));
 529                         return status;
 530                 }
 531         }
 532
 533         /* Copy 'other' sids.  We need to do sid filtering here to
 534            prevent possible elevation of privileges.  See:
 535
 536            http://www.microsoft.com/windows2000/techinfo/administration/security/sidfilter.asp
 537          */
 538
 539         for (i = 0; i < info3->sidcount; i++) {
 540
 541                 if (skip_ressource_groups &&
 542                     (info3->sids[i].attributes & SE_GROUP_RESOURCE)) {
 543                         continue;
 544                 }
 545
 546                 status = add_sid_to_array(mem_ctx, info3->sids[i].sid,
 547                                       &sid_array, &num_sids);
 548                 if (!NT_STATUS_IS_OK(status)) {
 549                         DEBUG(3, ("could not add SID to array: %s\n",
 550                                   sid_string_dbg(info3->sids[i].sid)));
 551                         return status;
 552                 }
 553         }
 554
 555         *user_sids = sid_array;
 556         *num_user_sids = num_sids;
 557
 558         return NT_STATUS_OK;
 559 }