Skip to contentSkip to conversation

resource: Fix integer overflow at reallocation

PATCH In review Takashi Iwai 3 participants 7 messages Apr 8, 2018 – Apr 11, 2018

lore
Share & tools
lore
#0 lore raw

PATCH v2 1/1 resource: Fix integer overflow at reallocation

We've got a bug report indicating a kernel panic at booting on an x86-32 system, and it turned out to be the invalid resource assigned after PCI resource reallocation. __find_resource() first aligns the resource start address and resets the end address with start+size-1 accordingly, then checks whether it's contained. Here the end address may overflow the integer, although resource_contains() still returns true because the function validates only start and end address. So this ends up with returning an invalid resource (start > end).

There was already an attempt to cover such a problem in the commit 47ea91b4052d ("Resource: fix wrong resource window calculation"), but this case is an overseen one.

This patch adds the validity check in resource_contains() to see whether the given resource has a valid range for avoiding the integer overflow problem.

Bugzilla: http://bugzilla.opensuse.org/show_bug.cgi?id=1086739

Fixes 23c570a67448 ("resource: ability to resize an allocated resource")

---

Andrew, could you pick this? It's still in a wild west... Thanks!

v1->v2: check in resource_contains() instead of in __find_resource()

 include/linux/ioport.h | 3 +++
 1 file changed, 3 insertions(+)
include/linux/ioport.h +3 -0
index da0ebaec25f0..466d7be046eb 100644
@@ -212,6 +212,9 @@ static inline bool resource_contains(struct resource *r1, struct resource *r2)
 		return false;
 	if (r1->flags & IORESOURCE_UNSET || r2->flags & IORESOURCE_UNSET)
 		return false;
+	/* sanity check whether it's a valid resource range */
+	if (r2->end < r2->start)
+		return false;
 	return r1->start <= r2->start && r1->end >= r2->end;
 }
 
Signature · 1 line
2.16.3
#1 lore raw
Quoted 22 lines · On Sun, 8 Apr 2018 09:20:26 +0200 Takashi Iwai <[email protected]> wrote:

We've got a bug report indicating a kernel panic at booting on an x86-32 system, and it turned out to be the invalid resource assigned after PCI resource reallocation. __find_resource() first aligns the resource start address and resets the end address with start+size-1 accordingly, then checks whether it's contained. Here the end address may overflow the integer, although resource_contains() still returns true because the function validates only start and end address. So this ends up with returning an invalid resource (start > end).

There was already an attempt to cover such a problem in the commit 47ea91b4052d ("Resource: fix wrong resource window calculation"), but this case is an overseen one.

This patch adds the validity check in resource_contains() to see whether the given resource has a valid range for avoiding the integer overflow problem.

...

include/linux/ioport.h static inline bool resource_contains(struct resource *r1, struct resource *r2) · line 219

Quoted 8 lines
include/linux/ioport.h +3 -0
@@ -212,6 +212,9 @@ static inline bool resource_contains(struct resource *r1, struct resource *r2)
 		return false;
 	if (r1->flags & IORESOURCE_UNSET || r2->flags & IORESOURCE_UNSET)
 		return false;
+	/* sanity check whether it's a valid resource range */
+	if (r2->end < r2->start)
+		return false;
 	return r1->start <= r2->start && r1->end >= r2->end;
 }

This doesn't look like the correct place to handle this? Clearly .end < .start is an invalid state for a resource and we should never have constructed such a thing in the first place? So adding a check at the place where this resource was initially created seems to be the correct fix?

#2 lore raw
Quoted 31 lines · Andrew Morton
Quoted 28 lines · On Sun, 8 Apr 2018 09:20:26 +0200 Takashi Iwai <[email protected]> wrote:

We've got a bug report indicating a kernel panic at booting on an x86-32 system, and it turned out to be the invalid resource assigned after PCI resource reallocation. __find_resource() first aligns the resource start address and resets the end address with start+size-1 accordingly, then checks whether it's contained. Here the end address may overflow the integer, although resource_contains() still returns true because the function validates only start and end address. So this ends up with returning an invalid resource (start > end).

There was already an attempt to cover such a problem in the commit 47ea91b4052d ("Resource: fix wrong resource window calculation"), but this case is an overseen one.

This patch adds the validity check in resource_contains() to see whether the given resource has a valid range for avoiding the integer overflow problem.

...

include/linux/ioport.h +3 -0
@@ -212,6 +212,9 @@ static inline bool resource_contains(struct resource *r1, struct resource *r2)
 		return false;
 	if (r1->flags & IORESOURCE_UNSET || r2->flags & IORESOURCE_UNSET)
 		return false;
+	/* sanity check whether it's a valid resource range */
+	if (r2->end < r2->start)
+		return false;
Quoted 8 lines

include/linux/ioport.h static inline bool resource_contains(struct resource *r1, struct resource *r2) · line 219

Quoted 2 lines
include/linux/ioport.h +0 -0
 	return r1->start <= r2->start && r1->end >= r2->end;
 }

This doesn't look like the correct place to handle this? Clearly .end < .start is an invalid state for a resource and we should never have constructed such a thing in the first place? So adding a check at the place where this resource was initially created seems to be the correct fix?

Yes, that was also my first thought and actually the v1 patch was like that. The v2 one was by Ram's suggestion so that we can cover potential bugs by all other callers as well.

I don't mind in which way to fix; below is the v1 version. Please choose the one you think better.

Thanks!

Takashi

-- 8< --

From: Takashi Iwai <[email protected]>
Subject: [PATCH v1] resource: Fix integer overflow at reallocation

We've got a bug report indicating a kernel panic at booting on an x86-32 system, and it turned out to be the invalid PCI resource assigned after reallocation. __find_resource() first aligns the resource start address and resets the end address with start+size-1 accordingly, then checks whether it's contained. Here the end address may overflow the integer, although resource_contains() still returns true because the function validates only start and end address. So this ends up with returning an invalid resource (start > end).

There was already an attempt to cover such a problem in the commit 47ea91b4052d ("Resource: fix wrong resource window calculation"), but this case is an overseen one.

This patch adds the validity check of the newly calculated resource for avoiding the integer overflow problem.

Bugzilla: http://bugzilla.opensuse.org/show_bug.cgi?id=1086739

Fixes 23c570a67448 ("resource: ability to resize an allocated resource")

---

 kernel/resource.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)
kernel/resource.c +2 -1
index e270b5048988..2af6c03858b9 100644
@@ -651,7 +651,8 @@ static int __find_resource(struct resource *root, struct resource *old,
 			alloc.start = constraint->alignf(constraint->alignf_data, &avail,
 					size, constraint->align);
 			alloc.end = alloc.start + size - 1;
-			if (resource_contains(&avail, &alloc)) {
+			if (alloc.start <= alloc.end &&
+			    resource_contains(&avail, &alloc)) {
 				new->start = alloc.start;
 				new->end = alloc.end;
 				return 0;
Signature · 1 line
2.16.2
#3 lore raw
Quoted 42 lines · On Tue, 10 Apr 2018 06:54:11 +0200 Takashi Iwai <[email protected]> wrote:
Quoted 31 lines · Andrew Morton
Quoted 28 lines · On Sun, 8 Apr 2018 09:20:26 +0200 Takashi Iwai <[email protected]> wrote:

We've got a bug report indicating a kernel panic at booting on an x86-32 system, and it turned out to be the invalid resource assigned after PCI resource reallocation. __find_resource() first aligns the resource start address and resets the end address with start+size-1 accordingly, then checks whether it's contained. Here the end address may overflow the integer, although resource_contains() still returns true because the function validates only start and end address. So this ends up with returning an invalid resource (start > end).

There was already an attempt to cover such a problem in the commit 47ea91b4052d ("Resource: fix wrong resource window calculation"), but this case is an overseen one.

This patch adds the validity check in resource_contains() to see whether the given resource has a valid range for avoiding the integer overflow problem.

...

include/linux/ioport.h +3 -0
@@ -212,6 +212,9 @@ static inline bool resource_contains(struct resource *r1, struct resource *r2)
 		return false;
 	if (r1->flags & IORESOURCE_UNSET || r2->flags & IORESOURCE_UNSET)
 		return false;
+	/* sanity check whether it's a valid resource range */
+	if (r2->end < r2->start)
+		return false;
Quoted 8 lines

include/linux/ioport.h static inline bool resource_contains(struct resource *r1, struct resource *r2) · line 219

Quoted 2 lines
include/linux/ioport.h +0 -0
 	return r1->start <= r2->start && r1->end >= r2->end;
 }

This doesn't look like the correct place to handle this? Clearly .end < .start is an invalid state for a resource and we should never have constructed such a thing in the first place? So adding a check at the place where this resource was initially created seems to be the correct fix?

Quoted 2 lines

Yes, that was also my first thought and actually the v1 patch was like that.

Yes, I do prefer.

Quoted 2 lines

The v2 one was by Ram's suggestion so that we can cover
potential bugs by all other callers as well.

That could be done as a separate thing?

#4 lore raw
Quoted 47 lines · Andrew Morton
Quoted 42 lines · On Tue, 10 Apr 2018 06:54:11 +0200 Takashi Iwai <[email protected]> wrote:
Quoted 31 lines · Andrew Morton
Quoted 28 lines · On Sun, 8 Apr 2018 09:20:26 +0200 Takashi Iwai <[email protected]> wrote:

We've got a bug report indicating a kernel panic at booting on an x86-32 system, and it turned out to be the invalid resource assigned after PCI resource reallocation. __find_resource() first aligns the resource start address and resets the end address with start+size-1 accordingly, then checks whether it's contained. Here the end address may overflow the integer, although resource_contains() still returns true because the function validates only start and end address. So this ends up with returning an invalid resource (start > end).

There was already an attempt to cover such a problem in the commit 47ea91b4052d ("Resource: fix wrong resource window calculation"), but this case is an overseen one.

This patch adds the validity check in resource_contains() to see whether the given resource has a valid range for avoiding the integer overflow problem.

...

include/linux/ioport.h +3 -0
@@ -212,6 +212,9 @@ static inline bool resource_contains(struct resource *r1, struct resource *r2)
 		return false;
 	if (r1->flags & IORESOURCE_UNSET || r2->flags & IORESOURCE_UNSET)
 		return false;
+	/* sanity check whether it's a valid resource range */
+	if (r2->end < r2->start)
+		return false;
Quoted 8 lines

include/linux/ioport.h static inline bool resource_contains(struct resource *r1, struct resource *r2) · line 219

Quoted 2 lines
include/linux/ioport.h +0 -0
 	return r1->start <= r2->start && r1->end >= r2->end;
 }

This doesn't look like the correct place to handle this? Clearly .end < .start is an invalid state for a resource and we should never have constructed such a thing in the first place? So adding a check at the place where this resource was initially created seems to be the correct fix?

Quoted 2 lines

Yes, that was also my first thought and actually the v1 patch was like that.

Quoted 6 lines

Yes, I do prefer.

Quoted 2 lines

The v2 one was by Ram's suggestion so that we can cover
potential bugs by all other callers as well.

That could be done as a separate thing?

the first approach will fix overflows in just that particular case. The second approach will catch and error-out overflows anywhere. There is a short-term down side to the second approach; it might cause a slew of error reports but will eventually help clean up all bad behavior.

RP

#5 lore raw
Quoted 54 lines · Ram Pai
Quoted 52 lines · Andrew Morton
Quoted 42 lines · On Tue, 10 Apr 2018 06:54:11 +0200 Takashi Iwai <[email protected]> wrote:
Quoted 31 lines · Andrew Morton
Quoted 28 lines · On Sun, 8 Apr 2018 09:20:26 +0200 Takashi Iwai <[email protected]> wrote:

We've got a bug report indicating a kernel panic at booting on an x86-32 system, and it turned out to be the invalid resource assigned after PCI resource reallocation. __find_resource() first aligns the resource start address and resets the end address with start+size-1 accordingly, then checks whether it's contained. Here the end address may overflow the integer, although resource_contains() still returns true because the function validates only start and end address. So this ends up with returning an invalid resource (start > end).

There was already an attempt to cover such a problem in the commit 47ea91b4052d ("Resource: fix wrong resource window calculation"), but this case is an overseen one.

This patch adds the validity check in resource_contains() to see whether the given resource has a valid range for avoiding the integer overflow problem.

...

include/linux/ioport.h +3 -0
@@ -212,6 +212,9 @@ static inline bool resource_contains(struct resource *r1, struct resource *r2)
 		return false;
 	if (r1->flags & IORESOURCE_UNSET || r2->flags & IORESOURCE_UNSET)
 		return false;
+	/* sanity check whether it's a valid resource range */
+	if (r2->end < r2->start)
+		return false;
Quoted 8 lines

include/linux/ioport.h static inline bool resource_contains(struct resource *r1, struct resource *r2) · line 219

Quoted 2 lines
include/linux/ioport.h +0 -0
 	return r1->start <= r2->start && r1->end >= r2->end;
 }

This doesn't look like the correct place to handle this? Clearly .end < .start is an invalid state for a resource and we should never have constructed such a thing in the first place? So adding a check at the place where this resource was initially created seems to be the correct fix?

Quoted 2 lines

Yes, that was also my first thought and actually the v1 patch was like that.

Yes, I do prefer.

Quoted 2 lines

The v2 one was by Ram's suggestion so that we can cover
potential bugs by all other callers as well.

Quoted 6 lines
Quoted 1 line

That could be done as a separate thing?

the first approach will fix overflows in just that particular case. The second approach will catch and error-out overflows anywhere. There is a short-term down side to the second approach; it might cause a slew of error reports but will eventually help clean up all bad behavior.

For that purpose, maybe we should do in two folds: at first fix this specific issue in __find_resource(), then put the sanity check in resource_contains() in addition but with WARN_ON() so that we can catch more obviously.

thanks,

Takashi

#6 lore raw
Quoted 63 lines · Takashi Iwai
Quoted 54 lines · Ram Pai
Quoted 52 lines · Andrew Morton
Quoted 42 lines · On Tue, 10 Apr 2018 06:54:11 +0200 Takashi Iwai <[email protected]> wrote:
Quoted 31 lines · Andrew Morton
Quoted 28 lines · On Sun, 8 Apr 2018 09:20:26 +0200 Takashi Iwai <[email protected]> wrote:

We've got a bug report indicating a kernel panic at booting on an x86-32 system, and it turned out to be the invalid resource assigned after PCI resource reallocation. __find_resource() first aligns the resource start address and resets the end address with start+size-1 accordingly, then checks whether it's contained. Here the end address may overflow the integer, although resource_contains() still returns true because the function validates only start and end address. So this ends up with returning an invalid resource (start > end).

There was already an attempt to cover such a problem in the commit 47ea91b4052d ("Resource: fix wrong resource window calculation"), but this case is an overseen one.

This patch adds the validity check in resource_contains() to see whether the given resource has a valid range for avoiding the integer overflow problem.

...

include/linux/ioport.h +3 -0
@@ -212,6 +212,9 @@ static inline bool resource_contains(struct resource *r1, struct resource *r2)
 		return false;
 	if (r1->flags & IORESOURCE_UNSET || r2->flags & IORESOURCE_UNSET)
 		return false;
+	/* sanity check whether it's a valid resource range */
+	if (r2->end < r2->start)
+		return false;
Quoted 8 lines

include/linux/ioport.h static inline bool resource_contains(struct resource *r1, struct resource *r2) · line 219

Quoted 2 lines
include/linux/ioport.h +0 -0
 	return r1->start <= r2->start && r1->end >= r2->end;
 }

This doesn't look like the correct place to handle this? Clearly .end < .start is an invalid state for a resource and we should never have constructed such a thing in the first place? So adding a check at the place where this resource was initially created seems to be the correct fix?

Quoted 2 lines

Yes, that was also my first thought and actually the v1 patch was like that.

Yes, I do prefer.

Quoted 2 lines

The v2 one was by Ram's suggestion so that we can cover
potential bugs by all other callers as well.

Quoted 6 lines
Quoted 1 line

That could be done as a separate thing?

the first approach will fix overflows in just that particular case. The second approach will catch and error-out overflows anywhere. There is a short-term down side to the second approach; it might cause a slew of error reports but will eventually help clean up all bad behavior.

Quoted 4 lines

For that purpose, maybe we should do in two folds: at first fix this specific issue in __find_resource(), then put the sanity check in resource_contains() in addition but with WARN_ON() so that we can catch more obviously.

Yes WARN_ON() is a better solution.

do the v1 way for this bug and replace the check in resource_contains() to a WARN_ON() in a separate patch?

RP