mirrors
/
linux-stable
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
1
0
Fork 0
Code Issues Releases Wiki Activity

fortify: Provide KUnit counters for failure testing 

The standard C string APIs were not designed to have a failure mode;
they were expected to always succeed without memory safety issues.
Normally, CONFIG_FORTIFY_SOURCE will use fortify_panic() to stop
processing, as truncating a read or write may provide an even worse
system state. However, this creates a problem for testing under things
like KUnit, which needs a way to survive failures.

When building with CONFIG_KUNIT, provide a failure path for all users
of fortify_panic, and track whether the failure was a read overflow or
a write overflow, for KUnit tests to examine. Inspired by similar logic
in the slab tests.

Signed-off-by: Kees Cook <keescook@chromium.org>
This commit is contained in:
Kees Cook 2023-04-07 12:27:14 -07:00
parent 1a78f8cb5d
commit 4ce615e798
3 changed files with 66 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -15,8 +15,10 @@
#define FORTIFY_REASON(func, write) (FIELD_PREP(BIT(0), write) | \
FIELD_PREP(GENMASK(7, 1), func))
#define fortify_panic(func, write) \
__fortify_panic(FORTIFY_REASON(func, write))
#ifndef fortify_panic
# define fortify_panic(func, write, retfail) \
__fortify_panic(FORTIFY_REASON(func, write))
#endif
#define FORTIFY_READ 0
#define FORTIFY_WRITE 1
@ -181,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);
fortify_panic(FORTIFY_FUNC_strncpy, FORTIFY_WRITE, p);
return __underlying_strncpy(p, q, size);
}
@ -212,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);
fortify_panic(FORTIFY_FUNC_strnlen, FORTIFY_READ, ret);
return ret;
}
@ -248,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);
fortify_panic(FORTIFY_FUNC_strlen, FORTIFY_READ, ret);
return ret;
}
@ -299,7 +301,7 @@ __FORTIFY_INLINE ssize_t sized_strscpy(char * const POS p, const char * const PO
* p_size.
*/
if (len > p_size)
fortify_panic(FORTIFY_FUNC_strscpy, FORTIFY_WRITE);
fortify_panic(FORTIFY_FUNC_strscpy, FORTIFY_WRITE, -E2BIG);
/*
* We can now safely call vanilla strscpy because we are protected from:
@ -357,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);
fortify_panic(FORTIFY_FUNC_strlcat, FORTIFY_READ, wanted);
if (actual >= avail) {
copy_len = avail - p_len - 1;
@ -366,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);
fortify_panic(FORTIFY_FUNC_strlcat, FORTIFY_WRITE, wanted);
__underlying_memcpy(p + p_len, q, copy_len);
p[actual] = '\0';
@ -395,7 +397,7 @@ char *strcat(char * const POS p, const char *q)
const size_t p_size = __member_size(p);
if (strlcat(p, q, p_size) >= p_size)
fortify_panic(FORTIFY_FUNC_strcat, FORTIFY_WRITE);
fortify_panic(FORTIFY_FUNC_strcat, FORTIFY_WRITE, p);
return p;
}
@ -431,13 +433,13 @@ char *strncat(char * const POS p, const char * const POS q, __kernel_size_t coun
p_len = strlen(p);
copy_len = strnlen(q, count);
if (p_size < p_len + copy_len + 1)
fortify_panic(FORTIFY_FUNC_strncat, FORTIFY_WRITE);
fortify_panic(FORTIFY_FUNC_strncat, FORTIFY_WRITE, p);
__underlying_memcpy(p + p_len, q, copy_len);
p[p_len + copy_len] = '\0';
return p;
}
__FORTIFY_INLINE void fortify_memset_chk(__kernel_size_t size,
__FORTIFY_INLINE bool fortify_memset_chk(__kernel_size_t size,
const size_t p_size,
const size_t p_size_field)
{
@ -472,7 +474,8 @@ __FORTIFY_INLINE void 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);
fortify_panic(FORTIFY_FUNC_memset, FORTIFY_WRITE, true);
return false;
}
#define __fortify_memset_chk(p, c, size, p_size, p_size_field) ({ \
@ -571,9 +574,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);
fortify_panic(func, FORTIFY_WRITE, true);
else if (q_size != SIZE_MAX && q_size < size)
fortify_panic(func, FORTIFY_READ);
fortify_panic(func, FORTIFY_READ, true);
/*
* Warn when writing beyond destination field size.
@ -673,7 +676,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);
fortify_panic(FORTIFY_FUNC_memscan, FORTIFY_READ, NULL);
return __real_memscan(p, c, size);
}
@ -690,7 +693,7 @@ int memcmp(const void * const POS0 p, const void * const POS0 q, __kernel_size_t
__read_overflow2();
}
if (p_size < size || q_size < size)
fortify_panic(FORTIFY_FUNC_memcmp, FORTIFY_READ);
fortify_panic(FORTIFY_FUNC_memcmp, FORTIFY_READ, INT_MIN);
return __underlying_memcmp(p, q, size);
}
@ -702,7 +705,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);
fortify_panic(FORTIFY_FUNC_memchr, FORTIFY_READ, NULL);
return __underlying_memchr(p, c, size);
}
@ -714,7 +717,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);
fortify_panic(FORTIFY_FUNC_memchr_inv, FORTIFY_READ, NULL);
return __real_memchr_inv(p, c, size);
}
@ -727,7 +730,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);
fortify_panic(FORTIFY_FUNC_kmemdup, FORTIFY_READ, NULL);
return __real_kmemdup(p, size, gfp);
}
@ -764,7 +767,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);
fortify_panic(FORTIFY_FUNC_strcpy, FORTIFY_WRITE, p);
__underlying_memcpy(p, q, size);
return p;
}

41
lib/fortify_kunit.c
View File

@ -15,8 +15,17 @@
*/
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
/* 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)); \
fortify_add_kunit_error(write); \
return (retfail); \
} while (0)
#include <kunit/device.h>
#include <kunit/test.h>
#include <kunit/test-bug.h>
#include <linux/device.h>
#include <linux/slab.h>
#include <linux/string.h>
@ -27,10 +36,34 @@
# define __compiletime_strlen __builtin_strlen
#endif
static struct kunit_resource read_resource;
static struct kunit_resource write_resource;
static int fortify_read_overflows;
static int fortify_write_overflows;
static const char array_of_10[] = "this is 10";
static const char *ptr_of_11 = "this is 11!";
static char array_unknown[] = "compiler thinks I might change";
void fortify_add_kunit_error(int write)
{
struct kunit_resource *resource;
struct kunit *current_test;
current_test = kunit_get_current_test();
if (!current_test)
return;
resource = kunit_find_named_resource(current_test,
write ? "fortify_write_overflows"
: "fortify_read_overflows");
if (!resource)
return;
(*(int *)resource->data)++;
kunit_put_resource(resource);
}
static void known_sizes_test(struct kunit *test)
{
KUNIT_EXPECT_EQ(test, __compiletime_strlen("88888888"), 8);
@ -318,6 +351,14 @@ static int fortify_test_init(struct kunit *test)
if (!IS_ENABLED(CONFIG_FORTIFY_SOURCE))
kunit_skip(test, "Not built with CONFIG_FORTIFY_SOURCE=y");
fortify_read_overflows = 0;
kunit_add_named_resource(test, NULL, NULL, &read_resource,
"fortify_read_overflows",
&fortify_read_overflows);
fortify_write_overflows = 0;
kunit_add_named_resource(test, NULL, NULL, &write_resource,
"fortify_write_overflows",
&fortify_write_overflows);
return 0;
}

2
lib/string_helpers.c
View File

@ -18,6 +18,8 @@
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/string_helpers.h>
#include <kunit/test.h>
#include <kunit/test-bug.h>
/**
* string_get_size - get the size in the specified units