c28960be8037f09c9677ea3a186a227e35cddd21
[samba.git] / source / libcli / security / security_descriptor.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    security descriptror utility functions
5
6    Copyright (C) Andrew Tridgell                2004
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 #include "librpc/gen_ndr/ndr_security.h"
25
26 /*
27   return a blank security descriptor (no owners, dacl or sacl)
28 */
29 struct security_descriptor *security_descriptor_initialise(TALLOC_CTX *mem_ctx)
30 {
31         struct security_descriptor *sd;
32
33         sd = talloc(mem_ctx, struct security_descriptor);
34         if (!sd) {
35                 return NULL;
36         }
37
38         sd->revision = SD_REVISION;
39         /* we mark as self relative, even though it isn't while it remains
40            a pointer in memory because this simplifies the ndr code later.
41            All SDs that we store/emit are in fact SELF_RELATIVE
42         */
43         sd->type = SEC_DESC_SELF_RELATIVE;
44
45         sd->owner_sid = NULL;
46         sd->group_sid = NULL;
47         sd->sacl = NULL;
48         sd->dacl = NULL;
49
50         return sd;
51 }
52
53 static struct security_acl *security_acl_dup(TALLOC_CTX *mem_ctx,
54                                              const struct security_acl *oacl)
55 {
56         struct security_acl *nacl;
57         int i;
58
59         nacl = talloc (mem_ctx, struct security_acl);
60         if (nacl == NULL) {
61                 return NULL;
62         }
63
64         nacl->aces = talloc_memdup (nacl, oacl->aces, sizeof(struct security_ace) * oacl->num_aces);
65         if ((nacl->aces == NULL) && (oacl->num_aces > 0)) {
66                 goto failed;
67         }
68
69         /* remapping array in trustee dom_sid from old acl to new acl */
70
71         for (i = 0; i < oacl->num_aces; i++) {
72                 nacl->aces[i].trustee.sub_auths = 
73                         talloc_memdup(nacl->aces, nacl->aces[i].trustee.sub_auths,
74                                       sizeof(uint32_t) * nacl->aces[i].trustee.num_auths);
75
76                 if ((nacl->aces[i].trustee.sub_auths == NULL) && (nacl->aces[i].trustee.num_auths > 0)) {
77                         goto failed;
78                 }
79         }
80
81         nacl->revision = oacl->revision;
82         nacl->size = oacl->size;
83         nacl->num_aces = oacl->num_aces;
84         
85         return nacl;
86
87  failed:
88         talloc_free (nacl);
89         return NULL;
90         
91 }
92
93 /* 
94    talloc and copy a security descriptor
95  */
96 struct security_descriptor *security_descriptor_copy(TALLOC_CTX *mem_ctx, 
97                                                      const struct security_descriptor *osd)
98 {
99         struct security_descriptor *nsd;
100
101         nsd = talloc_zero(mem_ctx, struct security_descriptor);
102         if (!nsd) {
103                 return NULL;
104         }
105
106         if (osd->owner_sid) {
107                 nsd->owner_sid = dom_sid_dup(nsd, osd->owner_sid);
108                 if (nsd->owner_sid == NULL) {
109                         goto failed;
110                 }
111         }
112         
113         if (osd->group_sid) {
114                 nsd->group_sid = dom_sid_dup(nsd, osd->group_sid);
115                 if (nsd->group_sid == NULL) {
116                         goto failed;
117                 }
118         }
119
120         if (osd->sacl) {
121                 nsd->sacl = security_acl_dup(nsd, osd->sacl);
122                 if (nsd->sacl == NULL) {
123                         goto failed;
124                 }
125         }
126
127         if (osd->dacl) {
128                 nsd->dacl = security_acl_dup(nsd, osd->dacl);
129                 if (nsd->dacl == NULL) {
130                         goto failed;
131                 }
132         }
133
134         return nsd;
135
136  failed:
137         talloc_free(nsd);
138
139         return NULL;
140 }
141
142 /*
143   add an ACE to the DACL of a security_descriptor
144 */
145 NTSTATUS security_descriptor_dacl_add(struct security_descriptor *sd, 
146                                       const struct security_ace *ace)
147 {
148         if (sd->dacl == NULL) {
149                 sd->dacl = talloc(sd, struct security_acl);
150                 if (sd->dacl == NULL) {
151                         return NT_STATUS_NO_MEMORY;
152                 }
153                 sd->dacl->revision = NT4_ACL_REVISION;
154                 sd->dacl->size     = 0;
155                 sd->dacl->num_aces = 0;
156                 sd->dacl->aces     = NULL;
157         }
158
159         sd->dacl->aces = talloc_realloc(sd->dacl, sd->dacl->aces, 
160                                           struct security_ace, sd->dacl->num_aces+1);
161         if (sd->dacl->aces == NULL) {
162                 return NT_STATUS_NO_MEMORY;
163         }
164
165         sd->dacl->aces[sd->dacl->num_aces] = *ace;
166         sd->dacl->aces[sd->dacl->num_aces].trustee.sub_auths = 
167                 talloc_memdup(sd->dacl->aces, 
168                               sd->dacl->aces[sd->dacl->num_aces].trustee.sub_auths,
169                               sizeof(uint32_t) * 
170                               sd->dacl->aces[sd->dacl->num_aces].trustee.num_auths);
171         if (sd->dacl->aces[sd->dacl->num_aces].trustee.sub_auths == NULL) {
172                 return NT_STATUS_NO_MEMORY;
173         }
174         
175         sd->dacl->num_aces++;
176
177         sd->type |= SEC_DESC_DACL_PRESENT;
178
179         return NT_STATUS_OK;
180 }
181
182
183 /*
184   delete the ACE corresponding to the given trustee in the DACL of a security_descriptor
185 */
186 NTSTATUS security_descriptor_dacl_del(struct security_descriptor *sd, 
187                                       struct dom_sid *trustee)
188 {
189         int i;
190
191         if (sd->dacl == NULL) {
192                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
193         }
194         
195         for (i=0;i<sd->dacl->num_aces;i++) {
196                 if (dom_sid_equal(trustee, &sd->dacl->aces[i].trustee)) {
197                         memmove(&sd->dacl->aces[i], &sd->dacl->aces[i+1],
198                                 sizeof(sd->dacl->aces[i]) * (sd->dacl->num_aces - (i+1)));
199                         sd->dacl->num_aces--;
200                         if (sd->dacl->num_aces == 0) {
201                                 sd->dacl->aces = NULL;
202                         }
203                         return NT_STATUS_OK;
204                 }
205         }
206         return NT_STATUS_OBJECT_NAME_NOT_FOUND;
207 }
208
209
210 /*
211   compare two security ace structures
212 */
213 BOOL security_ace_equal(const struct security_ace *ace1, 
214                         const struct security_ace *ace2)
215 {
216         if (ace1 == ace2) return True;
217         if (!ace1 || !ace2) return False;
218         if (ace1->type != ace2->type) return False;
219         if (ace1->flags != ace2->flags) return False;
220         if (ace1->access_mask != ace2->access_mask) return False;
221         if (!dom_sid_equal(&ace1->trustee, &ace2->trustee)) return False;
222
223         return True;    
224 }
225
226
227 /*
228   compare two security acl structures
229 */
230 BOOL security_acl_equal(const struct security_acl *acl1, 
231                         const struct security_acl *acl2)
232 {
233         int i;
234
235         if (acl1 == acl2) return True;
236         if (!acl1 || !acl2) return False;
237         if (acl1->revision != acl2->revision) return False;
238         if (acl1->num_aces != acl2->num_aces) return False;
239
240         for (i=0;i<acl1->num_aces;i++) {
241                 if (!security_ace_equal(&acl1->aces[i], &acl2->aces[i])) return False;
242         }
243         return True;    
244 }
245
246 /*
247   compare two security descriptors.
248 */
249 BOOL security_descriptor_equal(const struct security_descriptor *sd1, 
250                                const struct security_descriptor *sd2)
251 {
252         if (sd1 == sd2) return True;
253         if (!sd1 || !sd2) return False;
254         if (sd1->revision != sd2->revision) return False;
255         if (sd1->type != sd2->type) return False;
256
257         if (!dom_sid_equal(sd1->owner_sid, sd2->owner_sid)) return False;
258         if (!dom_sid_equal(sd1->group_sid, sd2->group_sid)) return False;
259         if (!security_acl_equal(sd1->sacl, sd2->sacl))      return False;
260         if (!security_acl_equal(sd1->dacl, sd2->dacl))      return False;
261
262         return True;    
263 }
264
265 /*
266   compare two security descriptors, but allow certain (missing) parts
267   to be masked out of the comparison
268 */
269 BOOL security_descriptor_mask_equal(const struct security_descriptor *sd1, 
270                                     const struct security_descriptor *sd2, 
271                                     uint32_t mask)
272 {
273         if (sd1 == sd2) return True;
274         if (!sd1 || !sd2) return False;
275         if (sd1->revision != sd2->revision) return False;
276         if ((sd1->type & mask) != (sd2->type & mask)) return False;
277
278         if (!dom_sid_equal(sd1->owner_sid, sd2->owner_sid)) return False;
279         if (!dom_sid_equal(sd1->group_sid, sd2->group_sid)) return False;
280         if ((mask & SEC_DESC_DACL_PRESENT) && !security_acl_equal(sd1->dacl, sd2->dacl))      return False;
281         if ((mask & SEC_DESC_SACL_PRESENT) && !security_acl_equal(sd1->sacl, sd2->sacl))      return False;
282
283         return True;    
284 }
285
286
287 /*
288   create a security descriptor using string SIDs. This is used by the
289   torture code to allow the easy creation of complex ACLs
290   This is a varargs function. The list of DACL ACEs ends with a NULL sid.
291
292   Each ACE contains a set of 4 parameters:
293   SID, ACCESS_TYPE, MASK, FLAGS
294
295   a typical call would be:
296
297     sd = security_descriptor_create(mem_ctx,
298                                     mysid,
299                                     mygroup,
300                                     SID_AUTHENTICATED_USERS, 
301                                     SEC_ACE_TYPE_ACCESS_ALLOWED,
302                                     SEC_FILE_ALL,
303                                     SEC_ACE_FLAG_OBJECT_INHERIT,
304                                     NULL);
305   that would create a sd with one DACL ACE
306 */
307 struct security_descriptor *security_descriptor_create(TALLOC_CTX *mem_ctx,
308                                                        const char *owner_sid,
309                                                        const char *group_sid,
310                                                        ...)
311 {
312         va_list ap;
313         struct security_descriptor *sd;
314         const char *sidstr;
315
316         sd = security_descriptor_initialise(mem_ctx);
317         if (sd == NULL) return NULL;
318
319         if (owner_sid) {
320                 sd->owner_sid = dom_sid_parse_talloc(sd, owner_sid);
321                 if (sd->owner_sid == NULL) {
322                         talloc_free(sd);
323                         return NULL;
324                 }
325         }
326         if (group_sid) {
327                 sd->group_sid = dom_sid_parse_talloc(sd, group_sid);
328                 if (sd->group_sid == NULL) {
329                         talloc_free(sd);
330                         return NULL;
331                 }
332         }
333
334         va_start(ap, group_sid);
335         while ((sidstr = va_arg(ap, const char *))) {
336                 struct dom_sid *sid;
337                 struct security_ace *ace = talloc(sd, struct security_ace);
338                 NTSTATUS status;
339
340                 if (ace == NULL) {
341                         talloc_free(sd);
342                         va_end(ap);
343                         return NULL;
344                 }
345                 ace->type = va_arg(ap, unsigned int);
346                 ace->access_mask = va_arg(ap, unsigned int);
347                 ace->flags = va_arg(ap, unsigned int);
348                 sid = dom_sid_parse_talloc(ace, sidstr);
349                 if (sid == NULL) {
350                         va_end(ap);
351                         talloc_free(sd);
352                         return NULL;
353                 }
354                 ace->trustee = *sid;
355                 status = security_descriptor_dacl_add(sd, ace);
356                 /* TODO: check: would talloc_free(ace) here be correct? */
357                 if (!NT_STATUS_IS_OK(status)) {
358                         va_end(ap);
359                         talloc_free(sd);
360                         return NULL;
361                 }
362         }
363         va_end(ap);
364
365         return sd;
366 }