source4/libcli/security/sddl.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    security descriptor description language functions
   5
   6    Copyright (C) Andrew Tridgell                2005
   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 "system/iconv.h"
  25 #include "librpc/gen_ndr/ndr_security.h"
  26
  27 struct flag_map {
  28         const char *name;
  29         uint32_t flag;
  30 };
  31
  32 /*
  33   map a series of letter codes into a uint32_t
  34 */
  35 static BOOL sddl_map_flags(const struct flag_map *map, const char *str,
  36                            uint32_t *flags, size_t *len)
  37 {
  38         const char *str0 = str;
  39         if (len) *len = 0;
  40         *flags = 0;
  41         while (str[0] && isupper(str[0])) {
  42                 int i;
  43                 for (i=0;map[i].name;i++) {
  44                         size_t l = strlen(map[i].name);
  45                         if (strncmp(map[i].name, str, l) == 0) {
  46                                 *flags |= map[i].flag;
  47                                 str += l;
  48                                 if (len) *len += l;
  49                                 break;
  50                         }
  51                 }
  52                 if (map[i].name == NULL) {
  53                         DEBUG(1, ("Unknown flag - %s in %s\n", str, str0));
  54                         return False;
  55                 }
  56         }
  57         return True;
  58 }
  59
  60 /*
  61   a mapping between the 2 letter SID codes and sid strings
  62 */
  63 static const struct {
  64         const char *code;
  65         const char *sid;
  66         uint32_t rid;
  67 } sid_codes[] = {
  68         { "AO", SID_BUILTIN_ACCOUNT_OPERATORS },
  69         { "BA", SID_BUILTIN_ADMINISTRATORS },
  70         { "RU", SID_BUILTIN_PREW2K },
  71         { "PO", SID_BUILTIN_PRINT_OPERATORS },
  72         { "RS", SID_BUILTIN_RAS_SERVERS },
  73
  74         { "AU", SID_NT_AUTHENTICATED_USERS },
  75         { "SY", SID_NT_SYSTEM },
  76         { "PS", SID_NT_SELF },
  77         { "WD", SID_WORLD },
  78         { "ED", SID_NT_ENTERPRISE_DCS },
  79
  80         { "CO", SID_CREATOR_OWNER },
  81         { "CG", SID_CREATOR_GROUP },
  82
  83         { "DA", NULL, DOMAIN_RID_ADMINS },
  84         { "EA", NULL, DOMAIN_RID_ENTERPRISE_ADMINS },
  85         { "DD", NULL, DOMAIN_RID_DCS },
  86         { "DU", NULL, DOMAIN_RID_USERS },
  87         { "CA", NULL, DOMAIN_RID_CERT_ADMINS },
  88 };
  89
  90 /*
  91   decode a SID
  92   It can either be a special 2 letter code, or in S-* format
  93 */
  94 static struct dom_sid *sddl_decode_sid(TALLOC_CTX *mem_ctx, const char **sddlp,
  95                                        struct dom_sid *domain_sid)
  96 {
  97         const char *sddl = (*sddlp);
  98         int i;
  99
 100         /* see if its in the numeric format */
 101         if (strncmp(sddl, "S-", 2) == 0) {
 102                 size_t len = strspn(sddl+2, "-0123456789");
 103                 (*sddlp) += len+2;
 104                 return dom_sid_parse_talloc(mem_ctx, sddl);
 105         }
 106
 107         /* now check for one of the special codes */
 108         for (i=0;i<ARRAY_SIZE(sid_codes);i++) {
 109                 if (strncmp(sid_codes[i].code, sddl, 2) == 0) break;
 110         }
 111         if (i == ARRAY_SIZE(sid_codes)) {
 112                 DEBUG(1,("Unknown sddl sid code '%2.2s'\n", sddl));
 113                 return NULL;
 114         }
 115
 116         (*sddlp) += 2;
 117
 118         if (sid_codes[i].sid == NULL) {
 119                 return dom_sid_add_rid(mem_ctx, domain_sid, sid_codes[i].rid);
 120         }
 121
 122         return dom_sid_parse_talloc(mem_ctx, sid_codes[i].sid);
 123 }
 124
 125 static const struct flag_map ace_types[] = {
 126         { "AU", SEC_ACE_TYPE_SYSTEM_AUDIT },
 127         { "AL", SEC_ACE_TYPE_SYSTEM_ALARM },
 128         { "OA", SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT },
 129         { "OD", SEC_ACE_TYPE_ACCESS_DENIED_OBJECT },
 130         { "OU", SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT },
 131         { "OL", SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT },
 132         { "A",  SEC_ACE_TYPE_ACCESS_ALLOWED },
 133         { "D",  SEC_ACE_TYPE_ACCESS_DENIED },
 134         { NULL, 0 }
 135 };
 136
 137 static const struct flag_map ace_flags[] = {
 138         { "OI", SEC_ACE_FLAG_OBJECT_INHERIT },
 139         { "CI", SEC_ACE_FLAG_CONTAINER_INHERIT },
 140         { "NP", SEC_ACE_FLAG_NO_PROPAGATE_INHERIT },
 141         { "IO", SEC_ACE_FLAG_INHERIT_ONLY },
 142         { "ID", SEC_ACE_FLAG_INHERITED_ACE },
 143         { "SA", SEC_ACE_FLAG_SUCCESSFUL_ACCESS },
 144         { "FA", SEC_ACE_FLAG_FAILED_ACCESS },
 145         { NULL, 0 },
 146 };
 147
 148 static const struct flag_map ace_access_mask[] = {
 149         { "RC", SEC_STD_READ_CONTROL },
 150         { "RP", SEC_ADS_READ_PROP },
 151         { "WP", SEC_ADS_WRITE_PROP },
 152         { "CR", SEC_ADS_CONTROL_ACCESS },
 153         { "CC", SEC_ADS_CREATE_CHILD },
 154         { "DC", SEC_ADS_DELETE_CHILD },
 155         { "LC", SEC_ADS_LIST },
 156         { "LO", SEC_ADS_LIST_OBJECT },
 157         { "WO", SEC_STD_WRITE_OWNER },
 158         { "WD", SEC_STD_WRITE_DAC },
 159         { "SD", SEC_STD_DELETE },
 160         { "DT", SEC_ADS_DELETE_TREE },
 161         { "SW", SEC_ADS_SELF_WRITE },
 162         { "GA", SEC_GENERIC_ALL },
 163         { "GR", SEC_GENERIC_READ },
 164         { "GW", SEC_GENERIC_WRITE },
 165         { "GX", SEC_GENERIC_EXECUTE },
 166         { NULL, 0 }
 167 };
 168
 169 /*
 170   decode an ACE
 171   return True on success, False on failure
 172   note that this routine modifies the string
 173 */
 174 static BOOL sddl_decode_ace(TALLOC_CTX *mem_ctx, struct security_ace *ace, char *str,
 175                             struct dom_sid *domain_sid)
 176 {
 177         const char *tok[6];
 178         const char *s;
 179         int i;
 180         uint32_t v;
 181         struct dom_sid *sid;
 182
 183         ZERO_STRUCTP(ace);
 184
 185         /* parse out the 6 tokens */
 186         tok[0] = str;
 187         for (i=0;i<5;i++) {
 188                 char *ptr = strchr(str, ';');
 189                 if (ptr == NULL) return False;
 190                 *ptr = 0;
 191                 str = ptr+1;
 192                 tok[i+1] = str;
 193         }
 194
 195         /* parse ace type */
 196         if (!sddl_map_flags(ace_types, tok[0], &v, NULL)) {
 197                 return False;
 198         }
 199         ace->type = v;
 200
 201         /* ace flags */
 202         if (!sddl_map_flags(ace_flags, tok[1], &v, NULL)) {
 203                 return False;
 204         }
 205         ace->flags = v;
 206
 207         /* access mask */
 208         if (strncmp(tok[2], "0x", 2) == 0) {
 209                 ace->access_mask = strtol(tok[2], NULL, 16);
 210         } else {
 211                 if (!sddl_map_flags(ace_access_mask, tok[2], &v, NULL)) {
 212                         return False;
 213                 }
 214                 ace->access_mask = v;
 215         }
 216
 217         /* object */
 218         if (tok[3][0] != 0) {
 219                 NTSTATUS status = GUID_from_string(tok[3],
 220                                                    &ace->object.object.type.type);
 221                 if (!NT_STATUS_IS_OK(status)) {
 222                         return False;
 223                 }
 224         }
 225
 226         /* inherit object */
 227         if (tok[4][0] != 0) {
 228                 NTSTATUS status = GUID_from_string(tok[4],
 229                                                    &ace->object.object.inherited_type.inherited_type);
 230                 if (!NT_STATUS_IS_OK(status)) {
 231                         return False;
 232                 }
 233         }
 234
 235         /* trustee */
 236         s = tok[5];
 237         sid = sddl_decode_sid(mem_ctx, &s, domain_sid);
 238         if (sid == NULL) {
 239                 return False;
 240         }
 241         ace->trustee = *sid;
 242         talloc_steal(mem_ctx, sid->sub_auths);
 243         talloc_free(sid);
 244
 245         return True;
 246 }
 247
 248 static const struct flag_map acl_flags[] = {
 249         { "P", SEC_DESC_DACL_PROTECTED },
 250         { "AR", SEC_DESC_DACL_AUTO_INHERIT_REQ },
 251         { "AI", SEC_DESC_DACL_AUTO_INHERITED },
 252         { NULL, 0 }
 253 };
 254
 255 /*
 256   decode an ACL
 257 */
 258 static struct security_acl *sddl_decode_acl(struct security_descriptor *sd,
 259                                             const char **sddlp, uint32_t *flags,
 260                                             struct dom_sid *domain_sid)
 261 {
 262         const char *sddl = *sddlp;
 263         struct security_acl *acl;
 264         size_t len;
 265
 266         acl = talloc_zero(sd, struct security_acl);
 267         if (acl == NULL) return NULL;
 268         acl->revision = SECURITY_ACL_REVISION_NT4;
 269
 270         if (isupper(sddl[0]) && sddl[1] == ':') {
 271                 /* its an empty ACL */
 272                 return acl;
 273         }
 274
 275         /* work out the ACL flags */
 276         if (!sddl_map_flags(acl_flags, sddl, flags, &len)) {
 277                 talloc_free(acl);
 278                 return NULL;
 279         }
 280         sddl += len;
 281
 282         /* now the ACEs */
 283         while (*sddl == '(') {
 284                 len = strcspn(sddl+1, ")");
 285                 char *astr = talloc_strndup(acl, sddl+1, len);
 286                 if (astr == NULL || sddl[len+1] != ')') {
 287                         talloc_free(acl);
 288                         return NULL;
 289                 }
 290                 acl->aces = talloc_realloc(acl, acl->aces, struct security_ace,
 291                                            acl->num_aces+1);
 292                 if (acl->aces == NULL) {
 293                         talloc_free(acl);
 294                         return NULL;
 295                 }
 296                 if (!sddl_decode_ace(acl->aces, &acl->aces[acl->num_aces],
 297                                      astr, domain_sid)) {
 298                         talloc_free(acl);
 299                         return NULL;
 300                 }
 301                 talloc_free(astr);
 302                 sddl += len+2;
 303                 acl->num_aces++;
 304         }
 305
 306         (*sddlp) = sddl;
 307         return acl;
 308 }
 309
 310 /*
 311   decode a security descriptor in SDDL format
 312 */
 313 struct security_descriptor *sddl_decode(TALLOC_CTX *mem_ctx, const char *sddl,
 314                                         struct dom_sid *domain_sid)
 315 {
 316         struct security_descriptor *sd;
 317         sd = talloc_zero(mem_ctx, struct security_descriptor);
 318
 319         sd->revision = SECURITY_DESCRIPTOR_REVISION_1;
 320         sd->type     = SEC_DESC_SELF_RELATIVE;
 321
 322         while (*sddl) {
 323                 uint32_t flags;
 324                 char c = sddl[0];
 325                 if (sddl[1] != ':') goto failed;
 326
 327                 sddl += 2;
 328                 switch (c) {
 329                 case 'D':
 330                         if (sd->dacl != NULL) goto failed;
 331                         sd->dacl = sddl_decode_acl(sd, &sddl, &flags, domain_sid);
 332                         if (sd->dacl == NULL) goto failed;
 333                         sd->type |= flags | SEC_DESC_DACL_PRESENT;
 334                         break;
 335                 case 'S':
 336                         if (sd->sacl != NULL) goto failed;
 337                         sd->sacl = sddl_decode_acl(sd, &sddl, &flags, domain_sid);
 338                         if (sd->sacl == NULL) goto failed;
 339                         /* this relies on the SEC_DESC_SACL_* flags being
 340                            1 bit shifted from the SEC_DESC_DACL_* flags */
 341                         sd->type |= (flags<<1) | SEC_DESC_SACL_PRESENT;
 342                         break;
 343                 case 'O':
 344                         if (sd->owner_sid != NULL) goto failed;
 345                         sd->owner_sid = sddl_decode_sid(sd, &sddl, domain_sid);
 346                         if (sd->owner_sid == NULL) goto failed;
 347                         break;
 348                 case 'G':
 349                         if (sd->group_sid != NULL) goto failed;
 350                         sd->group_sid = sddl_decode_sid(sd, &sddl, domain_sid);
 351                         if (sd->group_sid == NULL) goto failed;
 352                         break;
 353                 }
 354         }
 355
 356         return sd;
 357
 358 failed:
 359         DEBUG(2,("Badly formatted SDDL '%s'\n", sddl));
 360         talloc_free(sd);
 361         return NULL;
 362 }