Kernel/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2025-01-01 10:45:49 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

fortify: Improve buffer overflow reporting

Browse Source 
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>
This commit is contained in:
Kees Cook 2023-04-07 12:27:16 -07:00
parent fa4a3f86d4
commit 3d965b33e4
6 changed files with 40 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
arch/arm/boot/compressed/misc.c
View File

@ -154,7 +154,7 @@ decompress_kernel(unsigned long output_start, unsigned long free_mem_ptr_p,
putstr(" done, booting the kernel.\n"); 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"); error("detected buffer overflow");
} }

2
arch/arm/boot/compressed/misc.h
View File

@ -10,7 +10,7 @@ void __div0(void);
void void
decompress_kernel(unsigned long output_start, unsigned long free_mem_ptr_p, decompress_kernel(unsigned long output_start, unsigned long free_mem_ptr_p,
unsigned long free_mem_ptr_end_p, int arch_id); 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); 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); 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)); int do_decompress(u8 *input, int len, u8 *output, void (*error)(char *x));

2
arch/x86/boot/compressed/misc.c
View File

@ -496,7 +496,7 @@ asmlinkage __visible void *extract_kernel(void *rmode, unsigned char *output)
return output + entry_offset; 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"); error("detected buffer overflow");
} }

56
include/linux/fortify-string.h
View File

@ -16,8 +16,8 @@
FIELD_PREP(GENMASK(7, 1), func)) FIELD_PREP(GENMASK(7, 1), func))
#ifndef fortify_panic #ifndef fortify_panic
# define fortify_panic(func, write, retfail) \ # define fortify_panic(func, write, avail, size, retfail) \
__fortify_panic(FORTIFY_REASON(func, write)) __fortify_panic(FORTIFY_REASON(func, write), avail, size)
#endif #endif
#define FORTIFY_READ 0 #define FORTIFY_READ 0
@ -48,8 +48,8 @@ enum fortify_func {
EACH_FORTIFY_FUNC(MAKE_FORTIFY_FUNC) EACH_FORTIFY_FUNC(MAKE_FORTIFY_FUNC)
}; };
void __fortify_report(const u8 reason); void __fortify_report(const u8 reason, const size_t avail, const size_t size);
void __fortify_panic(const u8 reason) __cold __noreturn; 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_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(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()?"); 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)) if (__compiletime_lessthan(p_size, size))
__write_overflow(); __write_overflow();
if (p_size < size) 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); 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. */ /* Do not check characters beyond the end of p. */
ret = __real_strnlen(p, maxlen < p_size ? maxlen : p_size); ret = __real_strnlen(p, maxlen < p_size ? maxlen : p_size);
if (p_size <= ret && maxlen != ret) 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; return ret;
} }
@ -250,7 +250,7 @@ __kernel_size_t __fortify_strlen(const char * const POS p)
return __underlying_strlen(p); return __underlying_strlen(p);
ret = strnlen(p, p_size); ret = strnlen(p, p_size);
if (p_size <= ret) 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; 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 * Generate a runtime write overflow error if len is greater than
* p_size. * p_size.
*/ */
if (len > p_size) if (p_size < len)
fortify_panic(FORTIFY_FUNC_strscpy, FORTIFY_WRITE, -E2BIG); fortify_panic(FORTIFY_FUNC_strscpy, FORTIFY_WRITE, p_size, len, -E2BIG);
/* /*
* We can now safely call vanilla strscpy because we are protected from: * 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. */ /* Give up if string is already overflowed. */
if (p_size <= p_len) 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) { if (actual >= avail) {
copy_len = avail - p_len - 1; 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. */ /* Give up if copy will overflow. */
if (p_size <= actual) 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); __underlying_memcpy(p + p_len, q, copy_len);
p[actual] = '\0'; p[actual] = '\0';
@ -395,9 +395,10 @@ __FORTIFY_INLINE __diagnose_as(__builtin_strcat, 1, 2)
char *strcat(char * const POS p, const char *q) char *strcat(char * const POS p, const char *q)
{ {
const size_t p_size = __member_size(p); 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) if (p_size <= wanted)
fortify_panic(FORTIFY_FUNC_strcat, FORTIFY_WRITE, p); fortify_panic(FORTIFY_FUNC_strcat, FORTIFY_WRITE, p_size, wanted + 1, p);
return 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 p_size = __member_size(p);
const size_t q_size = __member_size(q); 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) if (p_size == SIZE_MAX && q_size == SIZE_MAX)
return __underlying_strncat(p, q, count); return __underlying_strncat(p, q, count);
p_len = strlen(p); p_len = strlen(p);
copy_len = strnlen(q, count); copy_len = strnlen(q, count);
if (p_size < p_len + copy_len + 1) total = p_len + copy_len + 1;
fortify_panic(FORTIFY_FUNC_strncat, FORTIFY_WRITE, p); if (p_size < total)
fortify_panic(FORTIFY_FUNC_strncat, FORTIFY_WRITE, p_size, total, p);
__underlying_memcpy(p + p_len, q, copy_len); __underlying_memcpy(p + p_len, q, copy_len);
p[p_len + copy_len] = '\0'; p[p_len + copy_len] = '\0';
return p; return p;
@ -474,7 +476,7 @@ __FORTIFY_INLINE bool fortify_memset_chk(__kernel_size_t size,
* lengths are unknown.) * lengths are unknown.)
*/ */
if (p_size != SIZE_MAX && p_size < size) 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; return false;
} }
@ -574,9 +576,9 @@ __FORTIFY_INLINE bool fortify_memcpy_chk(__kernel_size_t size,
* lengths are unknown.) * lengths are unknown.)
*/ */
if (p_size != SIZE_MAX && p_size < size) 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) 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. * 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)) if (__compiletime_lessthan(p_size, size))
__read_overflow(); __read_overflow();
if (p_size < size) 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); 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)) if (__compiletime_lessthan(q_size, size))
__read_overflow2(); __read_overflow2();
} }
if (p_size < size || q_size < size) if (p_size < size)
fortify_panic(FORTIFY_FUNC_memcmp, FORTIFY_READ, INT_MIN); 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); 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)) if (__compiletime_lessthan(p_size, size))
__read_overflow(); __read_overflow();
if (p_size < size) 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); 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)) if (__compiletime_lessthan(p_size, size))
__read_overflow(); __read_overflow();
if (p_size < size) 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); 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)) if (__compiletime_lessthan(p_size, size))
__read_overflow(); __read_overflow();
if (p_size < size) 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); return __real_kmemdup(p, size, gfp);
} }
@ -767,7 +771,7 @@ char *strcpy(char * const POS p, const char * const POS q)
__write_overflow(); __write_overflow();
/* Run-time check for dynamic size overflow. */ /* Run-time check for dynamic size overflow. */
if (p_size < size) 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); __underlying_memcpy(p, q, size);
return p; return p;
} }

4
lib/fortify_kunit.c
View File

@ -17,8 +17,8 @@
/* Redefine fortify_panic() to track failures. */ /* Redefine fortify_panic() to track failures. */
void fortify_add_kunit_error(int write); void fortify_add_kunit_error(int write);
#define fortify_panic(func, write, retfail) do { \ #define fortify_panic(func, write, avail, size, retfail) do { \
__fortify_report(FORTIFY_REASON(func, write)); \ __fortify_report(FORTIFY_REASON(func, write), avail, size); \
fortify_add_kunit_error(write); \ fortify_add_kunit_error(write); \
return (retfail); \ return (retfail); \
} while (0) } while (0)

9
lib/string_helpers.c
View File

@ -1016,20 +1016,21 @@ static const char * const fortify_func_name[] = {
#undef MAKE_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 u8 func = FORTIFY_REASON_FUNC(reason);
const bool write = FORTIFY_REASON_DIR(reason); const bool write = FORTIFY_REASON_DIR(reason);
const char *name; const char *name;
name = fortify_func_name[umin(func, FORTIFY_FUNC_UNKNOWN)]; 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); 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(); BUG();
} }
EXPORT_SYMBOL(__fortify_panic); EXPORT_SYMBOL(__fortify_panic);