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