kasan: test: avoid crashing the kernel with HW_TAGS
Subsystems (2)
PATCH v2 1/8 kasan: test: rework kmalloc_oob_right
In reply to [email protected]From: Andrey Konovalov <[email protected]>
Rework kmalloc_oob_right() to do these bad access checks:
1. An unaligned access one byte past the requested kmalloc size (can only be detected by KASAN_GENERIC).
2. An aligned access into the first out-of-bounds granule that falls within the aligned kmalloc object.
3. Out-of-bounds access past the aligned kmalloc object.
Test #3 deliberately uses a read access to avoid corrupting memory. Otherwise, this test might lead to crashes with the HW_TAGS mode, as it neither uses quarantine nor redzones.
--- lib/test_kasan.c | 20 ++++++++++++++++++-- 1 file changed, 18 insertions(+), 2 deletions(-)
lib/test_kasan.c +18 -2
@@ -122,12 +122,28 @@ static void kasan_test_exit(struct kunit *test)static void kmalloc_oob_right (struct kunit *test) {char *ptr; -size_t size =123 ; +size_t size =128 -KASAN_GRANULE_SIZE -5 ; ptr =kmalloc (size,GFP_KERNEL );KUNIT_ASSERT_NOT_ERR_OR_NULL (test, ptr); -KUNIT_EXPECT_KASAN_FAIL (test, ptr[size +OOB_TAG_OFF ] ='x' ); +/* +* An unaligned access past the requested kmalloc size. +* Only generic KASAN can precisely detect these. +*/ +if (IS_ENABLED (CONFIG_KASAN_GENERIC )) +KUNIT_EXPECT_KASAN_FAIL (test, ptr[size] ='x' ); + +/* +* An aligned access into the first out-of-bounds granule that falls +* within the aligned kmalloc object. +*/ +KUNIT_EXPECT_KASAN_FAIL (test, ptr[size +5 ] ='y' ); + +/* Out-of-bounds access past the aligned kmalloc object. */ +KUNIT_EXPECT_KASAN_FAIL (test, ptr[0 ] = + ptr[size +KASAN_GRANULE_SIZE +5 ]); +kfree (ptr); }
Signature · 1 line
2.25.1
PATCH v2 2/8 kasan: test: avoid writing invalid memory
In reply to [email protected]From: Andrey Konovalov <[email protected]>
Multiple KASAN tests do writes past the allocated objects or writes to freed memory. Turn these writes into reads to avoid corrupting memory. Otherwise, these tests might lead to crashes with the HW_TAGS mode, as it neither uses quarantine nor redzones.
--- lib/test_kasan.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-)
lib/test_kasan.c +7 -7
@@ -167,7 +167,7 @@ static void kmalloc_node_oob_right(struct kunit *test) ptr =kmalloc_node (size,GFP_KERNEL ,0 );KUNIT_ASSERT_NOT_ERR_OR_NULL (test, ptr); -KUNIT_EXPECT_KASAN_FAIL (test, ptr[size] =0 ); +KUNIT_EXPECT_KASAN_FAIL (test, ptr[0 ] = ptr[size]);kfree (ptr); }
@@ -203,7 +203,7 @@ static void kmalloc_pagealloc_uaf(struct kunit *test)KUNIT_ASSERT_NOT_ERR_OR_NULL (test, ptr);kfree (ptr); -KUNIT_EXPECT_KASAN_FAIL (test, ptr[0 ] =0 ); +KUNIT_EXPECT_KASAN_FAIL (test, ((volatile char *)ptr)[0 ]); }static void kmalloc_pagealloc_invalid_free (struct kunit *test)
@@ -237,7 +237,7 @@ static void pagealloc_oob_right(struct kunit *test) ptr =page_address (pages);KUNIT_ASSERT_NOT_ERR_OR_NULL (test, ptr); -KUNIT_EXPECT_KASAN_FAIL (test, ptr[size] =0 ); +KUNIT_EXPECT_KASAN_FAIL (test, ptr[0 ] = ptr[size]);free_pages ((unsigned long )ptr, order); }
@@ -252,7 +252,7 @@ static void pagealloc_uaf(struct kunit *test)KUNIT_ASSERT_NOT_ERR_OR_NULL (test, ptr);free_pages ((unsigned long )ptr, order); -KUNIT_EXPECT_KASAN_FAIL (test, ptr[0 ] =0 ); +KUNIT_EXPECT_KASAN_FAIL (test, ((volatile char *)ptr)[0 ]); }static void kmalloc_large_oob_right (struct kunit *test)
@@ -514,7 +514,7 @@ static void kmalloc_uaf(struct kunit *test)KUNIT_ASSERT_NOT_ERR_OR_NULL (test, ptr);kfree (ptr); -KUNIT_EXPECT_KASAN_FAIL (test, *(ptr +8 ) ='x' ); +KUNIT_EXPECT_KASAN_FAIL (test, ((volatile char *)ptr)[8 ]); }static void kmalloc_uaf_memset (struct kunit *test)
@@ -553,7 +553,7 @@ static void kmalloc_uaf2(struct kunit *test) goto again; } -KUNIT_EXPECT_KASAN_FAIL (test, ptr1[40 ] ='x' ); +KUNIT_EXPECT_KASAN_FAIL (test, ((volatile char *)ptr1)[40 ]);KUNIT_EXPECT_PTR_NE (test, ptr1, ptr2);kfree (ptr2);
@@ -700,7 +700,7 @@ static void ksize_unpoisons_memory(struct kunit *test) ptr[size] ='x' ;/* This one must. */ -KUNIT_EXPECT_KASAN_FAIL (test, ptr[real_size] ='y' ); +KUNIT_EXPECT_KASAN_FAIL (test, ((volatile char *)ptr)[real_size]);kfree (ptr); }
Signature · 1 line
2.25.1
PATCH v2 3/8 kasan: test: avoid corrupting memory via memset
In reply to [email protected]From: Andrey Konovalov <[email protected]>
kmalloc_oob_memset_*() tests do writes past the allocated objects. As the result, they corrupt memory, which might lead to crashes with the HW_TAGS mode, as it neither uses quarantine nor redzones.
Adjust the tests to only write memory within the aligned kmalloc objects.
Also add a comment mentioning that memset tests are designed to touch both valid and invalid memory.
--- lib/test_kasan.c | 28 +++++++++++++++++----------- 1 file changed, 17 insertions(+), 11 deletions(-)
lib/test_kasan.c +17 -11
@@ -428,64 +428,70 @@ static void kmalloc_uaf_16(struct kunit *test)kfree (ptr1); } +/* +* Note: in the memset tests below, the written range touches both valid and +* invalid memory. This makes sure that the instrumentation does not only check +* the starting address but the whole range. +*/ +static void kmalloc_oob_memset_2 (struct kunit *test) {char *ptr; -size_t size =8 ; +size_t size =128 -KASAN_GRANULE_SIZE ; ptr =kmalloc (size,GFP_KERNEL );KUNIT_ASSERT_NOT_ERR_OR_NULL (test, ptr); -KUNIT_EXPECT_KASAN_FAIL (test,memset (ptr +7 +OOB_TAG_OFF ,0 ,2 )); +KUNIT_EXPECT_KASAN_FAIL (test,memset (ptr + size -1 ,0 ,2 ));kfree (ptr); }static void kmalloc_oob_memset_4 (struct kunit *test) {char *ptr; -size_t size =8 ; +size_t size =128 -KASAN_GRANULE_SIZE ; ptr =kmalloc (size,GFP_KERNEL );KUNIT_ASSERT_NOT_ERR_OR_NULL (test, ptr); -KUNIT_EXPECT_KASAN_FAIL (test,memset (ptr +5 +OOB_TAG_OFF ,0 ,4 )); +KUNIT_EXPECT_KASAN_FAIL (test,memset (ptr + size -3 ,0 ,4 ));kfree (ptr); } -static void kmalloc_oob_memset_8 (struct kunit *test) {char *ptr; -size_t size =8 ; +size_t size =128 -KASAN_GRANULE_SIZE ; ptr =kmalloc (size,GFP_KERNEL );KUNIT_ASSERT_NOT_ERR_OR_NULL (test, ptr); -KUNIT_EXPECT_KASAN_FAIL (test,memset (ptr +1 +OOB_TAG_OFF ,0 ,8 )); +KUNIT_EXPECT_KASAN_FAIL (test,memset (ptr + size -7 ,0 ,8 ));kfree (ptr); }static void kmalloc_oob_memset_16 (struct kunit *test) {char *ptr; -size_t size =16 ; +size_t size =128 -KASAN_GRANULE_SIZE ; ptr =kmalloc (size,GFP_KERNEL );KUNIT_ASSERT_NOT_ERR_OR_NULL (test, ptr); -KUNIT_EXPECT_KASAN_FAIL (test,memset (ptr +1 +OOB_TAG_OFF ,0 ,16 )); +KUNIT_EXPECT_KASAN_FAIL (test,memset (ptr + size -15 ,0 ,16 ));kfree (ptr); }static void kmalloc_oob_in_memset (struct kunit *test) {char *ptr; -size_t size =666 ; +size_t size =128 -KASAN_GRANULE_SIZE ; ptr =kmalloc (size,GFP_KERNEL );KUNIT_ASSERT_NOT_ERR_OR_NULL (test, ptr); -KUNIT_EXPECT_KASAN_FAIL (test,memset (ptr,0 , size +5 +OOB_TAG_OFF )); +KUNIT_EXPECT_KASAN_FAIL (test, +memset (ptr,0 , size +KASAN_GRANULE_SIZE ));kfree (ptr); }
Signature · 1 line
2.25.1
v2 cover kasan: test: avoid crashing the kernel with HW_TAGS
From: Andrey Konovalov <[email protected]>
KASAN tests do out-of-bounds and use-after-free accesses. Running the tests works fine for the GENERIC mode, as it uses qurantine and redzones. But the HW_TAGS mode uses neither, and running the tests might crash the kernel.
Rework the tests to avoid corrupting kernel memory.
Changes v1->v2:
- Touch both good and bad memory in memset tests as suggested by Marco.
Andrey Konovalov (8):
kasan: test: rework kmalloc_oob_right
kasan: test: avoid writing invalid memory
kasan: test: avoid corrupting memory via memset
kasan: test: disable kmalloc_memmove_invalid_size for HW_TAGS
kasan: test: only do kmalloc_uaf_memset for generic mode
kasan: test: clean up ksize_uaf
kasan: test: avoid corrupting memory in copy_user_test
kasan: test: avoid corrupting memory in kasan_rcu_uaf
lib/test_kasan.c | 80 +++++++++++++++++++++++++++++------------ lib/test_kasan_module.c | 20 +++++------ 2 files changed, 66 insertions(+), 34 deletions(-)
Signature · 1 line
2.25.1
PATCH v2 4/8 kasan: test: disable kmalloc_memmove_invalid_size for HW_TAGS
From: Andrey Konovalov <[email protected]>
The HW_TAGS mode doesn't check memmove for negative size. As a result, the kmalloc_memmove_invalid_size test corrupts memory, which can result in a crash.
Disable this test with HW_TAGS KASAN.
--- lib/test_kasan.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-)
lib/test_kasan.c +7 -1
@@ -501,11 +501,17 @@ static void kmalloc_memmove_invalid_size(struct kunit *test)size_t size =64 ;volatile size_t invalid_size =-2 ; +/* +* Hardware tag-based mode doesn't check memmove for negative size. +* As a result, this test introduces a side-effect memory corruption, +* which can result in a crash. +*/ +KASAN_TEST_NEEDS_CONFIG_OFF (test,CONFIG_KASAN_HW_TAGS ); + ptr =kmalloc (size,GFP_KERNEL );KUNIT_ASSERT_NOT_ERR_OR_NULL (test, ptr);memset ((char *)ptr,0 ,64 ); -KUNIT_EXPECT_KASAN_FAIL (test,memmove ((char *)ptr, (char *)ptr +4 , invalid_size));kfree (ptr);
Signature · 1 line
2.25.1
PATCH v2 5/8 kasan: test: only do kmalloc_uaf_memset for generic mode
In reply to [email protected]From: Andrey Konovalov <[email protected]>
kmalloc_uaf_memset() writes to freed memory, which is only safe with the GENERIC mode (as it uses quarantine). For other modes, this test corrupts kernel memory, which might result in a crash.
Only enable kmalloc_uaf_memset() for the GENERIC mode.
--- lib/test_kasan.c | 6 ++++++ 1 file changed, 6 insertions(+)
lib/test_kasan.c +6 -0
@@ -534,6 +534,12 @@ static void kmalloc_uaf_memset(struct kunit *test)char *ptr;size_t size =33 ; +/* +* Only generic KASAN uses quarantine, which is required to avoid a +* kernel memory corruption this test causes. +*/ +KASAN_TEST_NEEDS_CONFIG_ON (test,CONFIG_KASAN_GENERIC ); + ptr =kmalloc (size,GFP_KERNEL );KUNIT_ASSERT_NOT_ERR_OR_NULL (test, ptr);
Signature · 1 line
2.25.1
PATCH v2 6/8 kasan: test: clean up ksize_uaf
In reply to [email protected]From: Andrey Konovalov <[email protected]>
Some KASAN tests use global variables to store function returns values so that the compiler doesn't optimize away these functions.
ksize_uaf() doesn't call any functions, so it doesn't need to use kasan_int_result. Use volatile accesses instead, to be consistent with other similar tests.
--- lib/test_kasan.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
lib/test_kasan.c +2 -2
@@ -737,8 +737,8 @@ static void ksize_uaf(struct kunit *test)kfree (ptr);KUNIT_EXPECT_KASAN_FAIL (test,ksize (ptr)); -KUNIT_EXPECT_KASAN_FAIL (test, kasan_int_result = *ptr); -KUNIT_EXPECT_KASAN_FAIL (test, kasan_int_result = *(ptr + size)); +KUNIT_EXPECT_KASAN_FAIL (test, ((volatile char *)ptr)[0 ]); +KUNIT_EXPECT_KASAN_FAIL (test, ((volatile char *)ptr)[size]); }static void kasan_stack_oob (struct kunit *test)
Signature · 1 line
2.25.1
PATCH v2 7/8 kasan: test: avoid corrupting memory in copy_user_test
In reply to [email protected]From: Andrey Konovalov <[email protected]>
copy_user_test() does writes past the allocated object. As the result, it corrupts kernel memory, which might lead to crashes with the HW_TAGS mode, as it neither uses quarantine nor redzones.
(Technically, this test can't yet be enabled with the HW_TAGS mode, but this will be implemented in the future.)
Adjust the test to only write memory within the aligned kmalloc object.
--- lib/test_kasan_module.c | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-)
lib/test_kasan_module.c +8 -10
@@ -15,13 +15,11 @@#include "../mm/kasan/kasan.h" -#define OOB_TAG_OFF (IS_ENABLED(CONFIG_KASAN_GENERIC) ? 0 : KASAN_GRANULE_SIZE) - static noinline void __init copy_user_test(void) {char *kmem;char __user *usermem; -size_t size =10 ; +size_t size =128 -KASAN_GRANULE_SIZE ;int __maybe_unused unused; kmem =kmalloc (size,GFP_KERNEL );
@@ -38,25 +36,25 @@ static noinline void __init copy_user_test(void) }pr_info ("out-of-bounds in copy_from_user()\n" ); - unused =copy_from_user (kmem, usermem, size +1 +OOB_TAG_OFF ); + 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 +OOB_TAG_OFF ); + 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 +OOB_TAG_OFF ); + 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 +OOB_TAG_OFF ); + 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 +OOB_TAG_OFF ); + 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 +OOB_TAG_OFF ); + 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 +OOB_TAG_OFF ); + unused =strncpy_from_user (kmem, usermem, size +1 );vm_munmap ((unsigned long )usermem,PAGE_SIZE );kfree (kmem);
Signature · 1 line
2.25.1
PATCH v2 8/8 kasan: test: avoid corrupting memory in kasan_rcu_uaf
In reply to [email protected]From: Andrey Konovalov <[email protected]>
kasan_rcu_uaf() writes to freed memory via kasan_rcu_reclaim(), which is only safe with the GENERIC mode (as it uses quarantine). For other modes, this test corrupts kernel memory, which might result in a crash.
Turn the write into a read.
--- lib/test_kasan_module.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
lib/test_kasan_module.c +1 -1
@@ -71,7 +71,7 @@ static noinline void __init kasan_rcu_reclaim(struct rcu_head *rp) struct kasan_rcu_info, rcu);kfree (fp); - fp->i =1 ; + ((volatile struct kasan_rcu_info *)fp)->i; } static noinline void __init kasan_rcu_uaf(void)
Signature · 1 line
2.25.1
Quoted 8 lines · On Thu, Aug 12, 2021 at 4:53 PM <[email protected]> wrote:
From: Andrey Konovalov <[email protected]>
KASAN tests do out-of-bounds and use-after-free accesses. Running the tests works fine for the GENERIC mode, as it uses qurantine and redzones. But the
HW_TAGSmode uses neither, and running the tests might crash the kernel.
Quoted 4 lines
Rework the tests to avoid corrupting kernel memory.
Changes
v1->v2:
- Touch both good and bad memory in memset tests as suggested by Marco.
Ah, I forgot to include your reviews/acks, Marco.
Perhaps you can give one for the whole series now.
Thanks!
Marco Elver
Reviewed-byQuoted 8 lines · Andrey Konovalov
Quoted 7 lines · On Thu, Aug 12, 2021 at 4:53 PM <[email protected]> wrote:
From: Andrey Konovalov <[email protected]>
KASAN tests do out-of-bounds and use-after-free accesses. Running the tests works fine for the GENERIC mode, as it uses qurantine and redzones. But the
HW_TAGSmode uses neither, and running the tests might crash the kernel.
Quoted 8 lines
Quoted 4 lines
Rework the tests to avoid corrupting kernel memory.
Changes
v1->v2:
- Touch both good and bad memory in memset tests as suggested by Marco.Ah, I forgot to include your reviews/acks, Marco.
Perhaps you can give one for the whole series now.
Looks good, thank you!