00f14d7d26b059c12504e0f2c52a30e0d0e15967
[tprouty/samba.git] / source / 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       
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 2 of the License, or
13    (at your option) any later version.
14    
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19    
20    You should have received a copy of the GNU General Public License
21    along with this program; if not, write to the Free Software
22    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 */
24
25 #include "includes.h"
26
27 /*
28  * Some useful sids
29  */
30
31 DOM_SID global_sid_World_Domain;                /* Everyone domain */
32 DOM_SID global_sid_World;                               /* Everyone */
33 DOM_SID global_sid_Creator_Owner_Domain;    /* Creator Owner domain */
34 DOM_SID global_sid_NT_Authority;                /* NT Authority */
35 DOM_SID global_sid_System;              /* System */
36 DOM_SID global_sid_NULL;                        /* NULL sid */
37 DOM_SID global_sid_Authenticated_Users;         /* All authenticated rids */
38 DOM_SID global_sid_Network;                     /* Network rids */
39
40 DOM_SID global_sid_Creator_Owner;       /* Creator Owner */
41 DOM_SID global_sid_Creator_Group;       /* Creator Group */
42 DOM_SID global_sid_Anonymous;           /* Anonymous login */
43
44 DOM_SID global_sid_Builtin;                     /* Local well-known domain */
45 DOM_SID global_sid_Builtin_Administrators;      /* Builtin administrators */
46 DOM_SID global_sid_Builtin_Users;               /* Builtin users */
47 DOM_SID global_sid_Builtin_Guests;              /* Builtin guest users */
48 DOM_SID global_sid_Builtin_Power_Users;         /* Builtin power users */
49 DOM_SID global_sid_Builtin_Account_Operators;   /* Builtin account operators */
50 DOM_SID global_sid_Builtin_Server_Operators;    /* Builtin server operators */
51 DOM_SID global_sid_Builtin_Print_Operators;     /* Builtin print operators */
52 DOM_SID global_sid_Builtin_Backup_Operators;    /* Builtin backup operators */
53 DOM_SID global_sid_Builtin_Replicator;          /* Builtin replicator */
54
55 #define SECURITY_NULL_SID_AUTHORITY    0
56 #define SECURITY_WORLD_SID_AUTHORITY   1
57 #define SECURITY_LOCAL_SID_AUTHORITY   2
58 #define SECURITY_CREATOR_SID_AUTHORITY 3
59 #define SECURITY_NT_AUTHORITY          5
60
61 /*
62  * An NT compatible anonymous token.
63  */
64
65 static DOM_SID anon_sid_array[3];
66
67 NT_USER_TOKEN anonymous_token = {
68         3,
69         anon_sid_array
70 };
71
72 static DOM_SID system_sid_array[4];
73 NT_USER_TOKEN system_token = {
74         1,
75         system_sid_array
76 };
77
78 /****************************************************************************
79  Lookup string names for SID types.
80 ****************************************************************************/
81
82 static const struct {
83         enum SID_NAME_USE sid_type;
84         const char *string;
85 } sid_name_type[] = {
86         {SID_NAME_USER, "User"},
87         {SID_NAME_DOM_GRP, "Domain Group"},
88         {SID_NAME_DOMAIN, "Domain"},
89         {SID_NAME_ALIAS, "Local Group"},
90         {SID_NAME_WKN_GRP, "Well-known Group"},
91         {SID_NAME_DELETED, "Deleted Account"},
92         {SID_NAME_INVALID, "Invalid Account"},
93         {SID_NAME_UNKNOWN, "UNKNOWN"},
94         {SID_NAME_COMPUTER, "Computer"},
95
96         {0, NULL}
97 };
98
99 const char *sid_type_lookup(uint32 sid_type) 
100 {
101         int i = 0;
102
103         /* Look through list */
104         while(sid_name_type[i].sid_type != 0) {
105                 if (sid_name_type[i].sid_type == sid_type)
106                         return sid_name_type[i].string;
107                 i++;
108         }
109
110         /* Default return */
111         return "SID *TYPE* is INVALID";
112 }
113
114 /****************************************************************************
115  Creates some useful well known sids
116 ****************************************************************************/
117
118 void generate_wellknown_sids(void)
119 {
120         static BOOL initialised = False;
121
122         if (initialised) 
123                 return;
124
125         /* SECURITY_NULL_SID_AUTHORITY */
126         string_to_sid(&global_sid_NULL, "S-1-0-0");
127
128         /* SECURITY_WORLD_SID_AUTHORITY */
129         string_to_sid(&global_sid_World_Domain, "S-1-1");
130         string_to_sid(&global_sid_World, "S-1-1-0");
131
132         /* SECURITY_CREATOR_SID_AUTHORITY */
133         string_to_sid(&global_sid_Creator_Owner_Domain, "S-1-3");
134         string_to_sid(&global_sid_Creator_Owner, "S-1-3-0");
135         string_to_sid(&global_sid_Creator_Group, "S-1-3-1");
136
137         /* SECURITY_NT_AUTHORITY */
138         string_to_sid(&global_sid_NT_Authority, "S-1-5");
139         string_to_sid(&global_sid_Network, "S-1-5-2");
140         string_to_sid(&global_sid_Anonymous, "S-1-5-7");
141         string_to_sid(&global_sid_Authenticated_Users, "S-1-5-11");
142         string_to_sid(&global_sid_System, "S-1-5-18");
143
144         /* SECURITY_BUILTIN_DOMAIN_RID */
145         string_to_sid(&global_sid_Builtin, "S-1-5-32");
146         string_to_sid(&global_sid_Builtin_Administrators, "S-1-5-32-544");
147         string_to_sid(&global_sid_Builtin_Users, "S-1-5-32-545");
148         string_to_sid(&global_sid_Builtin_Guests, "S-1-5-32-546");
149         string_to_sid(&global_sid_Builtin_Power_Users, "S-1-5-32-547");
150         string_to_sid(&global_sid_Builtin_Account_Operators, "S-1-5-32-548");
151         string_to_sid(&global_sid_Builtin_Server_Operators, "S-1-5-32-549");
152         string_to_sid(&global_sid_Builtin_Print_Operators, "S-1-5-32-550");
153         string_to_sid(&global_sid_Builtin_Backup_Operators, "S-1-5-32-551");
154         string_to_sid(&global_sid_Builtin_Replicator, "S-1-5-32-552");
155
156         /* Create the anon token. */
157         sid_copy( &anonymous_token.user_sids[0], &global_sid_World);
158         sid_copy( &anonymous_token.user_sids[1], &global_sid_Network);
159         sid_copy( &anonymous_token.user_sids[2], &global_sid_Anonymous);
160
161         /* Create the system token. */
162         sid_copy( &system_token.user_sids[0], &global_sid_System);
163         
164         initialised = True;
165 }
166
167 /**************************************************************************
168  Create the SYSTEM token.
169 ***************************************************************************/
170
171 NT_USER_TOKEN *get_system_token(void) 
172 {
173         generate_wellknown_sids(); /* The token is initialised here */
174         return &system_token;
175 }
176
177 /**************************************************************************
178  Splits a name of format \DOMAIN\name or name into its two components.
179  Sets the DOMAIN name to global_myname() if it has not been specified.
180 ***************************************************************************/
181
182 void split_domain_name(const char *fullname, char *domain, char *name)
183 {
184         pstring full_name;
185         const char *sep;
186         char *p;
187
188         sep = lp_winbind_separator();
189
190         *domain = *name = '\0';
191
192         if (fullname[0] == sep[0] || fullname[0] == '\\')
193                 fullname++;
194
195         pstrcpy(full_name, fullname);
196         p = strchr_m(full_name+1, '\\');
197         if (!p) p = strchr_m(full_name+1, sep[0]);
198
199         if (p != NULL) {
200                 *p = 0;
201                 fstrcpy(domain, full_name);
202                 fstrcpy(name, p+1);
203         } else {
204                 fstrcpy(domain, global_myname());
205                 fstrcpy(name, full_name);
206         }
207
208         DEBUG(10,("split_domain_name:name '%s' split into domain :'%s' and user :'%s'\n",
209                         fullname, domain, name));
210 }
211
212 /****************************************************************************
213  Test if a SID is wellknown and resolvable.
214 ****************************************************************************/
215
216 BOOL resolvable_wellknown_sid(DOM_SID *sid)
217 {
218         uint32 ia = (sid->id_auth[5]) +
219                         (sid->id_auth[4] << 8 ) +
220                         (sid->id_auth[3] << 16) +
221                         (sid->id_auth[2] << 24);
222
223         if (sid->sid_rev_num != SEC_DESC_REVISION || sid->num_auths < 1)
224                 return False;
225
226         return (ia == SECURITY_WORLD_SID_AUTHORITY ||
227                 ia == SECURITY_CREATOR_SID_AUTHORITY);
228 }
229
230 /*****************************************************************
231  Convert a SID to an ascii string.
232 *****************************************************************/
233
234 char *sid_to_string(fstring sidstr_out, const DOM_SID *sid)
235 {
236         char subauth[16];
237         int i;
238         uint32 ia;
239   
240         if (!sid) {
241                 fstrcpy(sidstr_out, "(NULL SID)");
242                 return sidstr_out;
243         }
244
245         /*
246          * BIG NOTE: this function only does SIDS where the identauth is not >= 2^32 
247          * in a range of 2^48.
248          */
249         ia = (sid->id_auth[5]) +
250                 (sid->id_auth[4] << 8 ) +
251                 (sid->id_auth[3] << 16) +
252                 (sid->id_auth[2] << 24);
253
254         slprintf(sidstr_out, sizeof(fstring) - 1, "S-%u-%lu", (unsigned int)sid->sid_rev_num, (unsigned long)ia);
255
256         for (i = 0; i < sid->num_auths; i++) {
257                 slprintf(subauth, sizeof(subauth)-1, "-%lu", (unsigned long)sid->sub_auths[i]);
258                 fstrcat(sidstr_out, subauth);
259         }
260
261         return sidstr_out;
262 }
263
264 /*****************************************************************
265  Useful function for debug lines.
266 *****************************************************************/  
267
268 const char *sid_string_static(const DOM_SID *sid)
269 {
270         static fstring sid_str;
271         sid_to_string(sid_str, sid);
272         return sid_str;
273 }
274
275 /*****************************************************************
276  Convert a string to a SID. Returns True on success, False on fail.
277 *****************************************************************/  
278    
279 BOOL string_to_sid(DOM_SID *sidout, const char *sidstr)
280 {
281         pstring tok;
282         char *q;
283         const char *p;
284         /* BIG NOTE: this function only does SIDS where the identauth is not >= 2^32 */
285         uint32 ia;
286   
287         if (StrnCaseCmp( sidstr, "S-", 2)) {
288                 DEBUG(0,("string_to_sid: Sid %s does not start with 'S-'.\n", sidstr));
289                 return False;
290         }
291
292         memset((char *)sidout, '\0', sizeof(DOM_SID));
293
294         p = q = strdup(sidstr + 2);
295         if (p == NULL) {
296                 DEBUG(0, ("string_to_sid: out of memory!\n"));
297                 return False;
298         }
299
300         if (!next_token(&p, tok, "-", sizeof(tok))) {
301                 DEBUG(0,("string_to_sid: Sid %s is not in a valid format.\n", sidstr));
302                 SAFE_FREE(q);
303                 return False;
304         }
305
306         /* Get the revision number. */
307         sidout->sid_rev_num = (uint8)strtoul(tok, NULL, 10);
308
309         if (!next_token(&p, tok, "-", sizeof(tok))) {
310                 DEBUG(0,("string_to_sid: Sid %s is not in a valid format.\n", sidstr));
311                 SAFE_FREE(q);
312                 return False;
313         }
314
315         /* identauth in decimal should be <  2^32 */
316         ia = (uint32)strtoul(tok, NULL, 10);
317
318         /* NOTE - the ia value is in big-endian format. */
319         sidout->id_auth[0] = 0;
320         sidout->id_auth[1] = 0;
321         sidout->id_auth[2] = (ia & 0xff000000) >> 24;
322         sidout->id_auth[3] = (ia & 0x00ff0000) >> 16;
323         sidout->id_auth[4] = (ia & 0x0000ff00) >> 8;
324         sidout->id_auth[5] = (ia & 0x000000ff);
325
326         sidout->num_auths = 0;
327
328         while(next_token(&p, tok, "-", sizeof(tok)) && 
329                 sidout->num_auths < MAXSUBAUTHS) {
330                 /* 
331                  * NOTE - the subauths are in native machine-endian format. They
332                  * are converted to little-endian when linearized onto the wire.
333                  */
334                 sid_append_rid(sidout, (uint32)strtoul(tok, NULL, 10));
335         }
336
337         SAFE_FREE(q);
338         return True;
339 }
340
341 /*****************************************************************
342  Add a rid to the end of a sid
343 *****************************************************************/  
344
345 BOOL sid_append_rid(DOM_SID *sid, uint32 rid)
346 {
347         if (sid->num_auths < MAXSUBAUTHS) {
348                 sid->sub_auths[sid->num_auths++] = rid;
349                 return True;
350         }
351         return False;
352 }
353
354 /*****************************************************************
355  Removes the last rid from the end of a sid
356 *****************************************************************/  
357
358 BOOL sid_split_rid(DOM_SID *sid, uint32 *rid)
359 {
360         if (sid->num_auths > 0) {
361                 sid->num_auths--;
362                 *rid = sid->sub_auths[sid->num_auths];
363                 return True;
364         }
365         return False;
366 }
367
368 /*****************************************************************
369  Return the last rid from the end of a sid
370 *****************************************************************/  
371
372 BOOL sid_peek_rid(const DOM_SID *sid, uint32 *rid)
373 {
374         if (!sid || !rid)
375                 return False;           
376         
377         if (sid->num_auths > 0) {
378                 *rid = sid->sub_auths[sid->num_auths - 1];
379                 return True;
380         }
381         return False;
382 }
383
384 /*****************************************************************
385  Return the last rid from the end of a sid
386  and check the sid against the exp_dom_sid  
387 *****************************************************************/  
388
389 BOOL sid_peek_check_rid(const DOM_SID *exp_dom_sid, const DOM_SID *sid, uint32 *rid)
390 {
391         if (!exp_dom_sid || !sid || !rid)
392                 return False;
393                         
394         if (sid->num_auths != (exp_dom_sid->num_auths+1)) {
395                 return False;
396         }
397
398         if (sid_compare_domain(exp_dom_sid, sid)!=0){
399                 *rid=(-1);
400                 return False;
401         }
402         
403         return sid_peek_rid(sid, rid);
404 }
405
406 /*****************************************************************
407  Copies a sid
408 *****************************************************************/  
409
410 void sid_copy(DOM_SID *dst, const DOM_SID *src)
411 {
412         int i;
413
414         ZERO_STRUCTP(dst);
415
416         dst->sid_rev_num = src->sid_rev_num;
417         dst->num_auths = src->num_auths;
418
419         memcpy(&dst->id_auth[0], &src->id_auth[0], sizeof(src->id_auth));
420
421         for (i = 0; i < src->num_auths; i++)
422                 dst->sub_auths[i] = src->sub_auths[i];
423 }
424
425 /*****************************************************************
426  Write a sid out into on-the-wire format.
427 *****************************************************************/  
428
429 BOOL sid_linearize(char *outbuf, size_t len, const DOM_SID *sid)
430 {
431         size_t i;
432
433         if (len < sid_size(sid))
434                 return False;
435
436         SCVAL(outbuf,0,sid->sid_rev_num);
437         SCVAL(outbuf,1,sid->num_auths);
438         memcpy(&outbuf[2], sid->id_auth, 6);
439         for(i = 0; i < sid->num_auths; i++)
440                 SIVAL(outbuf, 8 + (i*4), sid->sub_auths[i]);
441
442         return True;
443 }
444
445 /*****************************************************************
446  Parse a on-the-wire SID to a DOM_SID.
447 *****************************************************************/  
448
449 BOOL sid_parse(const char *inbuf, size_t len, DOM_SID *sid)
450 {
451         int i;
452         if (len < 8)
453                 return False;
454
455         ZERO_STRUCTP(sid);
456
457         sid->sid_rev_num = CVAL(inbuf, 0);
458         sid->num_auths = CVAL(inbuf, 1);
459         memcpy(sid->id_auth, inbuf+2, 6);
460         if (len < 8 + sid->num_auths*4)
461                 return False;
462         for (i=0;i<sid->num_auths;i++)
463                 sid->sub_auths[i] = IVAL(inbuf, 8+i*4);
464         return True;
465 }
466
467 /*****************************************************************
468  Compare the auth portion of two sids.
469 *****************************************************************/  
470
471 static int sid_compare_auth(const DOM_SID *sid1, const DOM_SID *sid2)
472 {
473         int i;
474
475         if (sid1 == sid2)
476                 return 0;
477         if (!sid1)
478                 return -1;
479         if (!sid2)
480                 return 1;
481
482         if (sid1->sid_rev_num != sid2->sid_rev_num)
483                 return sid1->sid_rev_num - sid2->sid_rev_num;
484
485         for (i = 0; i < 6; i++)
486                 if (sid1->id_auth[i] != sid2->id_auth[i])
487                         return sid1->id_auth[i] - sid2->id_auth[i];
488
489         return 0;
490 }
491
492 /*****************************************************************
493  Compare two sids.
494 *****************************************************************/  
495
496 int sid_compare(const DOM_SID *sid1, const DOM_SID *sid2)
497 {
498         int i;
499
500         if (sid1 == sid2)
501                 return 0;
502         if (!sid1)
503                 return -1;
504         if (!sid2)
505                 return 1;
506
507         /* Compare most likely different rids, first: i.e start at end */
508         if (sid1->num_auths != sid2->num_auths)
509                 return sid1->num_auths - sid2->num_auths;
510
511         for (i = sid1->num_auths-1; i >= 0; --i)
512                 if (sid1->sub_auths[i] != sid2->sub_auths[i])
513                         return sid1->sub_auths[i] - sid2->sub_auths[i];
514
515         return sid_compare_auth(sid1, sid2);
516 }
517
518 /*****************************************************************
519  See if 2 SIDs are in the same domain
520  this just compares the leading sub-auths
521 *****************************************************************/  
522
523 int sid_compare_domain(const DOM_SID *sid1, const DOM_SID *sid2)
524 {
525         int n, i;
526
527         n = MIN(sid1->num_auths, sid2->num_auths);
528
529         for (i = n-1; i >= 0; --i)
530                 if (sid1->sub_auths[i] != sid2->sub_auths[i])
531                         return sid1->sub_auths[i] - sid2->sub_auths[i];
532
533         return sid_compare_auth(sid1, sid2);
534 }
535
536 /*****************************************************************
537  Compare two sids.
538 *****************************************************************/  
539
540 BOOL sid_equal(const DOM_SID *sid1, const DOM_SID *sid2)
541 {
542         return sid_compare(sid1, sid2) == 0;
543 }
544
545 /*****************************************************************
546  Check if the SID is the builtin SID (S-1-5-32).
547 *****************************************************************/  
548
549 BOOL sid_check_is_builtin(const DOM_SID *sid)
550 {
551         return sid_equal(sid, &global_sid_Builtin);
552 }
553
554 /*****************************************************************
555  Check if the SID is one of the builtin SIDs (S-1-5-32-a).
556 *****************************************************************/  
557
558 BOOL sid_check_is_in_builtin(const DOM_SID *sid)
559 {
560         DOM_SID dom_sid;
561         uint32 rid;
562
563         sid_copy(&dom_sid, sid);
564         sid_split_rid(&dom_sid, &rid);
565         
566         return sid_equal(&dom_sid, &global_sid_Builtin);
567 }
568
569 /*****************************************************************
570  Calculates size of a sid.
571 *****************************************************************/  
572
573 size_t sid_size(const DOM_SID *sid)
574 {
575         if (sid == NULL)
576                 return 0;
577
578         return sid->num_auths * sizeof(uint32) + 8;
579 }
580
581 /*****************************************************************
582  Returns true if SID is internal (and non-mappable).
583 *****************************************************************/
584
585 BOOL non_mappable_sid(DOM_SID *sid)
586 {
587         DOM_SID dom;
588         uint32 rid;
589
590         sid_copy(&dom, sid);
591         sid_split_rid(&dom, &rid);
592
593         if (sid_equal(&dom, &global_sid_Builtin))
594                 return True;
595
596         if (sid_equal(&dom, &global_sid_NT_Authority))
597                 return True;
598
599         return False;
600 }
601
602 /*****************************************************************
603  Return the binary string representation of a DOM_SID.
604  Caller must free.
605 *****************************************************************/
606
607 char *sid_binstring(const DOM_SID *sid)
608 {
609         char *buf, *s;
610         int len = sid_size(sid);
611         buf = malloc(len);
612         if (!buf)
613                 return NULL;
614         sid_linearize(buf, len, sid);
615         s = binary_string(buf, len);
616         free(buf);
617         return s;
618 }
619
620
621 /*****************************************************************
622  Print a GUID structure for debugging.
623 *****************************************************************/
624
625 void print_guid(GUID *guid)
626 {
627         int i;
628
629         d_printf("%08x-%04x-%04x", 
630                  IVAL(guid->info, 0), SVAL(guid->info, 4), SVAL(guid->info, 6));
631         d_printf("-%02x%02x-", guid->info[8], guid->info[9]);
632         for (i=10;i<GUID_SIZE;i++)
633                 d_printf("%02x", guid->info[i]);
634         d_printf("\n");
635 }
636
637 /*******************************************************************
638  Tallocs a duplicate SID. 
639 ********************************************************************/ 
640
641 DOM_SID *sid_dup_talloc(TALLOC_CTX *ctx, DOM_SID *src)
642 {
643         DOM_SID *dst;
644         
645         if(!src)
646                 return NULL;
647         
648         if((dst = talloc_zero(ctx, sizeof(DOM_SID))) != NULL) {
649                 sid_copy( dst, src);
650         }
651         
652         return dst;
653 }