source3/rpc_server/srv_sid.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    Samba utility functions
   5    Copyright (C) Andrew Tridgell 1992-1998
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23
  24
  25 extern int DEBUGLEVEL;
  26 extern pstring scope;
  27 extern pstring global_myname;
  28
  29 /*
  30  * This is set on startup - it defines the SID for this
  31  * machine, and therefore the SAM database for which it is
  32  * responsible.
  33  */
  34
  35 DOM_SID global_sam_sid;
  36
  37 /*
  38  * This is the name associated with the SAM database for
  39  * which this machine is responsible.  In the case of a PDC
  40  * or PDC, this name is the same as the workgroup.  In the
  41  * case of "security = domain" mode, this is the same as
  42  * the name of the server (global_myname).
  43  */
  44
  45 fstring global_sam_name;
  46
  47 /*
  48  * This is obtained on startup - it defines the SID for which
  49  * this machine is a member.  It is therefore only set, and
  50  * used, in "security = domain" mode.
  51  */
  52
  53 DOM_SID global_member_sid;
  54
  55 /*
  56  * note the lack of a "global_member_name" - this is because
  57  * this is the same as "global_myworkgroup".
  58  */
  59
  60 /*
  61  * some useful sids
  62  */
  63
  64 DOM_SID global_sid_S_1_5_20; /* local well-known domain */
  65 DOM_SID global_sid_S_1_1;    /* everyone */
  66 DOM_SID global_sid_S_1_3;    /* */
  67 DOM_SID global_sid_S_1_5;    /* NT Authority */
  68
  69 extern pstring global_myworkgroup;
  70 /* extern fstring global_member_dom_name; */
  71
  72 static struct sid_name_map_info
  73 {
  74         DOM_SID *sid;
  75         char *name;
  76
  77 }
  78 sid_name_map[] =
  79 {
  80         { &global_sid_S_1_5_20, "BUILTIN" },
  81         { &global_sid_S_1_1   , "Everyone" },
  82         { &global_sid_S_1_3   , "don't know" },
  83         { &global_sid_S_1_5   , "NT Authority" },
  84         { &global_sam_sid     , global_sam_name },
  85         { &global_member_sid  , global_myworkgroup },
  86         { NULL                 , NULL      }
  87 };
  88
  89 /****************************************************************************
  90  Read the machine SID from a file.
  91 ****************************************************************************/
  92
  93 static BOOL read_sid_from_file(int fd, char *sid_file)
  94 {
  95   fstring fline;
  96         fstring sid_str;
  97
  98   memset(fline, '\0', sizeof(fline));
  99
 100   if (read(fd, fline, sizeof(fline) -1 ) < 0) {
 101     DEBUG(0,("unable to read file %s. Error was %s\n",
 102            sid_file, strerror(errno) ));
 103     return False;
 104   }
 105
 106   /*
 107    * Convert to the machine SID.
 108    */
 109
 110   fline[sizeof(fline)-1] = '\0';
 111   if (!string_to_sid( &global_sam_sid, fline)) {
 112     DEBUG(0,("unable to generate machine SID.\n"));
 113     return False;
 114   }
 115
 116         sid_to_string(sid_str, &global_sam_sid);
 117         DEBUG(5,("read_sid_from_file: sid %s\n", sid_str));
 118
 119   return True;
 120 }
 121
 122 /****************************************************************************
 123  sets up the name associated with the SAM database for which we are responsible
 124 ****************************************************************************/
 125 void get_sam_domain_name(void)
 126 {
 127         switch (lp_server_role())
 128         {
 129                 case ROLE_DOMAIN_PDC:
 130                 case ROLE_DOMAIN_BDC:
 131                 {
 132                         /* we are PDC (or BDC) for a Domain */
 133                         fstrcpy(global_sam_name, lp_workgroup());
 134                         break;
 135                 }
 136                 case ROLE_DOMAIN_MEMBER:
 137                 {
 138                         /* we are a "PDC", but FOR LOCAL SAM DATABASE ONLY */
 139                         fstrcpy(global_sam_name, global_myname);
 140                         break;
 141                 }
 142                 default:
 143                 {
 144                         /* no domain role, probably due to "security = share" */
 145                         memset(global_sam_name, 0, sizeof(global_sam_name));
 146                         break;
 147                 }
 148         }
 149 }
 150
 151 /****************************************************************************
 152  obtain the sid from the PDC.  do some verification along the way...
 153 ****************************************************************************/
 154 BOOL get_member_domain_sid(void)
 155 {
 156         POLICY_HND pol;
 157         fstring srv_name;
 158         struct cli_state cli;
 159         BOOL res = True;
 160         DOM_SID sid3;
 161         DOM_SID sid5;
 162         fstring dom3;
 163         fstring dom5;
 164
 165         if (!cli_connect_serverlist(&cli, lp_passwordserver()))
 166         {
 167                 DEBUG(0,("get_member_domain_sid: unable to initialise client connection.\n"));
 168                 return False;
 169         }
 170
 171         /*
 172          * Ok - we have an anonymous connection to the IPC$ share.
 173          * Now start the NT Domain stuff :-).
 174          */
 175
 176         fstrcpy(dom3, "");
 177         fstrcpy(dom5, "");
 178         ZERO_STRUCT(sid3);
 179         ZERO_STRUCT(sid5);
 180
 181         fstrcpy(srv_name, "\\\\");
 182         fstrcat(srv_name, global_myname);
 183         strupper(srv_name);
 184
 185         /* open LSARPC session. */
 186         res = res ? cli_nt_session_open(&cli, PIPE_LSARPC) : False;
 187
 188         /* lookup domain controller; receive a policy handle */
 189         res = res ? do_lsa_open_policy(&cli, srv_name, &pol, False) : False;
 190
 191         /* send client info query, level 3.  receive domain name and sid */
 192         res = res ? do_lsa_query_info_pol(&cli, &pol, 3, dom3, &sid3) : False;
 193
 194         /* send client info query, level 5.  receive domain name and sid */
 195         res = res ? do_lsa_query_info_pol(&cli, &pol, 5, dom5, &sid5) : False;
 196
 197         /* close policy handle */
 198         res = res ? do_lsa_close(&cli, &pol) : False;
 199
 200         /* close the session */
 201         cli_nt_session_close(&cli);
 202         cli_ulogoff(&cli);
 203         cli_shutdown(&cli);
 204
 205         if (res)
 206         {
 207                 pstring sid;
 208                 DEBUG(2,("LSA Query Info Policy\n"));
 209                 sid_to_string(sid, &sid3);
 210                 DEBUG(2,("Domain Member     - Domain: %s SID: %s\n", dom3, sid));
 211                 sid_to_string(sid, &sid5);
 212                 DEBUG(2,("Domain Controller - Domain: %s SID: %s\n", dom5, sid));
 213
 214                 if (!strequal(dom3, global_myworkgroup) ||
 215                     !strequal(dom5, global_myworkgroup))
 216                 {
 217                         DEBUG(0,("get_member_domain_sid: %s is a DC for %s not %s\n",
 218                                   cli.desthost, dom5, global_myworkgroup));
 219                         res = False;
 220                 }
 221         }
 222         else
 223         {
 224                 DEBUG(1,("lsa query info failed\n"));
 225         }
 226         if (!res)
 227         {
 228                 DEBUG(0,("get_member_domain_sid: unable to obtain Domain member SID\n"));
 229         }
 230         else
 231         {
 232                 /* this is a _lot_ of trouble to go to for just this info: */
 233                 global_member_sid = sid5;
 234         }
 235
 236         return res;
 237 }
 238
 239 /****************************************************************************
 240  creates some useful well known sids
 241 ****************************************************************************/
 242 void generate_wellknown_sids(void)
 243 {
 244         string_to_sid(&global_sid_S_1_5_20, "S-1-5-32");
 245         string_to_sid(&global_sid_S_1_1   , "S-1-1"   );
 246         string_to_sid(&global_sid_S_1_3   , "S-1-3"   );
 247         string_to_sid(&global_sid_S_1_5   , "S-1-5"   );
 248 }
 249
 250 /****************************************************************************
 251  Generate the global machine sid. Look for the MACHINE.SID file first, if
 252  not found then look in smb.conf and use it to create the MACHINE.SID file.
 253 ****************************************************************************/
 254 BOOL generate_sam_sid(void)
 255 {
 256         int fd;
 257         int i;
 258         char *p;
 259         pstring sid_file;
 260         fstring sid_string;
 261         SMB_STRUCT_STAT st;
 262         uchar raw_sid_data[12];
 263
 264         pstrcpy(sid_file, lp_smb_passwd_file());
 265         p = strrchr(sid_file, '/');
 266         if (p != NULL) {
 267                 *++p = '\0';
 268         }
 269
 270         if (!directory_exist(sid_file, NULL)) {
 271                 if (dos_mkdir(sid_file, 0700) != 0) {
 272                         DEBUG(0,("can't create private directory %s : %s\n",
 273                                  sid_file, strerror(errno)));
 274                         return False;
 275                 }
 276         }
 277
 278         pstrcat(sid_file, "MACHINE.SID");
 279
 280         if ((fd = sys_open(sid_file, O_RDWR | O_CREAT, 0644)) == -1) {
 281                 DEBUG(0,("unable to open or create file %s. Error was %s\n",
 282                          sid_file, strerror(errno) ));
 283                 return False;
 284         }
 285
 286         /*
 287          * Check if the file contains data.
 288          */
 289
 290         if (sys_fstat( fd, &st) < 0) {
 291                 DEBUG(0,("unable to stat file %s. Error was %s\n",
 292                          sid_file, strerror(errno) ));
 293                 close(fd);
 294                 return False;
 295         }
 296
 297         if (st.st_size > 0) {
 298                 /*
 299                  * We have a valid SID - read it.
 300                  */
 301                 if (!read_sid_from_file( fd, sid_file)) {
 302                         DEBUG(0,("unable to read file %s. Error was %s\n",
 303                                  sid_file, strerror(errno) ));
 304                         close(fd);
 305                         return False;
 306                 }
 307                 close(fd);
 308                 return True;
 309         }
 310
 311         /*
 312          * Generate the new sid data & turn it into a string.
 313          */
 314         generate_random_buffer( raw_sid_data, 12, True);
 315
 316         fstrcpy( sid_string, "S-1-5-21");
 317         for( i = 0; i < 3; i++) {
 318                 fstring tmp_string;
 319                 slprintf( tmp_string, sizeof(tmp_string) - 1, "-%u", IVAL(raw_sid_data, i*4));
 320                 fstrcat( sid_string, tmp_string);
 321         }
 322
 323         fstrcat(sid_string, "\n");
 324
 325         /*
 326          * Ensure our new SID is valid.
 327          */
 328
 329         if (!string_to_sid( &global_sam_sid, sid_string)) {
 330                 DEBUG(0,("unable to generate machine SID.\n"));
 331                 return False;
 332         }
 333
 334         /*
 335          * Do an exclusive blocking lock on the file.
 336          */
 337
 338         if (!do_file_lock( fd, 60, F_WRLCK)) {
 339                 DEBUG(0,("unable to lock file %s. Error was %s\n",
 340                          sid_file, strerror(errno) ));
 341                 close(fd);
 342                 return False;
 343         }
 344
 345         /*
 346          * At this point we have a blocking lock on the SID
 347          * file - check if in the meantime someone else wrote
 348          * SID data into the file. If so - they were here first,
 349          * use their data.
 350          */
 351
 352         if (sys_fstat( fd, &st) < 0) {
 353                 DEBUG(0,("unable to stat file %s. Error was %s\n",
 354                          sid_file, strerror(errno) ));
 355                 close(fd);
 356                 return False;
 357         }
 358
 359         if (st.st_size > 0) {
 360                 /*
 361                  * Unlock as soon as possible to reduce
 362                  * contention on the exclusive lock.
 363                  */
 364                 do_file_lock( fd, 60, F_UNLCK);
 365
 366                 /*
 367                  * We have a valid SID - read it.
 368                  */
 369
 370                 if (!read_sid_from_file( fd, sid_file)) {
 371                         DEBUG(0,("unable to read file %s. Error was %s\n",
 372                                  sid_file, strerror(errno) ));
 373                         close(fd);
 374                         return False;
 375                 }
 376                 close(fd);
 377                 return True;
 378         }
 379
 380         /*
 381          * The file is still empty and we have an exlusive lock on it.
 382          * Write out out SID data into the file.
 383          */
 384
 385         if (fchmod(fd, 0644) < 0) {
 386                 DEBUG(0,("unable to set correct permissions on file %s. \
 387 Error was %s\n", sid_file, strerror(errno) ));
 388                 close(fd);
 389                 return False;
 390         }
 391
 392         if (write( fd, sid_string, strlen(sid_string)) != strlen(sid_string)) {
 393                 DEBUG(0,("unable to write file %s. Error was %s\n",
 394                          sid_file, strerror(errno) ));
 395                 close(fd);
 396                 return False;
 397         }
 398
 399         /*
 400          * Unlock & exit.
 401          */
 402
 403         do_file_lock( fd, 60, F_UNLCK);
 404         close(fd);
 405         return True;
 406 }
 407
 408 /**************************************************************************
 409  turns a domain name into a SID.
 410
 411  *** side-effect: if the domain name is NULL, it is set to our domain ***
 412
 413 ***************************************************************************/
 414 BOOL map_domain_name_to_sid(DOM_SID *sid, char **nt_domain)
 415 {
 416         fstring sid_str;
 417         sid_to_string(sid_str, sid);
 418         DEBUG(5,("map_domain_name_to_sid: %s\n", sid_str));
 419
 420         if (nt_domain == NULL)
 421         {
 422                 *sid = global_sam_sid;
 423                 return True;
 424         }
 425
 426         if ((*nt_domain) == NULL)
 427         {
 428                 DEBUG(5,("map_domain_name_to_sid: overriding NULL name to %s\n",
 429                           global_sam_name));
 430                 (*nt_domain) = strdup(global_sam_name);
 431                 *sid = global_sam_sid;
 432                 return True;
 433         }
 434
 435         if (strequal((*nt_domain), global_sam_name))
 436         {
 437                 *sid = global_sam_sid;
 438                 return True;
 439         }
 440
 441         DEBUG(0,("map_domain_name_to_sid: mapping to %s NOT IMPLEMENTED\n",
 442                   (*nt_domain)));
 443         return False;
 444 }
 445
 446 /**************************************************************************
 447  turns a domain SID into a name.
 448
 449 ***************************************************************************/
 450 BOOL map_domain_sid_to_name(DOM_SID *sid, char *nt_domain)
 451 {
 452         fstring sid_str;
 453         int i = 0;
 454         sid_to_string(sid_str, sid);
 455
 456         DEBUG(5,("map_domain_sid_to_name: %s\n", sid_str));
 457
 458         if (nt_domain == NULL)
 459         {
 460                 return False;
 461         }
 462
 463         while (sid_name_map[i].sid != NULL)
 464         {
 465                 sid_to_string(sid_str, sid_name_map[i].sid);
 466                 DEBUG(5,("compare: %s\n", sid_str));
 467                 if (sid_equal(sid_name_map[i].sid, sid))
 468                 {
 469                         fstrcpy(nt_domain, sid_name_map[i].name);
 470                         DEBUG(5,("found %s\n", nt_domain));
 471                         return True;
 472                 }
 473                 i++;
 474         }
 475
 476         DEBUG(0,("map_domain_sid_to_name: mapping NOT IMPLEMENTED\n"));
 477
 478         return False;
 479 }
 480
 481 /**************************************************************************
 482  splits a name of format \DOMAIN\name into its two components.
 483  sets the DOMAIN name to global_sam_name if it has not been specified.
 484 ***************************************************************************/
 485 BOOL split_domain_name(char *fullname, char *domain, char *name)
 486 {
 487         fstring full_name;
 488         char *p;
 489
 490         if (fullname == NULL || domain == NULL || name == NULL)
 491         {
 492                 return False;
 493         }
 494
 495         if (fullname[0] == '\\')
 496         {
 497                 fullname++;
 498         }
 499         fstrcpy(full_name, fullname);
 500         p = strchr(full_name+1, '\\');
 501
 502         if (p != NULL)
 503         {
 504                 *p = 0;
 505                 fstrcpy(domain, full_name);
 506                 fstrcpy(name, p+1);
 507         }
 508         else
 509         {
 510                 fstrcpy(domain, global_sam_name);
 511                 fstrcpy(name, full_name);
 512         }
 513
 514         DEBUG(5,("name '%s' split into '\\%s\\%s'\n", fullname, domain, name));
 515         return True;
 516 }