// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
/*
* Tests validating that KASAN reports are properly instrumented and
* generated on a wide variety of instructions. The running kernel needs
* kasan_multi_shot to run multiple kasan-generating subtests at once
*/
#include <bpf/bpf.h>
#include <errno.h>
#include <fcntl.h>
#include <linux/if_ether.h>
#include <unistd.h>
#include <test_progs.h>
#include <unpriv_helpers.h>
#include "sysctl_helpers.h"
#include "kasan.skel.h"
#include "kasan_harden.skel.h"
#define SUBTEST_NAME_MAX_LEN 128
#define PROG_NAME_MAX_LEN 128
#define MAX_LOG_SIZE (8 * 1024)
#define READ_CHUNK_SIZE 256
#define KASAN_PATTERN_SLAB_UAF "BUG: KASAN: slab-use-after-free " \
"in bpf_prog_%02x%02x%02x%02x%02x%02x%02x%02x_%s"
#define KASAN_PATTERN_SLAB_OOB "BUG: KASAN: slab-out-of-bounds " \
"in bpf_prog_%02x%02x%02x%02x%02x%02x%02x%02x_%s"
#define KASAN_PATTERN_REPORT "%s of size %d at addr"
static char klog_buffer[MAX_LOG_SIZE];
static char record[MAX_LOG_SIZE];
struct test_spec {
char *prog_type;
bool is_write;
bool only_32_or_64;
bool needs_load_acq_store_rel;
bool needs_st;
bool skip_multi_size_testing;
bool skip_on_stack_testing;
int run_size;
bool expect_no_report;
bool rnd_hi32;
bool is_oob;
};
struct kasan_write_val {
__u8 data_1;
__u16 data_2;
__u32 data_4;
__u64 data_8;
};
struct test_ctx {
__u8 prog_tag[BPF_TAG_SIZE];
struct bpf_object *obj;
int *access_size;
bool skip_load_acq_store_rel;
bool skip_st_tests;
struct bpf_program *prog;
char prog_name[SUBTEST_NAME_MAX_LEN];
int klog_fd;
};
static int open_kernel_logs(void)
{
int fd;
fd = open("/dev/kmsg", O_RDONLY | O_NONBLOCK);
return fd;
}
static void skip_kernel_logs(int fd)
{
lseek(fd, 0, SEEK_END);
}
static int read_kernel_logs(int fd, char *buf, size_t max_len)
{
size_t total = 0;
ssize_t n;
buf[0] = '\0';
while (1) {
char *msg, *eol;
size_t len;
n = read(fd, record, sizeof(record) - 1);
if (n == 0)
break;
if (n < 0) {
if (errno == EAGAIN)
break;
return n;
}
record[n] = '\0';
/*
* Each kmsg record starts with some metadata, separated
* from the actual content by a semi-colon
*/
msg = strchr(record, ';');
if (!msg)
continue;
msg++;
eol = strchr(msg, '\n');
if (eol)
*eol = '\0';
len = strlen(msg);
if (total + len + 2 > max_len)
break;
memcpy(buf + total, msg, len);
total += len;
buf[total++] = '\n';
buf[total] = '\0';
}
return total;
}
static int check_kasan_report_in_kernel_logs(char *buf, struct test_ctx *ctx,
bool is_write, int size,
bool is_oob)
{
char access_log[READ_CHUNK_SIZE];
const char *pattern;
char *kasan_report_start;
int nsize;
pattern = is_oob ? KASAN_PATTERN_SLAB_OOB : KASAN_PATTERN_SLAB_UAF;
nsize = snprintf(access_log, READ_CHUNK_SIZE, pattern,
ctx->prog_tag[0], ctx->prog_tag[1], ctx->prog_tag[2],
ctx->prog_tag[3], ctx->prog_tag[4], ctx->prog_tag[5],
ctx->prog_tag[6], ctx->prog_tag[7], ctx->prog_name);
if (!ASSERT_GE(nsize, 0, "format kasan access header line"))
return nsize;
/*
* Searched kasan report is valid if
* - it contains the expected kasan pattern
* - the description of the faulty access is found somewhere
* after the header (not necessarily on the very next line,
* because other kernel messages may interleave)
* - faulty access properties match the tested type and size
*/
kasan_report_start = strstr(buf, access_log);
if (!kasan_report_start)
return 1;
nsize = snprintf(access_log, READ_CHUNK_SIZE, KASAN_PATTERN_REPORT,
is_write ? "Write" : "Read", size);
if (!ASSERT_GE(nsize, 0, "format kasan access report line"))
return nsize;
if (!strstr(kasan_report_start, access_log))
return 1;
return 0;
}
static void exec_subtest(struct test_ctx *ctx, struct test_spec *test,
int access_size, bool on_stack)
{
LIBBPF_OPTS(bpf_test_run_opts, topts);
struct bpf_prog_info info;
uint8_t buf[ETH_HLEN] = {0};
int ret, prog_fd;
__u32 info_len;
ctx->prog = bpf_object__find_program_by_name(ctx->obj,
ctx->prog_name);
if (!ASSERT_OK_PTR(ctx->prog, "find test prog"))
return;
info_len = sizeof(info);
memset(&info, 0, info_len);
prog_fd = bpf_program__fd(ctx->prog);
if (!ASSERT_OK_FD(prog_fd, "get prog fd"))
return;
ret = bpf_prog_get_info_by_fd(prog_fd, &info, &info_len);
if (!ASSERT_OK(ret, "fetch loaded program info"))
return;
memcpy(ctx->prog_tag, info.tag, BPF_TAG_SIZE);
skip_kernel_logs(ctx->klog_fd);
topts.sz = sizeof(struct bpf_test_run_opts);
topts.data_size_in = ETH_HLEN;
topts.data_in = buf;
if (ctx->access_size)
*ctx->access_size = access_size;
ret = bpf_prog_test_run_opts(bpf_program__fd(ctx->prog),
&topts);
if (!ASSERT_OK(ret, "run prog"))
return;
ret = read_kernel_logs(ctx->klog_fd, klog_buffer, MAX_LOG_SIZE);
if (!ASSERT_GE(ret, 0, "read kernel logs"))
return;
ret = check_kasan_report_in_kernel_logs(klog_buffer, ctx,
test->is_write, access_size,
test->is_oob);
if (on_stack || test->expect_no_report)
ASSERT_NEQ(ret, 0, "no report should be generated");
else
ASSERT_OK(ret, "report should be generated");
}
static void run_subtest_with_size_and_location(struct test_ctx *ctx,
struct test_spec *test,
int access_size,
bool on_stack)
{
char subtest_name[SUBTEST_NAME_MAX_LEN];
if (test->skip_multi_size_testing) {
snprintf(subtest_name, SUBTEST_NAME_MAX_LEN, "%s%s",
test->prog_type,
test->skip_on_stack_testing ? "" :
on_stack ? "_on_stack" :
"_not_on_stack");
} else {
snprintf(subtest_name, SUBTEST_NAME_MAX_LEN, "%s_%d_%s",
test->prog_type, access_size,
on_stack ? "on_stack" : "not_on_stack");
}
snprintf(ctx->prog_name, PROG_NAME_MAX_LEN, "%s%s", test->prog_type,
test->skip_on_stack_testing ? "" :
on_stack ? "_on_stack" :
"_not_on_stack");
if (!test__start_subtest(subtest_name))
return;
if (test->needs_load_acq_store_rel && ctx->skip_load_acq_store_rel) {
test__skip();
return;
}
if (test->needs_st && ctx->skip_st_tests) {
test__skip();
return;
}
exec_subtest(ctx, test, access_size, on_stack);
}
static void run_subtest_with_size(struct test_ctx *ctx, struct test_spec *test,
int size)
{
run_subtest_with_size_and_location(ctx, test, size, false);
if (!test->skip_on_stack_testing)
run_subtest_with_size_and_location(ctx, test, size, true);
}
static void run_subtest(struct test_ctx *ctx, struct test_spec *test)
{
if (test->skip_multi_size_testing) {
run_subtest_with_size(ctx, test, test->run_size);
return;
}
if (!test->only_32_or_64) {
run_subtest_with_size(ctx, test, 1);
run_subtest_with_size(ctx, test, 2);
}
run_subtest_with_size(ctx, test, 4);
run_subtest_with_size(ctx, test, 8);
}
static void run_blinding_subtest(void)
{
struct test_spec blinding_spec = {
.prog_type = "st_blinded",
.is_write = true,
};
char bpf_jit_harden_orig[2];
struct kasan_harden *skel;
struct test_ctx *ctx;
if (!test__start_subtest("st_blinded"))
return;
ctx = calloc(1, sizeof(*ctx));
if (!ASSERT_OK_PTR(ctx, "alloc blinding ctx"))
return;
ctx->klog_fd = -1;
if (sysctl_set_or_fail("/proc/sys/net/core/bpf_jit_harden",
bpf_jit_harden_orig, "2"))
goto free_ctx;
skel = kasan_harden__open_and_load();
if (!ASSERT_OK_PTR(skel, "open and load blinded prog"))
goto restore;
if (skel->data->skip_st_tests) {
test__skip();
goto destroy;
}
ctx->klog_fd = open_kernel_logs();
if (!ASSERT_OK_FD(ctx->klog_fd, "open kernel logs"))
goto destroy;
ctx->obj = skel->obj;
strncpy(ctx->prog_name, "st_blinded", PROG_NAME_MAX_LEN);
exec_subtest(ctx, &blinding_spec, 1, false);
destroy:
close(ctx->klog_fd);
kasan_harden__destroy(skel);
restore:
sysctl_set_or_fail("/proc/sys/net/core/bpf_jit_harden", NULL,
bpf_jit_harden_orig);
free_ctx:
free(ctx);
}
static struct test_spec tests[] = {
{
.prog_type = "st",
.is_write = true,
.needs_st = true
},
{
.prog_type = "stx",
.is_write = true
},
{
.prog_type = "ldx",
.is_write = false
},
{
.prog_type = "simple_atomic",
.is_write = true,
.only_32_or_64 = true
},
{
.prog_type = "simple_atomic_fetch",
.is_write = true,
.skip_multi_size_testing = true,
.run_size = 8,
},
{
.prog_type = "load_acquire",
.is_write = false,
.needs_load_acq_store_rel = true
},
{
.prog_type = "store_release",
.is_write = true,
.needs_load_acq_store_rel = true
},
{
.prog_type = "ldx_patched",
.is_write = false,
.skip_multi_size_testing = true,
.run_size = 4,
.rnd_hi32 = true
},
{
.prog_type = "verifier_paths_stack_and_non_stack",
.is_write = true,
.skip_multi_size_testing = true,
.skip_on_stack_testing = true,
.run_size = 1
},
{
.prog_type = "ldx_oob",
.is_write = false,
.skip_on_stack_testing = true,
.is_oob = true
},
{
.prog_type = "ldx_self_alias_on_stack",
.is_write = false,
.skip_multi_size_testing = true,
.skip_on_stack_testing = true,
.run_size = 8,
.expect_no_report = true
}
};
void serial_test_kasan(void)
{
struct kasan_write_val val;
struct test_spec *test;
struct test_ctx *ctx;
struct kasan *skel;
__u32 key = 0;
int i, ret;
ctx = calloc(1, sizeof(struct test_ctx));
if (!ASSERT_OK_PTR(ctx, "alloc test ctx"))
return;
if (!is_jit_enabled() || !get_kasan_jit_enabled() ||
!get_kasan_multi_shot_enabled()) {
test__skip();
goto end;
}
skel = kasan__open();
if (!ASSERT_OK_PTR(skel, "open prog"))
goto end;
for (i = 0; i < ARRAY_SIZE(tests); i++) {
char prog_name[SUBTEST_NAME_MAX_LEN];
struct bpf_program *prog;
if (!tests[i].rnd_hi32)
continue;
snprintf(prog_name, SUBTEST_NAME_MAX_LEN, "%s_%s",
tests[i].prog_type, "on_stack");
prog = bpf_object__find_program_by_name(skel->obj, prog_name);
if (!ASSERT_OK_PTR(prog, "find rnd_hi32 on_stack prog"))
goto destroy;
bpf_program__add_flags(prog, BPF_F_TEST_RND_HI32);
snprintf(prog_name, SUBTEST_NAME_MAX_LEN, "%s_%s",
tests[i].prog_type, "not_on_stack");
prog = bpf_object__find_program_by_name(skel->obj, prog_name);
if (!ASSERT_OK_PTR(prog, "find rnd_hi32 not_on_stack prog"))
goto destroy;
bpf_program__add_flags(prog, BPF_F_TEST_RND_HI32);
}
if (!ASSERT_OK(kasan__load(skel), "load prog"))
goto destroy;
ctx->obj = skel->obj;
ctx->access_size = &skel->bss->access_size;
ctx->skip_load_acq_store_rel = skel->data->skip_load_acq_store_rel_tests;
ctx->skip_st_tests = skel->data->skip_st_tests;
ctx->klog_fd = open_kernel_logs();
if (!ASSERT_OK_FD(ctx->klog_fd, "open kernel logs"))
goto destroy;
/* Fill map with recognizable values */
ret = bpf_map__lookup_elem(skel->maps.test_map, &key, sizeof(key),
&val, sizeof(val), 0);
if (!ASSERT_OK(ret, "get map"))
goto close;
val.data_1 = 0xAA;
val.data_2 = 0xBBBB;
val.data_4 = 0xCCCCCCCC;
val.data_8 = 0xDDDDDDDDDDDDDDDD;
ret = bpf_map__update_elem(skel->maps.test_map, &key, sizeof(key),
&val, sizeof(val), 0);
if (!ASSERT_OK(ret, "set map"))
goto close;
for (i = 0; i < ARRAY_SIZE(tests); i++) {
test = &tests[i];
run_subtest(ctx, test);
}
/*
* Blinding subtest is handled differently as it needs the
* corresponding program to be loaded with bpf_jit_harden raised
*/
run_blinding_subtest();
close:
close(ctx->klog_fd);
destroy:
kasan__destroy(skel);
end:
free(ctx);
}