kasan/tests: add tests for user memory access functions
Subsystems (4)
PATCH 1/4 kasan/tests: add tests for user memory access functions
This patch adds some tests for user memory access API.
KASAN doesn't pass these tests yet, but follow on patches will fix that.
--- lib/test_kasan.c | 49 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 49 insertions(+)
lib/test_kasan.c +49 -0
@@ -12,9 +12,12 @@#define pr_fmt (fmt) "kasan test: %s " fmt, __func__#include <linux/kernel.h> +#include <linux/mman.h> +#include <linux/mm.h> #include <linux/printk.h> #include <linux/slab.h> #include <linux/string.h> +#include <linux/uaccess.h> #include <linux/module.h> static noinline void __init kmalloc_oob_right(void)
@@ -389,6 +392,51 @@ static noinline void __init ksize_unpoisons_memory(void)kfree (ptr); } +static noinline void __init copy_user_test(void) +{ +char *kmem; +char __user *usermem; +size_t size =10 ; +int unused; + + kmem =kmalloc (size,GFP_KERNEL ); +if (!kmem) +return ; + + usermem = (char __user *)vm_mmap (NULL ,0 ,PAGE_SIZE , +PROT_READ |PROT_WRITE |PROT_EXEC , +MAP_ANONYMOUS |MAP_PRIVATE ,0 ); +if (IS_ERR (usermem)) { +pr_err ("Failed to allocate user memory\n" ); +kfree (kmem); +return ; + } + +pr_info ("out-of-bounds in copy_from_user()\n" ); + unused =copy_from_user (kmem, usermem, size +1 ); + +pr_info ("out-of-bounds in copy_to_user()\n" ); + unused =copy_to_user (usermem, kmem, size +1 ); + +pr_info ("out-of-bounds in __copy_from_user()\n" ); + unused =__copy_from_user (kmem, usermem, size +1 ); + +pr_info ("out-of-bounds in __copy_to_user()\n" ); + unused =__copy_to_user (usermem, kmem, size +1 ); + +pr_info ("out-of-bounds in __copy_from_user_inatomic()\n" ); + unused =__copy_from_user_inatomic (kmem, usermem, size +1 ); + +pr_info ("out-of-bounds in __copy_to_user_inatomic()\n" ); + unused =__copy_to_user_inatomic (usermem, kmem, size +1 ); + +pr_info ("out-of-bounds in strncpy_from_user()\n" ); + unused =strncpy_from_user (kmem, usermem, size +1 ); + +vm_munmap ((unsigned long )usermem,PAGE_SIZE ); +kfree (kmem); +} +static int __init kmalloc_tests_init (void ) {kmalloc_oob_right ();
@@ -416,6 +464,7 @@ static int __init kmalloc_tests_init(void)kasan_quarantine_cache ();#endif ksize_unpoisons_memory (); +copy_user_test ();return -EAGAIN ; }
Signature · 7 lines
2.7.3 -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
PATCH 2/4 mm/kasan: print name of mem[set,cpy,move]() caller in report
When bogus memory access happens in mem[set,cpy,move]() it's usually caller's fault. So don't blame mem[set,cpy,move]() in bug report, blame the caller instead.
Before:
BUG: KASAN: out-of-bounds access in memset+0x23/0x40 at <address> After: BUG: KASAN: out-of-bounds access in <memset_caller> at <address>
--- mm/kasan/kasan.c | 64 ++++++++++++++++++++++++++++++-------------------------- 1 file changed, 34 insertions(+), 30 deletions(-)
mm/kasan/kasan.c +34 -30
@@ -273,32 +273,36 @@ static __always_inline bool memory_is_poisoned(unsigned long addr, size_t size)return memory_is_poisoned_n (addr, size); } - -static __always_inline void check_memory_region(unsigned long addr, -size_t size,bool write) +static __always_inline void check_memory_region_inline(unsigned long addr, +size_t size,bool write, +unsigned long ret_ip) {if (unlikely (size ==0 ))return ;if (unlikely ((void *)addr <kasan_shadow_to_mem ((void *)KASAN_SHADOW_START ))) { -kasan_report (addr, size, write, _RET_IP_); +kasan_report (addr, size, write, ret_ip);return ; }if (likely (!memory_is_poisoned (addr, size)))return ; -kasan_report (addr, size, write, _RET_IP_); +kasan_report (addr, size, write, ret_ip); } -void __asan_loadN (unsigned long addr,size_t size); -void __asan_storeN (unsigned long addr,size_t size); +static void check_memory_region (unsigned long addr, +size_t size,bool write, +unsigned long ret_ip) +{ +check_memory_region_inline (addr, size, write, ret_ip); +}#undef memsetvoid *memset (void *addr,int c,size_t len) { -__asan_storeN ((unsigned long )addr, len); +check_memory_region ((unsigned long )addr, len, true, _RET_IP_);return __memset (addr, c, len); }
@@ -306,8 +310,8 @@ void *memset(void *addr, int c, size_t len)#undef memmovevoid *memmove (void *dest,const void *src,size_t len) { -__asan_loadN ((unsigned long )src, len); -__asan_storeN ((unsigned long )dest, len); +check_memory_region ((unsigned long )src, len, false, _RET_IP_); +check_memory_region ((unsigned long )dest, len, true, _RET_IP_);return __memmove (dest, src, len); }
@@ -315,8 +319,8 @@ void *memmove(void *dest, const void *src, size_t len)#undef memcpyvoid *memcpy (void *dest,const void *src,size_t len) { -__asan_loadN ((unsigned long )src, len); -__asan_storeN ((unsigned long )dest, len); +check_memory_region ((unsigned long )src, len, false, _RET_IP_); +check_memory_region ((unsigned long )dest, len, true, _RET_IP_);return __memcpy (dest, src, len); }
@@ -698,22 +702,22 @@ void __asan_unregister_globals(struct kasan_global *globals, size_t size) }EXPORT_SYMBOL (__asan_unregister_globals); -#define DEFINE_ASAN_LOAD_STORE (size) \ - void __asan_load##size(unsigned long addr) \ - { \ - check_memory_region(addr, size, false); \ - } \ - EXPORT_SYMBOL(__asan_load##size); \ - __alias(__asan_load##size) \ - void __asan_load##size##_noabort(unsigned long); \ - EXPORT_SYMBOL(__asan_load##size##_noabort); \ - void __asan_store##size(unsigned long addr) \ - { \ - check_memory_region(addr, size, true); \ - } \ - EXPORT_SYMBOL(__asan_store##size); \ - __alias(__asan_store##size) \ - void __asan_store##size##_noabort(unsigned long); \ +#define DEFINE_ASAN_LOAD_STORE (size) \ + void __asan_load##size(unsigned long addr) \ + { \ + check_memory_region_inline(addr, size, false, _RET_IP_);\ + } \ + EXPORT_SYMBOL(__asan_load##size); \ + __alias(__asan_load##size) \ + void __asan_load##size##_noabort(unsigned long); \ + EXPORT_SYMBOL(__asan_load##size##_noabort); \ + void __asan_store##size(unsigned long addr) \ + { \ + check_memory_region_inline(addr, size, true, _RET_IP_); \ + } \ + EXPORT_SYMBOL(__asan_store##size); \ + __alias(__asan_store##size) \ + void __asan_store##size##_noabort(unsigned long); \ EXPORT_SYMBOL(__asan_store##size##_noabort)DEFINE_ASAN_LOAD_STORE (1 );
@@ -724,7 +728,7 @@ DEFINE_ASAN_LOAD_STORE(16);void __asan_loadN (unsigned long addr,size_t size) { -check_memory_region (addr, size, false); +check_memory_region (addr, size, false, _RET_IP_); }EXPORT_SYMBOL (__asan_loadN);
@@ -734,7 +738,7 @@ EXPORT_SYMBOL(__asan_loadN_noabort);void __asan_storeN (unsigned long addr,size_t size) { -check_memory_region (addr, size, true); +check_memory_region (addr, size, true, _RET_IP_); }EXPORT_SYMBOL (__asan_storeN);
Signature · 7 lines
2.7.3 -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [PATCH 2/4] mm/kasan: print name of mem[set,cpy,move]() caller in report
Quoted 145 lines · Andrey Ryabinin
When bogus memory access happens in mem[set,cpy,move]() it's usually caller's fault. So don't blame mem[set,cpy,move]() in bug report, blame the caller instead.
Before:
BUG: KASAN: out-of-bounds access in memset+0x23/0x40 at <address> After: BUG: KASAN: out-of-bounds access in <memset_caller> at <address>Signed-off-by Andrey Ryabinin <[email protected]>Cc Alexander Potapenko <[email protected]>Cc Dmitry Vyukov <[email protected]>--- mm/kasan/kasan.c | 64 ++++++++++++++++++++++++++++++-------------------------- 1 file changed, 34 insertions(+), 30 deletions(-)mm/kasan/kasan.c +34
-31@@ -273,32 +273,36 @@ static __always_inline bool memory_is_poisoned(unsigned long addr, size_t size)return memory_is_poisoned_n (addr, size); } - -static __always_inline void check_memory_region(unsigned long addr, -size_t size,bool write) +static __always_inline void check_memory_region_inline(unsigned long addr, +size_t size,bool write, +unsigned long ret_ip) {if (unlikely (size ==0 ))return ;if (unlikely ((void *)addr <kasan_shadow_to_mem ((void *)KASAN_SHADOW_START ))) { -kasan_report (addr, size, write, _RET_IP_); +kasan_report (addr, size, write, ret_ip);return ; }if (likely (!memory_is_poisoned (addr, size)))return ; -kasan_report (addr, size, write, _RET_IP_); +kasan_report (addr, size, write, ret_ip); } -void __asan_loadN (unsigned long addr,size_t size); -void __asan_storeN (unsigned long addr,size_t size); +static void check_memory_region (unsigned long addr, +size_t size,bool write, +unsigned long ret_ip) +{ +check_memory_region_inline (addr, size, write, ret_ip); +}#undef memsetvoid *memset (void *addr,int c,size_t len) { -__asan_storeN ((unsigned long )addr, len); +check_memory_region ((unsigned long )addr, len, true, _RET_IP_);return __memset (addr, c, len); }@@ -306,8 +310,8 @@ void *memset(void *addr, int c, size_t len)#undef memmovevoid *memmove (void *dest,const void *src,size_t len) { -__asan_loadN ((unsigned long )src, len); -__asan_storeN ((unsigned long )dest, len); +check_memory_region ((unsigned long )src, len, false, _RET_IP_); +check_memory_region ((unsigned long )dest, len, true, _RET_IP_);return __memmove (dest, src, len); }@@ -315,8 +319,8 @@ void *memmove(void *dest, const void *src, size_t len)#undef memcpyvoid *memcpy (void *dest,const void *src,size_t len) { -__asan_loadN ((unsigned long )src, len); -__asan_storeN ((unsigned long )dest, len); +check_memory_region ((unsigned long )src, len, false, _RET_IP_); +check_memory_region ((unsigned long )dest, len, true, _RET_IP_);return __memcpy (dest, src, len); }@@ -698,22 +702,22 @@ void __asan_unregister_globals(struct kasan_global *globals, size_t size) }EXPORT_SYMBOL (__asan_unregister_globals); -#define DEFINE_ASAN_LOAD_STORE (size) \ - void __asan_load##size(unsigned long addr) \ - { \ - check_memory_region(addr, size, false); \ - } \ - EXPORT_SYMBOL(__asan_load##size); \ - __alias(__asan_load##size) \ - void __asan_load##size##_noabort(unsigned long); \ - EXPORT_SYMBOL(__asan_load##size##_noabort); \ - void __asan_store##size(unsigned long addr) \ - { \ - check_memory_region(addr, size, true); \ - } \ - EXPORT_SYMBOL(__asan_store##size); \ - __alias(__asan_store##size) \ - void __asan_store##size##_noabort(unsigned long); \ +#define DEFINE_ASAN_LOAD_STORE (size) \ + void __asan_load##size(unsigned long addr) \ + { \ + check_memory_region_inline(addr, size, false, _RET_IP_);\ + } \ + EXPORT_SYMBOL(__asan_load##size); \ + __alias(__asan_load##size) \ + void __asan_load##size##_noabort(unsigned long); \ + EXPORT_SYMBOL(__asan_load##size##_noabort); \ + void __asan_store##size(unsigned long addr) \ + { \ + check_memory_region_inline(addr, size, true, _RET_IP_); \ + } \ + EXPORT_SYMBOL(__asan_store##size); \ + __alias(__asan_store##size) \ + void __asan_store##size##_noabort(unsigned long); \ EXPORT_SYMBOL(__asan_store##size##_noabort)DEFINE_ASAN_LOAD_STORE (1 );@@ -724,7 +728,7 @@ DEFINE_ASAN_LOAD_STORE(16);void __asan_loadN (unsigned long addr,size_t size) { -check_memory_region (addr, size, false); +check_memory_region (addr, size, false, _RET_IP_); }EXPORT_SYMBOL (__asan_loadN);@@ -734,7 +738,7 @@ EXPORT_SYMBOL(__asan_loadN_noabort);void __asan_storeN (unsigned long addr,size_t size) { -check_memory_region (addr, size, true); +check_memory_region (addr, size, true, _RET_IP_); }EXPORT_SYMBOL (__asan_storeN); --Reviewed-by:
Quoted 2 lines
2.7.3
Signature · 16 lines
Alexander Potapenko Software Engineer Google Germany GmbH Erika-Mann-Straße, 33 80636 München Geschäftsführer: Matthew Scott Sucherman, Paul Terence Manicle Registergericht und -nummer: Hamburg, HRB 86891 Sitz der Gesellschaft: Hamburg -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
PATCH 3/4 mm/kasan: add API to check memory regions
In reply to Andrey RyabininMemory access coded in an assembly won't be seen by KASAN as a compiler can instrument only C code. Add kasan_check_[read,write]() API which is going to be used to check a certain memory range.
--- MAINTAINERS | 2 +- include/linux/kasan-checks.h | 12 ++++++++++++ mm/kasan/kasan.c | 12 ++++++++++++ 3 files changed, 25 insertions(+), 1 deletion(-) create mode 100644 include/linux/kasan-checks.h
MAINTAINERS +1 -1
@@ -6363,7 +6363,7 @@ S: Maintained F: arch/*/include/asm/kasan.h F: arch/*/mm/kasan_init* F: Documentation/kasan.txt -F: include/linux/kasan.h +F: include/linux/kasan*.h F: lib/test_kasan.c F: mm/kasan/ F: scripts/Makefile.kasan
include/linux/kasan-checks.h new file +12 -0
@@ -0,0 +1,12 @@ +#ifndef _LINUX_KASAN_CHECKS_H +#define _LINUX_KASAN_CHECKS_H + +#ifdef CONFIG_KASAN +void kasan_check_read (const void *p,unsigned int size); +void kasan_check_write (const void *p,unsigned int size); +#else +static inline void kasan_check_read (const void *p,unsigned int size) { } +static inline void kasan_check_write (const void *p,unsigned int size) { } +#endif + +#endif
mm/kasan/kasan.c +12 -0
@@ -299,6 +299,18 @@ static void check_memory_region(unsigned long addr,check_memory_region_inline (addr, size, write, ret_ip); } +void kasan_check_read (const void *p,unsigned int size) +{ +check_memory_region ((unsigned long )p, size, false, _RET_IP_); +} +EXPORT_SYMBOL (kasan_check_read); + +void kasan_check_write (const void *p,unsigned int size) +{ +check_memory_region ((unsigned long )p, size, true, _RET_IP_); +} +EXPORT_SYMBOL (kasan_check_write); +#undef memsetvoid *memset (void *addr,int c,size_t len) {
Signature · 7 lines
2.7.3 -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [PATCH 3/4] mm/kasan: add API to check memory regions
Quoted 69 lines · Andrey Ryabinin
Memory access coded in an assembly won't be seen by KASAN as a compiler can instrument only C code. Add kasan_check_[read,write]() API which is going to be used to check a certain memory range.
Signed-off-by Andrey Ryabinin <[email protected]>Cc Alexander Potapenko <[email protected]>Cc Dmitry Vyukov <[email protected]>--- MAINTAINERS | 2 +- include/linux/kasan-checks.h | 12 ++++++++++++ mm/kasan/kasan.c | 12 ++++++++++++ 3 files changed, 25 insertions(+), 1 deletion(-) create mode 100644 include/linux/kasan-checks.hMAINTAINERS +1
-1@@ -6363,7 +6363,7 @@ S: Maintained F: arch/*/include/asm/kasan.h F: arch/*/mm/kasan_init* F: Documentation/kasan.txt -F: include/linux/kasan.h +F: include/linux/kasan*.h F: lib/test_kasan.c F: mm/kasan/ F: scripts/Makefile.kasaninclude/linux/kasan-checks.h new file +12
-0@@ -0,0 +1,12 @@ +#ifndef _LINUX_KASAN_CHECKS_H +#define _LINUX_KASAN_CHECKS_H + +#ifdef CONFIG_KASAN +void kasan_check_read (const void *p,unsigned int size); +void kasan_check_write (const void *p,unsigned int size); +#else +static inline void kasan_check_read (const void *p,unsigned int size) { } +static inline void kasan_check_write (const void *p,unsigned int size) { } +#endif + +#endif mm/kasan/kasan.c +12
-1@@ -299,6 +299,18 @@ static void check_memory_region(unsigned long addr,check_memory_region_inline (addr, size, write, ret_ip); } +void kasan_check_read (const void *p,unsigned int size) +{ +check_memory_region ((unsigned long )p, size, false, _RET_IP_); +} +EXPORT_SYMBOL (kasan_check_read); + +void kasan_check_write (const void *p,unsigned int size) +{ +check_memory_region ((unsigned long )p, size, true, _RET_IP_); +} +EXPORT_SYMBOL (kasan_check_write); +#undef memsetvoid *memset (void *addr,int c,size_t len) { --
Quoted 2 lines
2.7.3
Signature · 16 lines
Alexander Potapenko Software Engineer Google Germany GmbH Erika-Mann-Straße, 33 80636 München Geschäftsführer: Matthew Scott Sucherman, Paul Terence Manicle Registergericht und -nummer: Hamburg, HRB 86891 Sitz der Gesellschaft: Hamburg -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
PATCH 4/4 x86/kasan: Instrument user memory access API
In reply to Andrey RyabininExchange between user and kernel memory is coded in assembly language. Which means that such accesses won't be spotted by KASAN as a compiler instruments only C code.
Add explicit KASAN checks to user memory access API to ensure that userspace writes to (or reads from) a valid kernel memory.
Note: Unlike others strncpy_from_user() is written mostly in C and KASAN sees memory accesses in it. However, it makes sense to add explicit check for all @count bytes that *potentially* could be written to the kernel.
--- arch/x86/include/asm/uaccess.h | 5 +++++ arch/x86/include/asm/uaccess_64.h | 7 +++++++ lib/strncpy_from_user.c | 2 ++ 3 files changed, 14 insertions(+)
arch/x86/include/asm/uaccess.h +5 -0
@@ -5,6 +5,7 @@*/ #include <linux/errno.h> #include <linux/compiler.h> +#include <linux/kasan-checks.h> #include <linux/thread_info.h> #include <linux/string.h> #include <asm/asm.h>
@@ -732,6 +733,8 @@ copy_from_user(void *to, const void __user *from, unsigned long n)might_fault (); +kasan_check_write (to, n); +/* * While we would like to have the compiler do the checking for us * even in the non-constant size case, any false positives there are
@@ -765,6 +768,8 @@ copy_to_user(void __user *to, const void *from, unsigned long n) {int sz =__compiletime_object_size (from); +kasan_check_read (from, n); +might_fault ();/* See the comment in copy_from_user() above. */
arch/x86/include/asm/uaccess_64.h +7 -0
@@ -7,6 +7,7 @@#include <linux/compiler.h> #include <linux/errno.h> #include <linux/lockdep.h> +#include <linux/kasan-checks.h> #include <asm/alternative.h> #include <asm/cpufeatures.h> #include <asm/page.h>
@@ -109,6 +110,7 @@ static __always_inline __must_checkint __copy_from_user (void *dst,const void __user *src,unsigned size) {might_fault (); +kasan_check_write (dst, size);return __copy_from_user_nocheck (dst, src, size); }
@@ -175,6 +177,7 @@ static __always_inline __must_checkint __copy_to_user (void __user *dst,const void *src,unsigned size) {might_fault (); +kasan_check_read (src, size);return __copy_to_user_nocheck (dst, src, size); }
@@ -242,12 +245,14 @@ int __copy_in_user(void __user *dst, const void __user *src, unsigned size) static __must_check __always_inline int__copy_from_user_inatomic (void *dst,const void __user *src,unsigned size) { +kasan_check_write (dst, size);return __copy_from_user_nocheck (dst, src, size); } static __must_check __always_inline int__copy_to_user_inatomic (void __user *dst,const void *src,unsigned size) { +kasan_check_read (src, size);return __copy_to_user_nocheck (dst, src, size); }
@@ -258,6 +263,7 @@ static inline int __copy_from_user_nocache(void *dst, const void __user *src, unsigned size) {might_fault (); +kasan_check_write (dst, size);return __copy_user_nocache (dst, src, size,1 ); }
@@ -265,6 +271,7 @@ static inline int __copy_from_user_inatomic_nocache(void *dst, const void __user *src, unsigned size) { +kasan_check_write (dst, size);return __copy_user_nocache (dst, src, size,0 ); }
lib/strncpy_from_user.c +2 -0
@@ -1,5 +1,6 @@#include <linux/compiler.h> #include <linux/export.h> +#include <linux/kasan-checks.h> #include <linux/uaccess.h> #include <linux/kernel.h> #include <linux/errno.h>
@@ -103,6 +104,7 @@ long strncpy_from_user(char *dst, const char __user *src, long count)if (unlikely (count <=0 ))return 0 ; +kasan_check_write (dst, count); max_addr =user_addr_max (); src_addr = (unsigned long )src;if (likely (src_addr < max_addr)) {
Signature · 7 lines
2.7.3 -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [PATCH 4/4] x86/kasan: Instrument user memory access API
Quoted 9 lines · Andrey Ryabinin
Exchange between user and kernel memory is coded in assembly language. Which means that such accesses won't be spotted by KASAN as a compiler instruments only C code.
Add explicit KASAN checks to user memory access API to ensure that userspace writes to (or reads from) a valid kernel memory.Note: Unlike others
strncpy_from_user()is written mostly in C and KASAN sees memory accesses in it. However, it makes sense to add explicit check for all @count bytes that *potentially* could be written to the kernel.
Thanks!
Quoted 119 lines
Signed-off-by Andrey Ryabinin <[email protected]>Cc Alexander Potapenko <[email protected]>Cc Dmitry Vyukov <[email protected]>--- arch/x86/include/asm/uaccess.h | 5 +++++ arch/x86/include/asm/uaccess_64.h | 7 +++++++ lib/strncpy_from_user.c | 2 ++ 3 files changed, 14 insertions(+)arch/x86/include/asm/uaccess.h +5
-0@@ -5,6 +5,7 @@*/ #include <linux/errno.h> #include <linux/compiler.h> +#include <linux/kasan-checks.h> #include <linux/thread_info.h> #include <linux/string.h> #include <asm/asm.h> @@ -732,6 +733,8 @@ copy_from_user(void *to, const void __user *from, unsigned long n)might_fault (); +kasan_check_write (to, n); +/* * While we would like to have the compiler do the checking for us * even in the non-constant size case, any false positives there are @@ -765,6 +768,8 @@ copy_to_user(void __user *to, const void *from, unsigned long n) {int sz =__compiletime_object_size (from); +kasan_check_read (from, n); +might_fault ();/* See the comment in copy_from_user() above. */ arch/x86/include/asm/uaccess_64.h +7
-0@@ -7,6 +7,7 @@#include <linux/compiler.h> #include <linux/errno.h> #include <linux/lockdep.h> +#include <linux/kasan-checks.h> #include <asm/alternative.h> #include <asm/cpufeatures.h> #include <asm/page.h> @@ -109,6 +110,7 @@ static __always_inline __must_checkint __copy_from_user (void *dst,const void __user *src,unsigned size) {might_fault (); +kasan_check_write (dst, size);return __copy_from_user_nocheck (dst, src, size); }@@ -175,6 +177,7 @@ static __always_inline __must_checkint __copy_to_user (void __user *dst,const void *src,unsigned size) {might_fault (); +kasan_check_read (src, size);return __copy_to_user_nocheck (dst, src, size); }@@ -242,12 +245,14 @@ int __copy_in_user(void __user *dst, const void __user *src, unsigned size) static __must_check __always_inline int__copy_from_user_inatomic (void *dst,const void __user *src,unsigned size) { +kasan_check_write (dst, size);return __copy_from_user_nocheck (dst, src, size); } static __must_check __always_inline int__copy_to_user_inatomic (void __user *dst,const void *src,unsigned size) { +kasan_check_read (src, size);return __copy_to_user_nocheck (dst, src, size); }@@ -258,6 +263,7 @@ static inline int __copy_from_user_nocache(void *dst, const void __user *src, unsigned size) {might_fault (); +kasan_check_write (dst, size);return __copy_user_nocache (dst, src, size,1 ); }@@ -265,6 +271,7 @@ static inline int __copy_from_user_inatomic_nocache(void *dst, const void __user *src, unsigned size) { +kasan_check_write (dst, size);return __copy_user_nocache (dst, src, size,0 ); }lib/strncpy_from_user.c +2
-1@@ -1,5 +1,6 @@#include <linux/compiler.h> #include <linux/export.h> +#include <linux/kasan-checks.h> #include <linux/uaccess.h> #include <linux/kernel.h> #include <linux/errno.h> @@ -103,6 +104,7 @@ long strncpy_from_user(char *dst, const char __user *src, long count)if (unlikely (count <=0 ))return 0 ; +kasan_check_write (dst, count); max_addr =user_addr_max (); src_addr = (unsigned long )src;if (likely (src_addr < max_addr)) { --
Quoted 2 lines
2.7.3
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [PATCH 4/4] x86/kasan: Instrument user memory access API
In reply to Andrey RyabininQuoted 19 lines · Andrey Ryabinin
Exchange between user and kernel memory is coded in assembly language. Which means that such accesses won't be spotted by KASAN as a compiler instruments only C code.
Add explicit KASAN checks to user memory access API to ensure that userspace writes to (or reads from) a valid kernel memory.Note: Unlike others
strncpy_from_user()is written mostly in C and KASAN sees memory accesses in it. However, it makes sense to add explicit check for all @count bytes that *potentially* could be written to the kernel.Signed-off-by Andrey Ryabinin <[email protected]>Cc Alexander Potapenko <[email protected]>Cc Dmitry Vyukov <[email protected]>--- arch/x86/include/asm/uaccess.h | 5 +++++ arch/x86/include/asm/uaccess_64.h | 7 +++++++ lib/strncpy_from_user.c | 2 ++ 3 files changed, 14 insertions(+)
[...]
Quoted 12 lines
lib/strncpy_from_user.c +1
-0@@ -1,5 +1,6 @@#include <linux/compiler.h> #include <linux/export.h> +#include <linux/kasan-checks.h> #include <linux/uaccess.h> #include <linux/kernel.h> #include <linux/errno.h>
lib/strncpy_from_user.c long strncpy_from_user(char *dst, const char __user *src, long count) · line 110
Quoted 7 lines
lib/strncpy_from_user.c +1
-0@@ -103,6 +104,7 @@ long strncpy_from_user(char *dst, const char __user *src, long count)if (unlikely (count <=0 ))return 0 ; +kasan_check_write (dst, count); max_addr =user_addr_max (); src_addr = (unsigned long )src;if (likely (src_addr < max_addr)) {
Please do the check inside the condition, before the user_access_begin(), because where you've put the check we might still fail and not do a user copy and -EFAULT out.
With that fixed:
Thanks,
Ingo
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
PATCH 1/1 x86-kasan-instrument-user-memory-access-api-fix
Move kasan check under the condition, otherwise we may fail and not do a user copy.
--- lib/strncpy_from_user.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
lib/strncpy_from_user.c +1 -1
@@ -104,13 +104,13 @@ long strncpy_from_user(char *dst, const char __user *src, long count)if (unlikely (count <=0 ))return 0 ; -kasan_check_write (dst, count); max_addr =user_addr_max (); src_addr = (unsigned long )src;if (likely (src_addr < max_addr)) {unsigned long max = max_addr - src_addr;long retval; +kasan_check_write (dst, count);user_access_begin (); retval =do_strncpy_from_user (dst, src, count, max);user_access_end ();
Signature · 7 lines
2.7.3 -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Andrew Morton
maintainerQuoted 2 lines · On Fri, 6 May 2016 15:45:19 +0300 Andrey Ryabinin <[email protected]>…
This patch adds some tests for user memory access API.
KASAN doesn't pass these tests yet, but follow on patches will fix that.
I'll move this patch from [1/4] to [4/4] to avoid the minor bisection hole.
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>