s4:UID wrapper - Fix includes
[ira/wip.git] / source4 / ntvfs / posix / pvfs_acl.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    POSIX NTVFS backend - ACL support
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 3 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, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "auth/auth.h"
24 #include "vfs_posix.h"
25 #include "librpc/gen_ndr/xattr.h"
26 #include "libcli/security/security.h"
27 #include "param/param.h"
28
29 #if defined(UID_WRAPPER)
30 #if !defined(UID_WRAPPER_REPLACE) && !defined(UID_WRAPPER_NOT_REPLACE)
31 #define UID_WRAPPER_REPLACE
32 #include "../uid_wrapper/uid_wrapper.h"
33 #endif
34 #else
35 #define uwrap_enabled() 0
36 #endif
37
38 /* the list of currently registered ACL backends */
39 static struct pvfs_acl_backend {
40         const struct pvfs_acl_ops *ops;
41 } *backends = NULL;
42 static int num_backends;
43
44 /*
45   register a pvfs acl backend. 
46
47   The 'name' can be later used by other backends to find the operations
48   structure for this backend.  
49 */
50 NTSTATUS pvfs_acl_register(const struct pvfs_acl_ops *ops)
51 {
52         struct pvfs_acl_ops *new_ops;
53
54         if (pvfs_acl_backend_byname(ops->name) != NULL) {
55                 DEBUG(0,("pvfs acl backend '%s' already registered\n", ops->name));
56                 return NT_STATUS_OBJECT_NAME_COLLISION;
57         }
58
59         backends = talloc_realloc(talloc_autofree_context(), backends, struct pvfs_acl_backend, num_backends+1);
60         NT_STATUS_HAVE_NO_MEMORY(backends);
61
62         new_ops = (struct pvfs_acl_ops *)talloc_memdup(backends, ops, sizeof(*ops));
63         new_ops->name = talloc_strdup(new_ops, ops->name);
64
65         backends[num_backends].ops = new_ops;
66
67         num_backends++;
68
69         DEBUG(3,("NTVFS backend '%s' registered\n", ops->name));
70
71         return NT_STATUS_OK;
72 }
73
74
75 /*
76   return the operations structure for a named backend
77 */
78 const struct pvfs_acl_ops *pvfs_acl_backend_byname(const char *name)
79 {
80         int i;
81
82         for (i=0;i<num_backends;i++) {
83                 if (strcmp(backends[i].ops->name, name) == 0) {
84                         return backends[i].ops;
85                 }
86         }
87
88         return NULL;
89 }
90
91 NTSTATUS pvfs_acl_init(struct loadparm_context *lp_ctx)
92 {
93         static bool initialized = false;
94         extern NTSTATUS pvfs_acl_nfs4_init(void);
95         extern NTSTATUS pvfs_acl_xattr_init(void);
96         init_module_fn static_init[] = { STATIC_pvfs_acl_MODULES };
97         init_module_fn *shared_init;
98
99         if (initialized) return NT_STATUS_OK;
100         initialized = true;
101
102         shared_init = load_samba_modules(NULL, lp_ctx, "pvfs_acl");
103
104         run_init_functions(static_init);
105         run_init_functions(shared_init);
106
107         talloc_free(shared_init);
108
109         return NT_STATUS_OK;
110 }
111
112
113 /*
114   map a single access_mask from generic to specific bits for files/dirs
115 */
116 static uint32_t pvfs_translate_mask(uint32_t access_mask)
117 {
118         if (access_mask & SEC_MASK_GENERIC) {
119                 if (access_mask & SEC_GENERIC_READ)    access_mask |= SEC_RIGHTS_FILE_READ;
120                 if (access_mask & SEC_GENERIC_WRITE)   access_mask |= SEC_RIGHTS_FILE_WRITE;
121                 if (access_mask & SEC_GENERIC_EXECUTE) access_mask |= SEC_RIGHTS_FILE_EXECUTE;
122                 if (access_mask & SEC_GENERIC_ALL)     access_mask |= SEC_RIGHTS_FILE_ALL;
123                 access_mask &= ~SEC_MASK_GENERIC;
124         }
125         return access_mask;
126 }
127
128
129 /*
130   map any generic access bits in the given acl
131   this relies on the fact that the mappings for files and directories
132   are the same
133 */
134 static void pvfs_translate_generic_bits(struct security_acl *acl)
135 {
136         unsigned i;
137
138         if (!acl) return;
139
140         for (i=0;i<acl->num_aces;i++) {
141                 struct security_ace *ace = &acl->aces[i];
142                 ace->access_mask = pvfs_translate_mask(ace->access_mask);
143         }
144 }
145
146
147 /*
148   setup a default ACL for a file
149 */
150 static NTSTATUS pvfs_default_acl(struct pvfs_state *pvfs,
151                                  struct ntvfs_request *req,
152                                  struct pvfs_filename *name, int fd, 
153                                  struct security_descriptor **psd)
154 {
155         struct security_descriptor *sd;
156         NTSTATUS status;
157         struct security_ace ace;
158         mode_t mode;
159         struct id_mapping *ids;
160         struct composite_context *ctx;
161
162         *psd = security_descriptor_initialise(req);
163         if (*psd == NULL) {
164                 return NT_STATUS_NO_MEMORY;
165         }
166         sd = *psd;
167
168         ids = talloc_zero_array(sd, struct id_mapping, 2);
169         NT_STATUS_HAVE_NO_MEMORY(ids);
170
171         ids[0].unixid = talloc(ids, struct unixid);
172         NT_STATUS_HAVE_NO_MEMORY(ids[0].unixid);
173
174         ids[0].unixid->id = name->st.st_uid;
175         ids[0].unixid->type = ID_TYPE_UID;
176         ids[0].sid = NULL;
177
178         ids[1].unixid = talloc(ids, struct unixid);
179         NT_STATUS_HAVE_NO_MEMORY(ids[1].unixid);
180
181         ids[1].unixid->id = name->st.st_gid;
182         ids[1].unixid->type = ID_TYPE_GID;
183         ids[1].sid = NULL;
184
185         ctx = wbc_xids_to_sids_send(pvfs->wbc_ctx, ids, 2, ids);
186         NT_STATUS_HAVE_NO_MEMORY(ctx);
187
188         status = wbc_xids_to_sids_recv(ctx, &ids);
189         NT_STATUS_NOT_OK_RETURN(status);
190
191         sd->owner_sid = talloc_steal(sd, ids[0].sid);
192         sd->group_sid = talloc_steal(sd, ids[1].sid);
193
194         talloc_free(ids);
195         sd->type |= SEC_DESC_DACL_PRESENT;
196
197         mode = name->st.st_mode;
198
199         /*
200           we provide up to 4 ACEs
201             - Owner
202             - Group
203             - Everyone
204             - Administrator
205          */
206
207
208         /* setup owner ACE */
209         ace.type = SEC_ACE_TYPE_ACCESS_ALLOWED;
210         ace.flags = 0;
211         ace.trustee = *sd->owner_sid;
212         ace.access_mask = 0;
213
214         if (mode & S_IRUSR) {
215                 if (mode & S_IWUSR) {
216                         ace.access_mask |= SEC_RIGHTS_FILE_ALL;
217                 } else {
218                         ace.access_mask |= SEC_RIGHTS_FILE_READ | SEC_FILE_EXECUTE;
219                 }
220         }
221         if (mode & S_IWUSR) {
222                 ace.access_mask |= SEC_RIGHTS_FILE_WRITE | SEC_STD_DELETE;
223         }
224         if (ace.access_mask) {
225                 security_descriptor_dacl_add(sd, &ace);
226         }
227
228
229         /* setup group ACE */
230         ace.trustee = *sd->group_sid;
231         ace.access_mask = 0;
232         if (mode & S_IRGRP) {
233                 ace.access_mask |= SEC_RIGHTS_FILE_READ | SEC_FILE_EXECUTE;
234         }
235         if (mode & S_IWGRP) {
236                 /* note that delete is not granted - this matches posix behaviour */
237                 ace.access_mask |= SEC_RIGHTS_FILE_WRITE;
238         }
239         if (ace.access_mask) {
240                 security_descriptor_dacl_add(sd, &ace);
241         }
242
243         /* setup other ACE */
244         ace.trustee = *dom_sid_parse_talloc(req, SID_WORLD);
245         ace.access_mask = 0;
246         if (mode & S_IROTH) {
247                 ace.access_mask |= SEC_RIGHTS_FILE_READ | SEC_FILE_EXECUTE;
248         }
249         if (mode & S_IWOTH) {
250                 ace.access_mask |= SEC_RIGHTS_FILE_WRITE;
251         }
252         if (ace.access_mask) {
253                 security_descriptor_dacl_add(sd, &ace);
254         }
255
256         /* setup system ACE */
257         ace.trustee = *dom_sid_parse_talloc(req, SID_NT_SYSTEM);
258         ace.access_mask = SEC_RIGHTS_FILE_ALL;
259         security_descriptor_dacl_add(sd, &ace);
260         
261         return NT_STATUS_OK;
262 }
263                                  
264
265 /*
266   omit any security_descriptor elements not specified in the given
267   secinfo flags
268 */
269 static void normalise_sd_flags(struct security_descriptor *sd, uint32_t secinfo_flags)
270 {
271         if (!(secinfo_flags & SECINFO_OWNER)) {
272                 sd->owner_sid = NULL;
273         }
274         if (!(secinfo_flags & SECINFO_GROUP)) {
275                 sd->group_sid = NULL;
276         }
277         if (!(secinfo_flags & SECINFO_DACL)) {
278                 sd->dacl = NULL;
279         }
280         if (!(secinfo_flags & SECINFO_SACL)) {
281                 sd->sacl = NULL;
282         }
283 }
284
285 /*
286   answer a setfileinfo for an ACL
287 */
288 NTSTATUS pvfs_acl_set(struct pvfs_state *pvfs, 
289                       struct ntvfs_request *req,
290                       struct pvfs_filename *name, int fd, 
291                       uint32_t access_mask,
292                       union smb_setfileinfo *info)
293 {
294         uint32_t secinfo_flags = info->set_secdesc.in.secinfo_flags;
295         struct security_descriptor *new_sd, *sd, orig_sd;
296         NTSTATUS status = NT_STATUS_NOT_FOUND;
297         uid_t old_uid = -1;
298         gid_t old_gid = -1;
299         uid_t new_uid = -1;
300         gid_t new_gid = -1;
301         struct id_mapping *ids;
302         struct composite_context *ctx;
303
304         if (pvfs->acl_ops != NULL) {
305                 status = pvfs->acl_ops->acl_load(pvfs, name, fd, req, &sd);
306         }
307         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
308                 status = pvfs_default_acl(pvfs, req, name, fd, &sd);
309         }
310         if (!NT_STATUS_IS_OK(status)) {
311                 return status;
312         }
313
314         ids = talloc(req, struct id_mapping);
315         NT_STATUS_HAVE_NO_MEMORY(ids);
316         ids->unixid = NULL;
317         ids->sid = NULL;
318         ids->status = NT_STATUS_NONE_MAPPED;
319
320         new_sd = info->set_secdesc.in.sd;
321         orig_sd = *sd;
322
323         old_uid = name->st.st_uid;
324         old_gid = name->st.st_gid;
325
326         /* only set the elements that have been specified */
327         if (secinfo_flags & SECINFO_OWNER) {
328                 if (!(access_mask & SEC_STD_WRITE_OWNER)) {
329                         return NT_STATUS_ACCESS_DENIED;
330                 }
331                 if (!dom_sid_equal(sd->owner_sid, new_sd->owner_sid)) {
332                         ids->sid = new_sd->owner_sid;
333                         ctx = wbc_sids_to_xids_send(pvfs->wbc_ctx, ids, 1, ids);
334                         NT_STATUS_HAVE_NO_MEMORY(ctx);
335                         status = wbc_sids_to_xids_recv(ctx, &ids);
336                         NT_STATUS_NOT_OK_RETURN(status);
337
338                         if (ids->unixid->type == ID_TYPE_BOTH ||
339                             ids->unixid->type == ID_TYPE_UID) {
340                                 new_uid = ids->unixid->id;
341                         }
342                 }
343                 sd->owner_sid = new_sd->owner_sid;
344         }
345         if (secinfo_flags & SECINFO_GROUP) {
346                 if (!(access_mask & SEC_STD_WRITE_OWNER)) {
347                         return NT_STATUS_ACCESS_DENIED;
348                 }
349                 if (!dom_sid_equal(sd->group_sid, new_sd->group_sid)) {
350                         ids->sid = new_sd->group_sid;
351                         ctx = wbc_sids_to_xids_send(pvfs->wbc_ctx, ids, 1, ids);
352                         NT_STATUS_HAVE_NO_MEMORY(ctx);
353                         status = wbc_sids_to_xids_recv(ctx, &ids);
354                         NT_STATUS_NOT_OK_RETURN(status);
355
356                         if (ids->unixid->type == ID_TYPE_BOTH ||
357                             ids->unixid->type == ID_TYPE_GID) {
358                                 new_gid = ids->unixid->id;
359                         }
360
361                 }
362                 sd->group_sid = new_sd->group_sid;
363         }
364         if (secinfo_flags & SECINFO_DACL) {
365                 if (!(access_mask & SEC_STD_WRITE_DAC)) {
366                         return NT_STATUS_ACCESS_DENIED;
367                 }
368                 sd->dacl = new_sd->dacl;
369                 pvfs_translate_generic_bits(sd->dacl);
370         }
371         if (secinfo_flags & SECINFO_SACL) {
372                 if (!(access_mask & SEC_FLAG_SYSTEM_SECURITY)) {
373                         return NT_STATUS_ACCESS_DENIED;
374                 }
375                 sd->sacl = new_sd->sacl;
376                 pvfs_translate_generic_bits(sd->sacl);
377         }
378
379         if (new_uid == old_uid) {
380                 new_uid = -1;
381         }
382
383         if (new_gid == old_gid) {
384                 new_gid = -1;
385         }
386
387         /* if there's something to change try it */
388         if (new_uid != -1 || new_gid != -1) {
389                 int ret;
390                 if (fd == -1) {
391                         ret = chown(name->full_name, new_uid, new_gid);
392                 } else {
393                         ret = fchown(fd, new_uid, new_gid);
394                 }
395                 if (errno == EPERM && uwrap_enabled()) {
396                         ret = 0;
397                 }
398                 if (ret == -1) {
399                         return pvfs_map_errno(pvfs, errno);
400                 }
401         }
402
403         /* we avoid saving if the sd is the same. This means when clients
404            copy files and end up copying the default sd that we don't
405            needlessly use xattrs */
406         if (!security_descriptor_equal(sd, &orig_sd) && pvfs->acl_ops) {
407                 status = pvfs->acl_ops->acl_save(pvfs, name, fd, sd);
408         }
409
410         return status;
411 }
412
413
414 /*
415   answer a fileinfo query for the ACL
416 */
417 NTSTATUS pvfs_acl_query(struct pvfs_state *pvfs, 
418                         struct ntvfs_request *req,
419                         struct pvfs_filename *name, int fd, 
420                         union smb_fileinfo *info)
421 {
422         NTSTATUS status = NT_STATUS_NOT_FOUND;
423         struct security_descriptor *sd;
424
425         if (pvfs->acl_ops) {
426                 status = pvfs->acl_ops->acl_load(pvfs, name, fd, req, &sd);
427         }
428         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
429                 status = pvfs_default_acl(pvfs, req, name, fd, &sd);
430         }
431         if (!NT_STATUS_IS_OK(status)) {
432                 return status;
433         }
434
435         normalise_sd_flags(sd, info->query_secdesc.in.secinfo_flags);
436
437         info->query_secdesc.out.sd = sd;
438
439         return NT_STATUS_OK;
440 }
441
442
443 /*
444   check the read only bit against any of the write access bits
445 */
446 static bool pvfs_read_only(struct pvfs_state *pvfs, uint32_t access_mask)
447 {
448         if ((pvfs->flags & PVFS_FLAG_READONLY) &&
449             (access_mask & (SEC_FILE_WRITE_DATA |
450                             SEC_FILE_APPEND_DATA | 
451                             SEC_FILE_WRITE_EA | 
452                             SEC_FILE_WRITE_ATTRIBUTE | 
453                             SEC_STD_DELETE | 
454                             SEC_STD_WRITE_DAC | 
455                             SEC_STD_WRITE_OWNER | 
456                             SEC_DIR_DELETE_CHILD))) {
457                 return true;
458         }
459         return false;
460 }
461
462 /*
463   see if we are a member of the appropriate unix group
464  */
465 static bool pvfs_group_member(struct pvfs_state *pvfs, gid_t gid)
466 {
467         int i, ngroups;
468         gid_t *groups;
469         if (getegid() == gid) {
470                 return true;
471         }
472         ngroups = getgroups(0, NULL);
473         if (ngroups == 0) {
474                 return false;
475         }
476         groups = talloc_array(pvfs, gid_t, ngroups);
477         if (groups == NULL) {
478                 return false;
479         }
480         if (getgroups(ngroups, groups) != ngroups) {
481                 talloc_free(groups);
482                 return false;
483         }
484         for (i=0; i<ngroups; i++) {
485                 if (groups[i] == gid) break;
486         }
487         talloc_free(groups);
488         return i < ngroups;
489 }
490
491 /*
492   default access check function based on unix permissions
493   doing this saves on building a full security descriptor
494   for the common case of access check on files with no 
495   specific NT ACL
496
497   If name is NULL then treat as a new file creation
498 */
499 NTSTATUS pvfs_access_check_unix(struct pvfs_state *pvfs, 
500                                 struct ntvfs_request *req,
501                                 struct pvfs_filename *name,
502                                 uint32_t *access_mask)
503 {
504         uid_t uid = geteuid();
505         uint32_t max_bits = SEC_RIGHTS_FILE_READ | SEC_FILE_ALL;
506         struct security_token *token = req->session_info->security_token;
507
508         if (pvfs_read_only(pvfs, *access_mask)) {
509                 return NT_STATUS_ACCESS_DENIED;
510         }
511
512         if (name == NULL || uid == name->st.st_uid) {
513                 max_bits |= SEC_STD_ALL;
514         } else if (security_token_has_privilege(token, SEC_PRIV_RESTORE)) {
515                 max_bits |= SEC_STD_DELETE;
516         }
517
518         if (name == NULL ||
519             (name->st.st_mode & S_IWOTH) ||
520             ((name->st.st_mode & S_IWGRP) && 
521              pvfs_group_member(pvfs, name->st.st_gid))) {
522                 max_bits |= SEC_STD_ALL;
523         }
524
525         if (uwrap_enabled()) {
526                 /* when running with the uid wrapper, files will be created
527                    owned by the ruid, but we may have a different simulated 
528                    euid. We need to force the permission bits as though the 
529                    files owner matches the euid */
530                 max_bits |= SEC_STD_ALL;
531         }
532
533         if (*access_mask & SEC_FLAG_MAXIMUM_ALLOWED) {
534                 *access_mask |= max_bits;
535                 *access_mask &= ~SEC_FLAG_MAXIMUM_ALLOWED;
536         }
537
538         if ((*access_mask & SEC_FLAG_SYSTEM_SECURITY) &&
539             security_token_has_privilege(token, SEC_PRIV_SECURITY)) {
540                 max_bits |= SEC_FLAG_SYSTEM_SECURITY;
541         }
542         
543         if (((*access_mask & ~max_bits) & SEC_RIGHTS_PRIV_RESTORE) &&
544             security_token_has_privilege(token, SEC_PRIV_RESTORE)) {
545                 max_bits |= ~(SEC_RIGHTS_PRIV_RESTORE);
546         }
547         if (((*access_mask & ~max_bits) & SEC_RIGHTS_PRIV_BACKUP) &&
548             security_token_has_privilege(token, SEC_PRIV_BACKUP)) {
549                 max_bits |= ~(SEC_RIGHTS_PRIV_BACKUP);
550         }
551
552         if (*access_mask & ~max_bits) {
553                 DEBUG(0,(__location__ " denied access to '%s' - wanted 0x%08x but got 0x%08x (missing 0x%08x)\n",
554                          name?name->full_name:"(new file)", *access_mask, max_bits, *access_mask & ~max_bits));
555                 return NT_STATUS_ACCESS_DENIED;
556         }
557
558         if (pvfs->ntvfs->ctx->protocol != PROTOCOL_SMB2) {
559                 /* on SMB, this bit is always granted, even if not
560                    asked for */
561                 *access_mask |= SEC_FILE_READ_ATTRIBUTE;
562         }
563
564         return NT_STATUS_OK;
565 }
566
567
568 /*
569   check the security descriptor on a file, if any
570   
571   *access_mask is modified with the access actually granted
572 */
573 NTSTATUS pvfs_access_check(struct pvfs_state *pvfs, 
574                            struct ntvfs_request *req,
575                            struct pvfs_filename *name,
576                            uint32_t *access_mask)
577 {
578         struct security_token *token = req->session_info->security_token;
579         struct xattr_NTACL *acl;
580         NTSTATUS status;
581         struct security_descriptor *sd;
582
583         /* on SMB2 a blank access mask is always denied */
584         if (pvfs->ntvfs->ctx->protocol == PROTOCOL_SMB2 &&
585             *access_mask == 0) {
586                 return NT_STATUS_ACCESS_DENIED;
587         }
588
589         if (pvfs_read_only(pvfs, *access_mask)) {
590                 return NT_STATUS_ACCESS_DENIED;
591         }
592
593         acl = talloc(req, struct xattr_NTACL);
594         if (acl == NULL) {
595                 return NT_STATUS_NO_MEMORY;
596         }
597
598         /* expand the generic access bits to file specific bits */
599         *access_mask = pvfs_translate_mask(*access_mask);
600         if (pvfs->ntvfs->ctx->protocol != PROTOCOL_SMB2) {
601                 *access_mask &= ~SEC_FILE_READ_ATTRIBUTE;
602         }
603
604         status = pvfs_acl_load(pvfs, name, -1, acl);
605         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
606                 talloc_free(acl);
607                 return pvfs_access_check_unix(pvfs, req, name, access_mask);
608         }
609         if (!NT_STATUS_IS_OK(status)) {
610                 return status;
611         }
612
613         switch (acl->version) {
614         case 1:
615                 sd = acl->info.sd;
616                 break;
617         default:
618                 return NT_STATUS_INVALID_ACL;
619         }
620
621         /* check the acl against the required access mask */
622         status = sec_access_check(sd, token, *access_mask, access_mask);
623
624         if (pvfs->ntvfs->ctx->protocol != PROTOCOL_SMB2) {
625                 /* on SMB, this bit is always granted, even if not
626                    asked for */
627                 *access_mask |= SEC_FILE_READ_ATTRIBUTE;
628         }
629
630         talloc_free(acl);
631         
632         return status;
633 }
634
635
636 /*
637   a simplified interface to access check, designed for calls that
638   do not take or return an access check mask
639 */
640 NTSTATUS pvfs_access_check_simple(struct pvfs_state *pvfs, 
641                                   struct ntvfs_request *req,
642                                   struct pvfs_filename *name,
643                                   uint32_t access_needed)
644 {
645         if (access_needed == 0) {
646                 return NT_STATUS_OK;
647         }
648         return pvfs_access_check(pvfs, req, name, &access_needed);
649 }
650
651 /*
652   access check for creating a new file/directory
653 */
654 NTSTATUS pvfs_access_check_create(struct pvfs_state *pvfs, 
655                                   struct ntvfs_request *req,
656                                   struct pvfs_filename *name,
657                                   uint32_t *access_mask,
658                                   bool container,
659                                   struct security_descriptor **sd)
660 {
661         struct pvfs_filename *parent;
662         NTSTATUS status;
663
664         if (pvfs_read_only(pvfs, *access_mask)) {
665                 return NT_STATUS_ACCESS_DENIED;
666         }
667
668         status = pvfs_resolve_parent(pvfs, req, name, &parent);
669         NT_STATUS_NOT_OK_RETURN(status);
670
671         status = pvfs_access_check_simple(pvfs, req, parent, SEC_DIR_ADD_FILE);
672         NT_STATUS_NOT_OK_RETURN(status);
673
674         if (*sd == NULL) {
675                 status = pvfs_acl_inherited_sd(pvfs, req, req, parent, container, sd);
676         }
677
678         talloc_free(parent);
679         if (!NT_STATUS_IS_OK(status)) {
680                 return status;
681         }
682
683         /* expand the generic access bits to file specific bits */
684         *access_mask = pvfs_translate_mask(*access_mask);
685
686         if (*access_mask & SEC_FLAG_MAXIMUM_ALLOWED) {
687                 *access_mask |= SEC_RIGHTS_FILE_ALL;
688                 *access_mask &= ~SEC_FLAG_MAXIMUM_ALLOWED;
689         }
690
691         if (pvfs->ntvfs->ctx->protocol != PROTOCOL_SMB2) {
692                 /* on SMB, this bit is always granted, even if not
693                    asked for */
694                 *access_mask |= SEC_FILE_READ_ATTRIBUTE;
695         }
696
697         return NT_STATUS_OK;
698 }
699
700 /*
701   access check for creating a new file/directory - no access mask supplied
702 */
703 NTSTATUS pvfs_access_check_parent(struct pvfs_state *pvfs, 
704                                   struct ntvfs_request *req,
705                                   struct pvfs_filename *name,
706                                   uint32_t access_mask)
707 {
708         struct pvfs_filename *parent;
709         NTSTATUS status;
710
711         status = pvfs_resolve_parent(pvfs, req, name, &parent);
712         if (!NT_STATUS_IS_OK(status)) {
713                 return status;
714         }
715
716         return pvfs_access_check_simple(pvfs, req, parent, access_mask);
717 }
718
719
720 /*
721   determine if an ACE is inheritable
722 */
723 static bool pvfs_inheritable_ace(struct pvfs_state *pvfs,
724                                  const struct security_ace *ace,
725                                  bool container)
726 {
727         if (!container) {
728                 return (ace->flags & SEC_ACE_FLAG_OBJECT_INHERIT) != 0;
729         }
730
731         if (ace->flags & SEC_ACE_FLAG_CONTAINER_INHERIT) {
732                 return true;
733         }
734
735         if ((ace->flags & SEC_ACE_FLAG_OBJECT_INHERIT) &&
736             !(ace->flags & SEC_ACE_FLAG_NO_PROPAGATE_INHERIT)) {
737                 return true;
738         }
739
740         return false;
741 }
742
743 /*
744   this is the core of ACL inheritance. It copies any inheritable
745   aces from the parent SD to the child SD. Note that the algorithm 
746   depends on whether the child is a container or not
747 */
748 static NTSTATUS pvfs_acl_inherit_aces(struct pvfs_state *pvfs, 
749                                       struct security_descriptor *parent_sd,
750                                       struct security_descriptor *sd,
751                                       bool container)
752 {
753         int i;
754         
755         for (i=0;i<parent_sd->dacl->num_aces;i++) {
756                 struct security_ace ace = parent_sd->dacl->aces[i];
757                 NTSTATUS status;
758                 const struct dom_sid *creator = NULL, *new_id = NULL;
759                 uint32_t orig_flags;
760
761                 if (!pvfs_inheritable_ace(pvfs, &ace, container)) {
762                         continue;
763                 }
764
765                 orig_flags = ace.flags;
766
767                 /* see the RAW-ACLS inheritance test for details on these rules */
768                 if (!container) {
769                         ace.flags = 0;
770                 } else {
771                         ace.flags &= ~SEC_ACE_FLAG_INHERIT_ONLY;
772
773                         if (!(ace.flags & SEC_ACE_FLAG_CONTAINER_INHERIT)) {
774                                 ace.flags |= SEC_ACE_FLAG_INHERIT_ONLY;
775                         }
776                         if (ace.flags & SEC_ACE_FLAG_NO_PROPAGATE_INHERIT) {
777                                 ace.flags = 0;
778                         }
779                 }
780
781                 /* the CREATOR sids are special when inherited */
782                 if (dom_sid_equal(&ace.trustee, pvfs->sid_cache.creator_owner)) {
783                         creator = pvfs->sid_cache.creator_owner;
784                         new_id = sd->owner_sid;
785                 } else if (dom_sid_equal(&ace.trustee, pvfs->sid_cache.creator_group)) {
786                         creator = pvfs->sid_cache.creator_group;
787                         new_id = sd->group_sid;
788                 } else {
789                         new_id = &ace.trustee;
790                 }
791
792                 if (creator && container && 
793                     (ace.flags & SEC_ACE_FLAG_CONTAINER_INHERIT)) {
794                         uint32_t flags = ace.flags;
795
796                         ace.trustee = *new_id;
797                         ace.flags = 0;
798                         status = security_descriptor_dacl_add(sd, &ace);
799                         if (!NT_STATUS_IS_OK(status)) {
800                                 return status;
801                         }
802
803                         ace.trustee = *creator;
804                         ace.flags = flags | SEC_ACE_FLAG_INHERIT_ONLY;
805                         status = security_descriptor_dacl_add(sd, &ace);
806                 } else if (container && 
807                            !(orig_flags & SEC_ACE_FLAG_NO_PROPAGATE_INHERIT)) {
808                         status = security_descriptor_dacl_add(sd, &ace);
809                 } else {
810                         ace.trustee = *new_id;
811                         status = security_descriptor_dacl_add(sd, &ace);
812                 }
813
814                 if (!NT_STATUS_IS_OK(status)) {
815                         return status;
816                 }
817         }
818
819         return NT_STATUS_OK;
820 }
821
822
823
824 /*
825   calculate the ACL on a new file/directory based on the inherited ACL
826   from the parent. If there is no inherited ACL then return a NULL
827   ACL, which means the default ACL should be used
828 */
829 NTSTATUS pvfs_acl_inherited_sd(struct pvfs_state *pvfs, 
830                                TALLOC_CTX *mem_ctx,
831                                struct ntvfs_request *req,
832                                struct pvfs_filename *parent,
833                                bool container,
834                                struct security_descriptor **ret_sd)
835 {
836         struct xattr_NTACL *acl;
837         NTSTATUS status;
838         struct security_descriptor *parent_sd, *sd;
839         struct id_mapping *ids;
840         struct composite_context *ctx;
841         TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
842
843         *ret_sd = NULL;
844
845         acl = talloc(req, struct xattr_NTACL);
846         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(acl, tmp_ctx);
847
848         status = pvfs_acl_load(pvfs, parent, -1, acl);
849         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
850                 talloc_free(tmp_ctx);
851                 return NT_STATUS_OK;
852         }
853         NT_STATUS_NOT_OK_RETURN_AND_FREE(status, tmp_ctx);
854
855         switch (acl->version) {
856         case 1:
857                 parent_sd = acl->info.sd;
858                 break;
859         default:
860                 talloc_free(tmp_ctx);
861                 return NT_STATUS_INVALID_ACL;
862         }
863
864         if (parent_sd == NULL ||
865             parent_sd->dacl == NULL ||
866             parent_sd->dacl->num_aces == 0) {
867                 /* go with the default ACL */
868                 talloc_free(tmp_ctx);
869                 return NT_STATUS_OK;
870         }
871
872         /* create the new sd */
873         sd = security_descriptor_initialise(req);
874         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(sd, tmp_ctx);
875
876         ids = talloc_array(sd, struct id_mapping, 2);
877         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(ids, tmp_ctx);
878
879         ids[0].unixid = talloc(ids, struct unixid);
880         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(ids[0].unixid, tmp_ctx);
881         ids[0].unixid->id = geteuid();
882         ids[0].unixid->type = ID_TYPE_UID;
883         ids[0].sid = NULL;
884         ids[0].status = NT_STATUS_NONE_MAPPED;
885
886         ids[1].unixid = talloc(ids, struct unixid);
887         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(ids[1].unixid, tmp_ctx);
888         ids[1].unixid->id = getegid();
889         ids[1].unixid->type = ID_TYPE_GID;
890         ids[1].sid = NULL;
891         ids[1].status = NT_STATUS_NONE_MAPPED;
892
893         ctx = wbc_xids_to_sids_send(pvfs->wbc_ctx, ids, 2, ids);
894         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(ctx, tmp_ctx);
895
896         status = wbc_xids_to_sids_recv(ctx, &ids);
897         NT_STATUS_NOT_OK_RETURN_AND_FREE(status, tmp_ctx);
898
899         sd->owner_sid = talloc_steal(sd, ids[0].sid);
900         sd->group_sid = talloc_steal(sd, ids[1].sid);
901
902         sd->type |= SEC_DESC_DACL_PRESENT;
903
904         /* fill in the aces from the parent */
905         status = pvfs_acl_inherit_aces(pvfs, parent_sd, sd, container);
906         NT_STATUS_NOT_OK_RETURN_AND_FREE(status, tmp_ctx);
907
908         /* if there is nothing to inherit then we fallback to the
909            default acl */
910         if (sd->dacl == NULL || sd->dacl->num_aces == 0) {
911                 talloc_free(tmp_ctx);
912                 return NT_STATUS_OK;
913         }
914
915         *ret_sd = talloc_steal(mem_ctx, sd);
916
917         talloc_free(tmp_ctx);
918         return NT_STATUS_OK;
919 }
920
921
922 /*
923   setup an ACL on a new file/directory based on the inherited ACL from
924   the parent. If there is no inherited ACL then we don't set anything,
925   as the default ACL applies anyway
926 */
927 NTSTATUS pvfs_acl_inherit(struct pvfs_state *pvfs, 
928                           struct ntvfs_request *req,
929                           struct pvfs_filename *name,
930                           int fd)
931 {
932         struct xattr_NTACL acl;
933         NTSTATUS status;
934         struct security_descriptor *sd;
935         struct pvfs_filename *parent;
936         bool container;
937
938         /* form the parents path */
939         status = pvfs_resolve_parent(pvfs, req, name, &parent);
940         NT_STATUS_NOT_OK_RETURN(status);
941
942         container = (name->dos.attrib & FILE_ATTRIBUTE_DIRECTORY) ? true:false;
943
944         status = pvfs_acl_inherited_sd(pvfs, req, req, parent, container, &sd);
945         if (!NT_STATUS_IS_OK(status)) {
946                 talloc_free(parent);
947                 return status;
948         }
949
950         if (sd == NULL) {
951                 return NT_STATUS_OK;
952         }
953
954         acl.version = 1;
955         acl.info.sd = sd;
956
957         status = pvfs_acl_save(pvfs, name, fd, &acl);
958         talloc_free(sd);
959         talloc_free(parent);
960
961         return status;
962 }
963
964 /*
965   return the maximum allowed access mask
966 */
967 NTSTATUS pvfs_access_maximal_allowed(struct pvfs_state *pvfs, 
968                                      struct ntvfs_request *req,
969                                      struct pvfs_filename *name,
970                                      uint32_t *maximal_access)
971 {
972         *maximal_access = SEC_FLAG_MAXIMUM_ALLOWED;
973         return pvfs_access_check(pvfs, req, name, maximal_access);
974 }