Merge git://git.kernel.org:/pub/scm/linux/kernel/git/netdev/net

[linux-2.6-microblaze.git] / lib / test_kasan.c

diff --git a/lib/test_kasan.c b/lib/test_kasan.c
index 2557630..e5647d1 100644 (file)
--- a/lib/test_kasan.c
+++ b/lib/test_kasan.c
@@ -252,11 +252,14 @@ static void kmalloc_large_oob_right(struct kunit *test)
        kfree(ptr);
 }
 
-static void kmalloc_oob_krealloc_more(struct kunit *test)
+static void krealloc_more_oob_helper(struct kunit *test,
+                                       size_t size1, size_t size2)
 {
        char *ptr1, *ptr2;
-       size_t size1 = 17;
-       size_t size2 = 19;
+       size_t middle;
+
+       KUNIT_ASSERT_LT(test, size1, size2);
+       middle = size1 + (size2 - size1) / 2;
 
        ptr1 = kmalloc(size1, GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
@@ -264,15 +267,31 @@ static void kmalloc_oob_krealloc_more(struct kunit *test)
        ptr2 = krealloc(ptr1, size2, GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr2);
 
-       KUNIT_EXPECT_KASAN_FAIL(test, ptr2[size2 + OOB_TAG_OFF] = 'x');
+       /* All offsets up to size2 must be accessible. */
+       ptr2[size1 - 1] = 'x';
+       ptr2[size1] = 'x';
+       ptr2[middle] = 'x';
+       ptr2[size2 - 1] = 'x';
+
+       /* Generic mode is precise, so unaligned size2 must be inaccessible. */
+       if (IS_ENABLED(CONFIG_KASAN_GENERIC))
+               KUNIT_EXPECT_KASAN_FAIL(test, ptr2[size2] = 'x');
+
+       /* For all modes first aligned offset after size2 must be inaccessible. */
+       KUNIT_EXPECT_KASAN_FAIL(test,
+               ptr2[round_up(size2, KASAN_GRANULE_SIZE)] = 'x');
+
        kfree(ptr2);
 }
 
-static void kmalloc_oob_krealloc_less(struct kunit *test)
+static void krealloc_less_oob_helper(struct kunit *test,
+                                       size_t size1, size_t size2)
 {
        char *ptr1, *ptr2;
-       size_t size1 = 17;
-       size_t size2 = 15;
+       size_t middle;
+
+       KUNIT_ASSERT_LT(test, size2, size1);
+       middle = size2 + (size1 - size2) / 2;
 
        ptr1 = kmalloc(size1, GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
@@ -280,10 +299,79 @@ static void kmalloc_oob_krealloc_less(struct kunit *test)
        ptr2 = krealloc(ptr1, size2, GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr2);
 
-       KUNIT_EXPECT_KASAN_FAIL(test, ptr2[size2 + OOB_TAG_OFF] = 'x');
+       /* Must be accessible for all modes. */
+       ptr2[size2 - 1] = 'x';
+
+       /* Generic mode is precise, so unaligned size2 must be inaccessible. */
+       if (IS_ENABLED(CONFIG_KASAN_GENERIC))
+               KUNIT_EXPECT_KASAN_FAIL(test, ptr2[size2] = 'x');
+
+       /* For all modes first aligned offset after size2 must be inaccessible. */
+       KUNIT_EXPECT_KASAN_FAIL(test,
+               ptr2[round_up(size2, KASAN_GRANULE_SIZE)] = 'x');
+
+       /*
+        * For all modes all size2, middle, and size1 should land in separate
+        * granules and thus the latter two offsets should be inaccessible.
+        */
+       KUNIT_EXPECT_LE(test, round_up(size2, KASAN_GRANULE_SIZE),
+                               round_down(middle, KASAN_GRANULE_SIZE));
+       KUNIT_EXPECT_LE(test, round_up(middle, KASAN_GRANULE_SIZE),
+                               round_down(size1, KASAN_GRANULE_SIZE));
+       KUNIT_EXPECT_KASAN_FAIL(test, ptr2[middle] = 'x');
+       KUNIT_EXPECT_KASAN_FAIL(test, ptr2[size1 - 1] = 'x');
+       KUNIT_EXPECT_KASAN_FAIL(test, ptr2[size1] = 'x');
+
        kfree(ptr2);
 }
 
+static void krealloc_more_oob(struct kunit *test)
+{
+       krealloc_more_oob_helper(test, 201, 235);
+}
+
+static void krealloc_less_oob(struct kunit *test)
+{
+       krealloc_less_oob_helper(test, 235, 201);
+}
+
+static void krealloc_pagealloc_more_oob(struct kunit *test)
+{
+       /* page_alloc fallback in only implemented for SLUB. */
+       KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_SLUB);
+
+       krealloc_more_oob_helper(test, KMALLOC_MAX_CACHE_SIZE + 201,
+                                       KMALLOC_MAX_CACHE_SIZE + 235);
+}
+
+static void krealloc_pagealloc_less_oob(struct kunit *test)
+{
+       /* page_alloc fallback in only implemented for SLUB. */
+       KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_SLUB);
+
+       krealloc_less_oob_helper(test, KMALLOC_MAX_CACHE_SIZE + 235,
+                                       KMALLOC_MAX_CACHE_SIZE + 201);
+}
+
+/*
+ * Check that krealloc() detects a use-after-free, returns NULL,
+ * and doesn't unpoison the freed object.
+ */
+static void krealloc_uaf(struct kunit *test)
+{
+       char *ptr1, *ptr2;
+       int size1 = 201;
+       int size2 = 235;
+
+       ptr1 = kmalloc(size1, GFP_KERNEL);
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
+       kfree(ptr1);
+
+       KUNIT_EXPECT_KASAN_FAIL(test, ptr2 = krealloc(ptr1, size2, GFP_KERNEL));
+       KUNIT_ASSERT_PTR_EQ(test, (void *)ptr2, NULL);
+       KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)ptr1);
+}
+
 static void kmalloc_oob_16(struct kunit *test)
 {
        struct {
@@ -977,8 +1065,11 @@ static struct kunit_case kasan_kunit_test_cases[] = {
        KUNIT_CASE(pagealloc_oob_right),
        KUNIT_CASE(pagealloc_uaf),
        KUNIT_CASE(kmalloc_large_oob_right),
-       KUNIT_CASE(kmalloc_oob_krealloc_more),
-       KUNIT_CASE(kmalloc_oob_krealloc_less),
+       KUNIT_CASE(krealloc_more_oob),
+       KUNIT_CASE(krealloc_less_oob),
+       KUNIT_CASE(krealloc_pagealloc_more_oob),
+       KUNIT_CASE(krealloc_pagealloc_less_oob),
+       KUNIT_CASE(krealloc_uaf),
        KUNIT_CASE(kmalloc_oob_16),
        KUNIT_CASE(kmalloc_uaf_16),
        KUNIT_CASE(kmalloc_oob_in_memset),