Line data Source code
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 : #include "../libcli/security/security.h"
25 :
26 : struct rid_name_map {
27 : uint32_t rid;
28 : const char *name;
29 : };
30 :
31 : struct sid_name_map_info
32 : {
33 : const struct dom_sid *sid;
34 : const char *name;
35 : const struct rid_name_map *known_users;
36 : };
37 :
38 : static const struct rid_name_map everyone_users[] = {
39 : { 0, "Everyone" },
40 : { 0, NULL}};
41 :
42 : static const struct rid_name_map local_authority_users[] = {
43 : { 0, "Local" },
44 : { 1, "Console Logon" },
45 : { 0, NULL}};
46 :
47 : static const struct rid_name_map creator_owner_users[] = {
48 : { 0, "Creator Owner" },
49 : { 1, "Creator Group" },
50 : { 2, "Creator Owner Server" },
51 : { 3, "Creator Group Server" },
52 : { 4, "Owner Rights" },
53 : { 0, NULL}};
54 :
55 : static const struct rid_name_map nt_authority_users[] = {
56 : { 1, "Dialup" },
57 : { 2, "Network"},
58 : { 3, "Batch"},
59 : { 4, "Interactive"},
60 : { 6, "Service"},
61 : { 7, "Anonymous Logon"},
62 : { 8, "Proxy"},
63 : { 9, "Enterprise Domain Controllers"},
64 : { 10, "Self"},
65 : { 11, "Authenticated Users"},
66 : { 12, "Restricted"},
67 : { 13, "Terminal Server User"},
68 : { 14, "Remote Interactive Logon"},
69 : { 15, "This Organization"},
70 : { 17, "IUSR"},
71 : { 18, "SYSTEM"},
72 : { 19, "Local Service"},
73 : { 20, "Network Service"},
74 : { 0, NULL}};
75 :
76 : static struct sid_name_map_info special_domains[] = {
77 : { &global_sid_World_Domain, "", everyone_users },
78 : { &global_sid_Local_Authority, "", local_authority_users },
79 : { &global_sid_Creator_Owner_Domain, "", creator_owner_users },
80 : { &global_sid_NT_Authority, "NT Authority", nt_authority_users },
81 : { NULL, NULL, NULL }};
82 :
83 99168 : bool sid_check_is_wellknown_domain(const struct dom_sid *sid, const char **name)
84 : {
85 296 : int i;
86 :
87 410974 : for (i=0; special_domains[i].sid != NULL; i++) {
88 367092 : if (dom_sid_equal(sid, special_domains[i].sid)) {
89 55286 : if (name != NULL) {
90 0 : *name = special_domains[i].name;
91 : }
92 55286 : return True;
93 : }
94 : }
95 43600 : return False;
96 : }
97 :
98 74629 : bool sid_check_is_in_wellknown_domain(const struct dom_sid *sid)
99 : {
100 26 : struct dom_sid dom_sid;
101 :
102 74629 : sid_copy(&dom_sid, sid);
103 74629 : sid_split_rid(&dom_sid, NULL);
104 :
105 74629 : return sid_check_is_wellknown_domain(&dom_sid, NULL);
106 : }
107 :
108 : /**************************************************************************
109 : Looks up a known username from one of the known domains.
110 : ***************************************************************************/
111 :
112 124 : bool lookup_wellknown_sid(TALLOC_CTX *mem_ctx, const struct dom_sid *sid,
113 : const char **domain, const char **name)
114 : {
115 0 : int i;
116 0 : struct dom_sid dom_sid;
117 0 : uint32_t rid;
118 124 : const struct rid_name_map *users = NULL;
119 0 : struct dom_sid_buf buf;
120 :
121 124 : sid_copy(&dom_sid, sid);
122 124 : if (!sid_split_rid(&dom_sid, &rid)) {
123 0 : DEBUG(2, ("Could not split rid from SID\n"));
124 0 : return False;
125 : }
126 :
127 258 : for (i=0; special_domains[i].sid != NULL; i++) {
128 258 : if (dom_sid_equal(&dom_sid, special_domains[i].sid)) {
129 124 : *domain = talloc_strdup(mem_ctx,
130 : special_domains[i].name);
131 124 : users = special_domains[i].known_users;
132 124 : break;
133 : }
134 : }
135 :
136 124 : if (users == NULL) {
137 0 : DEBUG(10, ("SID %s is no special sid\n",
138 : dom_sid_str_buf(sid, &buf)));
139 0 : return False;
140 : }
141 :
142 390 : for (i=0; users[i].name != NULL; i++) {
143 390 : if (rid == users[i].rid) {
144 124 : *name = talloc_strdup(mem_ctx, users[i].name);
145 124 : return True;
146 : }
147 : }
148 :
149 0 : DEBUG(10, ("RID of special SID %s not found\n",
150 : dom_sid_str_buf(sid, &buf)));
151 :
152 0 : return False;
153 : }
154 :
155 : /**************************************************************************
156 : Try and map a name to one of the well known SIDs.
157 : ***************************************************************************/
158 :
159 1936 : bool lookup_wellknown_name(TALLOC_CTX *mem_ctx, const char *name,
160 : struct dom_sid *sid, const char **pdomain)
161 : {
162 0 : int i, j;
163 1936 : const char *domain = *pdomain;
164 :
165 1936 : DEBUG(10,("map_name_to_wellknown_sid: looking up %s\\%s\n", domain, name));
166 :
167 9584 : for (i=0; special_domains[i].sid != NULL; i++) {
168 7672 : const struct rid_name_map *users =
169 : special_domains[i].known_users;
170 :
171 7672 : if (domain[0] != '\0') {
172 0 : if (!strequal(domain, special_domains[i].name)) {
173 0 : continue;
174 : }
175 : }
176 :
177 7672 : if (users == NULL)
178 0 : continue;
179 :
180 57384 : for (j=0; users[j].name != NULL; j++) {
181 49736 : if ( strequal(users[j].name, name) ) {
182 24 : sid_compose(sid, special_domains[i].sid,
183 24 : users[j].rid);
184 24 : *pdomain = talloc_strdup(
185 : mem_ctx, special_domains[i].name);
186 24 : return True;
187 : }
188 : }
189 : }
190 :
191 1912 : return False;
192 : }
|
