Skip to contentSkip to conversation

lib: hashtable: fix integer overflow in himport_r

PATCH In review Aristo Chen 4 participants 5 messages Apr 8 – Apr 11 Library code

lore
Share & tools
lore
#0 lore raw

PATCH 1/2 lib: hashtable: fix integer overflow in himport_r

When size == SIZE_MAX, the expression malloc(size + 1) wraps to malloc(0) due to unsigned integer overflow. malloc(0) may return a non-NULL pointer, causing the subsequent memcpy(data, env, size) to write SIZE_MAX bytes into a zero-byte allocation.

This is reachable from the U-Boot console via "env import", where size is taken directly from a user-supplied hex argument.

Add an explicit check for SIZE_MAX before the malloc call and return EINVAL.

---
 lib/hashtable.c | 7 +++++++
 1 file changed, 7 insertions(+)
lib/hashtable.c +7 -0
index 75c263b5053..902fa6f3e98 100644
@@ -820,6 +820,13 @@ int himport_r(struct hsearch_data *htab,
 		return 0;
 	}
 
+	/* Check for potential integer overflow */
+	if (size == SIZE_MAX) {
+		debug("%s: size too large, would overflow\n", __func__);
+		__set_errno(EINVAL);
+		return 0;
+	}
+
 	/* we allocate new space to make sure we can write to the array */
 	if ((data = malloc(size + 1)) == NULL) {
 		debug("himport_r: can't malloc %lu bytes\n", (ulong)size + 1);
Signature · 1 line
2.43.0
#1 lore raw

PATCH 2/2 test: env: add test for himport_r SIZE_MAX overflow guard

Add a unit test that verifies himport_r rejects SIZE_MAX as the size argument, ensuring the integer overflow guard added to lib/hashtable.c is exercised and not accidentally regressed.

---
 test/env/hashtable.c | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
test/env/hashtable.c +17 -0
index 16e49358888..ce9689f46d7 100644
@@ -122,3 +122,20 @@ static int env_test_htab_deletes(struct unit_test_state *uts)
 	return 0;
 }
 ENV_TEST(env_test_htab_deletes, 0);
+
+/* Verify himport_r rejects SIZE_MAX to prevent integer overflow in malloc */
+static int env_test_htab_import_overflow(struct unit_test_state *uts)
+{
+	struct hsearch_data htab;
+
+	memset(&htab, 0, sizeof(htab));
+	ut_asserteq(1, hcreate_r(SIZE, &htab));
+
+	/* SIZE_MAX would cause malloc(size + 1) to wrap to malloc(0) */
+	ut_asserteq(0, himport_r(&htab, "", SIZE_MAX, '\0', 0, 0, 0, NULL));
+
+	hdestroy_r(&htab);
+	return 0;
+}
+
+ENV_TEST(env_test_htab_import_overflow, 0);
Signature · 1 line
2.43.0
Reviewed-by on v1 2/2
#2 lore raw

Re: [PATCH v1 2/2] test: env: add test for himport_r SIZE_MAX overflow guard

Hi Aristo,

Quoted 13 lines · Aristo Chen

test: env: add test for himport_r SIZE_MAX overflow guard

Add a unit test that verifies himport_r rejects SIZE_MAX as the size argument, ensuring the integer overflow guard added to lib/hashtable.c is exercised and not accidentally regressed.

test/env/hashtable.c | 17 +++++++++++++++++

 1 file changed, 17 insertions(+)

test/env/hashtable.c static int env_test_htab_deletes(struct unit_test_state *uts) · line 123

Quoted 2 lines
test/env/hashtable.c +2 -0
@@ -122,3 +122,20 @@ static int env_test_htab_deletes(struct unit_test_state *uts)
+     /* SIZE_MAX would cause malloc(size + 1) to wrap to malloc(0) */
+     ut_asserteq(0, himport_r(&htab, "", SIZE_MAX, '\0', 0, 0, 0, NULL));

Please can you add a check that errno is set to EINVAL after the himport_r() call?

It's a pretty old API that!

Regards,
Simon

#3 lore raw
In reply to Aristo Chen
Quoted 21 lines · Aristo Chen

When size == SIZE_MAX, the expression malloc(size + 1) wraps to malloc(0) due to unsigned integer overflow. malloc(0) may return a non-NULL pointer, causing the subsequent memcpy(data, env, size) to write SIZE_MAX bytes into a zero-byte allocation.

This is reachable from the U-Boot console via "env import", where size is taken directly from a user-supplied hex argument.

Add an explicit check for SIZE_MAX before the malloc call and return EINVAL.

---
 lib/hashtable.c | 7 +++++++
 1 file changed, 7 insertions(+)
lib/hashtable.c +0 -0
index 75c263b5053..902fa6f3e98 100644

lib/hashtable.c int himport_r(struct hsearch_data *htab, · line 829

Quoted 10 lines
lib/hashtable.c +7 -0
@@ -820,6 +820,13 @@ int himport_r(struct hsearch_data *htab,
 		return 0;
 	}
 
+	/* Check for potential integer overflow */
+	if (size == SIZE_MAX) {
+		debug("%s: size too large, would overflow\n", __func__);
+		__set_errno(EINVAL);
+		return 0;
+	}
+

Well, you can corrupt arbitrary memory from the u-boot shell, so "taken directly from a user-supplied hex argument" is not really a very compelling argument in the context of U-Boot.

Instead of adding such ad hoc checks that mostly just increase code size a little, I think it's better to zoom out and see what this really does. And this is ripe for adding a memdup_nul() helper (linux has that under the name kmemdup_nul). If we add that, we can do the overflow check inside that in that one place, and we can convert a lot of similar users all over the tree, and eliminate quite a lot of #loc.

I'll try to write something.

Rasmus

#4 lore raw
In reply to Aristo Chen

lib/hashtable.c int himport_r(struct hsearch_data *htab, · line 832

Quoted 10 lines
lib/hashtable.c +7 -0
+	/* Check for potential integer overflow */
+	if (size == SIZE_MAX) {
+		debug("%s: size too large, would overflow\n", __func__);
+		__set_errno(EINVAL);
+		return 0;
+	}
+
 	/* we allocate new space to make sure we can write to the array */
 	if ((data = malloc(size + 1)) == NULL) {
 		debug("himport_r: can't malloc %lu bytes\n", (ulong)size + 1);

Rather than depend on SIZE_MAX being the right boundary, can we do a check along the lines of size + 1 > size?

=== Stefan