X-Git-Url: https://wimlib.net/git/?a=blobdiff_plain;f=src%2Fsecurity.c;h=fef6043af2fdc0f5910f2c816aaf68b16ffe9c42;hb=d3a6c0b6414f880a9cea4d8655570d9f556f319d;hp=089067dc433f5152cd6cd4fd15261744d56eb48d;hpb=6f77434ea6ff1407603410e28d1edb966c40e568;p=wimlib

diff --git a/src/security.c b/src/security.c
index 089067dc..fef6043a 100644
--- a/src/security.c
+++ b/src/security.c
@@ -1,8 +1,9 @@
 /*
  * security.c
  *
- * Read the security data from the WIM.  Doing anything with the security data
- * is not yet implemented other than printing some information about it.
+ * Read and write the WIM security data.  The security data is a table of
+ * security descriptors. Each WIM image has its own security data, but it's
+ * possible that an image's security data have no security descriptors.
  */
 
 /*
@@ -11,16 +12,16 @@
  * This file is part of wimlib, a library for working with WIM files.
  *
  * wimlib is free software; you can redistribute it and/or modify it under the
- * terms of the GNU Lesser General Public License as published by the Free
- * Software Foundation; either version 2.1 of the License, or (at your option)
+ * 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.
  *
  * wimlib 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 Lesser General Public License for more
+ * A PARTICULAR PURPOSE. See the GNU General Public License for more
  * details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with wimlib; if not, see http://www.gnu.org/licenses/.
  */
 
@@ -28,70 +29,108 @@
 #include "io.h"
 #include "security.h"
 
-#ifdef ENABLE_SECURITY_DATA
+/* 
+ * 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  his ensures that that the security descriptors pass
+ * the validation in libntfs-3g.
+ */
+static void empty_sacl_fixup(char *descr, u64 *size_p)
+{
+	if (*size_p >= sizeof(SecurityDescriptor)) {
+		SecurityDescriptor *sd = (SecurityDescriptor*)descr;
+		u32 sacl_offset = le32_to_cpu(sd->sacl_offset);
+		if (sacl_offset == *size_p - sizeof(ACL)) {
+			sd->sacl_offset = to_le32(0);
+			*size_p -= sizeof(ACL);
+		}
+	}
+}
 
 /* 
  * Reads the security data from the metadata resource.
  *
  * @metadata_resource:	An array that contains the uncompressed metadata
  * 				resource for the WIM file.
- * @metadata_resource_len:	The length of @metadata_resource.
- * @sd_p:	A pointer to a pointer wim_security_data structure that will be filled
- * 		in with a pointer to a new wim_security_data structure on success.
+ * @metadata_resource_len:	The length of @metadata_resource.  It MUST be at
+ *				least 8 bytes.
+ * @sd_p:	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 on success.
  *
  * Note: There is no `offset' argument because the security data is located at
  * the beginning of the metadata resource.
  */
-int read_security_data(const u8 metadata_resource[], 
-		       u64 metadata_resource_len, struct wim_security_data **sd_p)
+int read_security_data(const u8 metadata_resource[], u64 metadata_resource_len,
+		       struct wim_security_data **sd_p)
 {
 	struct wim_security_data *sd;
 	const u8 *p;
-	u64 sizes_size;
+	int ret;
+	u64 total_len;
 
-	if (metadata_resource_len < 8) {
-		ERROR("Not enough space in %"PRIu64"-byte file resource for "
-				"security data!\n", metadata_resource_len);
-		return WIMLIB_ERR_INVALID_RESOURCE_SIZE;
-	}
 	sd = MALLOC(sizeof(struct wim_security_data));
-	if (!sd)
+	if (!sd) {
+		ERROR("Out of memory");
 		return WIMLIB_ERR_NOMEM;
-	p = get_u32(metadata_resource, &sd->total_length);
-	p = get_u32(p, &sd->num_entries);
+	}
+	sd->sizes	= NULL;
+	sd->descriptors = NULL;
+	sd->refcnt	= 1;
+
+	p = metadata_resource;
+	p = get_u32(p, &sd->total_length);
+	p = get_u32(p, (u32*)&sd->num_entries);
+
+	if (sd->num_entries > 0x7fffffff) {
+		ERROR("Security data has too many entries!");
+		ret = WIMLIB_ERR_INVALID_SECURITY_DATA;
+		goto out_free_sd;
+	}
 
 	/* Verify the listed total length of the security data is big enough to
 	 * include the sizes array, verify that the file data is big enough to
-	 * include it as well, then allocate the array of sizes. */
-	sizes_size = sd->num_entries * sizeof(u64);
+	 * include it as well, then allocate the array of sizes.
+	 *
+	 * Note: The total length of the security data must fit in a 32-bit
+	 * integer, even though each security descriptor size is a 64-bit
+	 * integer.  This is stupid, and we need to be careful not to actually
+	 * let the security descriptor sizes be over 0xffffffff.  */
+	if ((u64)sd->total_length > metadata_resource_len) {
+		ERROR("Security data total length (%u) is bigger than the "
+		      "metadata resource length (%"PRIu64")",
+		      sd->total_length, metadata_resource_len);
+		ret = WIMLIB_ERR_INVALID_SECURITY_DATA;
+		goto out_free_sd;
+	}
 
-	DEBUG("Reading security data with %u entries\n", sd->num_entries);
+	DEBUG("Reading security data: %u entries, length = %u",
+	      sd->num_entries, sd->total_length);
 
 	if (sd->num_entries == 0) {
-		FREE(sd);
-		return 0;
+		/* No security data. */
+		total_len = 8;
+		goto out;
 	}
 
+	u64 sizes_size = (u64)sd->num_entries * sizeof(u64);
 	u64 size_no_descriptors = 8 + sizes_size;
-	if (size_no_descriptors > sd->total_length) {
-		ERROR("Security data total length of %"PRIu64" is too short because\n"
-				"there must be at least %"PRIu64" bytes of security "
-				"data!\n", sd->total_length, 
-				8 + sizes_size);
-		FREE(sd);
-		return WIMLIB_ERR_INVALID_RESOURCE_SIZE;
-	}
-	if (size_no_descriptors > metadata_resource_len) {
-		ERROR("File resource of %"PRIu64" bytes is not big enough\n"
-				"to hold security data of at least %"PRIu64" "
-				"bytes!\n", metadata_resource_len, size_no_descriptors);
-		FREE(sd);
-		return WIMLIB_ERR_INVALID_RESOURCE_SIZE;
+	if (size_no_descriptors > (u64)sd->total_length) {
+		ERROR("Security data total length of %u is too short because "
+		      "there must be at least %"PRIu64" bytes of security data",
+		      sd->total_length, 8 + sizes_size);
+		ret = WIMLIB_ERR_INVALID_SECURITY_DATA;
+		goto out_free_sd;
 	}
 	sd->sizes = MALLOC(sizes_size);
 	if (!sd->sizes) {
-		FREE(sd);
-		return WIMLIB_ERR_NOMEM;
+		ret = WIMLIB_ERR_NOMEM;
+		goto out_free_sd;
 	}
 
 	/* Copy the sizes array in from the file data. */
@@ -101,39 +140,49 @@ int read_security_data(const u8 metadata_resource[],
 	/* Allocate the array of pointers to descriptors, and read them in. */
 	sd->descriptors = CALLOC(sd->num_entries, sizeof(u8*));
 	if (!sd->descriptors) {
-		FREE(sd);
-		FREE(sd->sizes);
-		return WIMLIB_ERR_NOMEM;
+		ERROR("Out of memory while allocating security "
+		      "descriptors");
+		ret = WIMLIB_ERR_NOMEM;
+		goto out_free_sd;
 	}
-	u64 total_len = size_no_descriptors;
+	total_len = size_no_descriptors;
 
-	for (uint i = 0; i < sd->num_entries; i++) {
-		total_len += sd->sizes[i];
-		if (total_len > sd->total_length) {
-			ERROR("Security data total length of %"PRIu64" is too "
-					"short because there are at least %"PRIu64" "
-					"bytes of security data!\n", 
-					sd->total_length, total_len);
-			free_security_data(sd);
-			return WIMLIB_ERR_INVALID_RESOURCE_SIZE;
+	for (u32 i = 0; i < sd->num_entries; i++) {
+		/* Watch out for huge security descriptor sizes that could
+		 * overflow the total length and wrap it around. */
+		if (total_len + sd->sizes[i] < total_len) {
+			ERROR("Caught overflow in security descriptor lengths "
+			      "(current total length = %"PRIu64", security "
+			      "descriptor size = %"PRIu64")",
+			      total_len, sd->sizes[i]);
+			ret = WIMLIB_ERR_INVALID_SECURITY_DATA;
+			goto out_free_sd;
 		}
-		if (total_len > metadata_resource_len) {
-			ERROR("File resource of %"PRIu64" bytes is not big enough "
-					"to hold security data of at least %"PRIu64" "
-					"bytes!\n", metadata_resource_len, total_len);
-			free_security_data(sd);
-			return WIMLIB_ERR_INVALID_RESOURCE_SIZE;
+		total_len += sd->sizes[i];
+		if (total_len > (u64)sd->total_length) {
+			ERROR("Security data total length of %u is too short "
+			      "because there are at least %"PRIu64" bytes of "
+			      "security data", sd->total_length, total_len);
+			ret = WIMLIB_ERR_INVALID_SECURITY_DATA;
+			goto out_free_sd;
 		}
 		sd->descriptors[i] = MALLOC(sd->sizes[i]);
 		if (!sd->descriptors[i]) {
-			free_security_data(sd);
-			return WIMLIB_ERR_NOMEM;
+			ERROR("Out of memory while allocating security "
+			      "descriptors");
+			ret = WIMLIB_ERR_NOMEM;
+			goto out_free_sd;
 		}
 		p = get_bytes(p, sd->sizes[i], sd->descriptors[i]);
+		empty_sacl_fixup(sd->descriptors[i], &sd->sizes[i]);
 	}
-	sd->refcnt = 1;
+out:
+	sd->total_length = (u32)total_len;
 	*sd_p = sd;
 	return 0;
+out_free_sd:
+	free_security_data(sd);
+	return ret;
 }
 
 /* 
@@ -141,44 +190,34 @@ int read_security_data(const u8 metadata_resource[],
  */
 u8 *write_security_data(const struct wim_security_data *sd, u8 *p)
 {
-	if (sd) {
-		DEBUG("Writing security data (total_length = %u, "
-				"num_entries = %u)\n", sd->total_length, 
-				sd->num_entries);
-		u8 *orig_p = p;
-		p = put_u32(p, sd->total_length);
-		p = put_u32(p, sd->num_entries);
+	DEBUG("Writing security data (total_length = %"PRIu32", num_entries "
+	      "= %"PRIu32")", sd->total_length, sd->num_entries);
 
-		for (uint i = 0; i < sd->num_entries; i++)
-			p = put_u64(p, sd->sizes[i]);
+	u32 aligned_length = (sd->total_length + 7) & ~7;
 
-		for (uint i = 0; i < sd->num_entries; i++)
-			p = put_bytes(p, sd->sizes[i], sd->descriptors[i]);
+	u8 *orig_p = p;
+	p = put_u32(p, aligned_length);
+	p = put_u32(p, sd->num_entries);
 
-		wimlib_assert(p - orig_p <= sd->total_length);
+	for (u32 i = 0; i < sd->num_entries; i++)
+		p = put_u64(p, sd->sizes[i]);
 
-		DEBUG("Successfully wrote security data.\n");
-		return orig_p + sd->total_length;
-	} else {
-		DEBUG("Writing security data (total_length = 8, "
-				"num_entries = 0)\n");
-		p = put_u32(p, 8);
-		return put_u32(p, 0);
+	for (u32 i = 0; i < sd->num_entries; i++)
+		p = put_bytes(p, sd->sizes[i], sd->descriptors[i]);
 
-	}
-}
+	wimlib_assert(p - orig_p == sd->total_length);
+	p = put_zeroes(p, aligned_length - sd->total_length);
 
-/* XXX We don't actually do anything with the ACL's yet besides being able to
- * print a few things.  It seems it would be a lot of work to have comprehensive
- * support for all the weird flags and stuff, and Windows PE seems to be okay
- * running from a WIM file that doesn't have any security data at all...  */
+	DEBUG("Successfully wrote security data.");
+	return p;
+}
 
-static void print_acl(const u8 *p)
+static void print_acl(const u8 *p, const char *type)
 {
 	ACL *acl = (ACL*)p;
 	TO_LE16(acl->acl_size);
 	TO_LE16(acl->acl_count);
-	printf("    [ACL]\n");
+	printf("    [%s ACL]\n", type);
 	printf("    Revision = %u\n", acl->revision);
 	printf("    ACL Size = %u\n", acl->acl_size);
 	printf("    ACE Count = %u\n", acl->ace_count);
@@ -195,12 +234,13 @@ static void print_acl(const u8 *p)
 		printf("        SID start = %u\n", to_le32(aaa->sid_start));
 		p += hdr->size;
 	}
+	putchar('\n');
 }
 
-static void print_sid(const u8 *p)
+static void print_sid(const u8 *p, const char *type)
 {
 	SID *sid = (SID*)p;
-	printf("    [SID]\n");
+	printf("    [%s SID]\n", type);
 	printf("    Revision = %u\n", sid->revision);
 	printf("    Subauthority count = %u\n", sid->sub_authority_count);
 	printf("    Identifier authority = ");
@@ -208,6 +248,7 @@ static void print_sid(const u8 *p)
 	putchar('\n');
 	for (uint i = 0; i < sid->sub_authority_count; i++)
 		printf("    Subauthority %u = %u\n", i, to_le32(sid->sub_authority[i]));
+	putchar('\n');
 }
 
 static void print_security_descriptor(const u8 *p, u64 size)
@@ -219,20 +260,20 @@ static void print_security_descriptor(const u8 *p, u64 size)
 	TO_LE32(sd->sacl_offset);
 	TO_LE32(sd->dacl_offset);
 	printf("Revision = %u\n", sd->revision);
-	printf("Security Descriptor Control = %u\n", sd->security_descriptor_control);
+	printf("Security Descriptor Control = %#x\n", sd->security_descriptor_control);
 	printf("Owner offset = %u\n", sd->owner_offset);
 	printf("Group offset = %u\n", sd->group_offset);
 	printf("System ACL offset = %u\n", sd->sacl_offset);
 	printf("Discretionary ACL offset = %u\n", sd->dacl_offset);
 
 	if (sd->owner_offset != 0)
-		print_sid(p + sd->owner_offset);
+		print_sid(p + sd->owner_offset, "Owner");
 	if (sd->group_offset != 0)
-		print_sid(p + sd->group_offset);
+		print_sid(p + sd->group_offset, "Group");
 	if (sd->sacl_offset != 0)
-		print_acl(p + sd->sacl_offset);
+		print_acl(p + sd->sacl_offset, "System");
 	if (sd->dacl_offset != 0)
-		print_acl(p + sd->dacl_offset);
+		print_acl(p + sd->dacl_offset, "Discretionary");
 }
 
 /* 
@@ -241,22 +282,14 @@ static void print_security_descriptor(const u8 *p, u64 size)
 void print_security_data(const struct wim_security_data *sd)
 {
 	puts("[SECURITY DATA]");
-	if (sd) {
-		printf("Length            = %u bytes\n", sd->total_length);
-		printf("Number of Entries = %u\n", sd->num_entries);
+	printf("Length            = %"PRIu32" bytes\n", sd->total_length);
+	printf("Number of Entries = %"PRIu32"\n", sd->num_entries);
 
-		u64 num_entries = (u64)sd->num_entries;
-		for (u64 i = 0; i < num_entries; i++) {
-			printf("[SecurityDescriptor %"PRIu64", "
-					"length = %"PRIu64"]\n", 
-					i, sd->sizes[i]);
-			print_security_descriptor(sd->descriptors[i], 
-						  sd->sizes[i]);
-			putchar('\n');
-		}
-	} else {
-		puts("Length            = 8 bytes\n"
-		     "Number of Entries = 0");
+	for (u32 i = 0; i < sd->num_entries; i++) {
+		printf("[SecurityDescriptor %"PRIu32", length = %"PRIu64"]\n", 
+		       i, sd->sizes[i]);
+		print_security_descriptor(sd->descriptors[i], sd->sizes[i]);
+		putchar('\n');
 	}
 	putchar('\n');
 }
@@ -265,20 +298,15 @@ void free_security_data(struct wim_security_data *sd)
 {
 	if (!sd)
 		return;
-	wimlib_assert(sd->refcnt >= 1);
-	if (sd->refcnt == 1) {
+	wimlib_assert(sd->refcnt != 0);
+	if (--sd->refcnt == 0) {
 		u8 **descriptors = sd->descriptors;
-		u32 num_entries = sd->num_entries;
-
+		u32 num_entries  = sd->num_entries;
 		if (descriptors)
 			while (num_entries--)
 				FREE(*descriptors++);
 		FREE(sd->sizes);
 		FREE(sd->descriptors);
 		FREE(sd);
-	} else {
-		sd->refcnt--;
 	}
 }
-
-#endif