source4/librpc/ndr/ndr_sec.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    routines for marshalling/unmarshalling security descriptors
   5    and related structures
   6
   7    Copyright (C) Andrew Tridgell 2003
   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 2 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, write to the Free Software
  21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22 */
  23
  24
  25 #include "includes.h"
  26
  27 /*
  28   parse a dom_sid2 - this is a dom_sid but with an extra copy of the num_auths field
  29 */
  30 NTSTATUS ndr_pull_dom_sid2(struct ndr_pull *ndr, int ndr_flags, struct dom_sid *sid)
  31 {
  32         uint32 num_auths;
  33         if (!(ndr_flags & NDR_SCALARS)) {
  34                 return NT_STATUS_OK;
  35         }
  36         NDR_CHECK(ndr_pull_uint32(ndr, &num_auths));
  37         return ndr_pull_dom_sid(ndr, ndr_flags, sid);
  38 }
  39
  40 /*
  41   parse a dom_sid2 - this is a dom_sid but with an extra copy of the num_auths field
  42 */
  43 NTSTATUS ndr_push_dom_sid2(struct ndr_push *ndr, int ndr_flags, struct dom_sid *sid)
  44 {
  45         if (!(ndr_flags & NDR_SCALARS)) {
  46                 return NT_STATUS_OK;
  47         }
  48         NDR_CHECK(ndr_push_uint32(ndr, sid->num_auths));
  49         return ndr_push_dom_sid(ndr, ndr_flags, sid);
  50 }
  51
  52
  53 /*
  54   print a dom_sid
  55 */
  56 void ndr_print_dom_sid(struct ndr_print *ndr, const char *name, struct dom_sid *sid)
  57 {
  58         int i, ofs, maxlen;
  59         uint32 ia;
  60         char *ret;
  61
  62         if (!sid) {
  63                 ndr->print(ndr, "%-25s: (NULL SID)", name);
  64                 return;
  65         }
  66
  67         maxlen = sid->num_auths * 11 + 25;
  68         ret = talloc(ndr->mem_ctx, maxlen);
  69         if (!ret) return;
  70
  71         ia = (sid->id_auth[5]) +
  72                 (sid->id_auth[4] << 8 ) +
  73                 (sid->id_auth[3] << 16) +
  74                 (sid->id_auth[2] << 24);
  75
  76         ofs = snprintf(ret, maxlen, "S-%u-%lu",
  77                        (unsigned int)sid->sid_rev_num, (unsigned long)ia);
  78
  79         for (i = 0; i < sid->num_auths; i++) {
  80                 ofs += snprintf(ret + ofs, maxlen - ofs, "-%lu", (unsigned long)sid->sub_auths[i]);
  81         }
  82
  83         ndr->print(ndr, "%-25s: %s", name, ret);
  84 }
  85
  86 void ndr_print_dom_sid2(struct ndr_print *ndr, const char *name, struct dom_sid2 *sid)
  87 {
  88         ndr_print_dom_sid(ndr, name, sid);
  89 }
  90
  91 /*
  92   return the wire size of a dom_sid
  93 */
  94 size_t ndr_size_dom_sid(struct dom_sid *sid)
  95 {
  96         if (!sid) return 0;
  97         return 8 + 4*sid->num_auths;
  98 }
  99
 100 /*
 101   add a rid to a domain dom_sid to make a full dom_sid
 102 */
 103 struct dom_sid *dom_sid_add_rid(TALLOC_CTX *mem_ctx,
 104                                 const struct dom_sid *domain_sid,
 105                                 uint32 rid)
 106 {
 107         struct dom_sid *sid;
 108
 109         sid = talloc_p(mem_ctx, struct dom_sid);
 110         if (!sid) return NULL;
 111
 112         *sid = *domain_sid;
 113         sid->sub_auths = talloc_array_p(mem_ctx, uint32, sid->num_auths+1);
 114         if (!sid->sub_auths) {
 115                 return NULL;
 116         }
 117         memcpy(sid->sub_auths, domain_sid->sub_auths, sid->num_auths*sizeof(uint32));
 118         sid->sub_auths[sid->num_auths] = rid;
 119         sid->num_auths++;
 120         return sid;
 121 }
 122
 123 /*
 124   return the wire size of a security_ace
 125 */
 126 size_t ndr_size_security_ace(struct security_ace *ace)
 127 {
 128         if (!ace) return 0;
 129         return 8 + ndr_size_dom_sid(&ace->trustee);
 130 }
 131
 132
 133 /*
 134   return the wire size of a security_acl
 135 */
 136 size_t ndr_size_security_acl(struct security_acl *acl)
 137 {
 138         size_t ret;
 139         int i;
 140         if (!acl) return 0;
 141         ret = 8;
 142         for (i=0;i<acl->num_aces;i++) {
 143                 ret += ndr_size_security_ace(&acl->aces[i]);
 144         }
 145         return ret;
 146 }
 147
 148 /*
 149   return the wire size of a security descriptor
 150 */
 151 size_t ndr_size_security_descriptor(struct security_descriptor *sd)
 152 {
 153         size_t ret;
 154         if (!sd) return 0;
 155
 156         ret = 20;
 157         ret += ndr_size_dom_sid(sd->owner_sid);
 158         ret += ndr_size_dom_sid(sd->group_sid);
 159         ret += ndr_size_security_acl(sd->dacl);
 160         ret += ndr_size_security_acl(sd->sacl);
 161         return ret;
 162 }
 163
 164 /*
 165    talloc and copy a security descriptor
 166  */
 167 struct security_descriptor *copy_security_descriptor(TALLOC_CTX *mem_ctx,
 168                                                         const struct security_descriptor *osd)
 169 {
 170         struct security_descriptor *nsd;
 171
 172         /* FIXME */
 173         DEBUG(1, ("copy_security_descriptor: sorry unimplemented yet\n"));
 174         nsd = NULL;
 175
 176         return nsd;
 177 }