Skip to contentSkip to conversation

ext4: limit xattr size to INT_MAX

PATCH In review Theodore Ts'o 3 participants 5 messages Mar 29, 2018 – Mar 30, 2018 1 message not in the archive

Subsystems (2)
lore
Share & tools
lore

A message that is not in the archive (sent off-list or not yet received): [email protected]

Theodore Ts'o

author maintainer
#1 lore raw

PATCH 1/1 ext4: limit xattr size to INT_MAX

From: Eric Biggers <[email protected]>

ext4 isn't validating the sizes of xattrs. This is problematic because ->e_value_size is a u32, but ext4_xattr_get() returns an int. A very large size is misinterpreted as an error code, which ext4_get_acl() translates into a bogus ERR_PTR() for which IS_ERR() returns false, causing a crash.

Fix this by validating that all xattrs are <= INT_MAX bytes. Also add explicit checks in ext4_xattr_block_get() and ext4_xattr_ibody_get() just in case the xattr block is corrupted in memory.

This issue has been assigned CVE-2018-1095.

https://bugzilla.kernel.org/show_bug.cgi?id=199185
https://bugzilla.redhat.com/show_bug.cgi?id=1560793

---
 fs/ext4/xattr.c | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)
fs/ext4/xattr.c +9 -2
index 63656dbafdc4..fea1108c3bea 100644
@@ -201,6 +201,9 @@ ext4_xattr_check_entries(struct ext4_xattr_entry *entry, void *end,
 			u32 size = le32_to_cpu(entry->e_value_size);
 			void *value;
 
+			if (size > INT_MAX)
+				return -EFSCORRUPTED;
+
 			/*
 			 * The value cannot overlap the names, and the value
 			 * with padding cannot extend beyond 'end'.  Check both
@@ -523,8 +526,10 @@ ext4_xattr_block_get(struct inode *inode, int name_index, const char *name,
 	if (error)
 		goto cleanup;
 	size = le32_to_cpu(entry->e_value_size);
+	error = -ERANGE;
+	if (unlikely(size > INT_MAX))
+		goto cleanup;
 	if (buffer) {
-		error = -ERANGE;
 		if (size > buffer_size)
 			goto cleanup;
 		if (entry->e_value_inum) {
@@ -572,8 +577,10 @@ ext4_xattr_ibody_get(struct inode *inode, int name_index, const char *name,
 	if (error)
 		goto cleanup;
 	size = le32_to_cpu(entry->e_value_size);
+	error = -ERANGE;
+	if (unlikely(size > INT_MAX))
+		goto cleanup;
 	if (buffer) {
-		error = -ERANGE;
 		if (size > buffer_size)
 			goto cleanup;
 		if (entry->e_value_inum) {
Signature · 1 line
2.16.1.72.g5be1f00a9a
Reviewed-by on v1 1/1
#2 lore raw
Quoted 13 lines · Theodore Ts'o

From: Eric Biggers <[email protected]>

ext4 isn't validating the sizes of xattrs. This is problematic because ->e_value_size is a u32, but ext4_xattr_get() returns an int. A very large size is misinterpreted as an error code, which ext4_get_acl() translates into a bogus ERR_PTR() for which IS_ERR() returns false, causing a crash.

Fix this by validating that all xattrs are <= INT_MAX bytes. Also add explicit checks in ext4_xattr_block_get() and ext4_xattr_ibody_get() just in case the xattr block is corrupted in memory.

Quoted 8 lines

This issue has been assigned CVE-2018-1095.

https://bugzilla.kernel.org/show_bug.cgi?id=199185
https://bugzilla.redhat.com/show_bug.cgi?id=1560793

Quoted 44 lines

---
fs/ext4/xattr.c | 11 +++++++++--

1 file changed, 9 insertions(+), 2 deletions(-)
fs/ext4/xattr.c +9 -3
index 63656dbafdc4..fea1108c3bea 100644
@@ -201,6 +201,9 @@ ext4_xattr_check_entries(struct ext4_xattr_entry *entry, void *end,
 			u32 size = le32_to_cpu(entry->e_value_size);
 			void *value;
 
+			if (size > INT_MAX)
+				return -EFSCORRUPTED;
+
 			/*
 			 * The value cannot overlap the names, and the value
 			 * with padding cannot extend beyond 'end'.  Check both
@@ -523,8 +526,10 @@ ext4_xattr_block_get(struct inode *inode, int name_index, const char *name,
 	if (error)
 		goto cleanup;
 	size = le32_to_cpu(entry->e_value_size);
+	error = -ERANGE;
+	if (unlikely(size > INT_MAX))
+		goto cleanup;
 	if (buffer) {
-		error = -ERANGE;
 		if (size > buffer_size)
 			goto cleanup;
 		if (entry->e_value_inum) {
@@ -572,8 +577,10 @@ ext4_xattr_ibody_get(struct inode *inode, int name_index, const char *name,
 	if (error)
 		goto cleanup;
 	size = le32_to_cpu(entry->e_value_size);
+	error = -ERANGE;
+	if (unlikely(size > INT_MAX))
+		goto cleanup;
 	if (buffer) {
-		error = -ERANGE;
 		if (size > buffer_size)
 			goto cleanup;
 		if (entry->e_value_inum) {
--
Quoted 2 lines

2.16.1.72.g5be1f00a9a

Cheers, Andreas

author maintainer
#3 lore raw

PATCH 1/1 ext4: limit xattr size to INT_MAX

In reply to a message not in the archive

From: Eric Biggers <[email protected]>

ext4 isn't validating the sizes of xattrs. This is problematic because ->e_value_size is a u32, but ext4_xattr_get() returns an int. A very large size is misinterpreted as an error code, which ext4_get_acl() translates into a bogus ERR_PTR() for which IS_ERR() returns false, causing a crash.

Fix this by validating that all xattrs are <= INT_MAX bytes. Also add explicit checks in ext4_xattr_block_get() and ext4_xattr_ibody_get() just in case the xattr block is corrupted in memory.

Also if the xattr block is corrupted, mark the file system as containing an error.

This issue has been assigned CVE-2018-1095.

https://bugzilla.kernel.org/show_bug.cgi?id=199185
https://bugzilla.redhat.com/show_bug.cgi?id=1560793

---
 fs/ext4/xattr.c | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)
fs/ext4/xattr.c +11 -3
index 63656dbafdc4..d2a9b078e121 100644
@@ -195,10 +195,14 @@ ext4_xattr_check_entries(struct ext4_xattr_entry *entry, void *end,
 
 	/* Check the values */
 	while (!IS_LAST_ENTRY(entry)) {
+		u32 size = le32_to_cpu(entry->e_value_size);
+
+		if (size > INT_MAX)
+			return -EFSCORRUPTED;
+
 		if (entry->e_value_size != 0 &&
 		    entry->e_value_inum == 0) {
 			u16 offs = le16_to_cpu(entry->e_value_offs);
-			u32 size = le32_to_cpu(entry->e_value_size);
 			void *value;
 
 			/*
@@ -523,8 +527,10 @@ ext4_xattr_block_get(struct inode *inode, int name_index, const char *name,
 	if (error)
 		goto cleanup;
 	size = le32_to_cpu(entry->e_value_size);
+	error = -ERANGE;
+	if (unlikely(size > INT_MAX))
+		goto cleanup;
 	if (buffer) {
-		error = -ERANGE;
 		if (size > buffer_size)
 			goto cleanup;
 		if (entry->e_value_inum) {
@@ -572,8 +578,10 @@ ext4_xattr_ibody_get(struct inode *inode, int name_index, const char *name,
 	if (error)
 		goto cleanup;
 	size = le32_to_cpu(entry->e_value_size);
+	error = -ERANGE;
+	if (unlikely(size > INT_MAX))
+		goto cleanup;
 	if (buffer) {
-		error = -ERANGE;
 		if (size > buffer_size)
 			goto cleanup;
 		if (entry->e_value_inum) {
Signature · 1 line
2.16.1.72.g5be1f00a9a
#4 lore raw

Hi Ted,

Quoted 3 lines · Theodore Ts'o

Also if the xattr block is corrupted, mark the file system as containing an error.

Weren't we doing that already?

Quoted 10 lines

This issue has been assigned CVE-2018-1095.

https://bugzilla.kernel.org/show_bug.cgi?id=199185
https://bugzilla.redhat.com/show_bug.cgi?id=1560793

I'm still confused why you removed my Fixes: line and the mentions of the bug affecting external inode xattrs only. Wasn't the size validation correct before then? We might want to send d7614cc16146 to the stable trees, but after that the sizes were being validated correctly, right?

Quoted 9 lines
---
 fs/ext4/xattr.c | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)
fs/ext4/xattr.c +0 -0
index 63656dbafdc4..d2a9b078e121 100644

fs/ext4/xattr.c ext4_xattr_check_entries(struct ext4_xattr_entry *entry, void *end, · line 204

Quoted 10 lines
fs/ext4/xattr.c +5 -0
@@ -195,10 +195,14 @@ ext4_xattr_check_entries(struct ext4_xattr_entry *entry, void *end,
 
 	/* Check the values */
 	while (!IS_LAST_ENTRY(entry)) {
+		u32 size = le32_to_cpu(entry->e_value_size);
+
+		if (size > INT_MAX)
+			return -EFSCORRUPTED;
+
 		if (entry->e_value_size != 0 &&
 		    entry->e_value_inum == 0) {

Use 'size' instead of 'entry->e_value_size' here, like in my original patch?

Quoted 20 lines
fs/ext4/xattr.c +3 -2
 			u16 offs = le16_to_cpu(entry->e_value_offs);
-			u32 size = le32_to_cpu(entry->e_value_size);
 			void *value;
 
 			/*
@@ -523,8 +527,10 @@ ext4_xattr_block_get(struct inode *inode, int name_index, const char *name,
 	if (error)
 		goto cleanup;
 	size = le32_to_cpu(entry->e_value_size);
+	error = -ERANGE;
+	if (unlikely(size > INT_MAX))
+		goto cleanup;
 
 
 	if (buffer) {
-		error = -ERANGE;
 		if (size > buffer_size)
fs/ext4/xattr.c +0 -0
 			goto cleanup;
 		if (entry->e_value_inum) {

fs/ext4/xattr.c ext4_xattr_ibody_get(struct inode *inode, int name_index, const char *name, · line 583

Quoted 6 lines
fs/ext4/xattr.c +3 -0
@@ -572,8 +578,10 @@ ext4_xattr_ibody_get(struct inode *inode, int name_index, const char *name,
 	if (error)
 		goto cleanup;
 	size = le32_to_cpu(entry->e_value_size);
+	error = -ERANGE;
+	if (unlikely(size > INT_MAX))
+		goto cleanup;

I still think the new checks here are misleading and shouldn't be added. If someone can actually modify the buffer_head concurrently then they could just make the size larger than the block but <= INT_MAX, so that the following page(s) are also copied to the xattr, disclosing memory or crashing. Or they could modify ->e_value_offs to point past the block. Also since this is not using a volatile memory access, the compiler is free to reload the value and assume it's the same.

- Eric

author maintainer
#5 lore raw
Quoted 8 lines · Eric Biggers

Hi Ted,

Quoted 3 lines · Theodore Ts'o

Also if the xattr block is corrupted, mark the file system as containing an error.

Weren't we doing that already?

Actually, not everywhere, but I decided to move that into a separate commit and forgot to remove this from the description. See the commit "ext4: move call to ext4_error() into ext4_xattr_check_block()".

Quoted 10 lines
Quoted 9 lines

This issue has been assigned CVE-2018-1095.

https://bugzilla.kernel.org/show_bug.cgi?id=199185
https://bugzilla.redhat.com/show_bug.cgi?id=1560793

Quoted 4 lines

I'm still confused why you removed my Fixes: line and the mentions of the bug affecting external inode xattrs only. Wasn't the size validation correct before then? We might want to send d7614cc16146 to the stable trees, but after that the sizes were being validated correctly, right?

Sorry, I forgot to add back the Fixes line. I'll fix that.

I removed the text because it was confusing me when I was originally parsing it. (The details of the ea-in-inode code had been swapped out, I'm embarassed to say.) I do see what you are driving at, and I'll add some text that makes the point you are trying to make.

Quoted 7 lines

I still think the new checks here are misleading and shouldn't be added. If someone can actually modify the buffer_head concurrently then they could just make the size larger than the block but <= INT_MAX, so that the following page(s) are also copied to the xattr, disclosing memory or crashing. Or they could modify ->e_value_offs to point past the block. Also since this is not using a volatile memory access, the compiler is free to reload the value and assume it's the same.

The most common case where we run into this problem is where it's not a CPU-CPU race, but rather where the buffer head gets read into memory and is validated, and then minutes later, file system corruption causes the buffer head to be modifeid. So I wasn't worried about races where we would need to copy the buffer to a temp buffer, and validate it every time before using it.

You're right that against someone who has both malicoiusly crafted the corrupted file system, *and* maliciously crafts the access patterns to deliberately trigger a race, the check that I've added isn't sufficient. Unfortunately, doing the copy and validate every time is a problem from a performance perspective.

The condition I added does protect us against a class of attacks. But it is not a universal protection, agreed. The way to fix the concern you raised would be to add a check for le16_to_cpu(entry->e_value_offs) before we using it. But that's for a different attack, and it's something we should add in a separate commit.

Looking at fs/ext4/xattr.c, there are a number of places where we are relying on buffer_verified() bit --- I'd call that a "target rich environment" for fixes. In my opinion, the check I added to fix this POC attack, or an explicit check for entry->e_value_offs in ext4_xattr_block_get() should be the primary protection for malformed on-disk data structures that might lead to buffer overflow attacks, since it eliminates the TOCTTOU gap. The buffer_verified bit should be a backup just in case we missed a check.

Cheers,

- Ted

P.S. If you are concerned that the extra checks makes it hard to find bugs, I would much rather add a #ifdef which disable the the ext4_xattr_*verify() functions, and see if Wen Xu's can find problems --- and if so, we should fix them.