/* Unix SMB/CIFS implementation. security descriptor description language functions Copyright (C) Andrew Tridgell 2005 This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include "replace.h" #include "lib/util/debug.h" #include "libcli/security/security.h" #include "libcli/security/conditional_ace.h" #include "librpc/gen_ndr/ndr_misc.h" #include "lib/util/smb_strtox.h" #include "libcli/security/sddl.h" #include "system/locale.h" #include "lib/util/util_str_hex.h" struct sddl_transition_state { const struct dom_sid *machine_sid; const struct dom_sid *domain_sid; const struct dom_sid *forest_sid; }; struct flag_map { const char *name; uint32_t flag; }; static bool sddl_map_flag( const struct flag_map *map, const char *str, size_t *plen, uint32_t *pflag) { while (map->name != NULL) { size_t len = strlen(map->name); int cmp = strncmp(map->name, str, len); if (cmp == 0) { *plen = len; *pflag = map->flag; return true; } map += 1; } return false; } /* map a series of letter codes into a uint32_t */ static bool sddl_map_flags(const struct flag_map *map, const char *str, uint32_t *pflags, size_t *plen, bool unknown_flag_is_part_of_next_thing) { const char *str0 = str; if (plen != NULL) { *plen = 0; } *pflags = 0; while (str[0] != '\0' && isupper((unsigned char)str[0])) { size_t len; uint32_t flags; bool found; found = sddl_map_flag(map, str, &len, &flags); if (!found) { break; } *pflags |= flags; if (plen != NULL) { *plen += len; } str += len; } /* * For ACL flags, unknown_flag_is_part_of_next_thing is set, * and we expect some more stuff that isn't flags. * * For ACE flags, unknown_flag_is_part_of_next_thing is unset, * and the flags have been tokenised into their own little * string. We don't expect anything here, even whitespace. */ if (*str == '\0' || unknown_flag_is_part_of_next_thing) { return true; } DBG_WARNING("Unknown flag - '%s' in '%s'\n", str, str0); return false; } /* a mapping between the 2 letter SID codes and sid strings */ static const struct { const char *code; const char *sid; uint32_t machine_rid; uint32_t domain_rid; uint32_t forest_rid; } sid_codes[] = { { .code = "WD", .sid = SID_WORLD }, { .code = "CO", .sid = SID_CREATOR_OWNER }, { .code = "CG", .sid = SID_CREATOR_GROUP }, { .code = "OW", .sid = SID_OWNER_RIGHTS }, { .code = "NU", .sid = SID_NT_NETWORK }, { .code = "IU", .sid = SID_NT_INTERACTIVE }, { .code = "SU", .sid = SID_NT_SERVICE }, { .code = "AN", .sid = SID_NT_ANONYMOUS }, { .code = "ED", .sid = SID_NT_ENTERPRISE_DCS }, { .code = "PS", .sid = SID_NT_SELF }, { .code = "AU", .sid = SID_NT_AUTHENTICATED_USERS }, { .code = "RC", .sid = SID_NT_RESTRICTED }, { .code = "SY", .sid = SID_NT_SYSTEM }, { .code = "LS", .sid = SID_NT_LOCAL_SERVICE }, { .code = "NS", .sid = SID_NT_NETWORK_SERVICE }, { .code = "WR", .sid = SID_SECURITY_RESTRICTED_CODE }, { .code = "BA", .sid = SID_BUILTIN_ADMINISTRATORS }, { .code = "BU", .sid = SID_BUILTIN_USERS }, { .code = "BG", .sid = SID_BUILTIN_GUESTS }, { .code = "PU", .sid = SID_BUILTIN_POWER_USERS }, { .code = "AO", .sid = SID_BUILTIN_ACCOUNT_OPERATORS }, { .code = "SO", .sid = SID_BUILTIN_SERVER_OPERATORS }, { .code = "PO", .sid = SID_BUILTIN_PRINT_OPERATORS }, { .code = "BO", .sid = SID_BUILTIN_BACKUP_OPERATORS }, { .code = "RE", .sid = SID_BUILTIN_REPLICATOR }, { .code = "RU", .sid = SID_BUILTIN_PREW2K }, { .code = "RD", .sid = SID_BUILTIN_REMOTE_DESKTOP_USERS }, { .code = "NO", .sid = SID_BUILTIN_NETWORK_CONF_OPERATORS }, { .code = "MU", .sid = SID_BUILTIN_PERFMON_USERS }, { .code = "LU", .sid = SID_BUILTIN_PERFLOG_USERS }, { .code = "IS", .sid = SID_BUILTIN_IUSERS }, { .code = "CY", .sid = SID_BUILTIN_CRYPTO_OPERATORS }, { .code = "ER", .sid = SID_BUILTIN_EVENT_LOG_READERS }, { .code = "CD", .sid = SID_BUILTIN_CERT_SERV_DCOM_ACCESS }, { .code = "RA", .sid = SID_BUILTIN_RDS_REMOTE_ACCESS_SERVERS }, { .code = "ES", .sid = SID_BUILTIN_RDS_ENDPOINT_SERVERS }, { .code = "MS", .sid = SID_BUILTIN_RDS_MANAGEMENT_SERVERS }, { .code = "HA", .sid = SID_BUILTIN_HYPER_V_ADMINS }, { .code = "AA", .sid = SID_BUILTIN_ACCESS_CONTROL_ASSISTANCE_OPS }, { .code = "RM", .sid = SID_BUILTIN_REMOTE_MANAGEMENT_USERS }, { .code = "UD", .sid = SID_USER_MODE_DRIVERS }, { .code = "AC", .sid = SID_SECURITY_BUILTIN_PACKAGE_ANY_PACKAGE }, { .code = "LW", .sid = SID_SECURITY_MANDATORY_LOW }, { .code = "ME", .sid = SID_SECURITY_MANDATORY_MEDIUM }, { .code = "MP", .sid = SID_SECURITY_MANDATORY_MEDIUM_PLUS }, { .code = "HI", .sid = SID_SECURITY_MANDATORY_HIGH }, { .code = "SI", .sid = SID_SECURITY_MANDATORY_SYSTEM }, { .code = "AS", .sid = SID_AUTHENTICATION_AUTHORITY_ASSERTED_IDENTITY }, { .code = "SS", .sid = SID_SERVICE_ASSERTED_IDENTITY }, { .code = "RO", .forest_rid = DOMAIN_RID_ENTERPRISE_READONLY_DCS }, { .code = "LA", .machine_rid = DOMAIN_RID_ADMINISTRATOR }, { .code = "LG", .machine_rid = DOMAIN_RID_GUEST }, { .code = "DA", .domain_rid = DOMAIN_RID_ADMINS }, { .code = "DU", .domain_rid = DOMAIN_RID_USERS }, { .code = "DG", .domain_rid = DOMAIN_RID_GUESTS }, { .code = "DC", .domain_rid = DOMAIN_RID_DOMAIN_MEMBERS }, { .code = "DD", .domain_rid = DOMAIN_RID_DCS }, { .code = "CA", .domain_rid = DOMAIN_RID_CERT_ADMINS }, { .code = "SA", .forest_rid = DOMAIN_RID_SCHEMA_ADMINS }, { .code = "EA", .forest_rid = DOMAIN_RID_ENTERPRISE_ADMINS }, { .code = "PA", .domain_rid = DOMAIN_RID_POLICY_ADMINS }, { .code = "CN", .domain_rid = DOMAIN_RID_CLONEABLE_CONTROLLERS }, { .code = "AP", .domain_rid = DOMAIN_RID_PROTECTED_USERS }, { .code = "KA", .domain_rid = DOMAIN_RID_KEY_ADMINS }, { .code = "EK", .forest_rid = DOMAIN_RID_ENTERPRISE_KEY_ADMINS }, { .code = "RS", .domain_rid = DOMAIN_RID_RAS_SERVERS } }; /* decode a SID It can either be a special 2 letter code, or in S-* format */ static struct dom_sid *sddl_transition_decode_sid(TALLOC_CTX *mem_ctx, const char **sddlp, struct sddl_transition_state *state) { const char *sddl = (*sddlp); size_t i; /* see if its in the numeric format */ if (strncasecmp(sddl, "S-", 2) == 0) { struct dom_sid *sid = NULL; char *sid_str = NULL; const char *end = NULL; bool ok; size_t len = strspn(sddl + 2, "-0123456789ABCDEFabcdefxX") + 2; if (len < 5) { /* S-1-x */ return NULL; } if (sddl[len - 1] == 'D' && sddl[len] == ':') { /* * we have run into the "D:" dacl marker, mistaking it * for a hex digit. There is no other way for this * pair to occur at the end of a SID in SDDL. */ len--; } sid_str = talloc_strndup(mem_ctx, sddl, len); if (sid_str == NULL) { return NULL; } if (sid_str[0] == 's') { /* * In SDDL, but not in the dom_sid parsers, a * lowercase "s-1-1-0" is accepted. */ sid_str[0] = 'S'; } sid = talloc(mem_ctx, struct dom_sid); if (sid == NULL) { TALLOC_FREE(sid_str); return NULL; }; ok = dom_sid_parse_endp(sid_str, sid, &end); if (!ok) { DBG_WARNING("could not parse SID '%s'\n", sid_str); TALLOC_FREE(sid_str); TALLOC_FREE(sid); return NULL; } if (end - sid_str != len) { DBG_WARNING("trailing junk after SID '%s'\n", sid_str); TALLOC_FREE(sid_str); TALLOC_FREE(sid); return NULL; } TALLOC_FREE(sid_str); (*sddlp) += len; return sid; } /* now check for one of the special codes */ for (i=0;imachine_sid, sid_codes[i].machine_rid); } if (sid_codes[i].domain_rid != 0) { return dom_sid_add_rid(mem_ctx, state->domain_sid, sid_codes[i].domain_rid); } if (sid_codes[i].forest_rid != 0) { return dom_sid_add_rid(mem_ctx, state->forest_sid, sid_codes[i].forest_rid); } return dom_sid_parse_talloc(mem_ctx, sid_codes[i].sid); } struct dom_sid *sddl_decode_sid(TALLOC_CTX *mem_ctx, const char **sddlp, const struct dom_sid *domain_sid) { struct sddl_transition_state state = { /* * TODO: verify .machine_rid values really belong * to the machine_sid on a member, once * we pass machine_sid from the caller... */ .machine_sid = domain_sid, .domain_sid = domain_sid, .forest_sid = domain_sid, }; return sddl_transition_decode_sid(mem_ctx, sddlp, &state); } static const struct flag_map ace_types[] = { { "AU", SEC_ACE_TYPE_SYSTEM_AUDIT }, { "AL", SEC_ACE_TYPE_SYSTEM_ALARM }, { "OA", SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT }, { "OD", SEC_ACE_TYPE_ACCESS_DENIED_OBJECT }, { "OU", SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT }, { "OL", SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT }, { "A", SEC_ACE_TYPE_ACCESS_ALLOWED }, { "D", SEC_ACE_TYPE_ACCESS_DENIED }, { "XA", SEC_ACE_TYPE_ACCESS_ALLOWED_CALLBACK }, { "XD", SEC_ACE_TYPE_ACCESS_DENIED_CALLBACK }, { "ZA", SEC_ACE_TYPE_ACCESS_ALLOWED_CALLBACK_OBJECT }, /* * SEC_ACE_TYPE_ACCESS_DENIED_CALLBACK_OBJECT exists but has * no SDDL flag. * * ZA and XU are switched in [MS-DTYP] as of version 36.0, * but this should be corrected in later versions. */ { "XU", SEC_ACE_TYPE_SYSTEM_AUDIT_CALLBACK }, { "RA", SEC_ACE_TYPE_SYSTEM_RESOURCE_ATTRIBUTE }, { NULL, 0 } }; static const struct flag_map ace_flags[] = { { "OI", SEC_ACE_FLAG_OBJECT_INHERIT }, { "CI", SEC_ACE_FLAG_CONTAINER_INHERIT }, { "NP", SEC_ACE_FLAG_NO_PROPAGATE_INHERIT }, { "IO", SEC_ACE_FLAG_INHERIT_ONLY }, { "ID", SEC_ACE_FLAG_INHERITED_ACE }, { "SA", SEC_ACE_FLAG_SUCCESSFUL_ACCESS }, { "FA", SEC_ACE_FLAG_FAILED_ACCESS }, { NULL, 0 }, }; static const struct flag_map ace_access_mask[] = { { "CC", SEC_ADS_CREATE_CHILD }, { "DC", SEC_ADS_DELETE_CHILD }, { "LC", SEC_ADS_LIST }, { "SW", SEC_ADS_SELF_WRITE }, { "RP", SEC_ADS_READ_PROP }, { "WP", SEC_ADS_WRITE_PROP }, { "DT", SEC_ADS_DELETE_TREE }, { "LO", SEC_ADS_LIST_OBJECT }, { "CR", SEC_ADS_CONTROL_ACCESS }, { "SD", SEC_STD_DELETE }, { "RC", SEC_STD_READ_CONTROL }, { "WD", SEC_STD_WRITE_DAC }, { "WO", SEC_STD_WRITE_OWNER }, { "GA", SEC_GENERIC_ALL }, { "GX", SEC_GENERIC_EXECUTE }, { "GW", SEC_GENERIC_WRITE }, { "GR", SEC_GENERIC_READ }, { NULL, 0 } }; static const struct flag_map decode_ace_access_mask[] = { { "FA", FILE_GENERIC_ALL }, { "FR", FILE_GENERIC_READ }, { "FW", FILE_GENERIC_WRITE }, { "FX", FILE_GENERIC_EXECUTE }, { NULL, 0 }, }; static char *sddl_match_file_rights(TALLOC_CTX *mem_ctx, uint32_t flags) { int i; /* try to find an exact match */ for (i=0;decode_ace_access_mask[i].name;i++) { if (decode_ace_access_mask[i].flag == flags) { return talloc_strdup(mem_ctx, decode_ace_access_mask[i].name); } } return NULL; } static bool sddl_decode_access(const char *str, uint32_t *pmask) { const char *str0 = str; char *end = NULL; uint32_t mask = 0; unsigned long long numeric_mask; int err; /* * The access mask can be a number or a series of flags. * * Canonically the number is expressed in hexadecimal (with 0x), but * per MS-DTYP and Windows behaviour, octal and decimal numbers are * also accepted. * * Windows has two behaviours we choose not to replicate: * * 1. numbers exceeding 0xffffffff are truncated at that point, * turning on all access flags. * * 2. negative numbers are accepted, so e.g. -2 becomes 0xfffffffe. */ numeric_mask = smb_strtoull(str, &end, 0, &err, SMB_STR_STANDARD); if (err == 0) { if (numeric_mask > UINT32_MAX) { DBG_WARNING("Bad numeric flag value - %llu in %s\n", numeric_mask, str0); return false; } if (end - str > sizeof("037777777777")) { /* here's the tricky thing: if a number is big * enough to overflow the uint64, it might end * up small enough to fit in the uint32, and * we'd miss that it overflowed. So we count * the digits -- any more than 12 (for * "037777777777") is too long for 32 bits, * and the shortest 64-bit wrapping string is * 19 (for "0x1" + 16 zeros). */ DBG_WARNING("Bad numeric flag value in '%s'\n", str0); return false; } if (*end != '\0') { DBG_WARNING("Bad characters in '%s'\n", str0); return false; } *pmask = numeric_mask; return true; } /* It's not a positive number, so we'll look for flags */ while ((str[0] != '\0') && (isupper((unsigned char)str[0]) || str[0] == ' ')) { uint32_t flags = 0; size_t len = 0; bool found; while (str[0] == ' ') { /* * Following Windows we accept spaces between flags * but not after flags. Not tabs, though, never tabs. */ str++; if (str[0] == '\0') { DBG_WARNING("trailing whitespace in flags " "- '%s'\n", str0); return false; } } found = sddl_map_flag( ace_access_mask, str, &len, &flags); found |= sddl_map_flag( decode_ace_access_mask, str, &len, &flags); if (!found) { DEBUG(1, ("Unknown flag - %s in %s\n", str, str0)); return false; } mask |= flags; str += len; } if (*str != '\0') { DBG_WARNING("Bad characters in '%s'\n", str0); return false; } *pmask = mask; return true; } static bool sddl_decode_guid(const char *str, struct GUID *guid) { if (strlen(str) != 36) { return false; } return parse_guid_string(str, guid); } static DATA_BLOB sddl_decode_conditions(TALLOC_CTX *mem_ctx, const enum ace_condition_flags ace_condition_flags, const char *conditions, size_t *length, const char **msg, size_t *msg_offset) { DATA_BLOB blob = {0}; struct ace_condition_script *script = NULL; script = ace_conditions_compile_sddl(mem_ctx, ace_condition_flags, conditions, msg, msg_offset, length); if (script != NULL) { bool ok = conditional_ace_encode_binary(mem_ctx, script, &blob); if (! ok) { DBG_ERR("could not blobify '%s'\n", conditions); } } return blob; } /* decode an ACE return true on success, false on failure note that this routine modifies the string */ static bool sddl_decode_ace(TALLOC_CTX *mem_ctx, struct security_ace *ace, const enum ace_condition_flags ace_condition_flags, char **sddl_copy, struct sddl_transition_state *state, const char **msg, size_t *msg_offset) { const char *tok[7]; const char *s; uint32_t v; struct dom_sid *sid; bool ok; size_t len; size_t count = 0; char *str = *sddl_copy; bool has_extra_data = false; ZERO_STRUCTP(ace); *msg_offset = 1; if (*str != '(') { *msg = talloc_strdup(mem_ctx, "Not an ACE"); return false; } str++; /* * First we split apart the 6 (or 7) tokens. * * 0. ace type * 1. ace flags * 2. access mask * 3. object guid * 4. inherit guid * 5. sid * * 6/extra_data rare optional extra data */ tok[0] = str; while (*str != '\0') { if (*str == ';') { *str = '\0'; str++; count++; tok[count] = str; if (count == 6) { /* * this looks like a conditional ACE * or resource ACE, but we can't say * for sure until we look at the ACE * type (tok[0]), after the loop. */ has_extra_data = true; break; } continue; } /* * we are not expecting a ')' in the 6 sections of an * ordinary ACE, except ending the last one. */ if (*str == ')') { count++; *str = '\0'; str++; break; } str++; } if (count != 6) { /* we hit the '\0' or ')' before all of ';;;;;)' */ *msg = talloc_asprintf(mem_ctx, "malformed ACE with only %zu ';'", MIN(count - 1, count)); return false; } /* parse ace type */ ok = sddl_map_flag(ace_types, tok[0], &len, &v); if (!ok) { *msg = talloc_asprintf(mem_ctx, "Unknown ACE type - %s", tok[0]); return false; } if (tok[0][len] != '\0') { *msg = talloc_asprintf(mem_ctx, "Garbage after ACE type - %s", tok[0]); return false; } ace->type = v; /* * Only callback and resource aces should have trailing data. */ if (sec_ace_callback(ace->type)) { if (! has_extra_data) { *msg = talloc_strdup( mem_ctx, "callback ACE has no trailing data"); *msg_offset = str - *sddl_copy; return false; } } else if (sec_ace_resource(ace->type)) { if (! has_extra_data) { *msg = talloc_strdup( mem_ctx, "resource attribute ACE has no trailing data"); *msg_offset = str - *sddl_copy; return false; } } else if (has_extra_data) { *msg = talloc_strdup( mem_ctx, "ACE has trailing section but is not a " "callback or resource ACE"); *msg_offset = str - *sddl_copy; return false; } /* ace flags */ if (!sddl_map_flags(ace_flags, tok[1], &v, NULL, false)) { *msg = talloc_strdup(mem_ctx, "could not parse flags"); *msg_offset = tok[1] - *sddl_copy; return false; } ace->flags = v; /* access mask */ ok = sddl_decode_access(tok[2], &ace->access_mask); if (!ok) { *msg = talloc_strdup(mem_ctx, "could not parse access string"); *msg_offset = tok[2] - *sddl_copy; return false; } /* object */ if (tok[3][0] != 0) { ok = sddl_decode_guid(tok[3], &ace->object.object.type.type); if (!ok) { *msg = talloc_strdup(mem_ctx, "could not parse object GUID"); *msg_offset = tok[3] - *sddl_copy; return false; } ace->object.object.flags |= SEC_ACE_OBJECT_TYPE_PRESENT; } /* inherit object */ if (tok[4][0] != 0) { ok = sddl_decode_guid(tok[4], &ace->object.object.inherited_type.inherited_type); if (!ok) { *msg = talloc_strdup( mem_ctx, "could not parse inherited object GUID"); *msg_offset = tok[4] - *sddl_copy; return false; } ace->object.object.flags |= SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT; } /* trustee */ s = tok[5]; sid = sddl_transition_decode_sid(mem_ctx, &s, state); if (sid == NULL) { *msg = talloc_strdup( mem_ctx, "could not parse trustee SID"); *msg_offset = tok[5] - *sddl_copy; return false; } ace->trustee = *sid; talloc_free(sid); if (*s != '\0') { *msg = talloc_strdup( mem_ctx, "garbage after trustee SID"); *msg_offset = s - *sddl_copy; return false; } if (sec_ace_callback(ace->type)) { /* * This is either a conditional ACE or some unknown * type of callback ACE that will be rejected by the * conditional ACE compiler. */ size_t length; DATA_BLOB conditions = {0}; s = tok[6]; conditions = sddl_decode_conditions(mem_ctx, ace_condition_flags, s, &length, msg, msg_offset); if (conditions.data == NULL) { DBG_NOTICE("Conditional ACE compilation failure at %zu: %s\n", *msg_offset, *msg); *msg_offset += s - *sddl_copy; return false; } ace->coda.conditions = conditions; /* * We have found the end of the conditions, and the * next character should be the ')' to end the ACE. */ if (s[length] != ')') { *msg = talloc_strdup( mem_ctx, "Conditional ACE has trailing bytes" " or lacks ')'"); *msg_offset = s + length - *sddl_copy; return false; } str = discard_const_p(char, s + length + 1); } else if (sec_ace_resource(ace->type)) { size_t length; struct CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 *claim = NULL; if (! dom_sid_equal(&ace->trustee, &global_sid_World)) { /* these are just the rules */ *msg = talloc_strdup( mem_ctx, "Resource Attribute ACE trustee must be " "'S-1-1-0' or 'WD'."); *msg_offset = tok[5] - *sddl_copy; return false; } s = tok[6]; claim = sddl_decode_resource_attr(mem_ctx, s, &length); if (claim == NULL) { *msg = talloc_strdup( mem_ctx, "Resource Attribute ACE parse failure"); *msg_offset = s - *sddl_copy; return false; } ace->coda.claim = *claim; /* * We want a ')' to end the ACE. */ if (s[length] != ')') { *msg = talloc_strdup( mem_ctx, "Resource Attribute ACE has trailing bytes" " or lacks ')'"); *msg_offset = s + length - *sddl_copy; return false; } str = discard_const_p(char, s + length + 1); } *sddl_copy = str; return true; } static const struct flag_map acl_flags[] = { { "P", SEC_DESC_DACL_PROTECTED }, { "AR", SEC_DESC_DACL_AUTO_INHERIT_REQ }, { "AI", SEC_DESC_DACL_AUTO_INHERITED }, { NULL, 0 } }; /* decode an ACL */ static struct security_acl *sddl_decode_acl(struct security_descriptor *sd, const enum ace_condition_flags ace_condition_flags, const char **sddlp, uint32_t *flags, struct sddl_transition_state *state, const char **msg, size_t *msg_offset) { const char *sddl = *sddlp; char *sddl_copy = NULL; char *aces_start = NULL; struct security_acl *acl; size_t len; *flags = 0; acl = talloc_zero(sd, struct security_acl); if (acl == NULL) { return NULL; } acl->revision = SECURITY_ACL_REVISION_ADS; if (isupper((unsigned char)sddl[0]) && sddl[1] == ':') { /* its an empty ACL */ return acl; } /* work out the ACL flags */ if (!sddl_map_flags(acl_flags, sddl, flags, &len, true)) { *msg = talloc_strdup(sd, "bad ACL flags"); *msg_offset = 0; talloc_free(acl); return NULL; } sddl += len; if (sddl[0] != '(') { /* * it is empty apart from the flags * (or the flags are bad, and we will find out when * we try to parse the next bit as a top-level fragment) */ *sddlp = sddl; return acl; } /* * now the ACEs * * For this we make a copy of the rest of the SDDL, which the ACE * tokeniser will mutilate by putting '\0' where it finds ';'. * * We need to copy the rest of the SDDL string because it is not * possible in general to find where an ACL ends if there are * conditional ACEs. */ sddl_copy = talloc_strdup(acl, sddl); if (sddl_copy == NULL) { TALLOC_FREE(acl); return NULL; } aces_start = sddl_copy; while (*sddl_copy == '(') { bool ok; if (acl->num_aces > UINT16_MAX / 16) { /* * We can't fit this many ACEs in a wire ACL * which has a 16 bit size field (and 16 is * the minimal size of an ACE with no subauths). */ talloc_free(acl); return NULL; } acl->aces = talloc_realloc(acl, acl->aces, struct security_ace, acl->num_aces+1); if (acl->aces == NULL) { talloc_free(acl); return NULL; } ok = sddl_decode_ace(acl->aces, &acl->aces[acl->num_aces], ace_condition_flags, &sddl_copy, state, msg, msg_offset); if (!ok) { *msg_offset += sddl_copy - aces_start; talloc_steal(sd, *msg); talloc_free(acl); return NULL; } acl->num_aces++; } sddl += sddl_copy - aces_start; TALLOC_FREE(aces_start); (*sddlp) = sddl; return acl; } /* * Decode a security descriptor in SDDL format, catching compilation * error messages, if any. * * The message will be a direct talloc child of mem_ctx or NULL. */ struct security_descriptor *sddl_decode_err_msg(TALLOC_CTX *mem_ctx, const char *sddl, const struct dom_sid *domain_sid, const enum ace_condition_flags ace_condition_flags, const char **msg, size_t *msg_offset) { struct sddl_transition_state state = { /* * TODO: verify .machine_rid values really belong * to the machine_sid on a member, once * we pass machine_sid from the caller... */ .machine_sid = domain_sid, .domain_sid = domain_sid, .forest_sid = domain_sid, }; const char *start = sddl; struct security_descriptor *sd = NULL; if (msg == NULL || msg_offset == NULL) { DBG_ERR("Programmer misbehaviour: use sddl_decode() " "or provide msg pointers.\n"); return NULL; } *msg = NULL; *msg_offset = 0; sd = talloc_zero(mem_ctx, struct security_descriptor); if (sd == NULL) { return NULL; } sd->revision = SECURITY_DESCRIPTOR_REVISION_1; sd->type = SEC_DESC_SELF_RELATIVE; while (*sddl) { uint32_t flags; char c = sddl[0]; if (sddl[1] != ':') { *msg = talloc_strdup(mem_ctx, "expected '[OGDS]:' section start " "(or the previous section ended prematurely)"); goto failed; } sddl += 2; switch (c) { case 'D': if (sd->dacl != NULL) goto failed; sd->dacl = sddl_decode_acl(sd, ace_condition_flags, &sddl, &flags, &state, msg, msg_offset); if (sd->dacl == NULL) goto failed; sd->type |= flags | SEC_DESC_DACL_PRESENT; break; case 'S': if (sd->sacl != NULL) goto failed; sd->sacl = sddl_decode_acl(sd, ace_condition_flags, &sddl, &flags, &state, msg, msg_offset); if (sd->sacl == NULL) goto failed; /* this relies on the SEC_DESC_SACL_* flags being 1 bit shifted from the SEC_DESC_DACL_* flags */ sd->type |= (flags<<1) | SEC_DESC_SACL_PRESENT; break; case 'O': if (sd->owner_sid != NULL) goto failed; sd->owner_sid = sddl_transition_decode_sid(sd, &sddl, &state); if (sd->owner_sid == NULL) goto failed; break; case 'G': if (sd->group_sid != NULL) goto failed; sd->group_sid = sddl_transition_decode_sid(sd, &sddl, &state); if (sd->group_sid == NULL) goto failed; break; default: *msg = talloc_strdup(mem_ctx, "unexpected character (expected [OGDS])"); goto failed; } } return sd; failed: if (*msg != NULL) { *msg = talloc_steal(mem_ctx, *msg); } /* * The actual message (*msg) might still be NULL, but the * offset at least provides a clue. */ *msg_offset += sddl - start; if (*msg_offset > strlen(sddl)) { /* * It's not that we *don't* trust our pointer difference * arithmetic, just that we *shouldn't*. Let's render it * harmless, before Python tries printing 18 quadrillion * spaces. */ DBG_WARNING("sddl error message offset %zu is too big\n", *msg_offset); *msg_offset = 0; } DEBUG(2,("Badly formatted SDDL '%s'\n", sddl)); talloc_free(sd); return NULL; } /* decode a security descriptor in SDDL format */ struct security_descriptor *sddl_decode(TALLOC_CTX *mem_ctx, const char *sddl, const struct dom_sid *domain_sid) { const char *msg = NULL; size_t msg_offset = 0; struct security_descriptor *sd = sddl_decode_err_msg(mem_ctx, sddl, domain_sid, ACE_CONDITION_FLAG_ALLOW_DEVICE, &msg, &msg_offset); if (sd == NULL) { DBG_NOTICE("could not decode '%s'\n", sddl); if (msg != NULL) { DBG_NOTICE(" %*c\n", (int)msg_offset, '^'); DBG_NOTICE("error '%s'\n", msg); talloc_free(discard_const(msg)); } } return sd; } /* turn a set of flags into a string */ static char *sddl_flags_to_string(TALLOC_CTX *mem_ctx, const struct flag_map *map, uint32_t flags, bool check_all) { int i; char *s; /* try to find an exact match */ for (i=0;map[i].name;i++) { if (map[i].flag == flags) { return talloc_strdup(mem_ctx, map[i].name); } } s = talloc_strdup(mem_ctx, ""); /* now by bits */ for (i=0;map[i].name;i++) { if ((flags & map[i].flag) != 0) { s = talloc_asprintf_append_buffer(s, "%s", map[i].name); if (s == NULL) goto failed; flags &= ~map[i].flag; } } if (check_all && flags != 0) { goto failed; } return s; failed: talloc_free(s); return NULL; } /* encode a sid in SDDL format */ static char *sddl_transition_encode_sid(TALLOC_CTX *mem_ctx, const struct dom_sid *sid, struct sddl_transition_state *state) { bool in_machine = dom_sid_in_domain(state->machine_sid, sid); bool in_domain = dom_sid_in_domain(state->domain_sid, sid); bool in_forest = dom_sid_in_domain(state->forest_sid, sid); struct dom_sid_buf buf; const char *sidstr = dom_sid_str_buf(sid, &buf); uint32_t rid = 0; size_t i; if (sid->num_auths > 1) { rid = sid->sub_auths[sid->num_auths-1]; } for (i=0;itype, true); if (sddl_type == NULL) { goto failed; } sddl_flags = sddl_flags_to_string(tmp_ctx, ace_flags, ace->flags, true); if (sddl_flags == NULL) { goto failed; } sddl_mask = sddl_flags_to_string(tmp_ctx, ace_access_mask, ace->access_mask, true); if (sddl_mask == NULL) { sddl_mask = sddl_match_file_rights(tmp_ctx, ace->access_mask); if (sddl_mask == NULL) { sddl_mask = talloc_asprintf(tmp_ctx, "0x%x", ace->access_mask); } if (sddl_mask == NULL) { goto failed; } } if (sec_ace_object(ace->type)) { const struct security_ace_object *object = &ace->object.object; if (ace->object.object.flags & SEC_ACE_OBJECT_TYPE_PRESENT) { sddl_object = GUID_buf_string( &object->type.type, &object_buf); } if (ace->object.object.flags & SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT) { sddl_iobject = GUID_buf_string( &object->inherited_type.inherited_type, &iobject_buf); } } sddl_trustee = sddl_transition_encode_sid(tmp_ctx, &ace->trustee, state); if (sddl_trustee == NULL) { goto failed; } if (sec_ace_callback(ace->type)) { /* encode the conditional part */ struct ace_condition_script *s = NULL; const char *sddl_conditions = NULL; s = parse_conditional_ace(tmp_ctx, ace->coda.conditions); if (s == NULL) { goto failed; } sddl_conditions = sddl_from_conditional_ace(tmp_ctx, s); if (sddl_conditions == NULL) { goto failed; } sddl = talloc_asprintf(mem_ctx, "%s;%s;%s;%s;%s;%s;%s", sddl_type, sddl_flags, sddl_mask, sddl_object, sddl_iobject, sddl_trustee, sddl_conditions); } else if (sec_ace_resource(ace->type)) { /* encode the resource part */ const char *coda = NULL; coda = sddl_resource_attr_from_claim(tmp_ctx, &ace->coda.claim); if (coda == NULL) { DBG_WARNING("resource ACE has invalid claim\n"); goto failed; } sddl = talloc_asprintf(mem_ctx, "%s;%s;%s;%s;%s;%s;%s", sddl_type, sddl_flags, sddl_mask, sddl_object, sddl_iobject, sddl_trustee, coda); } else { sddl = talloc_asprintf(mem_ctx, "%s;%s;%s;%s;%s;%s", sddl_type, sddl_flags, sddl_mask, sddl_object, sddl_iobject, sddl_trustee); } failed: talloc_free(tmp_ctx); return sddl; } char *sddl_encode_ace(TALLOC_CTX *mem_ctx, const struct security_ace *ace, const struct dom_sid *domain_sid) { struct sddl_transition_state state = { /* * TODO: verify .machine_rid values really belong * to the machine_sid on a member, once * we pass machine_sid from the caller... */ .machine_sid = domain_sid, .domain_sid = domain_sid, .forest_sid = domain_sid, }; return sddl_transition_encode_ace(mem_ctx, ace, &state); } /* encode an ACL in SDDL format */ static char *sddl_encode_acl(TALLOC_CTX *mem_ctx, const struct security_acl *acl, uint32_t flags, struct sddl_transition_state *state) { char *sddl; uint32_t i; /* add any ACL flags */ sddl = sddl_flags_to_string(mem_ctx, acl_flags, flags, false); if (sddl == NULL) goto failed; /* now the ACEs, encoded in braces */ for (i=0;inum_aces;i++) { char *ace = sddl_transition_encode_ace(sddl, &acl->aces[i], state); if (ace == NULL) goto failed; sddl = talloc_asprintf_append_buffer(sddl, "(%s)", ace); if (sddl == NULL) goto failed; talloc_free(ace); } return sddl; failed: talloc_free(sddl); return NULL; } /* encode a security descriptor to SDDL format */ char *sddl_encode(TALLOC_CTX *mem_ctx, const struct security_descriptor *sd, const struct dom_sid *domain_sid) { struct sddl_transition_state state = { /* * TODO: verify .machine_rid values really belong * to the machine_sid on a member, once * we pass machine_sid from the caller... */ .machine_sid = domain_sid, .domain_sid = domain_sid, .forest_sid = domain_sid, }; char *sddl; TALLOC_CTX *tmp_ctx; /* start with a blank string */ sddl = talloc_strdup(mem_ctx, ""); if (sddl == NULL) goto failed; tmp_ctx = talloc_new(sddl); if (tmp_ctx == NULL) { goto failed; } if (sd->owner_sid != NULL) { char *sid = sddl_transition_encode_sid(tmp_ctx, sd->owner_sid, &state); if (sid == NULL) goto failed; sddl = talloc_asprintf_append_buffer(sddl, "O:%s", sid); if (sddl == NULL) goto failed; } if (sd->group_sid != NULL) { char *sid = sddl_transition_encode_sid(tmp_ctx, sd->group_sid, &state); if (sid == NULL) goto failed; sddl = talloc_asprintf_append_buffer(sddl, "G:%s", sid); if (sddl == NULL) goto failed; } if ((sd->type & SEC_DESC_DACL_PRESENT) && sd->dacl != NULL) { char *acl = sddl_encode_acl(tmp_ctx, sd->dacl, sd->type, &state); if (acl == NULL) goto failed; sddl = talloc_asprintf_append_buffer(sddl, "D:%s", acl); if (sddl == NULL) goto failed; } if ((sd->type & SEC_DESC_SACL_PRESENT) && sd->sacl != NULL) { char *acl = sddl_encode_acl(tmp_ctx, sd->sacl, sd->type>>1, &state); if (acl == NULL) goto failed; sddl = talloc_asprintf_append_buffer(sddl, "S:%s", acl); if (sddl == NULL) goto failed; } talloc_free(tmp_ctx); return sddl; failed: talloc_free(sddl); return NULL; }