s3-lsa: Allow to lookup 'NT AUTHORITY\Anonymous Logon' as well.
[ira/wip.git] / source3 / passdb / util_wellknown.c
1 /* 
2    Unix SMB/CIFS implementation.
3    Lookup routines for well-known SIDs
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) Volker Lendecke 2005
8    
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 3 of the License, or
12    (at your option) any later version.
13    
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18    
19    You should have received a copy of the GNU General Public License
20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
21 */
22
23 #include "includes.h"
24
25 struct rid_name_map {
26         uint32 rid;
27         const char *name;
28 };
29
30 struct sid_name_map_info
31 {
32         const DOM_SID *sid;
33         const char *name;
34         const struct rid_name_map *known_users;
35 };
36
37 static const struct rid_name_map everyone_users[] = {
38         { 0, "Everyone" },
39         { 0, NULL}};
40
41 static const struct rid_name_map creator_owner_users[] = {
42         { 0, "Creator Owner" },
43         { 1, "Creator Group" },
44         { 0, NULL}};
45
46 static const struct rid_name_map nt_authority_users[] = {
47         {  1, "Dialup" },
48         {  2, "Network"},
49         {  3, "Batch"},
50         {  4, "Interactive"},
51         {  6, "Service"},
52         {  7, "AnonymousLogon"},
53         {  7, "Anonymous Logon"},
54         {  8, "Proxy"},
55         {  9, "ServerLogon"},
56         { 10, "Self"},
57         { 11, "Authenticated Users"},
58         { 12, "Restricted"},
59         { 13, "Terminal Server User"},
60         { 14, "Remote Interactive Logon"},
61         { 15, "This Organization"},
62         { 18, "SYSTEM"},
63         { 19, "Local Service"},
64         { 20, "Network Service"},
65         {  0,  NULL}};
66
67 static struct sid_name_map_info special_domains[] = {
68         { &global_sid_World_Domain, "", everyone_users },
69         { &global_sid_Creator_Owner_Domain, "", creator_owner_users },
70         { &global_sid_NT_Authority, "NT Authority", nt_authority_users },
71         { NULL, NULL, NULL }};
72
73 bool sid_check_is_wellknown_domain(const DOM_SID *sid, const char **name)
74 {
75         int i;
76
77         for (i=0; special_domains[i].sid != NULL; i++) {
78                 if (sid_equal(sid, special_domains[i].sid)) {
79                         if (name != NULL) {
80                                 *name = special_domains[i].name;
81                         }
82                         return True;
83                 }
84         }
85         return False;
86 }
87
88 bool sid_check_is_in_wellknown_domain(const DOM_SID *sid)
89 {
90         DOM_SID dom_sid;
91         uint32 rid;
92
93         sid_copy(&dom_sid, sid);
94         sid_split_rid(&dom_sid, &rid);
95         
96         return sid_check_is_wellknown_domain(&dom_sid, NULL);
97 }
98
99 /**************************************************************************
100  Looks up a known username from one of the known domains.
101 ***************************************************************************/
102
103 bool lookup_wellknown_sid(TALLOC_CTX *mem_ctx, const DOM_SID *sid,
104                           const char **domain, const char **name)
105 {
106         int i;
107         DOM_SID dom_sid;
108         uint32 rid;
109         const struct rid_name_map *users = NULL;
110
111         sid_copy(&dom_sid, sid);
112         if (!sid_split_rid(&dom_sid, &rid)) {
113                 DEBUG(2, ("Could not split rid from SID\n"));
114                 return False;
115         }
116
117         for (i=0; special_domains[i].sid != NULL; i++) {
118                 if (sid_equal(&dom_sid, special_domains[i].sid)) {
119                         *domain = talloc_strdup(mem_ctx,
120                                                 special_domains[i].name);
121                         users = special_domains[i].known_users;
122                         break;
123                 }
124         }
125
126         if (users == NULL) {
127                 DEBUG(10, ("SID %s is no special sid\n", sid_string_dbg(sid)));
128                 return False;
129         }
130
131         for (i=0; users[i].name != NULL; i++) {
132                 if (rid == users[i].rid) {
133                         *name = talloc_strdup(mem_ctx, users[i].name);
134                         return True;
135                 }
136         }
137
138         DEBUG(10, ("RID of special SID %s not found\n", sid_string_dbg(sid)));
139
140         return False;
141 }
142
143 /**************************************************************************
144  Try and map a name to one of the well known SIDs.
145 ***************************************************************************/
146
147 bool lookup_wellknown_name(TALLOC_CTX *mem_ctx, const char *name,
148                            DOM_SID *sid, const char **domain)
149 {
150         int i, j;
151
152         DEBUG(10,("map_name_to_wellknown_sid: looking up %s\n", name));
153
154         for (i=0; special_domains[i].sid != NULL; i++) {
155                 const struct rid_name_map *users =
156                         special_domains[i].known_users;
157
158                 if (users == NULL)
159                         continue;
160
161                 for (j=0; users[j].name != NULL; j++) {
162                         if ( strequal(users[j].name, name) ) {
163                                 sid_copy(sid, special_domains[i].sid);
164                                 sid_append_rid(sid, users[j].rid);
165                                 *domain = talloc_strdup(
166                                         mem_ctx, special_domains[i].name);
167                                 return True;
168                         }
169                 }
170         }
171
172         return False;
173 }