lib/test_kasan.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *
   4  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   5  * Author: Andrey Ryabinin <a.ryabinin@samsung.com>
   6  */
   7
   8 #include <linux/bitops.h>
   9 #include <linux/delay.h>
  10 #include <linux/kasan.h>
  11 #include <linux/kernel.h>
  12 #include <linux/mm.h>
  13 #include <linux/mman.h>
  14 #include <linux/module.h>
  15 #include <linux/printk.h>
  16 #include <linux/random.h>
  17 #include <linux/slab.h>
  18 #include <linux/string.h>
  19 #include <linux/uaccess.h>
  20 #include <linux/io.h>
  21 #include <linux/vmalloc.h>
  22
  23 #include <asm/page.h>
  24
  25 #include <kunit/test.h>
  26
  27 #include "../mm/kasan/kasan.h"
  28
  29 #define OOB_TAG_OFF (IS_ENABLED(CONFIG_KASAN_GENERIC) ? 0 : KASAN_GRANULE_SIZE)
  30
  31 /*
  32  * Some tests use these global variables to store return values from function
  33  * calls that could otherwise be eliminated by the compiler as dead code.
  34  */
  35 void *kasan_ptr_result;
  36 int kasan_int_result;
  37
  38 static struct kunit_resource resource;
  39 static struct kunit_kasan_expectation fail_data;
  40 static bool multishot;
  41
  42 /*
  43  * Temporarily enable multi-shot mode. Otherwise, KASAN would only report the
  44  * first detected bug and panic the kernel if panic_on_warn is enabled. For
  45  * hardware tag-based KASAN also allow tag checking to be reenabled for each
  46  * test, see the comment for KUNIT_EXPECT_KASAN_FAIL().
  47  */
  48 static int kasan_test_init(struct kunit *test)
  49 {
  50         if (!kasan_enabled()) {
  51                 kunit_err(test, "can't run KASAN tests with KASAN disabled");
  52                 return -1;
  53         }
  54
  55         multishot = kasan_save_enable_multi_shot();
  56         kasan_set_tagging_report_once(false);
  57         return 0;
  58 }
  59
  60 static void kasan_test_exit(struct kunit *test)
  61 {
  62         kasan_set_tagging_report_once(true);
  63         kasan_restore_multi_shot(multishot);
  64 }
  65
  66 /**
  67  * KUNIT_EXPECT_KASAN_FAIL() - check that the executed expression produces a
  68  * KASAN report; causes a test failure otherwise. This relies on a KUnit
  69  * resource named "kasan_data". Do not use this name for KUnit resources
  70  * outside of KASAN tests.
  71  *
  72  * For hardware tag-based KASAN, when a tag fault happens, tag checking is
  73  * normally auto-disabled. When this happens, this test handler reenables
  74  * tag checking. As tag checking can be only disabled or enabled per CPU, this
  75  * handler disables migration (preemption).
  76  *
  77  * Since the compiler doesn't see that the expression can change the fail_data
  78  * fields, it can reorder or optimize away the accesses to those fields.
  79  * Use READ/WRITE_ONCE() for the accesses and compiler barriers around the
  80  * expression to prevent that.
  81  */
  82 #define KUNIT_EXPECT_KASAN_FAIL(test, expression) do {          \
  83         if (IS_ENABLED(CONFIG_KASAN_HW_TAGS))                   \
  84                 migrate_disable();                              \
  85         WRITE_ONCE(fail_data.report_expected, true);            \
  86         WRITE_ONCE(fail_data.report_found, false);              \
  87         kunit_add_named_resource(test,                          \
  88                                 NULL,                           \
  89                                 NULL,                           \
  90                                 &resource,                      \
  91                                 "kasan_data", &fail_data);      \
  92         barrier();                                              \
  93         expression;                                             \
  94         barrier();                                              \
  95         KUNIT_EXPECT_EQ(test,                                   \
  96                         READ_ONCE(fail_data.report_expected),   \
  97                         READ_ONCE(fail_data.report_found));     \
  98         if (IS_ENABLED(CONFIG_KASAN_HW_TAGS)) {                 \
  99                 if (READ_ONCE(fail_data.report_found))          \
 100                         kasan_enable_tagging();                 \
 101                 migrate_enable();                               \
 102         }                                                       \
 103 } while (0)
 104
 105 #define KASAN_TEST_NEEDS_CONFIG_ON(test, config) do {                   \
 106         if (!IS_ENABLED(config)) {                                      \
 107                 kunit_info((test), "skipping, " #config " required");   \
 108                 return;                                                 \
 109         }                                                               \
 110 } while (0)
 111
 112 #define KASAN_TEST_NEEDS_CONFIG_OFF(test, config) do {                  \
 113         if (IS_ENABLED(config)) {                                       \
 114                 kunit_info((test), "skipping, " #config " enabled");    \
 115                 return;                                                 \
 116         }                                                               \
 117 } while (0)
 118
 119 static void kmalloc_oob_right(struct kunit *test)
 120 {
 121         char *ptr;
 122         size_t size = 123;
 123
 124         ptr = kmalloc(size, GFP_KERNEL);
 125         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 126
 127         KUNIT_EXPECT_KASAN_FAIL(test, ptr[size + OOB_TAG_OFF] = 'x');
 128         kfree(ptr);
 129 }
 130
 131 static void kmalloc_oob_left(struct kunit *test)
 132 {
 133         char *ptr;
 134         size_t size = 15;
 135
 136         ptr = kmalloc(size, GFP_KERNEL);
 137         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 138
 139         KUNIT_EXPECT_KASAN_FAIL(test, *ptr = *(ptr - 1));
 140         kfree(ptr);
 141 }
 142
 143 static void kmalloc_node_oob_right(struct kunit *test)
 144 {
 145         char *ptr;
 146         size_t size = 4096;
 147
 148         ptr = kmalloc_node(size, GFP_KERNEL, 0);
 149         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 150
 151         KUNIT_EXPECT_KASAN_FAIL(test, ptr[size] = 0);
 152         kfree(ptr);
 153 }
 154
 155 /*
 156  * These kmalloc_pagealloc_* tests try allocating a memory chunk that doesn't
 157  * fit into a slab cache and therefore is allocated via the page allocator
 158  * fallback. Since this kind of fallback is only implemented for SLUB, these
 159  * tests are limited to that allocator.
 160  */
 161 static void kmalloc_pagealloc_oob_right(struct kunit *test)
 162 {
 163         char *ptr;
 164         size_t size = KMALLOC_MAX_CACHE_SIZE + 10;
 165
 166         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_SLUB);
 167
 168         ptr = kmalloc(size, GFP_KERNEL);
 169         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 170
 171         KUNIT_EXPECT_KASAN_FAIL(test, ptr[size + OOB_TAG_OFF] = 0);
 172
 173         kfree(ptr);
 174 }
 175
 176 static void kmalloc_pagealloc_uaf(struct kunit *test)
 177 {
 178         char *ptr;
 179         size_t size = KMALLOC_MAX_CACHE_SIZE + 10;
 180
 181         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_SLUB);
 182
 183         ptr = kmalloc(size, GFP_KERNEL);
 184         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 185         kfree(ptr);
 186
 187         KUNIT_EXPECT_KASAN_FAIL(test, ptr[0] = 0);
 188 }
 189
 190 static void kmalloc_pagealloc_invalid_free(struct kunit *test)
 191 {
 192         char *ptr;
 193         size_t size = KMALLOC_MAX_CACHE_SIZE + 10;
 194
 195         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_SLUB);
 196
 197         ptr = kmalloc(size, GFP_KERNEL);
 198         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 199
 200         KUNIT_EXPECT_KASAN_FAIL(test, kfree(ptr + 1));
 201 }
 202
 203 static void pagealloc_oob_right(struct kunit *test)
 204 {
 205         char *ptr;
 206         struct page *pages;
 207         size_t order = 4;
 208         size_t size = (1UL << (PAGE_SHIFT + order));
 209
 210         /*
 211          * With generic KASAN page allocations have no redzones, thus
 212          * out-of-bounds detection is not guaranteed.
 213          * See https://bugzilla.kernel.org/show_bug.cgi?id=210503.
 214          */
 215         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_KASAN_GENERIC);
 216
 217         pages = alloc_pages(GFP_KERNEL, order);
 218         ptr = page_address(pages);
 219         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 220
 221         KUNIT_EXPECT_KASAN_FAIL(test, ptr[size] = 0);
 222         free_pages((unsigned long)ptr, order);
 223 }
 224
 225 static void pagealloc_uaf(struct kunit *test)
 226 {
 227         char *ptr;
 228         struct page *pages;
 229         size_t order = 4;
 230
 231         pages = alloc_pages(GFP_KERNEL, order);
 232         ptr = page_address(pages);
 233         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 234         free_pages((unsigned long)ptr, order);
 235
 236         KUNIT_EXPECT_KASAN_FAIL(test, ptr[0] = 0);
 237 }
 238
 239 static void kmalloc_large_oob_right(struct kunit *test)
 240 {
 241         char *ptr;
 242         size_t size = KMALLOC_MAX_CACHE_SIZE - 256;
 243
 244         /*
 245          * Allocate a chunk that is large enough, but still fits into a slab
 246          * and does not trigger the page allocator fallback in SLUB.
 247          */
 248         ptr = kmalloc(size, GFP_KERNEL);
 249         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 250
 251         KUNIT_EXPECT_KASAN_FAIL(test, ptr[size] = 0);
 252         kfree(ptr);
 253 }
 254
 255 static void krealloc_more_oob_helper(struct kunit *test,
 256                                         size_t size1, size_t size2)
 257 {
 258         char *ptr1, *ptr2;
 259         size_t middle;
 260
 261         KUNIT_ASSERT_LT(test, size1, size2);
 262         middle = size1 + (size2 - size1) / 2;
 263
 264         ptr1 = kmalloc(size1, GFP_KERNEL);
 265         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
 266
 267         ptr2 = krealloc(ptr1, size2, GFP_KERNEL);
 268         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr2);
 269
 270         /* All offsets up to size2 must be accessible. */
 271         ptr2[size1 - 1] = 'x';
 272         ptr2[size1] = 'x';
 273         ptr2[middle] = 'x';
 274         ptr2[size2 - 1] = 'x';
 275
 276         /* Generic mode is precise, so unaligned size2 must be inaccessible. */
 277         if (IS_ENABLED(CONFIG_KASAN_GENERIC))
 278                 KUNIT_EXPECT_KASAN_FAIL(test, ptr2[size2] = 'x');
 279
 280         /* For all modes first aligned offset after size2 must be inaccessible. */
 281         KUNIT_EXPECT_KASAN_FAIL(test,
 282                 ptr2[round_up(size2, KASAN_GRANULE_SIZE)] = 'x');
 283
 284         kfree(ptr2);
 285 }
 286
 287 static void krealloc_less_oob_helper(struct kunit *test,
 288                                         size_t size1, size_t size2)
 289 {
 290         char *ptr1, *ptr2;
 291         size_t middle;
 292
 293         KUNIT_ASSERT_LT(test, size2, size1);
 294         middle = size2 + (size1 - size2) / 2;
 295
 296         ptr1 = kmalloc(size1, GFP_KERNEL);
 297         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
 298
 299         ptr2 = krealloc(ptr1, size2, GFP_KERNEL);
 300         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr2);
 301
 302         /* Must be accessible for all modes. */
 303         ptr2[size2 - 1] = 'x';
 304
 305         /* Generic mode is precise, so unaligned size2 must be inaccessible. */
 306         if (IS_ENABLED(CONFIG_KASAN_GENERIC))
 307                 KUNIT_EXPECT_KASAN_FAIL(test, ptr2[size2] = 'x');
 308
 309         /* For all modes first aligned offset after size2 must be inaccessible. */
 310         KUNIT_EXPECT_KASAN_FAIL(test,
 311                 ptr2[round_up(size2, KASAN_GRANULE_SIZE)] = 'x');
 312
 313         /*
 314          * For all modes all size2, middle, and size1 should land in separate
 315          * granules and thus the latter two offsets should be inaccessible.
 316          */
 317         KUNIT_EXPECT_LE(test, round_up(size2, KASAN_GRANULE_SIZE),
 318                                 round_down(middle, KASAN_GRANULE_SIZE));
 319         KUNIT_EXPECT_LE(test, round_up(middle, KASAN_GRANULE_SIZE),
 320                                 round_down(size1, KASAN_GRANULE_SIZE));
 321         KUNIT_EXPECT_KASAN_FAIL(test, ptr2[middle] = 'x');
 322         KUNIT_EXPECT_KASAN_FAIL(test, ptr2[size1 - 1] = 'x');
 323         KUNIT_EXPECT_KASAN_FAIL(test, ptr2[size1] = 'x');
 324
 325         kfree(ptr2);
 326 }
 327
 328 static void krealloc_more_oob(struct kunit *test)
 329 {
 330         krealloc_more_oob_helper(test, 201, 235);
 331 }
 332
 333 static void krealloc_less_oob(struct kunit *test)
 334 {
 335         krealloc_less_oob_helper(test, 235, 201);
 336 }
 337
 338 static void krealloc_pagealloc_more_oob(struct kunit *test)
 339 {
 340         /* page_alloc fallback in only implemented for SLUB. */
 341         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_SLUB);
 342
 343         krealloc_more_oob_helper(test, KMALLOC_MAX_CACHE_SIZE + 201,
 344                                         KMALLOC_MAX_CACHE_SIZE + 235);
 345 }
 346
 347 static void krealloc_pagealloc_less_oob(struct kunit *test)
 348 {
 349         /* page_alloc fallback in only implemented for SLUB. */
 350         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_SLUB);
 351
 352         krealloc_less_oob_helper(test, KMALLOC_MAX_CACHE_SIZE + 235,
 353                                         KMALLOC_MAX_CACHE_SIZE + 201);
 354 }
 355
 356 static void kmalloc_oob_16(struct kunit *test)
 357 {
 358         struct {
 359                 u64 words[2];
 360         } *ptr1, *ptr2;
 361
 362         /* This test is specifically crafted for the generic mode. */
 363         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_GENERIC);
 364
 365         ptr1 = kmalloc(sizeof(*ptr1) - 3, GFP_KERNEL);
 366         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
 367
 368         ptr2 = kmalloc(sizeof(*ptr2), GFP_KERNEL);
 369         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr2);
 370
 371         KUNIT_EXPECT_KASAN_FAIL(test, *ptr1 = *ptr2);
 372         kfree(ptr1);
 373         kfree(ptr2);
 374 }
 375
 376 static void kmalloc_uaf_16(struct kunit *test)
 377 {
 378         struct {
 379                 u64 words[2];
 380         } *ptr1, *ptr2;
 381
 382         ptr1 = kmalloc(sizeof(*ptr1), GFP_KERNEL);
 383         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
 384
 385         ptr2 = kmalloc(sizeof(*ptr2), GFP_KERNEL);
 386         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr2);
 387         kfree(ptr2);
 388
 389         KUNIT_EXPECT_KASAN_FAIL(test, *ptr1 = *ptr2);
 390         kfree(ptr1);
 391 }
 392
 393 static void kmalloc_oob_memset_2(struct kunit *test)
 394 {
 395         char *ptr;
 396         size_t size = 8;
 397
 398         ptr = kmalloc(size, GFP_KERNEL);
 399         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 400
 401         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr + 7 + OOB_TAG_OFF, 0, 2));
 402         kfree(ptr);
 403 }
 404
 405 static void kmalloc_oob_memset_4(struct kunit *test)
 406 {
 407         char *ptr;
 408         size_t size = 8;
 409
 410         ptr = kmalloc(size, GFP_KERNEL);
 411         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 412
 413         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr + 5 + OOB_TAG_OFF, 0, 4));
 414         kfree(ptr);
 415 }
 416
 417
 418 static void kmalloc_oob_memset_8(struct kunit *test)
 419 {
 420         char *ptr;
 421         size_t size = 8;
 422
 423         ptr = kmalloc(size, GFP_KERNEL);
 424         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 425
 426         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr + 1 + OOB_TAG_OFF, 0, 8));
 427         kfree(ptr);
 428 }
 429
 430 static void kmalloc_oob_memset_16(struct kunit *test)
 431 {
 432         char *ptr;
 433         size_t size = 16;
 434
 435         ptr = kmalloc(size, GFP_KERNEL);
 436         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 437
 438         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr + 1 + OOB_TAG_OFF, 0, 16));
 439         kfree(ptr);
 440 }
 441
 442 static void kmalloc_oob_in_memset(struct kunit *test)
 443 {
 444         char *ptr;
 445         size_t size = 666;
 446
 447         ptr = kmalloc(size, GFP_KERNEL);
 448         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 449
 450         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr, 0, size + 5 + OOB_TAG_OFF));
 451         kfree(ptr);
 452 }
 453
 454 static void kmalloc_memmove_invalid_size(struct kunit *test)
 455 {
 456         char *ptr;
 457         size_t size = 64;
 458         volatile size_t invalid_size = -2;
 459
 460         ptr = kmalloc(size, GFP_KERNEL);
 461         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 462
 463         memset((char *)ptr, 0, 64);
 464
 465         KUNIT_EXPECT_KASAN_FAIL(test,
 466                 memmove((char *)ptr, (char *)ptr + 4, invalid_size));
 467         kfree(ptr);
 468 }
 469
 470 static void kmalloc_uaf(struct kunit *test)
 471 {
 472         char *ptr;
 473         size_t size = 10;
 474
 475         ptr = kmalloc(size, GFP_KERNEL);
 476         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 477
 478         kfree(ptr);
 479         KUNIT_EXPECT_KASAN_FAIL(test, *(ptr + 8) = 'x');
 480 }
 481
 482 static void kmalloc_uaf_memset(struct kunit *test)
 483 {
 484         char *ptr;
 485         size_t size = 33;
 486
 487         ptr = kmalloc(size, GFP_KERNEL);
 488         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 489
 490         kfree(ptr);
 491         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr, 0, size));
 492 }
 493
 494 static void kmalloc_uaf2(struct kunit *test)
 495 {
 496         char *ptr1, *ptr2;
 497         size_t size = 43;
 498         int counter = 0;
 499
 500 again:
 501         ptr1 = kmalloc(size, GFP_KERNEL);
 502         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
 503
 504         kfree(ptr1);
 505
 506         ptr2 = kmalloc(size, GFP_KERNEL);
 507         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr2);
 508
 509         /*
 510          * For tag-based KASAN ptr1 and ptr2 tags might happen to be the same.
 511          * Allow up to 16 attempts at generating different tags.
 512          */
 513         if (!IS_ENABLED(CONFIG_KASAN_GENERIC) && ptr1 == ptr2 && counter++ < 16) {
 514                 kfree(ptr2);
 515                 goto again;
 516         }
 517
 518         KUNIT_EXPECT_KASAN_FAIL(test, ptr1[40] = 'x');
 519         KUNIT_EXPECT_PTR_NE(test, ptr1, ptr2);
 520
 521         kfree(ptr2);
 522 }
 523
 524 static void kfree_via_page(struct kunit *test)
 525 {
 526         char *ptr;
 527         size_t size = 8;
 528         struct page *page;
 529         unsigned long offset;
 530
 531         ptr = kmalloc(size, GFP_KERNEL);
 532         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 533
 534         page = virt_to_page(ptr);
 535         offset = offset_in_page(ptr);
 536         kfree(page_address(page) + offset);
 537 }
 538
 539 static void kfree_via_phys(struct kunit *test)
 540 {
 541         char *ptr;
 542         size_t size = 8;
 543         phys_addr_t phys;
 544
 545         ptr = kmalloc(size, GFP_KERNEL);
 546         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 547
 548         phys = virt_to_phys(ptr);
 549         kfree(phys_to_virt(phys));
 550 }
 551
 552 static void kmem_cache_oob(struct kunit *test)
 553 {
 554         char *p;
 555         size_t size = 200;
 556         struct kmem_cache *cache;
 557
 558         cache = kmem_cache_create("test_cache", size, 0, 0, NULL);
 559         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 560
 561         p = kmem_cache_alloc(cache, GFP_KERNEL);
 562         if (!p) {
 563                 kunit_err(test, "Allocation failed: %s\n", __func__);
 564                 kmem_cache_destroy(cache);
 565                 return;
 566         }
 567
 568         KUNIT_EXPECT_KASAN_FAIL(test, *p = p[size + OOB_TAG_OFF]);
 569
 570         kmem_cache_free(cache, p);
 571         kmem_cache_destroy(cache);
 572 }
 573
 574 static void kmem_cache_accounted(struct kunit *test)
 575 {
 576         int i;
 577         char *p;
 578         size_t size = 200;
 579         struct kmem_cache *cache;
 580
 581         cache = kmem_cache_create("test_cache", size, 0, SLAB_ACCOUNT, NULL);
 582         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 583
 584         /*
 585          * Several allocations with a delay to allow for lazy per memcg kmem
 586          * cache creation.
 587          */
 588         for (i = 0; i < 5; i++) {
 589                 p = kmem_cache_alloc(cache, GFP_KERNEL);
 590                 if (!p)
 591                         goto free_cache;
 592
 593                 kmem_cache_free(cache, p);
 594                 msleep(100);
 595         }
 596
 597 free_cache:
 598         kmem_cache_destroy(cache);
 599 }
 600
 601 static void kmem_cache_bulk(struct kunit *test)
 602 {
 603         struct kmem_cache *cache;
 604         size_t size = 200;
 605         char *p[10];
 606         bool ret;
 607         int i;
 608
 609         cache = kmem_cache_create("test_cache", size, 0, 0, NULL);
 610         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 611
 612         ret = kmem_cache_alloc_bulk(cache, GFP_KERNEL, ARRAY_SIZE(p), (void **)&p);
 613         if (!ret) {
 614                 kunit_err(test, "Allocation failed: %s\n", __func__);
 615                 kmem_cache_destroy(cache);
 616                 return;
 617         }
 618
 619         for (i = 0; i < ARRAY_SIZE(p); i++)
 620                 p[i][0] = p[i][size - 1] = 42;
 621
 622         kmem_cache_free_bulk(cache, ARRAY_SIZE(p), (void **)&p);
 623         kmem_cache_destroy(cache);
 624 }
 625
 626 static char global_array[10];
 627
 628 static void kasan_global_oob(struct kunit *test)
 629 {
 630         volatile int i = 3;
 631         char *p = &global_array[ARRAY_SIZE(global_array) + i];
 632
 633         /* Only generic mode instruments globals. */
 634         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_GENERIC);
 635
 636         KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)p);
 637 }
 638
 639 /* Check that ksize() makes the whole object accessible. */
 640 static void ksize_unpoisons_memory(struct kunit *test)
 641 {
 642         char *ptr;
 643         size_t size = 123, real_size;
 644
 645         ptr = kmalloc(size, GFP_KERNEL);
 646         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 647         real_size = ksize(ptr);
 648
 649         /* This access shouldn't trigger a KASAN report. */
 650         ptr[size] = 'x';
 651
 652         /* This one must. */
 653         KUNIT_EXPECT_KASAN_FAIL(test, ptr[real_size] = 'y');
 654
 655         kfree(ptr);
 656 }
 657
 658 /*
 659  * Check that a use-after-free is detected by ksize() and via normal accesses
 660  * after it.
 661  */
 662 static void ksize_uaf(struct kunit *test)
 663 {
 664         char *ptr;
 665         int size = 128 - KASAN_GRANULE_SIZE;
 666
 667         ptr = kmalloc(size, GFP_KERNEL);
 668         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 669         kfree(ptr);
 670
 671         KUNIT_EXPECT_KASAN_FAIL(test, ksize(ptr));
 672         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = *ptr);
 673         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = *(ptr + size));
 674 }
 675
 676 static void kasan_stack_oob(struct kunit *test)
 677 {
 678         char stack_array[10];
 679         volatile int i = OOB_TAG_OFF;
 680         char *p = &stack_array[ARRAY_SIZE(stack_array) + i];
 681
 682         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_STACK);
 683
 684         KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)p);
 685 }
 686
 687 static void kasan_alloca_oob_left(struct kunit *test)
 688 {
 689         volatile int i = 10;
 690         char alloca_array[i];
 691         char *p = alloca_array - 1;
 692
 693         /* Only generic mode instruments dynamic allocas. */
 694         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_GENERIC);
 695         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_STACK);
 696
 697         KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)p);
 698 }
 699
 700 static void kasan_alloca_oob_right(struct kunit *test)
 701 {
 702         volatile int i = 10;
 703         char alloca_array[i];
 704         char *p = alloca_array + i;
 705
 706         /* Only generic mode instruments dynamic allocas. */
 707         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_GENERIC);
 708         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_STACK);
 709
 710         KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)p);
 711 }
 712
 713 static void kmem_cache_double_free(struct kunit *test)
 714 {
 715         char *p;
 716         size_t size = 200;
 717         struct kmem_cache *cache;
 718
 719         cache = kmem_cache_create("test_cache", size, 0, 0, NULL);
 720         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 721
 722         p = kmem_cache_alloc(cache, GFP_KERNEL);
 723         if (!p) {
 724                 kunit_err(test, "Allocation failed: %s\n", __func__);
 725                 kmem_cache_destroy(cache);
 726                 return;
 727         }
 728
 729         kmem_cache_free(cache, p);
 730         KUNIT_EXPECT_KASAN_FAIL(test, kmem_cache_free(cache, p));
 731         kmem_cache_destroy(cache);
 732 }
 733
 734 static void kmem_cache_invalid_free(struct kunit *test)
 735 {
 736         char *p;
 737         size_t size = 200;
 738         struct kmem_cache *cache;
 739
 740         cache = kmem_cache_create("test_cache", size, 0, SLAB_TYPESAFE_BY_RCU,
 741                                   NULL);
 742         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 743
 744         p = kmem_cache_alloc(cache, GFP_KERNEL);
 745         if (!p) {
 746                 kunit_err(test, "Allocation failed: %s\n", __func__);
 747                 kmem_cache_destroy(cache);
 748                 return;
 749         }
 750
 751         /* Trigger invalid free, the object doesn't get freed. */
 752         KUNIT_EXPECT_KASAN_FAIL(test, kmem_cache_free(cache, p + 1));
 753
 754         /*
 755          * Properly free the object to prevent the "Objects remaining in
 756          * test_cache on __kmem_cache_shutdown" BUG failure.
 757          */
 758         kmem_cache_free(cache, p);
 759
 760         kmem_cache_destroy(cache);
 761 }
 762
 763 static void kasan_memchr(struct kunit *test)
 764 {
 765         char *ptr;
 766         size_t size = 24;
 767
 768         /*
 769          * str* functions are not instrumented with CONFIG_AMD_MEM_ENCRYPT.
 770          * See https://bugzilla.kernel.org/show_bug.cgi?id=206337 for details.
 771          */
 772         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_AMD_MEM_ENCRYPT);
 773
 774         if (OOB_TAG_OFF)
 775                 size = round_up(size, OOB_TAG_OFF);
 776
 777         ptr = kmalloc(size, GFP_KERNEL | __GFP_ZERO);
 778         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 779
 780         KUNIT_EXPECT_KASAN_FAIL(test,
 781                 kasan_ptr_result = memchr(ptr, '1', size + 1));
 782
 783         kfree(ptr);
 784 }
 785
 786 static void kasan_memcmp(struct kunit *test)
 787 {
 788         char *ptr;
 789         size_t size = 24;
 790         int arr[9];
 791
 792         /*
 793          * str* functions are not instrumented with CONFIG_AMD_MEM_ENCRYPT.
 794          * See https://bugzilla.kernel.org/show_bug.cgi?id=206337 for details.
 795          */
 796         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_AMD_MEM_ENCRYPT);
 797
 798         if (OOB_TAG_OFF)
 799                 size = round_up(size, OOB_TAG_OFF);
 800
 801         ptr = kmalloc(size, GFP_KERNEL | __GFP_ZERO);
 802         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 803         memset(arr, 0, sizeof(arr));
 804
 805         KUNIT_EXPECT_KASAN_FAIL(test,
 806                 kasan_int_result = memcmp(ptr, arr, size+1));
 807         kfree(ptr);
 808 }
 809
 810 static void kasan_strings(struct kunit *test)
 811 {
 812         char *ptr;
 813         size_t size = 24;
 814
 815         /*
 816          * str* functions are not instrumented with CONFIG_AMD_MEM_ENCRYPT.
 817          * See https://bugzilla.kernel.org/show_bug.cgi?id=206337 for details.
 818          */
 819         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_AMD_MEM_ENCRYPT);
 820
 821         ptr = kmalloc(size, GFP_KERNEL | __GFP_ZERO);
 822         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 823
 824         kfree(ptr);
 825
 826         /*
 827          * Try to cause only 1 invalid access (less spam in dmesg).
 828          * For that we need ptr to point to zeroed byte.
 829          * Skip metadata that could be stored in freed object so ptr
 830          * will likely point to zeroed byte.
 831          */
 832         ptr += 16;
 833         KUNIT_EXPECT_KASAN_FAIL(test, kasan_ptr_result = strchr(ptr, '1'));
 834
 835         KUNIT_EXPECT_KASAN_FAIL(test, kasan_ptr_result = strrchr(ptr, '1'));
 836
 837         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = strcmp(ptr, "2"));
 838
 839         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = strncmp(ptr, "2", 1));
 840
 841         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = strlen(ptr));
 842
 843         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = strnlen(ptr, 1));
 844 }
 845
 846 static void kasan_bitops_modify(struct kunit *test, int nr, void *addr)
 847 {
 848         KUNIT_EXPECT_KASAN_FAIL(test, set_bit(nr, addr));
 849         KUNIT_EXPECT_KASAN_FAIL(test, __set_bit(nr, addr));
 850         KUNIT_EXPECT_KASAN_FAIL(test, clear_bit(nr, addr));
 851         KUNIT_EXPECT_KASAN_FAIL(test, __clear_bit(nr, addr));
 852         KUNIT_EXPECT_KASAN_FAIL(test, clear_bit_unlock(nr, addr));
 853         KUNIT_EXPECT_KASAN_FAIL(test, __clear_bit_unlock(nr, addr));
 854         KUNIT_EXPECT_KASAN_FAIL(test, change_bit(nr, addr));
 855         KUNIT_EXPECT_KASAN_FAIL(test, __change_bit(nr, addr));
 856 }
 857
 858 static void kasan_bitops_test_and_modify(struct kunit *test, int nr, void *addr)
 859 {
 860         KUNIT_EXPECT_KASAN_FAIL(test, test_and_set_bit(nr, addr));
 861         KUNIT_EXPECT_KASAN_FAIL(test, __test_and_set_bit(nr, addr));
 862         KUNIT_EXPECT_KASAN_FAIL(test, test_and_set_bit_lock(nr, addr));
 863         KUNIT_EXPECT_KASAN_FAIL(test, test_and_clear_bit(nr, addr));
 864         KUNIT_EXPECT_KASAN_FAIL(test, __test_and_clear_bit(nr, addr));
 865         KUNIT_EXPECT_KASAN_FAIL(test, test_and_change_bit(nr, addr));
 866         KUNIT_EXPECT_KASAN_FAIL(test, __test_and_change_bit(nr, addr));
 867         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = test_bit(nr, addr));
 868
 869 #if defined(clear_bit_unlock_is_negative_byte)
 870         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result =
 871                                 clear_bit_unlock_is_negative_byte(nr, addr));
 872 #endif
 873 }
 874
 875 static void kasan_bitops_generic(struct kunit *test)
 876 {
 877         long *bits;
 878
 879         /* This test is specifically crafted for the generic mode. */
 880         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_GENERIC);
 881
 882         /*
 883          * Allocate 1 more byte, which causes kzalloc to round up to 16 bytes;
 884          * this way we do not actually corrupt other memory.
 885          */
 886         bits = kzalloc(sizeof(*bits) + 1, GFP_KERNEL);
 887         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, bits);
 888
 889         /*
 890          * Below calls try to access bit within allocated memory; however, the
 891          * below accesses are still out-of-bounds, since bitops are defined to
 892          * operate on the whole long the bit is in.
 893          */
 894         kasan_bitops_modify(test, BITS_PER_LONG, bits);
 895
 896         /*
 897          * Below calls try to access bit beyond allocated memory.
 898          */
 899         kasan_bitops_test_and_modify(test, BITS_PER_LONG + BITS_PER_BYTE, bits);
 900
 901         kfree(bits);
 902 }
 903
 904 static void kasan_bitops_tags(struct kunit *test)
 905 {
 906         long *bits;
 907
 908         /* This test is specifically crafted for tag-based modes. */
 909         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_KASAN_GENERIC);
 910
 911         /* kmalloc-64 cache will be used and the last 16 bytes will be the redzone. */
 912         bits = kzalloc(48, GFP_KERNEL);
 913         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, bits);
 914
 915         /* Do the accesses past the 48 allocated bytes, but within the redone. */
 916         kasan_bitops_modify(test, BITS_PER_LONG, (void *)bits + 48);
 917         kasan_bitops_test_and_modify(test, BITS_PER_LONG + BITS_PER_BYTE, (void *)bits + 48);
 918
 919         kfree(bits);
 920 }
 921
 922 static void kmalloc_double_kzfree(struct kunit *test)
 923 {
 924         char *ptr;
 925         size_t size = 16;
 926
 927         ptr = kmalloc(size, GFP_KERNEL);
 928         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 929
 930         kfree_sensitive(ptr);
 931         KUNIT_EXPECT_KASAN_FAIL(test, kfree_sensitive(ptr));
 932 }
 933
 934 static void vmalloc_oob(struct kunit *test)
 935 {
 936         void *area;
 937
 938         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_VMALLOC);
 939
 940         /*
 941          * We have to be careful not to hit the guard page.
 942          * The MMU will catch that and crash us.
 943          */
 944         area = vmalloc(3000);
 945         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, area);
 946
 947         KUNIT_EXPECT_KASAN_FAIL(test, ((volatile char *)area)[3100]);
 948         vfree(area);
 949 }
 950
 951 /*
 952  * Check that the assigned pointer tag falls within the [KASAN_TAG_MIN,
 953  * KASAN_TAG_KERNEL) range (note: excluding the match-all tag) for tag-based
 954  * modes.
 955  */
 956 static void match_all_not_assigned(struct kunit *test)
 957 {
 958         char *ptr;
 959         struct page *pages;
 960         int i, size, order;
 961
 962         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_KASAN_GENERIC);
 963
 964         for (i = 0; i < 256; i++) {
 965                 size = (get_random_int() % 1024) + 1;
 966                 ptr = kmalloc(size, GFP_KERNEL);
 967                 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 968                 KUNIT_EXPECT_GE(test, (u8)get_tag(ptr), (u8)KASAN_TAG_MIN);
 969                 KUNIT_EXPECT_LT(test, (u8)get_tag(ptr), (u8)KASAN_TAG_KERNEL);
 970                 kfree(ptr);
 971         }
 972
 973         for (i = 0; i < 256; i++) {
 974                 order = (get_random_int() % 4) + 1;
 975                 pages = alloc_pages(GFP_KERNEL, order);
 976                 ptr = page_address(pages);
 977                 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 978                 KUNIT_EXPECT_GE(test, (u8)get_tag(ptr), (u8)KASAN_TAG_MIN);
 979                 KUNIT_EXPECT_LT(test, (u8)get_tag(ptr), (u8)KASAN_TAG_KERNEL);
 980                 free_pages((unsigned long)ptr, order);
 981         }
 982 }
 983
 984 /* Check that 0xff works as a match-all pointer tag for tag-based modes. */
 985 static void match_all_ptr_tag(struct kunit *test)
 986 {
 987         char *ptr;
 988         u8 tag;
 989
 990         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_KASAN_GENERIC);
 991
 992         ptr = kmalloc(128, GFP_KERNEL);
 993         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 994
 995         /* Backup the assigned tag. */
 996         tag = get_tag(ptr);
 997         KUNIT_EXPECT_NE(test, tag, (u8)KASAN_TAG_KERNEL);
 998
 999         /* Reset the tag to 0xff.*/
1000         ptr = set_tag(ptr, KASAN_TAG_KERNEL);
1001
1002         /* This access shouldn't trigger a KASAN report. */
1003         *ptr = 0;
1004
1005         /* Recover the pointer tag and free. */
1006         ptr = set_tag(ptr, tag);
1007         kfree(ptr);
1008 }
1009
1010 /* Check that there are no match-all memory tags for tag-based modes. */
1011 static void match_all_mem_tag(struct kunit *test)
1012 {
1013         char *ptr;
1014         int tag;
1015
1016         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_KASAN_GENERIC);
1017
1018         ptr = kmalloc(128, GFP_KERNEL);
1019         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
1020         KUNIT_EXPECT_NE(test, (u8)get_tag(ptr), (u8)KASAN_TAG_KERNEL);
1021
1022         /* For each possible tag value not matching the pointer tag. */
1023         for (tag = KASAN_TAG_MIN; tag <= KASAN_TAG_KERNEL; tag++) {
1024                 if (tag == get_tag(ptr))
1025                         continue;
1026
1027                 /* Mark the first memory granule with the chosen memory tag. */
1028                 kasan_poison(ptr, KASAN_GRANULE_SIZE, (u8)tag);
1029
1030                 /* This access must cause a KASAN report. */
1031                 KUNIT_EXPECT_KASAN_FAIL(test, *ptr = 0);
1032         }
1033
1034         /* Recover the memory tag and free. */
1035         kasan_poison(ptr, KASAN_GRANULE_SIZE, get_tag(ptr));
1036         kfree(ptr);
1037 }
1038
1039 static struct kunit_case kasan_kunit_test_cases[] = {
1040         KUNIT_CASE(kmalloc_oob_right),
1041         KUNIT_CASE(kmalloc_oob_left),
1042         KUNIT_CASE(kmalloc_node_oob_right),
1043         KUNIT_CASE(kmalloc_pagealloc_oob_right),
1044         KUNIT_CASE(kmalloc_pagealloc_uaf),
1045         KUNIT_CASE(kmalloc_pagealloc_invalid_free),
1046         KUNIT_CASE(pagealloc_oob_right),
1047         KUNIT_CASE(pagealloc_uaf),
1048         KUNIT_CASE(kmalloc_large_oob_right),
1049         KUNIT_CASE(krealloc_more_oob),
1050         KUNIT_CASE(krealloc_less_oob),
1051         KUNIT_CASE(krealloc_pagealloc_more_oob),
1052         KUNIT_CASE(krealloc_pagealloc_less_oob),
1053         KUNIT_CASE(kmalloc_oob_16),
1054         KUNIT_CASE(kmalloc_uaf_16),
1055         KUNIT_CASE(kmalloc_oob_in_memset),
1056         KUNIT_CASE(kmalloc_oob_memset_2),
1057         KUNIT_CASE(kmalloc_oob_memset_4),
1058         KUNIT_CASE(kmalloc_oob_memset_8),
1059         KUNIT_CASE(kmalloc_oob_memset_16),
1060         KUNIT_CASE(kmalloc_memmove_invalid_size),
1061         KUNIT_CASE(kmalloc_uaf),
1062         KUNIT_CASE(kmalloc_uaf_memset),
1063         KUNIT_CASE(kmalloc_uaf2),
1064         KUNIT_CASE(kfree_via_page),
1065         KUNIT_CASE(kfree_via_phys),
1066         KUNIT_CASE(kmem_cache_oob),
1067         KUNIT_CASE(kmem_cache_accounted),
1068         KUNIT_CASE(kmem_cache_bulk),
1069         KUNIT_CASE(kasan_global_oob),
1070         KUNIT_CASE(kasan_stack_oob),
1071         KUNIT_CASE(kasan_alloca_oob_left),
1072         KUNIT_CASE(kasan_alloca_oob_right),
1073         KUNIT_CASE(ksize_unpoisons_memory),
1074         KUNIT_CASE(ksize_uaf),
1075         KUNIT_CASE(kmem_cache_double_free),
1076         KUNIT_CASE(kmem_cache_invalid_free),
1077         KUNIT_CASE(kasan_memchr),
1078         KUNIT_CASE(kasan_memcmp),
1079         KUNIT_CASE(kasan_strings),
1080         KUNIT_CASE(kasan_bitops_generic),
1081         KUNIT_CASE(kasan_bitops_tags),
1082         KUNIT_CASE(kmalloc_double_kzfree),
1083         KUNIT_CASE(vmalloc_oob),
1084         KUNIT_CASE(match_all_not_assigned),
1085         KUNIT_CASE(match_all_ptr_tag),
1086         KUNIT_CASE(match_all_mem_tag),
1087         {}
1088 };
1089
1090 static struct kunit_suite kasan_kunit_test_suite = {
1091         .name = "kasan",
1092         .init = kasan_test_init,
1093         .test_cases = kasan_kunit_test_cases,
1094         .exit = kasan_test_exit,
1095 };
1096
1097 kunit_test_suite(kasan_kunit_test_suite);
1098
1099 MODULE_LICENSE("GPL");