fortify: Improve buffer overflow reporting

Improve the reporting of buffer overflows under CONFIG_FORTIFY_SOURCE to
help accelerate debugging efforts. The calculations are all just sitting
in registers anyway, so pass them along to the function to be reported.

For example, before:

  detected buffer overflow in memcpy

and after:

  memcpy: detected buffer overflow: 4096 byte read of buffer size 1

Link: https://lore.kernel.org/r/20230407192717.636137-10-keescook@chromium.org
Signed-off-by: Kees Cook <keescook@chromium.org>

diff --git a/arch/arm/boot/compressed/misc.c b/arch/arm/boot/compressed/misc.c
index d93e2e466f6a7d76dd48caf25b4f85eef12191f7..6c41b270560e19b3edcb85e1ffef6f226fde3c3b 100644 (file)
--- a/arch/arm/boot/compressed/misc.c
+++ b/arch/arm/boot/compressed/misc.c
@@ -154,7 +154,7 @@ decompress_kernel(unsigned long output_start, unsigned long free_mem_ptr_p,
                putstr(" done, booting the kernel.\n");
 }
 
-void __fortify_panic(const u8 reason)
+void __fortify_panic(const u8 reason, size_t avail, size_t size)
 {
        error("detected buffer overflow");
 }

diff --git a/arch/arm/boot/compressed/misc.h b/arch/arm/boot/compressed/misc.h
index 4d59c427253ce2ef26694128df47aa3277ac344c..8c73940b5fe46d41b428b6c5aba147281c7fa0e0 100644 (file)
--- a/arch/arm/boot/compressed/misc.h
+++ b/arch/arm/boot/compressed/misc.h
@@ -10,7 +10,7 @@ void __div0(void);
 void
 decompress_kernel(unsigned long output_start, unsigned long free_mem_ptr_p,
                  unsigned long free_mem_ptr_end_p, int arch_id);
-void __fortify_panic(const u8 reason);
+void __fortify_panic(const u8 reason, size_t avail, size_t size);
 int atags_to_fdt(void *atag_list, void *fdt, int total_space);
 uint32_t fdt_check_mem_start(uint32_t mem_start, const void *fdt);
 int do_decompress(u8 *input, int len, u8 *output, void (*error)(char *x));

diff --git a/arch/x86/boot/compressed/misc.c b/arch/x86/boot/compressed/misc.c
index c9971b9dbb09b223bf404bd9f46a600ccc65fb91..1844da203da9aa6a240adfbe3eedaf1daa0449f9 100644 (file)
--- a/arch/x86/boot/compressed/misc.c
+++ b/arch/x86/boot/compressed/misc.c
@@ -496,7 +496,7 @@ asmlinkage __visible void *extract_kernel(void *rmode, unsigned char *output)
        return output + entry_offset;
 }
 
-void __fortify_panic(const u8 reason)
+void __fortify_panic(const u8 reason, size_t avail, size_t size)
 {
        error("detected buffer overflow");
 }

diff --git a/include/linux/fortify-string.h b/include/linux/fortify-string.h
index fbfb90479b8f7ae60a0678df3a3c7c8fee63bf77..6aeebe0a677704a0b036eeb57c60e5ffc2702895 100644 (file)
--- a/include/linux/fortify-string.h
+++ b/include/linux/fortify-string.h
@@ -16,8 +16,8 @@
                                         FIELD_PREP(GENMASK(7, 1), func))
 
 #ifndef fortify_panic
-# define fortify_panic(func, write, retfail)   \
-        __fortify_panic(FORTIFY_REASON(func, write))
+# define fortify_panic(func, write, avail, size, retfail)      \
+        __fortify_panic(FORTIFY_REASON(func, write), avail, size)
 #endif
 
 #define FORTIFY_READ            0
@@ -48,8 +48,8 @@ enum fortify_func {
        EACH_FORTIFY_FUNC(MAKE_FORTIFY_FUNC)
 };
 
-void __fortify_report(const u8 reason);
-void __fortify_panic(const u8 reason) __cold __noreturn;
+void __fortify_report(const u8 reason, const size_t avail, const size_t size);
+void __fortify_panic(const u8 reason, const size_t avail, const size_t size) __cold __noreturn;
 void __read_overflow(void) __compiletime_error("detected read beyond size of object (1st parameter)");
 void __read_overflow2(void) __compiletime_error("detected read beyond size of object (2nd parameter)");
 void __read_overflow2_field(size_t avail, size_t wanted) __compiletime_warning("detected read beyond size of field (2nd parameter); maybe use struct_group()?");
@@ -183,7 +183,7 @@ char *strncpy(char * const POS p, const char *q, __kernel_size_t size)
        if (__compiletime_lessthan(p_size, size))
                __write_overflow();
        if (p_size < size)
-               fortify_panic(FORTIFY_FUNC_strncpy, FORTIFY_WRITE, p);
+               fortify_panic(FORTIFY_FUNC_strncpy, FORTIFY_WRITE, p_size, size, p);
        return __underlying_strncpy(p, q, size);
 }
 
@@ -214,7 +214,7 @@ __FORTIFY_INLINE __kernel_size_t strnlen(const char * const POS p, __kernel_size
        /* Do not check characters beyond the end of p. */
        ret = __real_strnlen(p, maxlen < p_size ? maxlen : p_size);
        if (p_size <= ret && maxlen != ret)
-               fortify_panic(FORTIFY_FUNC_strnlen, FORTIFY_READ, ret);
+               fortify_panic(FORTIFY_FUNC_strnlen, FORTIFY_READ, p_size, ret + 1, ret);
        return ret;
 }
 
@@ -250,7 +250,7 @@ __kernel_size_t __fortify_strlen(const char * const POS p)
                return __underlying_strlen(p);
        ret = strnlen(p, p_size);
        if (p_size <= ret)
-               fortify_panic(FORTIFY_FUNC_strlen, FORTIFY_READ, ret);
+               fortify_panic(FORTIFY_FUNC_strlen, FORTIFY_READ, p_size, ret + 1, ret);
        return ret;
 }
 
@@ -300,8 +300,8 @@ __FORTIFY_INLINE ssize_t sized_strscpy(char * const POS p, const char * const PO
         * Generate a runtime write overflow error if len is greater than
         * p_size.
         */
-       if (len > p_size)
-               fortify_panic(FORTIFY_FUNC_strscpy, FORTIFY_WRITE, -E2BIG);
+       if (p_size < len)
+               fortify_panic(FORTIFY_FUNC_strscpy, FORTIFY_WRITE, p_size, len, -E2BIG);
 
        /*
         * We can now safely call vanilla strscpy because we are protected from:
@@ -359,7 +359,7 @@ size_t strlcat(char * const POS p, const char * const POS q, size_t avail)
 
        /* Give up if string is already overflowed. */
        if (p_size <= p_len)
-               fortify_panic(FORTIFY_FUNC_strlcat, FORTIFY_READ, wanted);
+               fortify_panic(FORTIFY_FUNC_strlcat, FORTIFY_READ, p_size, p_len + 1, wanted);
 
        if (actual >= avail) {
                copy_len = avail - p_len - 1;
@@ -368,7 +368,7 @@ size_t strlcat(char * const POS p, const char * const POS q, size_t avail)
 
        /* Give up if copy will overflow. */
        if (p_size <= actual)
-               fortify_panic(FORTIFY_FUNC_strlcat, FORTIFY_WRITE, wanted);
+               fortify_panic(FORTIFY_FUNC_strlcat, FORTIFY_WRITE, p_size, actual + 1, wanted);
        __underlying_memcpy(p + p_len, q, copy_len);
        p[actual] = '\0';
 
@@ -395,9 +395,10 @@ __FORTIFY_INLINE __diagnose_as(__builtin_strcat, 1, 2)
 char *strcat(char * const POS p, const char *q)
 {
        const size_t p_size = __member_size(p);
+       const size_t wanted = strlcat(p, q, p_size);
 
-       if (strlcat(p, q, p_size) >= p_size)
-               fortify_panic(FORTIFY_FUNC_strcat, FORTIFY_WRITE, p);
+       if (p_size <= wanted)
+               fortify_panic(FORTIFY_FUNC_strcat, FORTIFY_WRITE, p_size, wanted + 1, p);
        return p;
 }
 
@@ -426,14 +427,15 @@ char *strncat(char * const POS p, const char * const POS q, __kernel_size_t coun
 {
        const size_t p_size = __member_size(p);
        const size_t q_size = __member_size(q);
-       size_t p_len, copy_len;
+       size_t p_len, copy_len, total;
 
        if (p_size == SIZE_MAX && q_size == SIZE_MAX)
                return __underlying_strncat(p, q, count);
        p_len = strlen(p);
        copy_len = strnlen(q, count);
-       if (p_size < p_len + copy_len + 1)
-               fortify_panic(FORTIFY_FUNC_strncat, FORTIFY_WRITE, p);
+       total = p_len + copy_len + 1;
+       if (p_size < total)
+               fortify_panic(FORTIFY_FUNC_strncat, FORTIFY_WRITE, p_size, total, p);
        __underlying_memcpy(p + p_len, q, copy_len);
        p[p_len + copy_len] = '\0';
        return p;
@@ -474,7 +476,7 @@ __FORTIFY_INLINE bool fortify_memset_chk(__kernel_size_t size,
         * lengths are unknown.)
         */
        if (p_size != SIZE_MAX && p_size < size)
-               fortify_panic(FORTIFY_FUNC_memset, FORTIFY_WRITE, true);
+               fortify_panic(FORTIFY_FUNC_memset, FORTIFY_WRITE, p_size, size, true);
        return false;
 }
 
@@ -574,9 +576,9 @@ __FORTIFY_INLINE bool fortify_memcpy_chk(__kernel_size_t size,
         * lengths are unknown.)
         */
        if (p_size != SIZE_MAX && p_size < size)
-               fortify_panic(func, FORTIFY_WRITE, true);
+               fortify_panic(func, FORTIFY_WRITE, p_size, size, true);
        else if (q_size != SIZE_MAX && q_size < size)
-               fortify_panic(func, FORTIFY_READ, true);
+               fortify_panic(func, FORTIFY_READ, p_size, size, true);
 
        /*
         * Warn when writing beyond destination field size.
@@ -676,7 +678,7 @@ __FORTIFY_INLINE void *memscan(void * const POS0 p, int c, __kernel_size_t size)
        if (__compiletime_lessthan(p_size, size))
                __read_overflow();
        if (p_size < size)
-               fortify_panic(FORTIFY_FUNC_memscan, FORTIFY_READ, NULL);
+               fortify_panic(FORTIFY_FUNC_memscan, FORTIFY_READ, p_size, size, NULL);
        return __real_memscan(p, c, size);
 }
 
@@ -692,8 +694,10 @@ int memcmp(const void * const POS0 p, const void * const POS0 q, __kernel_size_t
                if (__compiletime_lessthan(q_size, size))
                        __read_overflow2();
        }
-       if (p_size < size || q_size < size)
-               fortify_panic(FORTIFY_FUNC_memcmp, FORTIFY_READ, INT_MIN);
+       if (p_size < size)
+               fortify_panic(FORTIFY_FUNC_memcmp, FORTIFY_READ, p_size, size, INT_MIN);
+       else if (q_size < size)
+               fortify_panic(FORTIFY_FUNC_memcmp, FORTIFY_READ, q_size, size, INT_MIN);
        return __underlying_memcmp(p, q, size);
 }
 
@@ -705,7 +709,7 @@ void *memchr(const void * const POS0 p, int c, __kernel_size_t size)
        if (__compiletime_lessthan(p_size, size))
                __read_overflow();
        if (p_size < size)
-               fortify_panic(FORTIFY_FUNC_memchr, FORTIFY_READ, NULL);
+               fortify_panic(FORTIFY_FUNC_memchr, FORTIFY_READ, p_size, size, NULL);
        return __underlying_memchr(p, c, size);
 }
 
@@ -717,7 +721,7 @@ __FORTIFY_INLINE void *memchr_inv(const void * const POS0 p, int c, size_t size)
        if (__compiletime_lessthan(p_size, size))
                __read_overflow();
        if (p_size < size)
-               fortify_panic(FORTIFY_FUNC_memchr_inv, FORTIFY_READ, NULL);
+               fortify_panic(FORTIFY_FUNC_memchr_inv, FORTIFY_READ, p_size, size, NULL);
        return __real_memchr_inv(p, c, size);
 }
 
@@ -730,7 +734,7 @@ __FORTIFY_INLINE void *kmemdup(const void * const POS0 p, size_t size, gfp_t gfp
        if (__compiletime_lessthan(p_size, size))
                __read_overflow();
        if (p_size < size)
-               fortify_panic(FORTIFY_FUNC_kmemdup, FORTIFY_READ, NULL);
+               fortify_panic(FORTIFY_FUNC_kmemdup, FORTIFY_READ, p_size, size, NULL);
        return __real_kmemdup(p, size, gfp);
 }
 
@@ -767,7 +771,7 @@ char *strcpy(char * const POS p, const char * const POS q)
                __write_overflow();
        /* Run-time check for dynamic size overflow. */
        if (p_size < size)
-               fortify_panic(FORTIFY_FUNC_strcpy, FORTIFY_WRITE, p);
+               fortify_panic(FORTIFY_FUNC_strcpy, FORTIFY_WRITE, p_size, size, p);
        __underlying_memcpy(p, q, size);
        return p;
 }

diff --git a/lib/fortify_kunit.c b/lib/fortify_kunit.c
index f0accebeca02f97ee9646d8e81c1fe74e487d882..493ec02dd5b32232c4333f4a2900fe863772040d 100644 (file)
--- a/lib/fortify_kunit.c
+++ b/lib/fortify_kunit.c
@@ -17,8 +17,8 @@
 
 /* Redefine fortify_panic() to track failures. */
 void fortify_add_kunit_error(int write);
-#define fortify_panic(func, write, retfail) do {                       \
-       __fortify_report(FORTIFY_REASON(func, write));                  \
+#define fortify_panic(func, write, avail, size, retfail) do {          \
+       __fortify_report(FORTIFY_REASON(func, write), avail, size);     \
        fortify_add_kunit_error(write);                                 \
        return (retfail);                                               \
 } while (0)

diff --git a/lib/string_helpers.c b/lib/string_helpers.c
index 5e53d42e32bb427c8575ca1e021c3847424cc82a..6bbafd6a10d92b634a3159adb1738b98b3ab9524 100644 (file)
--- a/lib/string_helpers.c
+++ b/lib/string_helpers.c
@@ -1016,20 +1016,21 @@ static const char * const fortify_func_name[] = {
 #undef  MAKE_FORTIFY_FUNC_NAME
 };
 
-void __fortify_report(const u8 reason)
+void __fortify_report(const u8 reason, const size_t avail, const size_t size)
 {
        const u8 func = FORTIFY_REASON_FUNC(reason);
        const bool write = FORTIFY_REASON_DIR(reason);
        const char *name;
 
        name = fortify_func_name[umin(func, FORTIFY_FUNC_UNKNOWN)];
-       WARN(1, "%s: detected buffer %s overflow\n", name, str_read_write(!write));
+       WARN(1, "%s: detected buffer overflow: %zu byte %s of buffer size %zu\n",
+                name, size, str_read_write(!write), avail);
 }
 EXPORT_SYMBOL(__fortify_report);
 
-void __fortify_panic(const u8 reason)
+void __fortify_panic(const u8 reason, const size_t avail, const size_t size)
 {
-       __fortify_report(reason);
+       __fortify_report(reason, avail, size);
        BUG();
 }
 EXPORT_SYMBOL(__fortify_panic);