kasan: detect invalid frees for large objects

Patch series "kasan: detect invalid frees".

KASAN detects double-frees, but does not detect invalid-frees (when a
pointer into a middle of heap object is passed to free).  We recently had
a very unpleasant case in crypto code which freed an inner object inside
of a heap allocation.  This left unnoticed during free, but totally
corrupted heap and later lead to a bunch of random crashes all over kernel
code.

Detect invalid frees.

This patch (of 5):

Detect frees of pointers into middle of large heap objects.

I dropped const from kasan_kfree_large() because it starts propagating
through a bunch of functions in kasan_report.c, slab/slub nearest_obj(),
all of their local variables, fixup_red_left(), etc.

Link: http://lkml.kernel.org/r/1b45b4fe1d20fc0de1329aab674c1dd973fee723.1514378558.git.dvyukov@google.com
Signed-off-by: Dmitry Vyukov <dvyukov@google.com>
Cc: Andrey Ryabinin <aryabinin@virtuozzo.com>a
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/include/linux/kasan.h b/include/linux/kasan.h
index e3eb834c9a35dc2ab17b54336285c353567a1b18..fc9e642533f8606301237026301a9f7f9fbcd394 100644 (file)
--- a/include/linux/kasan.h
+++ b/include/linux/kasan.h
@@ -56,7 +56,7 @@ void kasan_poison_object_data(struct kmem_cache *cache, void *object);
 void kasan_init_slab_obj(struct kmem_cache *cache, const void *object);
 
 void kasan_kmalloc_large(const void *ptr, size_t size, gfp_t flags);
-void kasan_kfree_large(const void *ptr);
+void kasan_kfree_large(void *ptr);
 void kasan_poison_kfree(void *ptr);
 void kasan_kmalloc(struct kmem_cache *s, const void *object, size_t size,
                  gfp_t flags);
@@ -108,7 +108,7 @@ static inline void kasan_init_slab_obj(struct kmem_cache *cache,
                                const void *object) {}
 
 static inline void kasan_kmalloc_large(void *ptr, size_t size, gfp_t flags) {}
-static inline void kasan_kfree_large(const void *ptr) {}
+static inline void kasan_kfree_large(void *ptr) {}
 static inline void kasan_poison_kfree(void *ptr) {}
 static inline void kasan_kmalloc(struct kmem_cache *s, const void *object,
                                size_t size, gfp_t flags) {}

diff --git a/lib/test_kasan.c b/lib/test_kasan.c
index 2724f86c4cef76bddb637501a7dcde9590ff0ea3..e9c5d765be66c10281833fe502029c2788167cda 100644 (file)
--- a/lib/test_kasan.c
+++ b/lib/test_kasan.c
@@ -94,6 +94,37 @@ static noinline void __init kmalloc_pagealloc_oob_right(void)
        ptr[size] = 0;
        kfree(ptr);
 }
+
+static noinline void __init kmalloc_pagealloc_uaf(void)
+{
+       char *ptr;
+       size_t size = KMALLOC_MAX_CACHE_SIZE + 10;
+
+       pr_info("kmalloc pagealloc allocation: use-after-free\n");
+       ptr = kmalloc(size, GFP_KERNEL);
+       if (!ptr) {
+               pr_err("Allocation failed\n");
+               return;
+       }
+
+       kfree(ptr);
+       ptr[0] = 0;
+}
+
+static noinline void __init kmalloc_pagealloc_invalid_free(void)
+{
+       char *ptr;
+       size_t size = KMALLOC_MAX_CACHE_SIZE + 10;
+
+       pr_info("kmalloc pagealloc allocation: invalid-free\n");
+       ptr = kmalloc(size, GFP_KERNEL);
+       if (!ptr) {
+               pr_err("Allocation failed\n");
+               return;
+       }
+
+       kfree(ptr + 1);
+}
 #endif
 
 static noinline void __init kmalloc_large_oob_right(void)
@@ -505,6 +536,8 @@ static int __init kmalloc_tests_init(void)
        kmalloc_node_oob_right();
 #ifdef CONFIG_SLUB
        kmalloc_pagealloc_oob_right();
+       kmalloc_pagealloc_uaf();
+       kmalloc_pagealloc_invalid_free();
 #endif
        kmalloc_large_oob_right();
        kmalloc_oob_krealloc_more();

diff --git a/mm/kasan/kasan.c b/mm/kasan/kasan.c
index 8aaee42fcfabf4cf0ea3f188311fc8d6c7b6e5f5..ecb64fda79e6b175ec86c32349141065a421843e 100644 (file)
--- a/mm/kasan/kasan.c
+++ b/mm/kasan/kasan.c
@@ -511,8 +511,7 @@ bool kasan_slab_free(struct kmem_cache *cache, void *object)
 
        shadow_byte = READ_ONCE(*(s8 *)kasan_mem_to_shadow(object));
        if (shadow_byte < 0 || shadow_byte >= KASAN_SHADOW_SCALE_SIZE) {
-               kasan_report_double_free(cache, object,
-                               __builtin_return_address(1));
+               kasan_report_invalid_free(object, __builtin_return_address(1));
                return true;
        }
 
@@ -602,12 +601,11 @@ void kasan_poison_kfree(void *ptr)
                kasan_poison_slab_free(page->slab_cache, ptr);
 }
 
-void kasan_kfree_large(const void *ptr)
+void kasan_kfree_large(void *ptr)
 {
-       struct page *page = virt_to_page(ptr);
-
-       kasan_poison_shadow(ptr, PAGE_SIZE << compound_order(page),
-                       KASAN_FREE_PAGE);
+       if (ptr != page_address(virt_to_head_page(ptr)))
+               kasan_report_invalid_free(ptr, __builtin_return_address(1));
+       /* The object will be poisoned by page_alloc. */
 }
 
 int kasan_module_alloc(void *addr, size_t size)

diff --git a/mm/kasan/kasan.h b/mm/kasan/kasan.h
index 9a768dd71c515db8713eeecc017c84e6359a3c06..bf353a18c9085bd1fc977e10b557d1d19a2a3134 100644 (file)
--- a/mm/kasan/kasan.h
+++ b/mm/kasan/kasan.h
@@ -107,8 +107,7 @@ static inline const void *kasan_shadow_to_mem(const void *shadow_addr)
 
 void kasan_report(unsigned long addr, size_t size,
                bool is_write, unsigned long ip);
-void kasan_report_double_free(struct kmem_cache *cache, void *object,
-                                       void *ip);
+void kasan_report_invalid_free(void *object, void *ip);
 
 #if defined(CONFIG_SLAB) || defined(CONFIG_SLUB)
 void quarantine_put(struct kasan_free_meta *info, struct kmem_cache *cache);

diff --git a/mm/kasan/report.c b/mm/kasan/report.c
index eff12e040498617ed0aad9927f828b9ec52b2e9b..55916ad2172205a454e9c7c47eaa08765fd4c8dc 100644 (file)
--- a/mm/kasan/report.c
+++ b/mm/kasan/report.c
@@ -326,8 +326,7 @@ static void print_shadow_for_address(const void *addr)
        }
 }
 
-void kasan_report_double_free(struct kmem_cache *cache, void *object,
-                               void *ip)
+void kasan_report_invalid_free(void *object, void *ip)
 {
        unsigned long flags;
 

diff --git a/mm/slub.c b/mm/slub.c
index cc71176c6eeff4e3d5dbd04668c4485b582a6b34..b54f8787c6749ccfb4a7b41f3578434dcd732928 100644 (file)
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -1356,7 +1356,7 @@ static inline void kmalloc_large_node_hook(void *ptr, size_t size, gfp_t flags)
        kasan_kmalloc_large(ptr, size, flags);
 }
 
-static inline void kfree_hook(const void *x)
+static inline void kfree_hook(void *x)
 {
        kmemleak_free(x);
        kasan_kfree_large(x);
@@ -3910,7 +3910,7 @@ void kfree(const void *x)
        page = virt_to_head_page(x);
        if (unlikely(!PageSlab(page))) {
                BUG_ON(!PageCompound(page));
-               kfree_hook(x);
+               kfree_hook(object);
                __free_pages(page, compound_order(page));
                return;
        }