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/slab.h>
  17 #include <linux/string.h>
  18 #include <linux/uaccess.h>
  19 #include <linux/io.h>
  20 #include <linux/vmalloc.h>
  21
  22 #include <asm/page.h>
  23
  24 #include <kunit/test.h>
  25
  26 #include "../mm/kasan/kasan.h"
  27
  28 #define OOB_TAG_OFF (IS_ENABLED(CONFIG_KASAN_GENERIC) ? 0 : KASAN_GRANULE_SIZE)
  29
  30 /*
  31  * Some tests use these global variables to store return values from function
  32  * calls that could otherwise be eliminated by the compiler as dead code.
  33  */
  34 void *kasan_ptr_result;
  35 int kasan_int_result;
  36
  37 static struct kunit_resource resource;
  38 static struct kunit_kasan_expectation fail_data;
  39 static bool multishot;
  40
  41 /*
  42  * Temporarily enable multi-shot mode. Otherwise, KASAN would only report the
  43  * first detected bug and panic the kernel if panic_on_warn is enabled.
  44  */
  45 static int kasan_test_init(struct kunit *test)
  46 {
  47         multishot = kasan_save_enable_multi_shot();
  48         return 0;
  49 }
  50
  51 static void kasan_test_exit(struct kunit *test)
  52 {
  53         kasan_restore_multi_shot(multishot);
  54 }
  55
  56 /**
  57  * KUNIT_EXPECT_KASAN_FAIL() - check that the executed expression produces a
  58  * KASAN report; causes a test failure otherwise. This relies on a KUnit
  59  * resource named "kasan_data". Do not use this name for KUnit resources
  60  * outside of KASAN tests.
  61  */
  62 #define KUNIT_EXPECT_KASAN_FAIL(test, expression) do { \
  63         fail_data.report_expected = true; \
  64         fail_data.report_found = false; \
  65         kunit_add_named_resource(test, \
  66                                 NULL, \
  67                                 NULL, \
  68                                 &resource, \
  69                                 "kasan_data", &fail_data); \
  70         expression; \
  71         KUNIT_EXPECT_EQ(test, \
  72                         fail_data.report_expected, \
  73                         fail_data.report_found); \
  74 } while (0)
  75
  76 static void kmalloc_oob_right(struct kunit *test)
  77 {
  78         char *ptr;
  79         size_t size = 123;
  80
  81         ptr = kmalloc(size, GFP_KERNEL);
  82         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
  83
  84         KUNIT_EXPECT_KASAN_FAIL(test, ptr[size + OOB_TAG_OFF] = 'x');
  85         kfree(ptr);
  86 }
  87
  88 static void kmalloc_oob_left(struct kunit *test)
  89 {
  90         char *ptr;
  91         size_t size = 15;
  92
  93         ptr = kmalloc(size, GFP_KERNEL);
  94         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
  95
  96         KUNIT_EXPECT_KASAN_FAIL(test, *ptr = *(ptr - 1));
  97         kfree(ptr);
  98 }
  99
 100 static void kmalloc_node_oob_right(struct kunit *test)
 101 {
 102         char *ptr;
 103         size_t size = 4096;
 104
 105         ptr = kmalloc_node(size, GFP_KERNEL, 0);
 106         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 107
 108         KUNIT_EXPECT_KASAN_FAIL(test, ptr[size] = 0);
 109         kfree(ptr);
 110 }
 111
 112 static void kmalloc_pagealloc_oob_right(struct kunit *test)
 113 {
 114         char *ptr;
 115         size_t size = KMALLOC_MAX_CACHE_SIZE + 10;
 116
 117         if (!IS_ENABLED(CONFIG_SLUB)) {
 118                 kunit_info(test, "CONFIG_SLUB is not enabled.");
 119                 return;
 120         }
 121
 122         /*
 123          * Allocate a chunk that does not fit into a SLUB cache to trigger
 124          * the page allocator fallback.
 125          */
 126         ptr = kmalloc(size, GFP_KERNEL);
 127         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 128
 129         KUNIT_EXPECT_KASAN_FAIL(test, ptr[size + OOB_TAG_OFF] = 0);
 130         kfree(ptr);
 131 }
 132
 133 static void kmalloc_pagealloc_uaf(struct kunit *test)
 134 {
 135         char *ptr;
 136         size_t size = KMALLOC_MAX_CACHE_SIZE + 10;
 137
 138         if (!IS_ENABLED(CONFIG_SLUB)) {
 139                 kunit_info(test, "CONFIG_SLUB is not enabled.");
 140                 return;
 141         }
 142
 143         ptr = kmalloc(size, GFP_KERNEL);
 144         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 145
 146         kfree(ptr);
 147         KUNIT_EXPECT_KASAN_FAIL(test, ptr[0] = 0);
 148 }
 149
 150 static void kmalloc_pagealloc_invalid_free(struct kunit *test)
 151 {
 152         char *ptr;
 153         size_t size = KMALLOC_MAX_CACHE_SIZE + 10;
 154
 155         if (!IS_ENABLED(CONFIG_SLUB)) {
 156                 kunit_info(test, "CONFIG_SLUB is not enabled.");
 157                 return;
 158         }
 159
 160         ptr = kmalloc(size, GFP_KERNEL);
 161         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 162
 163         KUNIT_EXPECT_KASAN_FAIL(test, kfree(ptr + 1));
 164 }
 165
 166 static void kmalloc_large_oob_right(struct kunit *test)
 167 {
 168         char *ptr;
 169         size_t size = KMALLOC_MAX_CACHE_SIZE - 256;
 170
 171         /*
 172          * Allocate a chunk that is large enough, but still fits into a slab
 173          * and does not trigger the page allocator fallback in SLUB.
 174          */
 175         ptr = kmalloc(size, GFP_KERNEL);
 176         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 177
 178         KUNIT_EXPECT_KASAN_FAIL(test, ptr[size] = 0);
 179         kfree(ptr);
 180 }
 181
 182 static void kmalloc_oob_krealloc_more(struct kunit *test)
 183 {
 184         char *ptr1, *ptr2;
 185         size_t size1 = 17;
 186         size_t size2 = 19;
 187
 188         ptr1 = kmalloc(size1, GFP_KERNEL);
 189         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
 190
 191         ptr2 = krealloc(ptr1, size2, GFP_KERNEL);
 192         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr2);
 193
 194         KUNIT_EXPECT_KASAN_FAIL(test, ptr2[size2 + OOB_TAG_OFF] = 'x');
 195         kfree(ptr2);
 196 }
 197
 198 static void kmalloc_oob_krealloc_less(struct kunit *test)
 199 {
 200         char *ptr1, *ptr2;
 201         size_t size1 = 17;
 202         size_t size2 = 15;
 203
 204         ptr1 = kmalloc(size1, GFP_KERNEL);
 205         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
 206
 207         ptr2 = krealloc(ptr1, size2, GFP_KERNEL);
 208         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr2);
 209
 210         KUNIT_EXPECT_KASAN_FAIL(test, ptr2[size2 + OOB_TAG_OFF] = 'x');
 211         kfree(ptr2);
 212 }
 213
 214 static void kmalloc_oob_16(struct kunit *test)
 215 {
 216         struct {
 217                 u64 words[2];
 218         } *ptr1, *ptr2;
 219
 220         /* This test is specifically crafted for the generic mode. */
 221         if (!IS_ENABLED(CONFIG_KASAN_GENERIC)) {
 222                 kunit_info(test, "CONFIG_KASAN_GENERIC required\n");
 223                 return;
 224         }
 225
 226         ptr1 = kmalloc(sizeof(*ptr1) - 3, GFP_KERNEL);
 227         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
 228
 229         ptr2 = kmalloc(sizeof(*ptr2), GFP_KERNEL);
 230         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr2);
 231
 232         KUNIT_EXPECT_KASAN_FAIL(test, *ptr1 = *ptr2);
 233         kfree(ptr1);
 234         kfree(ptr2);
 235 }
 236
 237 static void kmalloc_uaf_16(struct kunit *test)
 238 {
 239         struct {
 240                 u64 words[2];
 241         } *ptr1, *ptr2;
 242
 243         ptr1 = kmalloc(sizeof(*ptr1), GFP_KERNEL);
 244         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
 245
 246         ptr2 = kmalloc(sizeof(*ptr2), GFP_KERNEL);
 247         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr2);
 248         kfree(ptr2);
 249
 250         KUNIT_EXPECT_KASAN_FAIL(test, *ptr1 = *ptr2);
 251         kfree(ptr1);
 252 }
 253
 254 static void kmalloc_oob_memset_2(struct kunit *test)
 255 {
 256         char *ptr;
 257         size_t size = 8;
 258
 259         ptr = kmalloc(size, GFP_KERNEL);
 260         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 261
 262         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr + 7 + OOB_TAG_OFF, 0, 2));
 263         kfree(ptr);
 264 }
 265
 266 static void kmalloc_oob_memset_4(struct kunit *test)
 267 {
 268         char *ptr;
 269         size_t size = 8;
 270
 271         ptr = kmalloc(size, GFP_KERNEL);
 272         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 273
 274         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr + 5 + OOB_TAG_OFF, 0, 4));
 275         kfree(ptr);
 276 }
 277
 278
 279 static void kmalloc_oob_memset_8(struct kunit *test)
 280 {
 281         char *ptr;
 282         size_t size = 8;
 283
 284         ptr = kmalloc(size, GFP_KERNEL);
 285         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 286
 287         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr + 1 + OOB_TAG_OFF, 0, 8));
 288         kfree(ptr);
 289 }
 290
 291 static void kmalloc_oob_memset_16(struct kunit *test)
 292 {
 293         char *ptr;
 294         size_t size = 16;
 295
 296         ptr = kmalloc(size, GFP_KERNEL);
 297         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 298
 299         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr + 1 + OOB_TAG_OFF, 0, 16));
 300         kfree(ptr);
 301 }
 302
 303 static void kmalloc_oob_in_memset(struct kunit *test)
 304 {
 305         char *ptr;
 306         size_t size = 666;
 307
 308         ptr = kmalloc(size, GFP_KERNEL);
 309         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 310
 311         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr, 0, size + 5 + OOB_TAG_OFF));
 312         kfree(ptr);
 313 }
 314
 315 static void kmalloc_memmove_invalid_size(struct kunit *test)
 316 {
 317         char *ptr;
 318         size_t size = 64;
 319         volatile size_t invalid_size = -2;
 320
 321         ptr = kmalloc(size, GFP_KERNEL);
 322         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 323
 324         memset((char *)ptr, 0, 64);
 325
 326         KUNIT_EXPECT_KASAN_FAIL(test,
 327                 memmove((char *)ptr, (char *)ptr + 4, invalid_size));
 328         kfree(ptr);
 329 }
 330
 331 static void kmalloc_uaf(struct kunit *test)
 332 {
 333         char *ptr;
 334         size_t size = 10;
 335
 336         ptr = kmalloc(size, GFP_KERNEL);
 337         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 338
 339         kfree(ptr);
 340         KUNIT_EXPECT_KASAN_FAIL(test, *(ptr + 8) = 'x');
 341 }
 342
 343 static void kmalloc_uaf_memset(struct kunit *test)
 344 {
 345         char *ptr;
 346         size_t size = 33;
 347
 348         ptr = kmalloc(size, GFP_KERNEL);
 349         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 350
 351         kfree(ptr);
 352         KUNIT_EXPECT_KASAN_FAIL(test, memset(ptr, 0, size));
 353 }
 354
 355 static void kmalloc_uaf2(struct kunit *test)
 356 {
 357         char *ptr1, *ptr2;
 358         size_t size = 43;
 359
 360         ptr1 = kmalloc(size, GFP_KERNEL);
 361         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr1);
 362
 363         kfree(ptr1);
 364
 365         ptr2 = kmalloc(size, GFP_KERNEL);
 366         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr2);
 367
 368         KUNIT_EXPECT_KASAN_FAIL(test, ptr1[40] = 'x');
 369         KUNIT_EXPECT_PTR_NE(test, ptr1, ptr2);
 370
 371         kfree(ptr2);
 372 }
 373
 374 static void kfree_via_page(struct kunit *test)
 375 {
 376         char *ptr;
 377         size_t size = 8;
 378         struct page *page;
 379         unsigned long offset;
 380
 381         ptr = kmalloc(size, GFP_KERNEL);
 382         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 383
 384         page = virt_to_page(ptr);
 385         offset = offset_in_page(ptr);
 386         kfree(page_address(page) + offset);
 387 }
 388
 389 static void kfree_via_phys(struct kunit *test)
 390 {
 391         char *ptr;
 392         size_t size = 8;
 393         phys_addr_t phys;
 394
 395         ptr = kmalloc(size, GFP_KERNEL);
 396         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 397
 398         phys = virt_to_phys(ptr);
 399         kfree(phys_to_virt(phys));
 400 }
 401
 402 static void kmem_cache_oob(struct kunit *test)
 403 {
 404         char *p;
 405         size_t size = 200;
 406         struct kmem_cache *cache = kmem_cache_create("test_cache",
 407                                                 size, 0,
 408                                                 0, NULL);
 409         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 410         p = kmem_cache_alloc(cache, GFP_KERNEL);
 411         if (!p) {
 412                 kunit_err(test, "Allocation failed: %s\n", __func__);
 413                 kmem_cache_destroy(cache);
 414                 return;
 415         }
 416
 417         KUNIT_EXPECT_KASAN_FAIL(test, *p = p[size + OOB_TAG_OFF]);
 418         kmem_cache_free(cache, p);
 419         kmem_cache_destroy(cache);
 420 }
 421
 422 static void memcg_accounted_kmem_cache(struct kunit *test)
 423 {
 424         int i;
 425         char *p;
 426         size_t size = 200;
 427         struct kmem_cache *cache;
 428
 429         cache = kmem_cache_create("test_cache", size, 0, SLAB_ACCOUNT, NULL);
 430         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 431
 432         /*
 433          * Several allocations with a delay to allow for lazy per memcg kmem
 434          * cache creation.
 435          */
 436         for (i = 0; i < 5; i++) {
 437                 p = kmem_cache_alloc(cache, GFP_KERNEL);
 438                 if (!p)
 439                         goto free_cache;
 440
 441                 kmem_cache_free(cache, p);
 442                 msleep(100);
 443         }
 444
 445 free_cache:
 446         kmem_cache_destroy(cache);
 447 }
 448
 449 static char global_array[10];
 450
 451 static void kasan_global_oob(struct kunit *test)
 452 {
 453         volatile int i = 3;
 454         char *p = &global_array[ARRAY_SIZE(global_array) + i];
 455
 456         /* Only generic mode instruments globals. */
 457         if (!IS_ENABLED(CONFIG_KASAN_GENERIC)) {
 458                 kunit_info(test, "CONFIG_KASAN_GENERIC required");
 459                 return;
 460         }
 461
 462         KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)p);
 463 }
 464
 465 static void ksize_unpoisons_memory(struct kunit *test)
 466 {
 467         char *ptr;
 468         size_t size = 123, real_size;
 469
 470         ptr = kmalloc(size, GFP_KERNEL);
 471         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 472         real_size = ksize(ptr);
 473
 474         /* This access shouldn't trigger a KASAN report. */
 475         ptr[size] = 'x';
 476
 477         /* This one must. */
 478         KUNIT_EXPECT_KASAN_FAIL(test, ptr[real_size] = 'y');
 479
 480         kfree(ptr);
 481 }
 482
 483 static void kasan_stack_oob(struct kunit *test)
 484 {
 485         char stack_array[10];
 486         volatile int i = OOB_TAG_OFF;
 487         char *p = &stack_array[ARRAY_SIZE(stack_array) + i];
 488
 489         if (!IS_ENABLED(CONFIG_KASAN_STACK)) {
 490                 kunit_info(test, "CONFIG_KASAN_STACK is not enabled");
 491                 return;
 492         }
 493
 494         KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)p);
 495 }
 496
 497 static void kasan_alloca_oob_left(struct kunit *test)
 498 {
 499         volatile int i = 10;
 500         char alloca_array[i];
 501         char *p = alloca_array - 1;
 502
 503         /* Only generic mode instruments dynamic allocas. */
 504         if (!IS_ENABLED(CONFIG_KASAN_GENERIC)) {
 505                 kunit_info(test, "CONFIG_KASAN_GENERIC required");
 506                 return;
 507         }
 508
 509         if (!IS_ENABLED(CONFIG_KASAN_STACK)) {
 510                 kunit_info(test, "CONFIG_KASAN_STACK is not enabled");
 511                 return;
 512         }
 513
 514         KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)p);
 515 }
 516
 517 static void kasan_alloca_oob_right(struct kunit *test)
 518 {
 519         volatile int i = 10;
 520         char alloca_array[i];
 521         char *p = alloca_array + i;
 522
 523         /* Only generic mode instruments dynamic allocas. */
 524         if (!IS_ENABLED(CONFIG_KASAN_GENERIC)) {
 525                 kunit_info(test, "CONFIG_KASAN_GENERIC required");
 526                 return;
 527         }
 528
 529         if (!IS_ENABLED(CONFIG_KASAN_STACK)) {
 530                 kunit_info(test, "CONFIG_KASAN_STACK is not enabled");
 531                 return;
 532         }
 533
 534         KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)p);
 535 }
 536
 537 static void kmem_cache_double_free(struct kunit *test)
 538 {
 539         char *p;
 540         size_t size = 200;
 541         struct kmem_cache *cache;
 542
 543         cache = kmem_cache_create("test_cache", size, 0, 0, NULL);
 544         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 545
 546         p = kmem_cache_alloc(cache, GFP_KERNEL);
 547         if (!p) {
 548                 kunit_err(test, "Allocation failed: %s\n", __func__);
 549                 kmem_cache_destroy(cache);
 550                 return;
 551         }
 552
 553         kmem_cache_free(cache, p);
 554         KUNIT_EXPECT_KASAN_FAIL(test, kmem_cache_free(cache, p));
 555         kmem_cache_destroy(cache);
 556 }
 557
 558 static void kmem_cache_invalid_free(struct kunit *test)
 559 {
 560         char *p;
 561         size_t size = 200;
 562         struct kmem_cache *cache;
 563
 564         cache = kmem_cache_create("test_cache", size, 0, SLAB_TYPESAFE_BY_RCU,
 565                                   NULL);
 566         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cache);
 567
 568         p = kmem_cache_alloc(cache, GFP_KERNEL);
 569         if (!p) {
 570                 kunit_err(test, "Allocation failed: %s\n", __func__);
 571                 kmem_cache_destroy(cache);
 572                 return;
 573         }
 574
 575         /* Trigger invalid free, the object doesn't get freed. */
 576         KUNIT_EXPECT_KASAN_FAIL(test, kmem_cache_free(cache, p + 1));
 577
 578         /*
 579          * Properly free the object to prevent the "Objects remaining in
 580          * test_cache on __kmem_cache_shutdown" BUG failure.
 581          */
 582         kmem_cache_free(cache, p);
 583
 584         kmem_cache_destroy(cache);
 585 }
 586
 587 static void kasan_memchr(struct kunit *test)
 588 {
 589         char *ptr;
 590         size_t size = 24;
 591
 592         /*
 593          * str* functions are not instrumented with CONFIG_AMD_MEM_ENCRYPT.
 594          * See https://bugzilla.kernel.org/show_bug.cgi?id=206337 for details.
 595          */
 596         if (IS_ENABLED(CONFIG_AMD_MEM_ENCRYPT)) {
 597                 kunit_info(test,
 598                         "str* functions are not instrumented with CONFIG_AMD_MEM_ENCRYPT");
 599                 return;
 600         }
 601
 602         if (OOB_TAG_OFF)
 603                 size = round_up(size, OOB_TAG_OFF);
 604
 605         ptr = kmalloc(size, GFP_KERNEL | __GFP_ZERO);
 606         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 607
 608         KUNIT_EXPECT_KASAN_FAIL(test,
 609                 kasan_ptr_result = memchr(ptr, '1', size + 1));
 610
 611         kfree(ptr);
 612 }
 613
 614 static void kasan_memcmp(struct kunit *test)
 615 {
 616         char *ptr;
 617         size_t size = 24;
 618         int arr[9];
 619
 620         /*
 621          * str* functions are not instrumented with CONFIG_AMD_MEM_ENCRYPT.
 622          * See https://bugzilla.kernel.org/show_bug.cgi?id=206337 for details.
 623          */
 624         if (IS_ENABLED(CONFIG_AMD_MEM_ENCRYPT)) {
 625                 kunit_info(test,
 626                         "str* functions are not instrumented with CONFIG_AMD_MEM_ENCRYPT");
 627                 return;
 628         }
 629
 630         if (OOB_TAG_OFF)
 631                 size = round_up(size, OOB_TAG_OFF);
 632
 633         ptr = kmalloc(size, GFP_KERNEL | __GFP_ZERO);
 634         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 635         memset(arr, 0, sizeof(arr));
 636
 637         KUNIT_EXPECT_KASAN_FAIL(test,
 638                 kasan_int_result = memcmp(ptr, arr, size+1));
 639         kfree(ptr);
 640 }
 641
 642 static void kasan_strings(struct kunit *test)
 643 {
 644         char *ptr;
 645         size_t size = 24;
 646
 647         /*
 648          * str* functions are not instrumented with CONFIG_AMD_MEM_ENCRYPT.
 649          * See https://bugzilla.kernel.org/show_bug.cgi?id=206337 for details.
 650          */
 651         if (IS_ENABLED(CONFIG_AMD_MEM_ENCRYPT)) {
 652                 kunit_info(test,
 653                         "str* functions are not instrumented with CONFIG_AMD_MEM_ENCRYPT");
 654                 return;
 655         }
 656
 657         ptr = kmalloc(size, GFP_KERNEL | __GFP_ZERO);
 658         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 659
 660         kfree(ptr);
 661
 662         /*
 663          * Try to cause only 1 invalid access (less spam in dmesg).
 664          * For that we need ptr to point to zeroed byte.
 665          * Skip metadata that could be stored in freed object so ptr
 666          * will likely point to zeroed byte.
 667          */
 668         ptr += 16;
 669         KUNIT_EXPECT_KASAN_FAIL(test, kasan_ptr_result = strchr(ptr, '1'));
 670
 671         KUNIT_EXPECT_KASAN_FAIL(test, kasan_ptr_result = strrchr(ptr, '1'));
 672
 673         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = strcmp(ptr, "2"));
 674
 675         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = strncmp(ptr, "2", 1));
 676
 677         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = strlen(ptr));
 678
 679         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = strnlen(ptr, 1));
 680 }
 681
 682 static void kasan_bitops_modify(struct kunit *test, int nr, void *addr)
 683 {
 684         KUNIT_EXPECT_KASAN_FAIL(test, set_bit(nr, addr));
 685         KUNIT_EXPECT_KASAN_FAIL(test, __set_bit(nr, addr));
 686         KUNIT_EXPECT_KASAN_FAIL(test, clear_bit(nr, addr));
 687         KUNIT_EXPECT_KASAN_FAIL(test, __clear_bit(nr, addr));
 688         KUNIT_EXPECT_KASAN_FAIL(test, clear_bit_unlock(nr, addr));
 689         KUNIT_EXPECT_KASAN_FAIL(test, __clear_bit_unlock(nr, addr));
 690         KUNIT_EXPECT_KASAN_FAIL(test, change_bit(nr, addr));
 691         KUNIT_EXPECT_KASAN_FAIL(test, __change_bit(nr, addr));
 692 }
 693
 694 static void kasan_bitops_test_and_modify(struct kunit *test, int nr, void *addr)
 695 {
 696         KUNIT_EXPECT_KASAN_FAIL(test, test_and_set_bit(nr, addr));
 697         KUNIT_EXPECT_KASAN_FAIL(test, __test_and_set_bit(nr, addr));
 698         KUNIT_EXPECT_KASAN_FAIL(test, test_and_set_bit_lock(nr, addr));
 699         KUNIT_EXPECT_KASAN_FAIL(test, test_and_clear_bit(nr, addr));
 700         KUNIT_EXPECT_KASAN_FAIL(test, __test_and_clear_bit(nr, addr));
 701         KUNIT_EXPECT_KASAN_FAIL(test, test_and_change_bit(nr, addr));
 702         KUNIT_EXPECT_KASAN_FAIL(test, __test_and_change_bit(nr, addr));
 703         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result = test_bit(nr, addr));
 704
 705 #if defined(clear_bit_unlock_is_negative_byte)
 706         KUNIT_EXPECT_KASAN_FAIL(test, kasan_int_result =
 707                                 clear_bit_unlock_is_negative_byte(nr, addr));
 708 #endif
 709 }
 710
 711 static void kasan_bitops_generic(struct kunit *test)
 712 {
 713         long *bits;
 714
 715         /* This test is specifically crafted for the generic mode. */
 716         if (!IS_ENABLED(CONFIG_KASAN_GENERIC)) {
 717                 kunit_info(test, "CONFIG_KASAN_GENERIC required\n");
 718                 return;
 719         }
 720
 721         /*
 722          * Allocate 1 more byte, which causes kzalloc to round up to 16 bytes;
 723          * this way we do not actually corrupt other memory.
 724          */
 725         bits = kzalloc(sizeof(*bits) + 1, GFP_KERNEL);
 726         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, bits);
 727
 728         /*
 729          * Below calls try to access bit within allocated memory; however, the
 730          * below accesses are still out-of-bounds, since bitops are defined to
 731          * operate on the whole long the bit is in.
 732          */
 733         kasan_bitops_modify(test, BITS_PER_LONG, bits);
 734
 735         /*
 736          * Below calls try to access bit beyond allocated memory.
 737          */
 738         kasan_bitops_test_and_modify(test, BITS_PER_LONG + BITS_PER_BYTE, bits);
 739
 740         kfree(bits);
 741 }
 742
 743 static void kasan_bitops_tags(struct kunit *test)
 744 {
 745         long *bits;
 746
 747         /* This test is specifically crafted for the tag-based mode. */
 748         if (IS_ENABLED(CONFIG_KASAN_GENERIC)) {
 749                 kunit_info(test, "CONFIG_KASAN_SW_TAGS required\n");
 750                 return;
 751         }
 752
 753         /* Allocation size will be rounded to up granule size, which is 16. */
 754         bits = kzalloc(sizeof(*bits), GFP_KERNEL);
 755         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, bits);
 756
 757         /* Do the accesses past the 16 allocated bytes. */
 758         kasan_bitops_modify(test, BITS_PER_LONG, &bits[1]);
 759         kasan_bitops_test_and_modify(test, BITS_PER_LONG + BITS_PER_BYTE, &bits[1]);
 760
 761         kfree(bits);
 762 }
 763
 764 static void kmalloc_double_kzfree(struct kunit *test)
 765 {
 766         char *ptr;
 767         size_t size = 16;
 768
 769         ptr = kmalloc(size, GFP_KERNEL);
 770         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
 771
 772         kfree_sensitive(ptr);
 773         KUNIT_EXPECT_KASAN_FAIL(test, kfree_sensitive(ptr));
 774 }
 775
 776 static void vmalloc_oob(struct kunit *test)
 777 {
 778         void *area;
 779
 780         if (!IS_ENABLED(CONFIG_KASAN_VMALLOC)) {
 781                 kunit_info(test, "CONFIG_KASAN_VMALLOC is not enabled.");
 782                 return;
 783         }
 784
 785         /*
 786          * We have to be careful not to hit the guard page.
 787          * The MMU will catch that and crash us.
 788          */
 789         area = vmalloc(3000);
 790         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, area);
 791
 792         KUNIT_EXPECT_KASAN_FAIL(test, ((volatile char *)area)[3100]);
 793         vfree(area);
 794 }
 795
 796 static struct kunit_case kasan_kunit_test_cases[] = {
 797         KUNIT_CASE(kmalloc_oob_right),
 798         KUNIT_CASE(kmalloc_oob_left),
 799         KUNIT_CASE(kmalloc_node_oob_right),
 800         KUNIT_CASE(kmalloc_pagealloc_oob_right),
 801         KUNIT_CASE(kmalloc_pagealloc_uaf),
 802         KUNIT_CASE(kmalloc_pagealloc_invalid_free),
 803         KUNIT_CASE(kmalloc_large_oob_right),
 804         KUNIT_CASE(kmalloc_oob_krealloc_more),
 805         KUNIT_CASE(kmalloc_oob_krealloc_less),
 806         KUNIT_CASE(kmalloc_oob_16),
 807         KUNIT_CASE(kmalloc_uaf_16),
 808         KUNIT_CASE(kmalloc_oob_in_memset),
 809         KUNIT_CASE(kmalloc_oob_memset_2),
 810         KUNIT_CASE(kmalloc_oob_memset_4),
 811         KUNIT_CASE(kmalloc_oob_memset_8),
 812         KUNIT_CASE(kmalloc_oob_memset_16),
 813         KUNIT_CASE(kmalloc_memmove_invalid_size),
 814         KUNIT_CASE(kmalloc_uaf),
 815         KUNIT_CASE(kmalloc_uaf_memset),
 816         KUNIT_CASE(kmalloc_uaf2),
 817         KUNIT_CASE(kfree_via_page),
 818         KUNIT_CASE(kfree_via_phys),
 819         KUNIT_CASE(kmem_cache_oob),
 820         KUNIT_CASE(memcg_accounted_kmem_cache),
 821         KUNIT_CASE(kasan_global_oob),
 822         KUNIT_CASE(kasan_stack_oob),
 823         KUNIT_CASE(kasan_alloca_oob_left),
 824         KUNIT_CASE(kasan_alloca_oob_right),
 825         KUNIT_CASE(ksize_unpoisons_memory),
 826         KUNIT_CASE(kmem_cache_double_free),
 827         KUNIT_CASE(kmem_cache_invalid_free),
 828         KUNIT_CASE(kasan_memchr),
 829         KUNIT_CASE(kasan_memcmp),
 830         KUNIT_CASE(kasan_strings),
 831         KUNIT_CASE(kasan_bitops_generic),
 832         KUNIT_CASE(kasan_bitops_tags),
 833         KUNIT_CASE(kmalloc_double_kzfree),
 834         KUNIT_CASE(vmalloc_oob),
 835         {}
 836 };
 837
 838 static struct kunit_suite kasan_kunit_test_suite = {
 839         .name = "kasan",
 840         .init = kasan_test_init,
 841         .test_cases = kasan_kunit_test_cases,
 842         .exit = kasan_test_exit,
 843 };
 844
 845 kunit_test_suite(kasan_kunit_test_suite);
 846
 847 MODULE_LICENSE("GPL");