Re: [PATCH 2/2] string.h: fix incompatibility between FORTIFY_SOURCE and KASAN
Hi Daniel, Thank you for the patch! Perhaps something to improve: [auto build test WARNING on linux/master] [also build test WARNING on arm64/for-next/core powerpc/next s390/features tip/x86/core linus/master v5.5-rc6 next-20200110] [if your patch is applied to the wrong git tree, please drop us a note to help improve the system. BTW, we also suggest to use '--base' option to specify the base tree in git format-patch, please see https://stackoverflow.com/a/37406982] url: https://github.com/0day-ci/linux/commits/Daniel-Axtens/Fix-some-incompatibilites-between-KASAN-and-FORTIFY_SOURCE/20200116-172838 base: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git 1522d9da40bdfe502c91163e6d769332897201fa config: x86_64-randconfig-s1-20200116 (attached as .config) compiler: gcc-7 (Debian 7.5.0-3) 7.5.0 reproduce: # save the attached .config to linux build tree make ARCH=x86_64 If you fix the issue, kindly add following tag Reported-by: kbuild test robot All warnings (new ones prefixed by >>): >> mm/kasan/common.o: warning: objtool: __kasan_slab_free()+0xea: unreachable >> instruction --- 0-DAY kernel test infrastructure Open Source Technology Center https://lists.01.org/hyperkitty/list/kbuild-...@lists.01.org Intel Corporation .config.gz Description: application/gzip
Re: [PATCH 2/2] string.h: fix incompatibility between FORTIFY_SOURCE and KASAN
Dmitry Vyukov writes: > On Wed, Jan 15, 2020 at 7:37 AM Daniel Axtens wrote: >> >> The memcmp KASAN self-test fails on a kernel with both KASAN and >> FORTIFY_SOURCE. >> >> When FORTIFY_SOURCE is on, a number of functions are replaced with >> fortified versions, which attempt to check the sizes of the operands. >> However, these functions often directly invoke __builtin_foo() once they >> have performed the fortify check. Using __builtins may bypass KASAN >> checks if the compiler decides to inline it's own implementation as >> sequence of instructions, rather than emit a function call that goes out >> to a KASAN-instrumented implementation. >> >> Why is only memcmp affected? >> >> >> Of the string and string-like functions that kasan_test tests, only memcmp >> is replaced by an inline sequence of instructions in my testing on x86 with >> gcc version 9.2.1 20191008 (Ubuntu 9.2.1-9ubuntu2). >> >> I believe this is due to compiler heuristics. For example, if I annotate >> kmalloc calls with the alloc_size annotation (and disable some fortify >> compile-time checking!), the compiler will replace every memset except the >> one in kmalloc_uaf_memset with inline instructions. (I have some WIP >> patches to add this annotation.) >> >> Does this affect other functions in string.h? >> = >> >> Yes. Anything that uses __builtin_* rather than __real_* could be >> affected. This looks like: >> >> - strncpy >> - strcat >> - strlen >> - strlcpy maybe, under some circumstances? >> - strncat under some circumstances >> - memset >> - memcpy >> - memmove >> - memcmp (as noted) >> - memchr >> - strcpy >> >> Whether a function call is emitted always depends on the compiler. Most >> bugs should get caught by FORTIFY_SOURCE, but the missed memcmp test shows >> that this is not always the case. >> >> Isn't FORTIFY_SOURCE disabled with KASAN? >> - >> >> The string headers on all arches supporting KASAN disable fortify with >> kasan, but only when address sanitisation is _also_ disabled. For example >> from x86: >> >> #if defined(CONFIG_KASAN) && !defined(__SANITIZE_ADDRESS__) >> /* >> * For files that are not instrumented (e.g. mm/slub.c) we >> * should use not instrumented version of mem* functions. >> */ >> #define memcpy(dst, src, len) __memcpy(dst, src, len) >> #define memmove(dst, src, len) __memmove(dst, src, len) >> #define memset(s, c, n) __memset(s, c, n) >> >> #ifndef __NO_FORTIFY >> #define __NO_FORTIFY /* FORTIFY_SOURCE uses __builtin_memcpy, etc. */ >> #endif >> >> #endif >> >> This comes from commit 6974f0c4555e ("include/linux/string.h: add the >> option of fortified string.h functions"), and doesn't work when KASAN is >> enabled and the file is supposed to be sanitised - as with test_kasan.c > > Hi Daniel, > > Thanks for addressing this. And special kudos for description detail level! :) > > Phew, this layering of checking tools is a bit messy... > >> I'm pretty sure this is backwards: we shouldn't be using __builtin_memcpy >> when we have a KASAN instrumented file, but we can use __builtin_* - and in >> many cases all fortification - in files where we don't have >> instrumentation. > > I think if we use __builtin_* in a non-instrumented file, the compiler > can emit a call to normal mem* function which will be intercepted by > kasan and we will get instrumentation in a file which should not be > instrumented. Moreover this behavior will depend on optimization level > and compiler internals. > But as far as I see this does not affect any of the following and the > code change. > mmm OK - you are right, when I consider this and your other point... >> #if !defined(__NO_FORTIFY) && defined(__OPTIMIZE__) && >> defined(CONFIG_FORTIFY_SOURCE) >> + >> +#ifdef CONFIG_KASAN >> +extern void *__underlying_memchr(const void *p, int c, __kernel_size_t >> size) __RENAME(memchr); > > > arch headers do: > > #if defined(CONFIG_KASAN) && !defined(__SANITIZE_ADDRESS__) > #define memcpy(dst, src, len) __memcpy(dst, src, len) > ... > > to disable instrumentation. Does this still work with this change? > Previously they disabled fortify. What happens now? Will define of > memcpy to __memcpy also affect __RENAME(memcpy), so that > __underlying_memcpy will be an alias to __memcpy? This is a good question. It's a really intricate set of interactions!! Between these two things, I think I'm going to just drop the removal of architecture changes, which means that fortify will continue to be disabled for files that disable KASAN sanitisation. It's just too complicated to reason through and satisfy myself that we're not going to get weird bugs, and the payoff is really small. >> +extern int __underlying_memcmp(const void *p, const void *q, >> __kernel_size_t size) __RENAME(memcmp); > > All of these macros are leaking from the header file. Tomorrow we will > discover __underlying_memcpy uses somew
Re: [PATCH 2/2] string.h: fix incompatibility between FORTIFY_SOURCE and KASAN
On Wed, Jan 15, 2020 at 7:37 AM Daniel Axtens wrote: > > The memcmp KASAN self-test fails on a kernel with both KASAN and > FORTIFY_SOURCE. > > When FORTIFY_SOURCE is on, a number of functions are replaced with > fortified versions, which attempt to check the sizes of the operands. > However, these functions often directly invoke __builtin_foo() once they > have performed the fortify check. Using __builtins may bypass KASAN > checks if the compiler decides to inline it's own implementation as > sequence of instructions, rather than emit a function call that goes out > to a KASAN-instrumented implementation. > > Why is only memcmp affected? > > > Of the string and string-like functions that kasan_test tests, only memcmp > is replaced by an inline sequence of instructions in my testing on x86 with > gcc version 9.2.1 20191008 (Ubuntu 9.2.1-9ubuntu2). > > I believe this is due to compiler heuristics. For example, if I annotate > kmalloc calls with the alloc_size annotation (and disable some fortify > compile-time checking!), the compiler will replace every memset except the > one in kmalloc_uaf_memset with inline instructions. (I have some WIP > patches to add this annotation.) > > Does this affect other functions in string.h? > = > > Yes. Anything that uses __builtin_* rather than __real_* could be > affected. This looks like: > > - strncpy > - strcat > - strlen > - strlcpy maybe, under some circumstances? > - strncat under some circumstances > - memset > - memcpy > - memmove > - memcmp (as noted) > - memchr > - strcpy > > Whether a function call is emitted always depends on the compiler. Most > bugs should get caught by FORTIFY_SOURCE, but the missed memcmp test shows > that this is not always the case. > > Isn't FORTIFY_SOURCE disabled with KASAN? > - > > The string headers on all arches supporting KASAN disable fortify with > kasan, but only when address sanitisation is _also_ disabled. For example > from x86: > > #if defined(CONFIG_KASAN) && !defined(__SANITIZE_ADDRESS__) > /* > * For files that are not instrumented (e.g. mm/slub.c) we > * should use not instrumented version of mem* functions. > */ > #define memcpy(dst, src, len) __memcpy(dst, src, len) > #define memmove(dst, src, len) __memmove(dst, src, len) > #define memset(s, c, n) __memset(s, c, n) > > #ifndef __NO_FORTIFY > #define __NO_FORTIFY /* FORTIFY_SOURCE uses __builtin_memcpy, etc. */ > #endif > > #endif > > This comes from commit 6974f0c4555e ("include/linux/string.h: add the > option of fortified string.h functions"), and doesn't work when KASAN is > enabled and the file is supposed to be sanitised - as with test_kasan.c Hi Daniel, Thanks for addressing this. And special kudos for description detail level! :) Phew, this layering of checking tools is a bit messy... > I'm pretty sure this is backwards: we shouldn't be using __builtin_memcpy > when we have a KASAN instrumented file, but we can use __builtin_* - and in > many cases all fortification - in files where we don't have > instrumentation. I think if we use __builtin_* in a non-instrumented file, the compiler can emit a call to normal mem* function which will be intercepted by kasan and we will get instrumentation in a file which should not be instrumented. Moreover this behavior will depend on optimization level and compiler internals. But as far as I see this does not affect any of the following and the code change. > What is correct behaviour? > == > > Firstly, there is some overlap between fortification and KASAN: both > provide some level of _runtime_ checking. Only fortify provides > compile-time checking. > > KASAN and fortify can pick up different things at runtime: > > - Some fortify functions, notably the string functions, could easily be >modified to consider sub-object sizes (e.g. members within a struct), >and I have some WIP patches to do this. KASAN cannot detect these >because it cannot insert poision between members of a struct. > > - KASAN can detect many over-reads/over-writes when the sizes of both >operands are unknown, which fortify cannot. > > So there are a couple of options: > > 1) Flip the test: disable fortify in santised files and enable it in > unsanitised files. This at least stops us missing KASAN checking, but > we lose the fortify checking. > > 2) Make the fortify code always call out to real versions. Do this only > for KASAN, for fear of losing the inlining opportunities we get from > __builtin_*. > > (We can't use kasan_check_{read,write}: because the fortify functions are > _extern inline_, you can't include _static_ inline functions without a > compiler warning. kasan_check_{read,write} are static inline so we can't > use them even when they would otherwise be suitable.) > > Take approach 2 and call out to real versions when KASAN is enabled.
[PATCH 2/2] string.h: fix incompatibility between FORTIFY_SOURCE and KASAN
The memcmp KASAN self-test fails on a kernel with both KASAN and FORTIFY_SOURCE. When FORTIFY_SOURCE is on, a number of functions are replaced with fortified versions, which attempt to check the sizes of the operands. However, these functions often directly invoke __builtin_foo() once they have performed the fortify check. Using __builtins may bypass KASAN checks if the compiler decides to inline it's own implementation as sequence of instructions, rather than emit a function call that goes out to a KASAN-instrumented implementation. Why is only memcmp affected? Of the string and string-like functions that kasan_test tests, only memcmp is replaced by an inline sequence of instructions in my testing on x86 with gcc version 9.2.1 20191008 (Ubuntu 9.2.1-9ubuntu2). I believe this is due to compiler heuristics. For example, if I annotate kmalloc calls with the alloc_size annotation (and disable some fortify compile-time checking!), the compiler will replace every memset except the one in kmalloc_uaf_memset with inline instructions. (I have some WIP patches to add this annotation.) Does this affect other functions in string.h? = Yes. Anything that uses __builtin_* rather than __real_* could be affected. This looks like: - strncpy - strcat - strlen - strlcpy maybe, under some circumstances? - strncat under some circumstances - memset - memcpy - memmove - memcmp (as noted) - memchr - strcpy Whether a function call is emitted always depends on the compiler. Most bugs should get caught by FORTIFY_SOURCE, but the missed memcmp test shows that this is not always the case. Isn't FORTIFY_SOURCE disabled with KASAN? - The string headers on all arches supporting KASAN disable fortify with kasan, but only when address sanitisation is _also_ disabled. For example from x86: #if defined(CONFIG_KASAN) && !defined(__SANITIZE_ADDRESS__) /* * For files that are not instrumented (e.g. mm/slub.c) we * should use not instrumented version of mem* functions. */ #define memcpy(dst, src, len) __memcpy(dst, src, len) #define memmove(dst, src, len) __memmove(dst, src, len) #define memset(s, c, n) __memset(s, c, n) #ifndef __NO_FORTIFY #define __NO_FORTIFY /* FORTIFY_SOURCE uses __builtin_memcpy, etc. */ #endif #endif This comes from commit 6974f0c4555e ("include/linux/string.h: add the option of fortified string.h functions"), and doesn't work when KASAN is enabled and the file is supposed to be sanitised - as with test_kasan.c I'm pretty sure this is backwards: we shouldn't be using __builtin_memcpy when we have a KASAN instrumented file, but we can use __builtin_* - and in many cases all fortification - in files where we don't have instrumentation. What is correct behaviour? == Firstly, there is some overlap between fortification and KASAN: both provide some level of _runtime_ checking. Only fortify provides compile-time checking. KASAN and fortify can pick up different things at runtime: - Some fortify functions, notably the string functions, could easily be modified to consider sub-object sizes (e.g. members within a struct), and I have some WIP patches to do this. KASAN cannot detect these because it cannot insert poision between members of a struct. - KASAN can detect many over-reads/over-writes when the sizes of both operands are unknown, which fortify cannot. So there are a couple of options: 1) Flip the test: disable fortify in santised files and enable it in unsanitised files. This at least stops us missing KASAN checking, but we lose the fortify checking. 2) Make the fortify code always call out to real versions. Do this only for KASAN, for fear of losing the inlining opportunities we get from __builtin_*. (We can't use kasan_check_{read,write}: because the fortify functions are _extern inline_, you can't include _static_ inline functions without a compiler warning. kasan_check_{read,write} are static inline so we can't use them even when they would otherwise be suitable.) Take approach 2 and call out to real versions when KASAN is enabled. Use __underlying_foo to distinguish from __real_foo: __real_foo always refers to the kernel's implementation of foo, __underlying_foo could be either the kernel implementation or the __builtin_foo implementation. Remove all the attempted disablement code in arch string headers. This makes all the tests succeed with FORTIFY_SOURCE enabled. Cc: Daniel Micay Cc: Andrey Ryabinin Cc: Alexander Potapenko Cc: Dmitry Vyukov Fixes: 6974f0c4555e ("include/linux/string.h: add the option of fortified string.h functions") Signed-off-by: Daniel Axtens --- Dmitry, this might cause a few new syzkaller splats - I first picked it up building from a syskaller config. Or it might not, it just depends what gets replaced with an inline sequence of instructions. checkpatch complains ab