X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fsecurity.c;h=27c68a4ff9663cb5a7a0995da63bae83a3d916da;hp=62b6e8e9eb42cd1693544ad22d593c34988881e9;hb=1562bea589e9ef4039a04223bc9059f349316e3d;hpb=4d9794d1f1a6044c261faae0968af1b2c0480f4b diff --git a/src/security.c b/src/security.c index 62b6e8e9..27c68a4f 100644 --- a/src/security.c +++ b/src/security.c @@ -28,138 +28,19 @@ #endif #include "wimlib/assert.h" -#include "wimlib/buffer_io.h" +#include "wimlib/endianness.h" #include "wimlib/error.h" #include "wimlib/security.h" +#include "wimlib/security_descriptor.h" #include "wimlib/sha1.h" #include "wimlib/util.h" -/* At the start of each type of access control entry. */ -typedef struct _ACE_HEADER { - /* enum ace_type, specifies what type of ACE this is. */ - u8 type; - - /* bitwise OR of the inherit ACE flags #defined above */ - u8 flags; - - /* Size of the access control entry. */ - le16 size; -} _packed_attribute ACE_HEADER; - -/* Grants rights to a user or group */ -typedef struct _ACCESS_ALLOWED_ACE { - ACE_HEADER hdr; - le32 mask; - le32 sid_start; -} _packed_attribute ACCESS_ALLOWED_ACE; - -/* Denies rights to a user or group */ -typedef struct _ACCESS_DENIED_ACE { - ACE_HEADER hdr; - le32 mask; - le32 sid_start; -} _packed_attribute ACCESS_DENIED_ACE; - -typedef struct _SYSTEM_AUDIT_ACE { - ACE_HEADER hdr; - u32 mask; - u32 sid_start; -} _packed_attribute SYSTEM_AUDIT_ACE; - - -/* Header of an access control list. */ -typedef struct _ACL { - /* ACL_REVISION or ACL_REVISION_DS */ - u8 revision; - - /* padding */ - u8 sbz1; - - /* Total size of the ACL, including all access control entries */ - u16 acl_size; - - /* Number of access control entry structures that follow the ACL - * structure. */ - u16 ace_count; - - /* padding */ - u16 sbz2; -} _packed_attribute ACL; - -/* A structure used to identify users or groups. */ -typedef struct _SID { - - /* example: 0x1 */ - u8 revision; - u8 sub_authority_count; - - /* Identifies the authority that issued the SID. Can be, but does not - * have to be, one of enum sid_authority_value */ - u8 identifier_authority[6]; - - u32 sub_authority[]; -} _packed_attribute SID; - -typedef struct _SECURITY_DESCRIPTOR_RELATIVE { - /* Example: 0x1 */ - u8 revision; - /* Example: 0x0 */ - u8 sbz1; - /* Example: 0x4149 */ - u16 security_descriptor_control; - - /* Offset of a SID structure in the security descriptor. */ - /* Example: 0x14 */ - u32 owner_offset; - - /* Offset of a SID structure in the security descriptor. */ - /* Example: 0x24 */ - u32 group_offset; - - /* Offset of an ACL structure in the security descriptor. */ - /* System ACL. */ - /* Example: 0x00 */ - u32 sacl_offset; - - /* Offset of an ACL structure in the security descriptor. */ - /* Discretionary ACL. */ - /* Example: 0x34 */ - u32 dacl_offset; -} _packed_attribute SECURITY_DESCRIPTOR_RELATIVE; - struct wim_security_data_disk { - u32 total_length; - u32 num_entries; - u64 sizes[]; + le32 total_length; + le32 num_entries; + le64 sizes[]; } _packed_attribute; -/* - * This is a hack to work around a problem in libntfs-3g. libntfs-3g validates - * security descriptors with a function named ntfs_valid_descr(). - * ntfs_valid_descr() considers a security descriptor that ends in a SACL - * (Sysetm Access Control List) with no ACE's (Access Control Entries) to be - * invalid. However, a security descriptor like this exists in the Windows 7 - * install.wim. Here, security descriptors matching this pattern are modified - * to have no SACL. This should make no difference since the SACL had no - * entries anyway; however this ensures that that the security descriptors pass - * the validation in libntfs-3g. - */ -static void -empty_sacl_fixup(SECURITY_DESCRIPTOR_RELATIVE *descr, size_t *size_p) -{ - /* No-op if no NTFS-3g support, or if NTFS-3g is version 2013 or later - * */ -#if defined(WITH_NTFS_3G) && !defined(HAVE_NTFS_MNT_RDONLY) - if (*size_p >= sizeof(SECURITY_DESCRIPTOR_RELATIVE)) { - u32 sacl_offset = le32_to_cpu(descr->sacl_offset); - if (sacl_offset == *size_p - sizeof(ACL)) { - descr->sacl_offset = cpu_to_le32(0); - *size_p -= sizeof(ACL); - } - } -#endif -} - struct wim_security_data * new_wim_security_data(void) { @@ -170,19 +51,20 @@ new_wim_security_data(void) * Reads the security data from the metadata resource of a WIM image. * * @metadata_resource: An array that contains the uncompressed metadata - * resource for the WIM image. + * resource for the WIM image. * @metadata_resource_len: The length of @metadata_resource. It must be at * least 8 bytes. * @sd_ret: A pointer to a pointer to a wim_security_data structure that - * will be filled in with a pointer to a new wim_security_data - * structure containing the security data on success. + * will be filled in with a pointer to a new wim_security_data + * structure containing the security data on success. * * Note: There is no `offset' argument because the security data is located at * the beginning of the metadata resource. * - * Possible errors include: - * WIMLIB_ERR_NOMEM - * WIMLIB_ERR_INVALID_SECURITY_DATA + * Return values: + * WIMLIB_ERR_SUCCESS (0) + * WIMLIB_ERR_INVALID_METADATA_RESOURCE + * WIMLIB_ERR_NOMEM */ int read_wim_security_data(const u8 metadata_resource[], size_t metadata_resource_len, @@ -270,13 +152,10 @@ read_wim_security_data(const u8 metadata_resource[], size_t metadata_resource_le total_len += sd->sizes[i]; if (total_len > (u64)sd->total_length) goto out_invalid_sd; - sd->descriptors[i] = MALLOC(sd->sizes[i]); + sd->descriptors[i] = memdup(p, sd->sizes[i]); if (!sd->descriptors[i]) goto out_of_memory; - memcpy(sd->descriptors[i], p, sd->sizes[i]); p += sd->sizes[i]; - empty_sacl_fixup((SECURITY_DESCRIPTOR_RELATIVE*)sd->descriptors[i], - &sd->sizes[i]); } out_align_total_length: total_len = (total_len + 7) & ~7; @@ -286,13 +165,12 @@ out_align_total_length: "%u bytes, but calculated %u bytes", sd->total_length, (unsigned)total_len); } -out_return_sd: *sd_ret = sd; ret = 0; goto out; out_invalid_sd: ERROR("WIM security data is invalid!"); - ret = WIMLIB_ERR_INVALID_SECURITY_DATA; + ret = WIMLIB_ERR_INVALID_METADATA_RESOURCE; goto out_free_sd; out_of_memory: ERROR("Out of memory while reading WIM security data!"); @@ -315,19 +193,20 @@ write_wim_security_data(const struct wim_security_data * restrict sd, u8 *orig_p = p; struct wim_security_data_disk *sd_disk = (struct wim_security_data_disk*)p; + u32 num_entries = sd->num_entries; sd_disk->total_length = cpu_to_le32(sd->total_length); - sd_disk->num_entries = cpu_to_le32(sd->num_entries); + sd_disk->num_entries = cpu_to_le32(num_entries); - for (u32 i = 0; i < sd->num_entries; i++) + for (u32 i = 0; i < num_entries; i++) sd_disk->sizes[i] = cpu_to_le64(sd->sizes[i]); - p = (u8*)&sd_disk->sizes[sd_disk->num_entries]; + p = (u8*)&sd_disk->sizes[num_entries]; - for (u32 i = 0; i < sd->num_entries; i++) + for (u32 i = 0; i < num_entries; i++) p = mempcpy(p, sd->descriptors[i], sd->sizes[i]); - while (p - orig_p < sd->total_length) + while ((uintptr_t)p & 7) *p++ = 0; wimlib_assert(p - orig_p == sd->total_length); @@ -337,11 +216,11 @@ write_wim_security_data(const struct wim_security_data * restrict sd, } static void -print_acl(const ACL *acl, const tchar *type, size_t max_size) +print_acl(const wimlib_ACL *acl, const tchar *type, size_t max_size) { const u8 *p; - if (max_size < sizeof(ACL)) + if (max_size < sizeof(wimlib_ACL)) return; u8 revision = acl->revision; @@ -353,11 +232,11 @@ print_acl(const ACL *acl, const tchar *type, size_t max_size) tprintf(T(" ACL Size = %u\n"), acl_size); tprintf(T(" ACE Count = %u\n"), ace_count); - p = (const u8*)acl + sizeof(ACL); + p = (const u8*)acl + sizeof(wimlib_ACL); for (u16 i = 0; i < ace_count; i++) { - if (max_size < p + sizeof(ACCESS_ALLOWED_ACE) - (const u8*)acl) + if (max_size < p + sizeof(wimlib_ACCESS_ALLOWED_ACE) - (const u8*)acl) break; - const ACCESS_ALLOWED_ACE *aaa = (const ACCESS_ALLOWED_ACE*)p; + const wimlib_ACCESS_ALLOWED_ACE *aaa = (const wimlib_ACCESS_ALLOWED_ACE*)p; tprintf(T(" [ACE]\n")); tprintf(T(" ACE type = %d\n"), aaa->hdr.type); tprintf(T(" ACE flags = 0x%x\n"), aaa->hdr.flags); @@ -370,9 +249,9 @@ print_acl(const ACL *acl, const tchar *type, size_t max_size) } static void -print_sid(const SID *sid, const tchar *type, size_t max_size) +print_sid(const wimlib_SID *sid, const tchar *type, size_t max_size) { - if (max_size < sizeof(SID)) + if (max_size < sizeof(wimlib_SID)) return; tprintf(T(" [%"TS" SID]\n"), type); @@ -382,7 +261,7 @@ print_sid(const SID *sid, const tchar *type, size_t max_size) print_byte_field(sid->identifier_authority, sizeof(sid->identifier_authority), stdout); tputchar(T('\n')); - if (max_size < sizeof(SID) + (size_t)sid->sub_authority_count * sizeof(u32)) + if (max_size < sizeof(wimlib_SID) + (size_t)sid->sub_authority_count * sizeof(u32)) return; for (u8 i = 0; i < sid->sub_authority_count; i++) { tprintf(T(" Subauthority %u = %u\n"), @@ -392,11 +271,11 @@ print_sid(const SID *sid, const tchar *type, size_t max_size) } static void -print_security_descriptor(const SECURITY_DESCRIPTOR_RELATIVE *descr, +print_security_descriptor(const wimlib_SECURITY_DESCRIPTOR_RELATIVE *descr, size_t size) { u8 revision = descr->revision; - u16 control = le16_to_cpu(descr->security_descriptor_control); + u16 control = le16_to_cpu(descr->control); u32 owner_offset = le32_to_cpu(descr->owner_offset); u32 group_offset = le32_to_cpu(descr->group_offset); u32 dacl_offset = le32_to_cpu(descr->dacl_offset); @@ -410,19 +289,19 @@ print_security_descriptor(const SECURITY_DESCRIPTOR_RELATIVE *descr, tprintf(T("System ACL offset = %u\n"), sacl_offset); if (owner_offset != 0 && owner_offset <= size) - print_sid((const SID*)((const u8*)descr + owner_offset), + print_sid((const wimlib_SID*)((const u8*)descr + owner_offset), T("Owner"), size - owner_offset); if (group_offset != 0 && group_offset <= size) - print_sid((const SID*)((const u8*)descr + group_offset), + print_sid((const wimlib_SID*)((const u8*)descr + group_offset), T("Group"), size - group_offset); if (dacl_offset != 0 && dacl_offset <= size) - print_acl((const ACL*)((const u8*)descr + dacl_offset), + print_acl((const wimlib_ACL*)((const u8*)descr + dacl_offset), T("Discretionary"), size - dacl_offset); if (sacl_offset != 0 && sacl_offset <= size) - print_acl((const ACL*)((const u8*)descr + sacl_offset), + print_acl((const wimlib_ACL*)((const u8*)descr + sacl_offset), T("System"), size - sacl_offset); } @@ -439,7 +318,7 @@ print_wim_security_data(const struct wim_security_data *sd) for (u32 i = 0; i < sd->num_entries; i++) { tprintf(T("[SECURITY_DESCRIPTOR_RELATIVE %"PRIu32", length = %"PRIu64"]\n"), i, sd->sizes[i]); - print_security_descriptor((const SECURITY_DESCRIPTOR_RELATIVE*)sd->descriptors[i], + print_security_descriptor((const wimlib_SECURITY_DESCRIPTOR_RELATIVE*)sd->descriptors[i], sd->sizes[i]); tputchar(T('\n')); } @@ -552,7 +431,7 @@ sd_set_add_sd(struct wim_sd_set *sd_set, const char *descriptor, size_t size) struct sd_node *new; u8 **descriptors; u64 *sizes; - char *descr_copy; + u8 *descr_copy; struct wim_security_data *sd; bool bret; @@ -568,13 +447,12 @@ sd_set_add_sd(struct wim_sd_set *sd_set, const char *descriptor, size_t size) new = MALLOC(sizeof(*new)); if (!new) goto out; - descr_copy = MALLOC(size); + + descr_copy = memdup(descriptor, size); if (!descr_copy) goto out_free_node; sd = sd_set->sd; - - memcpy(descr_copy, descriptor, size); new->security_id = sd->num_entries; copy_hash(new->hash, hash);