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 #include <linux/set_memory.h>
  23
  24 #include <asm/page.h>
  25
  26 #include <kunit/test.h>
  27
  28 #include "../mm/kasan/kasan.h"
  29
  30 #define OOB_TAG_OFF (IS_ENABLED(CONFIG_KASAN_GENERIC) ? 0 : KASAN_GRANULE_SIZE)
  31
  32 /*
  33  * Some tests use these global variables to store return values from function
  34  * calls that could otherwise be eliminated by the compiler as dead code.
  35  */
  36 void *kasan_ptr_result;
  37 int kasan_int_result;
  38
  39 static struct kunit_resource resource;
  40 static struct kunit_kasan_status test_status;
  41 static bool multishot;
  42
  43 /*
  44  * Temporarily enable multi-shot mode. Otherwise, KASAN would only report the
  45  * first detected bug and panic the kernel if panic_on_warn is enabled. For
  46  * hardware tag-based KASAN also allow tag checking to be reenabled for each
  47  * test, see the comment for KUNIT_EXPECT_KASAN_FAIL().
  48  */
  49 static int kasan_test_init(struct kunit *test)
  50 {
  51         if (!kasan_enabled()) {
  52                 kunit_err(test, "can't run KASAN tests with KASAN disabled");
  53                 return -1;
  54         }
  55
  56         multishot = kasan_save_enable_multi_shot();
  57         test_status.report_found = false;
  58         test_status.sync_fault = false;
  59         kunit_add_named_resource(test, NULL, NULL, &resource,
  60                                         "kasan_status", &test_status);
  61         return 0;
  62 }
  63
  64 static void kasan_test_exit(struct kunit *test)
  65 {
  66         kasan_restore_multi_shot(multishot);
  67         KUNIT_EXPECT_FALSE(test, test_status.report_found);
  68 }
  69
  70 /**
  71  * KUNIT_EXPECT_KASAN_FAIL() - check that the executed expression produces a
  72  * KASAN report; causes a test failure otherwise. This relies on a KUnit
  73  * resource named "kasan_status". Do not use this name for KUnit resources
  74  * outside of KASAN tests.
  75  *
  76  * For hardware tag-based KASAN, when a synchronous tag fault happens, tag
  77  * checking is auto-disabled. When this happens, this test handler reenables
  78  * tag checking. As tag checking can be only disabled or enabled per CPU,
  79  * this handler disables migration (preemption).
  80  *
  81  * Since the compiler doesn't see that the expression can change the test_status
  82  * fields, it can reorder or optimize away the accesses to those fields.
  83  * Use READ/WRITE_ONCE() for the accesses and compiler barriers around the
  84  * expression to prevent that.
  85  *
  86  * In between KUNIT_EXPECT_KASAN_FAIL checks, test_status.report_found is kept
  87  * as false. This allows detecting KASAN reports that happen outside of the
  88  * checks by asserting !test_status.report_found at the start of
  89  * KUNIT_EXPECT_KASAN_FAIL and in kasan_test_exit.
  90  */
  91 #define KUNIT_EXPECT_KASAN_FAIL(test, expression) do {                  \
  92         if (IS_ENABLED(CONFIG_KASAN_HW_TAGS) &&                         \
  93             kasan_sync_fault_possible())                                \
  94                 migrate_disable();                                      \
  95         KUNIT_EXPECT_FALSE(test, READ_ONCE(test_status.report_found));  \
  96         barrier();                                                      \
  97         expression;                                                     \
  98         barrier();                                                      \
  99         if (kasan_async_fault_possible())                               \
 100                 kasan_force_async_fault();                              \
 101         if (!READ_ONCE(test_status.report_found)) {                     \
 102                 KUNIT_FAIL(test, KUNIT_SUBTEST_INDENT "KASAN failure "  \
 103                                 "expected in \"" #expression            \
 104                                  "\", but none occurred");              \
 105         }                                                               \
 106         if (IS_ENABLED(CONFIG_KASAN_HW_TAGS) &&                         \
 107             kasan_sync_fault_possible()) {                              \
 108                 if (READ_ONCE(test_status.report_found) &&              \
 109                     READ_ONCE(test_status.sync_fault))                  \
 110                         kasan_enable_tagging();                         \
 111                 migrate_enable();                                       \
 112         }                                                               \
 113         WRITE_ONCE(test_status.report_found, false);                    \
 114 } while (0)
 115
 116 #define KASAN_TEST_NEEDS_CONFIG_ON(test, config) do {                   \
 117         if (!IS_ENABLED(config))                                        \
 118                 kunit_skip((test), "Test requires " #config "=y");      \
 119 } while (0)
 120
 121 #define KASAN_TEST_NEEDS_CONFIG_OFF(test, config) do {                  \
 122         if (IS_ENABLED(config))                                         \
 123                 kunit_skip((test), "Test requires " #config "=n");      \
 124 } while (0)
 125
 126 static void kmalloc_oob_right(struct kunit *test)
 127 {
 128         char *ptr;
 129         size_t size = 128 - KASAN_GRANULE_SIZE - 5;
 130
 131         ptr = kmalloc(size, GFP_KERNEL);
 132         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 133
 134         /*
 135          * An unaligned access past the requested kmalloc size.
 136          * Only generic KASAN can precisely detect these.
 137          */
 138         if (IS_ENABLED(CONFIG_KASAN_GENERIC))
 139                 KUNIT_EXPECT_KASAN_FAIL(test, ptr[size] = 'x');
 140
 141         /*
 142          * An aligned access into the first out-of-bounds granule that falls
 143          * within the aligned kmalloc object.
 144          */
 145         KUNIT_EXPECT_KASAN_FAIL(test, ptr[size + 5] = 'y');
 146
 147         /* Out-of-bounds access past the aligned kmalloc object. */
 148         KUNIT_EXPECT_KASAN_FAIL(test, ptr[0] =
 149                                         ptr[size + KASAN_GRANULE_SIZE + 5]);
 150
 151         kfree(ptr);
 152 }
 153
 154 static void kmalloc_oob_left(struct kunit *test)
 155 {
 156         char *ptr;
 157         size_t size = 15;
 158
 159         ptr = kmalloc(size, GFP_KERNEL);
 160         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 161
 162         KUNIT_EXPECT_KASAN_FAIL(test, *ptr = *(ptr - 1));
 163         kfree(ptr);
 164 }
 165
 166 static void kmalloc_node_oob_right(struct kunit *test)
 167 {
 168         char *ptr;
 169         size_t size = 4096;
 170
 171         ptr = kmalloc_node(size, GFP_KERNEL, 0);
 172         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 173
 174         KUNIT_EXPECT_KASAN_FAIL(test, ptr[0] = ptr[size]);
 175         kfree(ptr);
 176 }
 177
 178 /*
 179  * These kmalloc_pagealloc_* tests try allocating a memory chunk that doesn't
 180  * fit into a slab cache and therefore is allocated via the page allocator
 181  * fallback. Since this kind of fallback is only implemented for SLUB, these
 182  * tests are limited to that allocator.
 183  */
 184 static void kmalloc_pagealloc_oob_right(struct kunit *test)
 185 {
 186         char *ptr;
 187         size_t size = KMALLOC_MAX_CACHE_SIZE + 10;
 188
 189         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_SLUB);
 190
 191         ptr = kmalloc(size, GFP_KERNEL);
 192         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 193
 194         KUNIT_EXPECT_KASAN_FAIL(test, ptr[size + OOB_TAG_OFF] = 0);
 195
 196         kfree(ptr);
 197 }
 198
 199 static void kmalloc_pagealloc_uaf(struct kunit *test)
 200 {
 201         char *ptr;
 202         size_t size = KMALLOC_MAX_CACHE_SIZE + 10;
 203
 204         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_SLUB);
 205
 206         ptr = kmalloc(size, GFP_KERNEL);
 207         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 208         kfree(ptr);
 209
 210         KUNIT_EXPECT_KASAN_FAIL(test, ((volatile char *)ptr)[0]);
 211 }
 212
 213 static void kmalloc_pagealloc_invalid_free(struct kunit *test)
 214 {
 215         char *ptr;
 216         size_t size = KMALLOC_MAX_CACHE_SIZE + 10;
 217
 218         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_SLUB);
 219
 220         ptr = kmalloc(size, GFP_KERNEL);
 221         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 222
 223         KUNIT_EXPECT_KASAN_FAIL(test, kfree(ptr + 1));
 224 }
 225
 226 static void pagealloc_oob_right(struct kunit *test)
 227 {
 228         char *ptr;
 229         struct page *pages;
 230         size_t order = 4;
 231         size_t size = (1UL << (PAGE_SHIFT + order));
 232
 233         /*
 234          * With generic KASAN page allocations have no redzones, thus
 235          * out-of-bounds detection is not guaranteed.
 236          * See https://bugzilla.kernel.org/show_bug.cgi?id=210503.
 237          */
 238         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_KASAN_GENERIC);
 239
 240         pages = alloc_pages(GFP_KERNEL, order);
 241         ptr = page_address(pages);
 242         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 243
 244         KUNIT_EXPECT_KASAN_FAIL(test, ptr[0] = ptr[size]);
 245         free_pages((unsigned long)ptr, order);
 246 }
 247
 248 static void pagealloc_uaf(struct kunit *test)
 249 {
 250         char *ptr;
 251         struct page *pages;
 252         size_t order = 4;
 253
 254         pages = alloc_pages(GFP_KERNEL, order);
 255         ptr = page_address(pages);
 256         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 257         free_pages((unsigned long)ptr, order);
 258
 259         KUNIT_EXPECT_KASAN_FAIL(test, ((volatile char *)ptr)[0]);
 260 }
 261
 262 static void kmalloc_large_oob_right(struct kunit *test)
 263 {
 264         char *ptr;
 265         size_t size = KMALLOC_MAX_CACHE_SIZE - 256;
 266
 267         /*
 268          * Allocate a chunk that is large enough, but still fits into a slab
 269          * and does not trigger the page allocator fallback in SLUB.
 270          */
 271         ptr = kmalloc(size, GFP_KERNEL);
 272         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 273
 274         KUNIT_EXPECT_KASAN_FAIL(test, ptr[size] = 0);
 275         kfree(ptr);
 276 }
 277
 278 static void krealloc_more_oob_helper(struct kunit *test,
 279                                         size_t size1, size_t size2)
 280 {
 281         char *ptr1, *ptr2;
 282         size_t middle;
 283
 284         KUNIT_ASSERT_LT(test, size1, size2);
 285         middle = size1 + (size2 - size1) / 2;
 286
 287         ptr1 = kmalloc(size1, GFP_KERNEL);
 288         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
 289
 290         ptr2 = krealloc(ptr1, size2, GFP_KERNEL);
 291         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr2);
 292
 293         /* All offsets up to size2 must be accessible. */
 294         ptr2[size1 - 1] = 'x';
 295         ptr2[size1] = 'x';
 296         ptr2[middle] = 'x';
 297         ptr2[size2 - 1] = 'x';
 298
 299         /* Generic mode is precise, so unaligned size2 must be inaccessible. */
 300         if (IS_ENABLED(CONFIG_KASAN_GENERIC))
 301                 KUNIT_EXPECT_KASAN_FAIL(test, ptr2[size2] = 'x');
 302
 303         /* For all modes first aligned offset after size2 must be inaccessible. */
 304         KUNIT_EXPECT_KASAN_FAIL(test,
 305                 ptr2[round_up(size2, KASAN_GRANULE_SIZE)] = 'x');
 306
 307         kfree(ptr2);
 308 }
 309
 310 static void krealloc_less_oob_helper(struct kunit *test,
 311                                         size_t size1, size_t size2)
 312 {
 313         char *ptr1, *ptr2;
 314         size_t middle;
 315
 316         KUNIT_ASSERT_LT(test, size2, size1);
 317         middle = size2 + (size1 - size2) / 2;
 318
 319         ptr1 = kmalloc(size1, GFP_KERNEL);
 320         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
 321
 322         ptr2 = krealloc(ptr1, size2, GFP_KERNEL);
 323         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr2);
 324
 325         /* Must be accessible for all modes. */
 326         ptr2[size2 - 1] = 'x';
 327
 328         /* Generic mode is precise, so unaligned size2 must be inaccessible. */
 329         if (IS_ENABLED(CONFIG_KASAN_GENERIC))
 330                 KUNIT_EXPECT_KASAN_FAIL(test, ptr2[size2] = 'x');
 331
 332         /* For all modes first aligned offset after size2 must be inaccessible. */
 333         KUNIT_EXPECT_KASAN_FAIL(test,
 334                 ptr2[round_up(size2, KASAN_GRANULE_SIZE)] = 'x');
 335
 336         /*
 337          * For all modes all size2, middle, and size1 should land in separate
 338          * granules and thus the latter two offsets should be inaccessible.
 339          */
 340         KUNIT_EXPECT_LE(test, round_up(size2, KASAN_GRANULE_SIZE),
 341                                 round_down(middle, KASAN_GRANULE_SIZE));
 342         KUNIT_EXPECT_LE(test, round_up(middle, KASAN_GRANULE_SIZE),
 343                                 round_down(size1, KASAN_GRANULE_SIZE));
 344         KUNIT_EXPECT_KASAN_FAIL(test, ptr2[middle] = 'x');
 345         KUNIT_EXPECT_KASAN_FAIL(test, ptr2[size1 - 1] = 'x');
 346         KUNIT_EXPECT_KASAN_FAIL(test, ptr2[size1] = 'x');
 347
 348         kfree(ptr2);
 349 }
 350
 351 static void krealloc_more_oob(struct kunit *test)
 352 {
 353         krealloc_more_oob_helper(test, 201, 235);
 354 }
 355
 356 static void krealloc_less_oob(struct kunit *test)
 357 {
 358         krealloc_less_oob_helper(test, 235, 201);
 359 }
 360
 361 static void krealloc_pagealloc_more_oob(struct kunit *test)
 362 {
 363         /* page_alloc fallback in only implemented for SLUB. */
 364         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_SLUB);
 365
 366         krealloc_more_oob_helper(test, KMALLOC_MAX_CACHE_SIZE + 201,
 367                                         KMALLOC_MAX_CACHE_SIZE + 235);
 368 }
 369
 370 static void krealloc_pagealloc_less_oob(struct kunit *test)
 371 {
 372         /* page_alloc fallback in only implemented for SLUB. */
 373         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_SLUB);
 374
 375         krealloc_less_oob_helper(test, KMALLOC_MAX_CACHE_SIZE + 235,
 376                                         KMALLOC_MAX_CACHE_SIZE + 201);
 377 }
 378
 379 /*
 380  * Check that krealloc() detects a use-after-free, returns NULL,
 381  * and doesn't unpoison the freed object.
 382  */
 383 static void krealloc_uaf(struct kunit *test)
 384 {
 385         char *ptr1, *ptr2;
 386         int size1 = 201;
 387         int size2 = 235;
 388
 389         ptr1 = kmalloc(size1, GFP_KERNEL);
 390         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
 391         kfree(ptr1);
 392
 393         KUNIT_EXPECT_KASAN_FAIL(test, ptr2 = krealloc(ptr1, size2, GFP_KERNEL));
 394         KUNIT_ASSERT_NULL(test, ptr2);
 395         KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)ptr1);
 396 }
 397
 398 static void kmalloc_oob_16(struct kunit *test)
 399 {
 400         struct {
 401                 u64 words[2];
 402         } *ptr1, *ptr2;
 403
 404         /* This test is specifically crafted for the generic mode. */
 405         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_GENERIC);
 406
 407         ptr1 = kmalloc(sizeof(*ptr1) - 3, GFP_KERNEL);
 408         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
 409
 410         ptr2 = kmalloc(sizeof(*ptr2), GFP_KERNEL);
 411         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr2);
 412
 413         KUNIT_EXPECT_KASAN_FAIL(test, *ptr1 = *ptr2);
 414         kfree(ptr1);
 415         kfree(ptr2);
 416 }
 417
 418 static void kmalloc_uaf_16(struct kunit *test)
 419 {
 420         struct {
 421                 u64 words[2];
 422         } *ptr1, *ptr2;
 423
 424         ptr1 = kmalloc(sizeof(*ptr1), GFP_KERNEL);
 425         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
 426
 427         ptr2 = kmalloc(sizeof(*ptr2), GFP_KERNEL);
 428         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr2);
 429         kfree(ptr2);
 430
 431         KUNIT_EXPECT_KASAN_FAIL(test, *ptr1 = *ptr2);
 432         kfree(ptr1);
 433 }
 434
 435 /*
 436  * Note: in the memset tests below, the written range touches both valid and
 437  * invalid memory. This makes sure that the instrumentation does not only check
 438  * the starting address but the whole range.
 439  */
 440
 441 static void kmalloc_oob_memset_2(struct kunit *test)
 442 {
 443         char *ptr;
 444         size_t size = 128 - KASAN_GRANULE_SIZE;
 445
 446         ptr = kmalloc(size, GFP_KERNEL);
 447         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 448
 449         OPTIMIZER_HIDE_VAR(size);
 450         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr + size - 1, 0, 2));
 451         kfree(ptr);
 452 }
 453
 454 static void kmalloc_oob_memset_4(struct kunit *test)
 455 {
 456         char *ptr;
 457         size_t size = 128 - KASAN_GRANULE_SIZE;
 458
 459         ptr = kmalloc(size, GFP_KERNEL);
 460         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 461
 462         OPTIMIZER_HIDE_VAR(size);
 463         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr + size - 3, 0, 4));
 464         kfree(ptr);
 465 }
 466
 467 static void kmalloc_oob_memset_8(struct kunit *test)
 468 {
 469         char *ptr;
 470         size_t size = 128 - KASAN_GRANULE_SIZE;
 471
 472         ptr = kmalloc(size, GFP_KERNEL);
 473         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 474
 475         OPTIMIZER_HIDE_VAR(size);
 476         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr + size - 7, 0, 8));
 477         kfree(ptr);
 478 }
 479
 480 static void kmalloc_oob_memset_16(struct kunit *test)
 481 {
 482         char *ptr;
 483         size_t size = 128 - KASAN_GRANULE_SIZE;
 484
 485         ptr = kmalloc(size, GFP_KERNEL);
 486         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 487
 488         OPTIMIZER_HIDE_VAR(size);
 489         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr + size - 15, 0, 16));
 490         kfree(ptr);
 491 }
 492
 493 static void kmalloc_oob_in_memset(struct kunit *test)
 494 {
 495         char *ptr;
 496         size_t size = 128 - KASAN_GRANULE_SIZE;
 497
 498         ptr = kmalloc(size, GFP_KERNEL);
 499         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 500
 501         OPTIMIZER_HIDE_VAR(ptr);
 502         OPTIMIZER_HIDE_VAR(size);
 503         KUNIT_EXPECT_KASAN_FAIL(test,
 504                                 memset(ptr, 0, size + KASAN_GRANULE_SIZE));
 505         kfree(ptr);
 506 }
 507
 508 static void kmalloc_memmove_negative_size(struct kunit *test)
 509 {
 510         char *ptr;
 511         size_t size = 64;
 512         size_t invalid_size = -2;
 513
 514         /*
 515          * Hardware tag-based mode doesn't check memmove for negative size.
 516          * As a result, this test introduces a side-effect memory corruption,
 517          * which can result in a crash.
 518          */
 519         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_KASAN_HW_TAGS);
 520
 521         ptr = kmalloc(size, GFP_KERNEL);
 522         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 523
 524         memset((char *)ptr, 0, 64);
 525         OPTIMIZER_HIDE_VAR(ptr);
 526         OPTIMIZER_HIDE_VAR(invalid_size);
 527         KUNIT_EXPECT_KASAN_FAIL(test,
 528                 memmove((char *)ptr, (char *)ptr + 4, invalid_size));
 529         kfree(ptr);
 530 }
 531
 532 static void kmalloc_memmove_invalid_size(struct kunit *test)
 533 {
 534         char *ptr;
 535         size_t size = 64;
 536         volatile size_t invalid_size = size;
 537
 538         ptr = kmalloc(size, GFP_KERNEL);
 539         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 540
 541         memset((char *)ptr, 0, 64);
 542         OPTIMIZER_HIDE_VAR(ptr);
 543         KUNIT_EXPECT_KASAN_FAIL(test,
 544                 memmove((char *)ptr, (char *)ptr + 4, invalid_size));
 545         kfree(ptr);
 546 }
 547
 548 static void kmalloc_uaf(struct kunit *test)
 549 {
 550         char *ptr;
 551         size_t size = 10;
 552
 553         ptr = kmalloc(size, GFP_KERNEL);
 554         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 555
 556         kfree(ptr);
 557         KUNIT_EXPECT_KASAN_FAIL(test, ((volatile char *)ptr)[8]);
 558 }
 559
 560 static void kmalloc_uaf_memset(struct kunit *test)
 561 {
 562         char *ptr;
 563         size_t size = 33;
 564
 565         /*
 566          * Only generic KASAN uses quarantine, which is required to avoid a
 567          * kernel memory corruption this test causes.
 568          */
 569         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_GENERIC);
 570
 571         ptr = kmalloc(size, GFP_KERNEL);
 572         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 573
 574         kfree(ptr);
 575         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr, 0, size));
 576 }
 577
 578 static void kmalloc_uaf2(struct kunit *test)
 579 {
 580         char *ptr1, *ptr2;
 581         size_t size = 43;
 582         int counter = 0;
 583
 584 again:
 585         ptr1 = kmalloc(size, GFP_KERNEL);
 586         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
 587
 588         kfree(ptr1);
 589
 590         ptr2 = kmalloc(size, GFP_KERNEL);
 591         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr2);
 592
 593         /*
 594          * For tag-based KASAN ptr1 and ptr2 tags might happen to be the same.
 595          * Allow up to 16 attempts at generating different tags.
 596          */
 597         if (!IS_ENABLED(CONFIG_KASAN_GENERIC) && ptr1 == ptr2 && counter++ < 16) {
 598                 kfree(ptr2);
 599                 goto again;
 600         }
 601
 602         KUNIT_EXPECT_KASAN_FAIL(test, ((volatile char *)ptr1)[40]);
 603         KUNIT_EXPECT_PTR_NE(test, ptr1, ptr2);
 604
 605         kfree(ptr2);
 606 }
 607
 608 static void kfree_via_page(struct kunit *test)
 609 {
 610         char *ptr;
 611         size_t size = 8;
 612         struct page *page;
 613         unsigned long offset;
 614
 615         ptr = kmalloc(size, GFP_KERNEL);
 616         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 617
 618         page = virt_to_page(ptr);
 619         offset = offset_in_page(ptr);
 620         kfree(page_address(page) + offset);
 621 }
 622
 623 static void kfree_via_phys(struct kunit *test)
 624 {
 625         char *ptr;
 626         size_t size = 8;
 627         phys_addr_t phys;
 628
 629         ptr = kmalloc(size, GFP_KERNEL);
 630         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 631
 632         phys = virt_to_phys(ptr);
 633         kfree(phys_to_virt(phys));
 634 }
 635
 636 static void kmem_cache_oob(struct kunit *test)
 637 {
 638         char *p;
 639         size_t size = 200;
 640         struct kmem_cache *cache;
 641
 642         cache = kmem_cache_create("test_cache", size, 0, 0, NULL);
 643         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 644
 645         p = kmem_cache_alloc(cache, GFP_KERNEL);
 646         if (!p) {
 647                 kunit_err(test, "Allocation failed: %s\n", __func__);
 648                 kmem_cache_destroy(cache);
 649                 return;
 650         }
 651
 652         KUNIT_EXPECT_KASAN_FAIL(test, *p = p[size + OOB_TAG_OFF]);
 653
 654         kmem_cache_free(cache, p);
 655         kmem_cache_destroy(cache);
 656 }
 657
 658 static void kmem_cache_accounted(struct kunit *test)
 659 {
 660         int i;
 661         char *p;
 662         size_t size = 200;
 663         struct kmem_cache *cache;
 664
 665         cache = kmem_cache_create("test_cache", size, 0, SLAB_ACCOUNT, NULL);
 666         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 667
 668         /*
 669          * Several allocations with a delay to allow for lazy per memcg kmem
 670          * cache creation.
 671          */
 672         for (i = 0; i < 5; i++) {
 673                 p = kmem_cache_alloc(cache, GFP_KERNEL);
 674                 if (!p)
 675                         goto free_cache;
 676
 677                 kmem_cache_free(cache, p);
 678                 msleep(100);
 679         }
 680
 681 free_cache:
 682         kmem_cache_destroy(cache);
 683 }
 684
 685 static void kmem_cache_bulk(struct kunit *test)
 686 {
 687         struct kmem_cache *cache;
 688         size_t size = 200;
 689         char *p[10];
 690         bool ret;
 691         int i;
 692
 693         cache = kmem_cache_create("test_cache", size, 0, 0, NULL);
 694         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 695
 696         ret = kmem_cache_alloc_bulk(cache, GFP_KERNEL, ARRAY_SIZE(p), (void **)&p);
 697         if (!ret) {
 698                 kunit_err(test, "Allocation failed: %s\n", __func__);
 699                 kmem_cache_destroy(cache);
 700                 return;
 701         }
 702
 703         for (i = 0; i < ARRAY_SIZE(p); i++)
 704                 p[i][0] = p[i][size - 1] = 42;
 705
 706         kmem_cache_free_bulk(cache, ARRAY_SIZE(p), (void **)&p);
 707         kmem_cache_destroy(cache);
 708 }
 709
 710 static char global_array[10];
 711
 712 static void kasan_global_oob_right(struct kunit *test)
 713 {
 714         /*
 715          * Deliberate out-of-bounds access. To prevent CONFIG_UBSAN_LOCAL_BOUNDS
 716          * from failing here and panicking the kernel, access the array via a
 717          * volatile pointer, which will prevent the compiler from being able to
 718          * determine the array bounds.
 719          *
 720          * This access uses a volatile pointer to char (char *volatile) rather
 721          * than the more conventional pointer to volatile char (volatile char *)
 722          * because we want to prevent the compiler from making inferences about
 723          * the pointer itself (i.e. its array bounds), not the data that it
 724          * refers to.
 725          */
 726         char *volatile array = global_array;
 727         char *p = &array[ARRAY_SIZE(global_array) + 3];
 728
 729         /* Only generic mode instruments globals. */
 730         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_GENERIC);
 731
 732         KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)p);
 733 }
 734
 735 static void kasan_global_oob_left(struct kunit *test)
 736 {
 737         char *volatile array = global_array;
 738         char *p = array - 3;
 739
 740         /*
 741          * GCC is known to fail this test, skip it.
 742          * See https://bugzilla.kernel.org/show_bug.cgi?id=215051.
 743          */
 744         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_CC_IS_CLANG);
 745         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_GENERIC);
 746         KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)p);
 747 }
 748
 749 /* Check that ksize() makes the whole object accessible. */
 750 static void ksize_unpoisons_memory(struct kunit *test)
 751 {
 752         char *ptr;
 753         size_t size = 123, real_size;
 754
 755         ptr = kmalloc(size, GFP_KERNEL);
 756         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 757         real_size = ksize(ptr);
 758
 759         /* This access shouldn't trigger a KASAN report. */
 760         ptr[size] = 'x';
 761
 762         /* This one must. */
 763         KUNIT_EXPECT_KASAN_FAIL(test, ((volatile char *)ptr)[real_size]);
 764
 765         kfree(ptr);
 766 }
 767
 768 /*
 769  * Check that a use-after-free is detected by ksize() and via normal accesses
 770  * after it.
 771  */
 772 static void ksize_uaf(struct kunit *test)
 773 {
 774         char *ptr;
 775         int size = 128 - KASAN_GRANULE_SIZE;
 776
 777         ptr = kmalloc(size, GFP_KERNEL);
 778         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 779         kfree(ptr);
 780
 781         KUNIT_EXPECT_KASAN_FAIL(test, ksize(ptr));
 782         KUNIT_EXPECT_KASAN_FAIL(test, ((volatile char *)ptr)[0]);
 783         KUNIT_EXPECT_KASAN_FAIL(test, ((volatile char *)ptr)[size]);
 784 }
 785
 786 static void kasan_stack_oob(struct kunit *test)
 787 {
 788         char stack_array[10];
 789         /* See comment in kasan_global_oob_right. */
 790         char *volatile array = stack_array;
 791         char *p = &array[ARRAY_SIZE(stack_array) + OOB_TAG_OFF];
 792
 793         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_STACK);
 794
 795         KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)p);
 796 }
 797
 798 static void kasan_alloca_oob_left(struct kunit *test)
 799 {
 800         volatile int i = 10;
 801         char alloca_array[i];
 802         /* See comment in kasan_global_oob_right. */
 803         char *volatile array = alloca_array;
 804         char *p = array - 1;
 805
 806         /* Only generic mode instruments dynamic allocas. */
 807         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_GENERIC);
 808         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_STACK);
 809
 810         KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)p);
 811 }
 812
 813 static void kasan_alloca_oob_right(struct kunit *test)
 814 {
 815         volatile int i = 10;
 816         char alloca_array[i];
 817         /* See comment in kasan_global_oob_right. */
 818         char *volatile array = alloca_array;
 819         char *p = array + i;
 820
 821         /* Only generic mode instruments dynamic allocas. */
 822         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_GENERIC);
 823         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_STACK);
 824
 825         KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)p);
 826 }
 827
 828 static void kmem_cache_double_free(struct kunit *test)
 829 {
 830         char *p;
 831         size_t size = 200;
 832         struct kmem_cache *cache;
 833
 834         cache = kmem_cache_create("test_cache", size, 0, 0, NULL);
 835         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 836
 837         p = kmem_cache_alloc(cache, GFP_KERNEL);
 838         if (!p) {
 839                 kunit_err(test, "Allocation failed: %s\n", __func__);
 840                 kmem_cache_destroy(cache);
 841                 return;
 842         }
 843
 844         kmem_cache_free(cache, p);
 845         KUNIT_EXPECT_KASAN_FAIL(test, kmem_cache_free(cache, p));
 846         kmem_cache_destroy(cache);
 847 }
 848
 849 static void kmem_cache_invalid_free(struct kunit *test)
 850 {
 851         char *p;
 852         size_t size = 200;
 853         struct kmem_cache *cache;
 854
 855         cache = kmem_cache_create("test_cache", size, 0, SLAB_TYPESAFE_BY_RCU,
 856                                   NULL);
 857         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 858
 859         p = kmem_cache_alloc(cache, GFP_KERNEL);
 860         if (!p) {
 861                 kunit_err(test, "Allocation failed: %s\n", __func__);
 862                 kmem_cache_destroy(cache);
 863                 return;
 864         }
 865
 866         /* Trigger invalid free, the object doesn't get freed. */
 867         KUNIT_EXPECT_KASAN_FAIL(test, kmem_cache_free(cache, p + 1));
 868
 869         /*
 870          * Properly free the object to prevent the "Objects remaining in
 871          * test_cache on __kmem_cache_shutdown" BUG failure.
 872          */
 873         kmem_cache_free(cache, p);
 874
 875         kmem_cache_destroy(cache);
 876 }
 877
 878 static void empty_cache_ctor(void *object) { }
 879
 880 static void kmem_cache_double_destroy(struct kunit *test)
 881 {
 882         struct kmem_cache *cache;
 883
 884         /* Provide a constructor to prevent cache merging. */
 885         cache = kmem_cache_create("test_cache", 200, 0, 0, empty_cache_ctor);
 886         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 887         kmem_cache_destroy(cache);
 888         KUNIT_EXPECT_KASAN_FAIL(test, kmem_cache_destroy(cache));
 889 }
 890
 891 static void kasan_memchr(struct kunit *test)
 892 {
 893         char *ptr;
 894         size_t size = 24;
 895
 896         /*
 897          * str* functions are not instrumented with CONFIG_AMD_MEM_ENCRYPT.
 898          * See https://bugzilla.kernel.org/show_bug.cgi?id=206337 for details.
 899          */
 900         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_AMD_MEM_ENCRYPT);
 901
 902         if (OOB_TAG_OFF)
 903                 size = round_up(size, OOB_TAG_OFF);
 904
 905         ptr = kmalloc(size, GFP_KERNEL | __GFP_ZERO);
 906         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 907
 908         OPTIMIZER_HIDE_VAR(ptr);
 909         OPTIMIZER_HIDE_VAR(size);
 910         KUNIT_EXPECT_KASAN_FAIL(test,
 911                 kasan_ptr_result = memchr(ptr, '1', size + 1));
 912
 913         kfree(ptr);
 914 }
 915
 916 static void kasan_memcmp(struct kunit *test)
 917 {
 918         char *ptr;
 919         size_t size = 24;
 920         int arr[9];
 921
 922         /*
 923          * str* functions are not instrumented with CONFIG_AMD_MEM_ENCRYPT.
 924          * See https://bugzilla.kernel.org/show_bug.cgi?id=206337 for details.
 925          */
 926         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_AMD_MEM_ENCRYPT);
 927
 928         if (OOB_TAG_OFF)
 929                 size = round_up(size, OOB_TAG_OFF);
 930
 931         ptr = kmalloc(size, GFP_KERNEL | __GFP_ZERO);
 932         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 933         memset(arr, 0, sizeof(arr));
 934
 935         OPTIMIZER_HIDE_VAR(ptr);
 936         OPTIMIZER_HIDE_VAR(size);
 937         KUNIT_EXPECT_KASAN_FAIL(test,
 938                 kasan_int_result = memcmp(ptr, arr, size+1));
 939         kfree(ptr);
 940 }
 941
 942 static void kasan_strings(struct kunit *test)
 943 {
 944         char *ptr;
 945         size_t size = 24;
 946
 947         /*
 948          * str* functions are not instrumented with CONFIG_AMD_MEM_ENCRYPT.
 949          * See https://bugzilla.kernel.org/show_bug.cgi?id=206337 for details.
 950          */
 951         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_AMD_MEM_ENCRYPT);
 952
 953         ptr = kmalloc(size, GFP_KERNEL | __GFP_ZERO);
 954         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 955
 956         kfree(ptr);
 957
 958         /*
 959          * Try to cause only 1 invalid access (less spam in dmesg).
 960          * For that we need ptr to point to zeroed byte.
 961          * Skip metadata that could be stored in freed object so ptr
 962          * will likely point to zeroed byte.
 963          */
 964         ptr += 16;
 965         KUNIT_EXPECT_KASAN_FAIL(test, kasan_ptr_result = strchr(ptr, '1'));
 966
 967         KUNIT_EXPECT_KASAN_FAIL(test, kasan_ptr_result = strrchr(ptr, '1'));
 968
 969         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = strcmp(ptr, "2"));
 970
 971         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = strncmp(ptr, "2", 1));
 972
 973         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = strlen(ptr));
 974
 975         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = strnlen(ptr, 1));
 976 }
 977
 978 static void kasan_bitops_modify(struct kunit *test, int nr, void *addr)
 979 {
 980         KUNIT_EXPECT_KASAN_FAIL(test, set_bit(nr, addr));
 981         KUNIT_EXPECT_KASAN_FAIL(test, __set_bit(nr, addr));
 982         KUNIT_EXPECT_KASAN_FAIL(test, clear_bit(nr, addr));
 983         KUNIT_EXPECT_KASAN_FAIL(test, __clear_bit(nr, addr));
 984         KUNIT_EXPECT_KASAN_FAIL(test, clear_bit_unlock(nr, addr));
 985         KUNIT_EXPECT_KASAN_FAIL(test, __clear_bit_unlock(nr, addr));
 986         KUNIT_EXPECT_KASAN_FAIL(test, change_bit(nr, addr));
 987         KUNIT_EXPECT_KASAN_FAIL(test, __change_bit(nr, addr));
 988 }
 989
 990 static void kasan_bitops_test_and_modify(struct kunit *test, int nr, void *addr)
 991 {
 992         KUNIT_EXPECT_KASAN_FAIL(test, test_and_set_bit(nr, addr));
 993         KUNIT_EXPECT_KASAN_FAIL(test, __test_and_set_bit(nr, addr));
 994         KUNIT_EXPECT_KASAN_FAIL(test, test_and_set_bit_lock(nr, addr));
 995         KUNIT_EXPECT_KASAN_FAIL(test, test_and_clear_bit(nr, addr));
 996         KUNIT_EXPECT_KASAN_FAIL(test, __test_and_clear_bit(nr, addr));
 997         KUNIT_EXPECT_KASAN_FAIL(test, test_and_change_bit(nr, addr));
 998         KUNIT_EXPECT_KASAN_FAIL(test, __test_and_change_bit(nr, addr));
 999         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = test_bit(nr, addr));
1000
1001 #if defined(clear_bit_unlock_is_negative_byte)
1002         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result =
1003                                 clear_bit_unlock_is_negative_byte(nr, addr));
1004 #endif
1005 }
1006
1007 static void kasan_bitops_generic(struct kunit *test)
1008 {
1009         long *bits;
1010
1011         /* This test is specifically crafted for the generic mode. */
1012         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_GENERIC);
1013
1014         /*
1015          * Allocate 1 more byte, which causes kzalloc to round up to 16 bytes;
1016          * this way we do not actually corrupt other memory.
1017          */
1018         bits = kzalloc(sizeof(*bits) + 1, GFP_KERNEL);
1019         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, bits);
1020
1021         /*
1022          * Below calls try to access bit within allocated memory; however, the
1023          * below accesses are still out-of-bounds, since bitops are defined to
1024          * operate on the whole long the bit is in.
1025          */
1026         kasan_bitops_modify(test, BITS_PER_LONG, bits);
1027
1028         /*
1029          * Below calls try to access bit beyond allocated memory.
1030          */
1031         kasan_bitops_test_and_modify(test, BITS_PER_LONG + BITS_PER_BYTE, bits);
1032
1033         kfree(bits);
1034 }
1035
1036 static void kasan_bitops_tags(struct kunit *test)
1037 {
1038         long *bits;
1039
1040         /* This test is specifically crafted for tag-based modes. */
1041         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_KASAN_GENERIC);
1042
1043         /* kmalloc-64 cache will be used and the last 16 bytes will be the redzone. */
1044         bits = kzalloc(48, GFP_KERNEL);
1045         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, bits);
1046
1047         /* Do the accesses past the 48 allocated bytes, but within the redone. */
1048         kasan_bitops_modify(test, BITS_PER_LONG, (void *)bits + 48);
1049         kasan_bitops_test_and_modify(test, BITS_PER_LONG + BITS_PER_BYTE, (void *)bits + 48);
1050
1051         kfree(bits);
1052 }
1053
1054 static void kmalloc_double_kzfree(struct kunit *test)
1055 {
1056         char *ptr;
1057         size_t size = 16;
1058
1059         ptr = kmalloc(size, GFP_KERNEL);
1060         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
1061
1062         kfree_sensitive(ptr);
1063         KUNIT_EXPECT_KASAN_FAIL(test, kfree_sensitive(ptr));
1064 }
1065
1066 static void vmalloc_helpers_tags(struct kunit *test)
1067 {
1068         void *ptr;
1069
1070         /* This test is intended for tag-based modes. */
1071         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_KASAN_GENERIC);
1072
1073         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_VMALLOC);
1074
1075         ptr = vmalloc(PAGE_SIZE);
1076         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
1077
1078         /* Check that the returned pointer is tagged. */
1079         KUNIT_EXPECT_GE(test, (u8)get_tag(ptr), (u8)KASAN_TAG_MIN);
1080         KUNIT_EXPECT_LT(test, (u8)get_tag(ptr), (u8)KASAN_TAG_KERNEL);
1081
1082         /* Make sure exported vmalloc helpers handle tagged pointers. */
1083         KUNIT_ASSERT_TRUE(test, is_vmalloc_addr(ptr));
1084         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, vmalloc_to_page(ptr));
1085
1086 #if !IS_MODULE(CONFIG_KASAN_KUNIT_TEST)
1087         {
1088                 int rv;
1089
1090                 /* Make sure vmalloc'ed memory permissions can be changed. */
1091                 rv = set_memory_ro((unsigned long)ptr, 1);
1092                 KUNIT_ASSERT_GE(test, rv, 0);
1093                 rv = set_memory_rw((unsigned long)ptr, 1);
1094                 KUNIT_ASSERT_GE(test, rv, 0);
1095         }
1096 #endif
1097
1098         vfree(ptr);
1099 }
1100
1101 static void vmalloc_oob(struct kunit *test)
1102 {
1103         char *v_ptr, *p_ptr;
1104         struct page *page;
1105         size_t size = PAGE_SIZE / 2 - KASAN_GRANULE_SIZE - 5;
1106
1107         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_VMALLOC);
1108
1109         v_ptr = vmalloc(size);
1110         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, v_ptr);
1111
1112         OPTIMIZER_HIDE_VAR(v_ptr);
1113
1114         /*
1115          * We have to be careful not to hit the guard page in vmalloc tests.
1116          * The MMU will catch that and crash us.
1117          */
1118
1119         /* Make sure in-bounds accesses are valid. */
1120         v_ptr[0] = 0;
1121         v_ptr[size - 1] = 0;
1122
1123         /*
1124          * An unaligned access past the requested vmalloc size.
1125          * Only generic KASAN can precisely detect these.
1126          */
1127         if (IS_ENABLED(CONFIG_KASAN_GENERIC))
1128                 KUNIT_EXPECT_KASAN_FAIL(test, ((volatile char *)v_ptr)[size]);
1129
1130         /* An aligned access into the first out-of-bounds granule. */
1131         KUNIT_EXPECT_KASAN_FAIL(test, ((volatile char *)v_ptr)[size + 5]);
1132
1133         /* Check that in-bounds accesses to the physical page are valid. */
1134         page = vmalloc_to_page(v_ptr);
1135         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, page);
1136         p_ptr = page_address(page);
1137         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, p_ptr);
1138         p_ptr[0] = 0;
1139
1140         vfree(v_ptr);
1141
1142         /*
1143          * We can't check for use-after-unmap bugs in this nor in the following
1144          * vmalloc tests, as the page might be fully unmapped and accessing it
1145          * will crash the kernel.
1146          */
1147 }
1148
1149 static void vmap_tags(struct kunit *test)
1150 {
1151         char *p_ptr, *v_ptr;
1152         struct page *p_page, *v_page;
1153
1154         /*
1155          * This test is specifically crafted for the software tag-based mode,
1156          * the only tag-based mode that poisons vmap mappings.
1157          */
1158         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_SW_TAGS);
1159
1160         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_VMALLOC);
1161
1162         p_page = alloc_pages(GFP_KERNEL, 1);
1163         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, p_page);
1164         p_ptr = page_address(p_page);
1165         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, p_ptr);
1166
1167         v_ptr = vmap(&p_page, 1, VM_MAP, PAGE_KERNEL);
1168         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, v_ptr);
1169
1170         /*
1171          * We can't check for out-of-bounds bugs in this nor in the following
1172          * vmalloc tests, as allocations have page granularity and accessing
1173          * the guard page will crash the kernel.
1174          */
1175
1176         KUNIT_EXPECT_GE(test, (u8)get_tag(v_ptr), (u8)KASAN_TAG_MIN);
1177         KUNIT_EXPECT_LT(test, (u8)get_tag(v_ptr), (u8)KASAN_TAG_KERNEL);
1178
1179         /* Make sure that in-bounds accesses through both pointers work. */
1180         *p_ptr = 0;
1181         *v_ptr = 0;
1182
1183         /* Make sure vmalloc_to_page() correctly recovers the page pointer. */
1184         v_page = vmalloc_to_page(v_ptr);
1185         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, v_page);
1186         KUNIT_EXPECT_PTR_EQ(test, p_page, v_page);
1187
1188         vunmap(v_ptr);
1189         free_pages((unsigned long)p_ptr, 1);
1190 }
1191
1192 static void vm_map_ram_tags(struct kunit *test)
1193 {
1194         char *p_ptr, *v_ptr;
1195         struct page *page;
1196
1197         /*
1198          * This test is specifically crafted for the software tag-based mode,
1199          * the only tag-based mode that poisons vm_map_ram mappings.
1200          */
1201         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_SW_TAGS);
1202
1203         page = alloc_pages(GFP_KERNEL, 1);
1204         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, page);
1205         p_ptr = page_address(page);
1206         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, p_ptr);
1207
1208         v_ptr = vm_map_ram(&page, 1, -1);
1209         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, v_ptr);
1210
1211         KUNIT_EXPECT_GE(test, (u8)get_tag(v_ptr), (u8)KASAN_TAG_MIN);
1212         KUNIT_EXPECT_LT(test, (u8)get_tag(v_ptr), (u8)KASAN_TAG_KERNEL);
1213
1214         /* Make sure that in-bounds accesses through both pointers work. */
1215         *p_ptr = 0;
1216         *v_ptr = 0;
1217
1218         vm_unmap_ram(v_ptr, 1);
1219         free_pages((unsigned long)p_ptr, 1);
1220 }
1221
1222 static void vmalloc_percpu(struct kunit *test)
1223 {
1224         char __percpu *ptr;
1225         int cpu;
1226
1227         /*
1228          * This test is specifically crafted for the software tag-based mode,
1229          * the only tag-based mode that poisons percpu mappings.
1230          */
1231         KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_KASAN_SW_TAGS);
1232
1233         ptr = __alloc_percpu(PAGE_SIZE, PAGE_SIZE);
1234
1235         for_each_possible_cpu(cpu) {
1236                 char *c_ptr = per_cpu_ptr(ptr, cpu);
1237
1238                 KUNIT_EXPECT_GE(test, (u8)get_tag(c_ptr), (u8)KASAN_TAG_MIN);
1239                 KUNIT_EXPECT_LT(test, (u8)get_tag(c_ptr), (u8)KASAN_TAG_KERNEL);
1240
1241                 /* Make sure that in-bounds accesses don't crash the kernel. */
1242                 *c_ptr = 0;
1243         }
1244
1245         free_percpu(ptr);
1246 }
1247
1248 /*
1249  * Check that the assigned pointer tag falls within the [KASAN_TAG_MIN,
1250  * KASAN_TAG_KERNEL) range (note: excluding the match-all tag) for tag-based
1251  * modes.
1252  */
1253 static void match_all_not_assigned(struct kunit *test)
1254 {
1255         char *ptr;
1256         struct page *pages;
1257         int i, size, order;
1258
1259         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_KASAN_GENERIC);
1260
1261         for (i = 0; i < 256; i++) {
1262                 size = (get_random_int() % 1024) + 1;
1263                 ptr = kmalloc(size, GFP_KERNEL);
1264                 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
1265                 KUNIT_EXPECT_GE(test, (u8)get_tag(ptr), (u8)KASAN_TAG_MIN);
1266                 KUNIT_EXPECT_LT(test, (u8)get_tag(ptr), (u8)KASAN_TAG_KERNEL);
1267                 kfree(ptr);
1268         }
1269
1270         for (i = 0; i < 256; i++) {
1271                 order = (get_random_int() % 4) + 1;
1272                 pages = alloc_pages(GFP_KERNEL, order);
1273                 ptr = page_address(pages);
1274                 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
1275                 KUNIT_EXPECT_GE(test, (u8)get_tag(ptr), (u8)KASAN_TAG_MIN);
1276                 KUNIT_EXPECT_LT(test, (u8)get_tag(ptr), (u8)KASAN_TAG_KERNEL);
1277                 free_pages((unsigned long)ptr, order);
1278         }
1279
1280         if (!IS_ENABLED(CONFIG_KASAN_VMALLOC))
1281                 return;
1282
1283         for (i = 0; i < 256; i++) {
1284                 size = (get_random_int() % 1024) + 1;
1285                 ptr = vmalloc(size);
1286                 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
1287                 KUNIT_EXPECT_GE(test, (u8)get_tag(ptr), (u8)KASAN_TAG_MIN);
1288                 KUNIT_EXPECT_LT(test, (u8)get_tag(ptr), (u8)KASAN_TAG_KERNEL);
1289                 vfree(ptr);
1290         }
1291 }
1292
1293 /* Check that 0xff works as a match-all pointer tag for tag-based modes. */
1294 static void match_all_ptr_tag(struct kunit *test)
1295 {
1296         char *ptr;
1297         u8 tag;
1298
1299         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_KASAN_GENERIC);
1300
1301         ptr = kmalloc(128, GFP_KERNEL);
1302         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
1303
1304         /* Backup the assigned tag. */
1305         tag = get_tag(ptr);
1306         KUNIT_EXPECT_NE(test, tag, (u8)KASAN_TAG_KERNEL);
1307
1308         /* Reset the tag to 0xff.*/
1309         ptr = set_tag(ptr, KASAN_TAG_KERNEL);
1310
1311         /* This access shouldn't trigger a KASAN report. */
1312         *ptr = 0;
1313
1314         /* Recover the pointer tag and free. */
1315         ptr = set_tag(ptr, tag);
1316         kfree(ptr);
1317 }
1318
1319 /* Check that there are no match-all memory tags for tag-based modes. */
1320 static void match_all_mem_tag(struct kunit *test)
1321 {
1322         char *ptr;
1323         int tag;
1324
1325         KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_KASAN_GENERIC);
1326
1327         ptr = kmalloc(128, GFP_KERNEL);
1328         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
1329         KUNIT_EXPECT_NE(test, (u8)get_tag(ptr), (u8)KASAN_TAG_KERNEL);
1330
1331         /* For each possible tag value not matching the pointer tag. */
1332         for (tag = KASAN_TAG_MIN; tag <= KASAN_TAG_KERNEL; tag++) {
1333                 if (tag == get_tag(ptr))
1334                         continue;
1335
1336                 /* Mark the first memory granule with the chosen memory tag. */
1337                 kasan_poison(ptr, KASAN_GRANULE_SIZE, (u8)tag, false);
1338
1339                 /* This access must cause a KASAN report. */
1340                 KUNIT_EXPECT_KASAN_FAIL(test, *ptr = 0);
1341         }
1342
1343         /* Recover the memory tag and free. */
1344         kasan_poison(ptr, KASAN_GRANULE_SIZE, get_tag(ptr), false);
1345         kfree(ptr);
1346 }
1347
1348 static struct kunit_case kasan_kunit_test_cases[] = {
1349         KUNIT_CASE(kmalloc_oob_right),
1350         KUNIT_CASE(kmalloc_oob_left),
1351         KUNIT_CASE(kmalloc_node_oob_right),
1352         KUNIT_CASE(kmalloc_pagealloc_oob_right),
1353         KUNIT_CASE(kmalloc_pagealloc_uaf),
1354         KUNIT_CASE(kmalloc_pagealloc_invalid_free),
1355         KUNIT_CASE(pagealloc_oob_right),
1356         KUNIT_CASE(pagealloc_uaf),
1357         KUNIT_CASE(kmalloc_large_oob_right),
1358         KUNIT_CASE(krealloc_more_oob),
1359         KUNIT_CASE(krealloc_less_oob),
1360         KUNIT_CASE(krealloc_pagealloc_more_oob),
1361         KUNIT_CASE(krealloc_pagealloc_less_oob),
1362         KUNIT_CASE(krealloc_uaf),
1363         KUNIT_CASE(kmalloc_oob_16),
1364         KUNIT_CASE(kmalloc_uaf_16),
1365         KUNIT_CASE(kmalloc_oob_in_memset),
1366         KUNIT_CASE(kmalloc_oob_memset_2),
1367         KUNIT_CASE(kmalloc_oob_memset_4),
1368         KUNIT_CASE(kmalloc_oob_memset_8),
1369         KUNIT_CASE(kmalloc_oob_memset_16),
1370         KUNIT_CASE(kmalloc_memmove_negative_size),
1371         KUNIT_CASE(kmalloc_memmove_invalid_size),
1372         KUNIT_CASE(kmalloc_uaf),
1373         KUNIT_CASE(kmalloc_uaf_memset),
1374         KUNIT_CASE(kmalloc_uaf2),
1375         KUNIT_CASE(kfree_via_page),
1376         KUNIT_CASE(kfree_via_phys),
1377         KUNIT_CASE(kmem_cache_oob),
1378         KUNIT_CASE(kmem_cache_accounted),
1379         KUNIT_CASE(kmem_cache_bulk),
1380         KUNIT_CASE(kasan_global_oob_right),
1381         KUNIT_CASE(kasan_global_oob_left),
1382         KUNIT_CASE(kasan_stack_oob),
1383         KUNIT_CASE(kasan_alloca_oob_left),
1384         KUNIT_CASE(kasan_alloca_oob_right),
1385         KUNIT_CASE(ksize_unpoisons_memory),
1386         KUNIT_CASE(ksize_uaf),
1387         KUNIT_CASE(kmem_cache_double_free),
1388         KUNIT_CASE(kmem_cache_invalid_free),
1389         KUNIT_CASE(kmem_cache_double_destroy),
1390         KUNIT_CASE(kasan_memchr),
1391         KUNIT_CASE(kasan_memcmp),
1392         KUNIT_CASE(kasan_strings),
1393         KUNIT_CASE(kasan_bitops_generic),
1394         KUNIT_CASE(kasan_bitops_tags),
1395         KUNIT_CASE(kmalloc_double_kzfree),
1396         KUNIT_CASE(vmalloc_helpers_tags),
1397         KUNIT_CASE(vmalloc_oob),
1398         KUNIT_CASE(vmap_tags),
1399         KUNIT_CASE(vm_map_ram_tags),
1400         KUNIT_CASE(vmalloc_percpu),
1401         KUNIT_CASE(match_all_not_assigned),
1402         KUNIT_CASE(match_all_ptr_tag),
1403         KUNIT_CASE(match_all_mem_tag),
1404         {}
1405 };
1406
1407 static struct kunit_suite kasan_kunit_test_suite = {
1408         .name = "kasan",
1409         .init = kasan_test_init,
1410         .test_cases = kasan_kunit_test_cases,
1411         .exit = kasan_test_exit,
1412 };
1413
1414 kunit_test_suite(kasan_kunit_test_suite);
1415
1416 MODULE_LICENSE("GPL");