source3/passdb/util_sam_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
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24
  25 extern pstring global_myname;
  26 extern fstring global_myworkgroup;
  27
  28 #define MAX_SID_NAMES   7
  29
  30 typedef struct _known_sid_users {
  31         uint32 rid;
  32         enum SID_NAME_USE sid_name_use;
  33         char *known_user_name;
  34 } known_sid_users;
  35
  36 static struct sid_name_map_info
  37 {
  38         DOM_SID *sid;
  39         char *name;
  40         known_sid_users *known_users;
  41 } sid_name_map[MAX_SID_NAMES];
  42
  43 extern DOM_SID global_sid_Builtin;                              /* Local well-known domain */
  44 extern DOM_SID global_sid_World_Domain;         /* Everyone domain */
  45 extern DOM_SID global_sid_Creator_Owner_Domain;    /* Creator Owner domain */
  46 extern DOM_SID global_sid_NT_Authority;                 /* NT Authority */
  47
  48
  49 static BOOL sid_name_map_initialized = False;
  50 /* static known_sid_users no_users[] = {{0, 0, NULL}}; */
  51
  52 static known_sid_users everyone_users[] = {
  53         { 0, SID_NAME_WKN_GRP, "Everyone" },
  54         {0, (enum SID_NAME_USE)0, NULL}};
  55
  56 static known_sid_users creator_owner_users[] = {
  57         { 0, SID_NAME_ALIAS, "Creator Owner" },
  58         {0, (enum SID_NAME_USE)0, NULL}};
  59
  60 static known_sid_users nt_authority_users[] = {
  61         {  1, SID_NAME_ALIAS, "Dialup" },
  62         {  2, SID_NAME_ALIAS, "Network"},
  63         {  3, SID_NAME_ALIAS, "Batch"},
  64         {  4, SID_NAME_ALIAS, "Interactive"},
  65         {  6, SID_NAME_ALIAS, "Service"},
  66         {  7, SID_NAME_ALIAS, "AnonymousLogon"},
  67         {  8, SID_NAME_ALIAS, "Proxy"},
  68         {  9, SID_NAME_ALIAS, "ServerLogon"},
  69         { 11, SID_NAME_ALIAS, "Authenticated Users"},
  70         { 18, SID_NAME_ALIAS, "SYSTEM"},
  71         {  0, (enum SID_NAME_USE)0, NULL}};
  72
  73 static known_sid_users builtin_groups[] = {
  74         { BUILTIN_ALIAS_RID_ADMINS, SID_NAME_ALIAS, "Administrators" },
  75         { BUILTIN_ALIAS_RID_USERS, SID_NAME_ALIAS, "Users" },
  76         { BUILTIN_ALIAS_RID_GUESTS, SID_NAME_ALIAS, "Guests" },
  77         { BUILTIN_ALIAS_RID_ACCOUNT_OPS, SID_NAME_ALIAS, "Account Operators" },
  78         { BUILTIN_ALIAS_RID_SYSTEM_OPS, SID_NAME_ALIAS, "Server Operators" },
  79         { BUILTIN_ALIAS_RID_PRINT_OPS, SID_NAME_ALIAS, "Print Operators" },
  80         { BUILTIN_ALIAS_RID_BACKUP_OPS, SID_NAME_ALIAS, "Backup Operators" },
  81         {  0, (enum SID_NAME_USE)0, NULL}};
  82
  83
  84
  85 /**************************************************************************
  86  quick init function
  87  *************************************************************************/
  88 static void init_sid_name_map (void)
  89 {
  90         int i = 0;
  91
  92         if (sid_name_map_initialized) return;
  93
  94         generate_wellknown_sids();
  95
  96         if ((lp_security() == SEC_USER) && lp_domain_logons()) {
  97                 sid_name_map[i].sid = get_global_sam_sid();
  98                 /* This is not lp_workgroup() for good reason:
  99                    it must stay around longer than the lp_*()
 100                    strings do */
 101                 sid_name_map[i].name = global_myworkgroup;
 102                 sid_name_map[i].known_users = NULL;
 103                 i++;
 104                 sid_name_map[i].sid = get_global_sam_sid();
 105                 sid_name_map[i].name = global_myname;
 106                 sid_name_map[i].known_users = NULL;
 107                 i++;
 108         }
 109         else {
 110                 sid_name_map[i].sid = get_global_sam_sid();
 111                 sid_name_map[i].name = global_myname;
 112                 sid_name_map[i].known_users = NULL;
 113                 i++;
 114         }
 115
 116         sid_name_map[i].sid = &global_sid_Builtin;
 117         sid_name_map[i].name = "BUILTIN";
 118         sid_name_map[i].known_users = &builtin_groups[0];
 119         i++;
 120
 121         sid_name_map[i].sid = &global_sid_World_Domain;
 122         sid_name_map[i].name = "";
 123         sid_name_map[i].known_users = &everyone_users[0];
 124         i++;
 125
 126         sid_name_map[i].sid = &global_sid_Creator_Owner_Domain;
 127         sid_name_map[i].name = "";
 128         sid_name_map[i].known_users = &creator_owner_users[0];
 129         i++;
 130
 131         sid_name_map[i].sid = &global_sid_NT_Authority;
 132         sid_name_map[i].name = "NT Authority";
 133         sid_name_map[i].known_users = &nt_authority_users[0];
 134         i++;
 135
 136
 137         /* end of array */
 138         sid_name_map[i].sid = NULL;
 139         sid_name_map[i].name = NULL;
 140         sid_name_map[i].known_users = NULL;
 141
 142         sid_name_map_initialized = True;
 143
 144         return;
 145
 146 }
 147
 148 /**************************************************************************
 149  Turns a domain SID into a name, returned in the nt_domain argument.
 150 ***************************************************************************/
 151
 152 BOOL map_domain_sid_to_name(DOM_SID *sid, fstring nt_domain)
 153 {
 154         fstring sid_str;
 155         int i = 0;
 156
 157         sid_to_string(sid_str, sid);
 158
 159         if (!sid_name_map_initialized)
 160                 init_sid_name_map();
 161
 162         DEBUG(5,("map_domain_sid_to_name: %s\n", sid_str));
 163
 164         if (nt_domain == NULL)
 165                 return False;
 166
 167         while (sid_name_map[i].sid != NULL) {
 168                 sid_to_string(sid_str, sid_name_map[i].sid);
 169                 DEBUG(5,("map_domain_sid_to_name: compare: %s\n", sid_str));
 170                 if (sid_equal(sid_name_map[i].sid, sid)) {
 171                         fstrcpy(nt_domain, sid_name_map[i].name);
 172                         DEBUG(5,("map_domain_sid_to_name: found '%s'\n", nt_domain));
 173                         return True;
 174                 }
 175                 i++;
 176         }
 177
 178         DEBUG(5,("map_domain_sid_to_name: mapping for %s not found\n", sid_str));
 179
 180     return False;
 181 }
 182
 183 /**************************************************************************
 184  Looks up a known username from one of the known domains.
 185 ***************************************************************************/
 186
 187 BOOL lookup_known_rid(DOM_SID *sid, uint32 rid, char *name, enum SID_NAME_USE *psid_name_use)
 188 {
 189         int i = 0;
 190         struct sid_name_map_info *psnm;
 191
 192         if (!sid_name_map_initialized)
 193                 init_sid_name_map();
 194
 195         for(i = 0; sid_name_map[i].sid != NULL; i++) {
 196                 psnm = &sid_name_map[i];
 197                 if(sid_equal(psnm->sid, sid)) {
 198                         int j;
 199                         for(j = 0; psnm->known_users && psnm->known_users[j].known_user_name != NULL; j++) {
 200                                 if(rid == psnm->known_users[j].rid) {
 201                                         DEBUG(5,("lookup_builtin_rid: rid = %u, domain = '%s', user = '%s'\n",
 202                                                 (unsigned int)rid, psnm->name, psnm->known_users[j].known_user_name ));
 203                                         fstrcpy( name, psnm->known_users[j].known_user_name);
 204                                         *psid_name_use = psnm->known_users[j].sid_name_use;
 205                                         return True;
 206                                 }
 207                         }
 208                 }
 209         }
 210
 211         return False;
 212 }
 213
 214 /**************************************************************************
 215  Turns a domain name into a SID.
 216  *** side-effect: if the domain name is NULL, it is set to our domain ***
 217 ***************************************************************************/
 218
 219 BOOL map_domain_name_to_sid(DOM_SID *sid, char *nt_domain)
 220 {
 221         int i = 0;
 222
 223         if (nt_domain == NULL) {
 224                 DEBUG(5,("map_domain_name_to_sid: mapping NULL domain to our SID.\n"));
 225                 sid_copy(sid, get_global_sam_sid());
 226                 return True;
 227         }
 228
 229         if (nt_domain[0] == 0) {
 230                 fstrcpy(nt_domain, global_myname);
 231                 DEBUG(5,("map_domain_name_to_sid: overriding blank name to %s\n", nt_domain));
 232                 sid_copy(sid, get_global_sam_sid());
 233                 return True;
 234         }
 235
 236         DEBUG(5,("map_domain_name_to_sid: %s\n", nt_domain));
 237
 238         if (!sid_name_map_initialized)
 239                 init_sid_name_map();
 240
 241         while (sid_name_map[i].name != NULL) {
 242                 DEBUG(5,("map_domain_name_to_sid: compare: %s\n", sid_name_map[i].name));
 243                 if (strequal(sid_name_map[i].name, nt_domain)) {
 244                         fstring sid_str;
 245                         sid_copy(sid, sid_name_map[i].sid);
 246                         sid_to_string(sid_str, sid_name_map[i].sid);
 247                         DEBUG(5,("map_domain_name_to_sid: found %s\n", sid_str));
 248                         return True;
 249                 }
 250                 i++;
 251         }
 252
 253         DEBUG(0,("map_domain_name_to_sid: mapping to %s not found.\n", nt_domain));
 254         return False;
 255 }
 256
 257 /*****************************************************************
 258  Check if the SID is our domain SID (S-1-5-21-x-y-z).
 259 *****************************************************************/
 260 BOOL sid_check_is_domain(const DOM_SID *sid)
 261 {
 262         return sid_equal(sid, get_global_sam_sid());
 263 }
 264
 265 /*****************************************************************
 266  Check if the SID is our domain SID (S-1-5-21-x-y-z).
 267 *****************************************************************/
 268 BOOL sid_check_is_in_our_domain(const DOM_SID *sid)
 269 {
 270         DOM_SID dom_sid;
 271         uint32 rid;
 272
 273         sid_copy(&dom_sid, sid);
 274         sid_split_rid(&dom_sid, &rid);
 275
 276         return sid_equal(&dom_sid, get_global_sam_sid());
 277 }
 278