From 3db96df43bad80b6b047b650fcf48db029a89dfa Mon Sep 17 00:00:00 2001 From: Ethan Graham Date: Tue, 12 Aug 2025 13:54:00 +0000 Subject: [PATCH 01/11] mm/kasan: implement kasan_poison_range Introduce a new helper function, kasan_poison_range(), to encapsulate the logic for poisoning an arbitrary memory range of a given size, and expose it publically in . This is a preparatory change for the upcoming KFuzzTest patches, which requires the ability to poison the inter-region padding in its input buffers. No functional change to any other subsystem is intended by this commit. Signed-off-by: Ethan Graham Signed-off-by: Ethan Graham Reviewed-by: Alexander Potapenko --- PR v3: - Move kasan_poison_range into mm/kasan/common.c so that it is built with HW_TAGS mode enabled. - Add a runtime check for kasan_enabled() in kasan_poison_range. - Add two WARN_ON()s in kasan_poison_range when the input is invalid. PR v1: - Enforce KASAN_GRANULE_SIZE alignment for the end of the range in kasan_poison_range(), and return -EINVAL when this isn't respected. --- --- include/linux/kasan.h | 11 +++++++++++ mm/kasan/common.c | 37 +++++++++++++++++++++++++++++++++++++ 2 files changed, 48 insertions(+) diff --git a/include/linux/kasan.h b/include/linux/kasan.h index 890011071f2b14..cd6cdf732378c2 100644 --- a/include/linux/kasan.h +++ b/include/linux/kasan.h @@ -102,6 +102,16 @@ static inline bool kasan_has_integrated_init(void) } #ifdef CONFIG_KASAN + +/** + * kasan_poison_range - poison the memory range [@addr, @addr + @size) + * + * The exact behavior is subject to alignment with KASAN_GRANULE_SIZE, defined + * in : if @start is unaligned, the initial partial granule + * at the beginning of the range is only poisoned if CONFIG_KASAN_GENERIC=y. + */ +int kasan_poison_range(const void *addr, size_t size); + void __kasan_unpoison_range(const void *addr, size_t size); static __always_inline void kasan_unpoison_range(const void *addr, size_t size) { @@ -402,6 +412,7 @@ static __always_inline bool kasan_check_byte(const void *addr) #else /* CONFIG_KASAN */ +static inline int kasan_poison_range(const void *start, size_t size) { return 0; } static inline void kasan_unpoison_range(const void *address, size_t size) {} static inline void kasan_poison_pages(struct page *page, unsigned int order, bool init) {} diff --git a/mm/kasan/common.c b/mm/kasan/common.c index 9142964ab9c957..c83579ef37c6c1 100644 --- a/mm/kasan/common.c +++ b/mm/kasan/common.c @@ -570,3 +570,40 @@ bool __kasan_check_byte(const void *address, unsigned long ip) } return true; } + +int kasan_poison_range(const void *addr, size_t size) +{ + uintptr_t start_addr = (uintptr_t)addr; + uintptr_t head_granule_start; + uintptr_t poison_body_start; + uintptr_t poison_body_end; + size_t head_prefix_size; + uintptr_t end_addr; + + if (!kasan_enabled()) + return 0; + + end_addr = start_addr + size; + if (WARN_ON(end_addr % KASAN_GRANULE_SIZE)) + return -EINVAL; + + if (WARN_ON(start_addr >= end_addr)) + return -EINVAL; + + head_granule_start = ALIGN_DOWN(start_addr, KASAN_GRANULE_SIZE); + head_prefix_size = start_addr - head_granule_start; + + if (IS_ENABLED(CONFIG_KASAN_GENERIC) && head_prefix_size > 0) + kasan_poison_last_granule((void *)head_granule_start, + head_prefix_size); + + poison_body_start = ALIGN(start_addr, KASAN_GRANULE_SIZE); + poison_body_end = end_addr; + + if (poison_body_start < poison_body_end) + kasan_poison((void *)poison_body_start, + poison_body_end - poison_body_start, + KASAN_SLAB_REDZONE, false); + return 0; +} +EXPORT_SYMBOL(kasan_poison_range); From 30bbafa3beec3b0b18de0fed49143ff198f36fa4 Mon Sep 17 00:00:00 2001 From: Ethan Graham Date: Tue, 12 Aug 2025 14:01:03 +0000 Subject: [PATCH 02/11] kfuzztest: add user-facing API and data structures Add the foundational user-facing components for the KFuzzTest framework. This includes the main API header , the Kconfig option to enable the feature, and the required linker script changes which introduce three new ELF sections in vmlinux. Note that KFuzzTest is intended strictly for debug builds only, and should never be enabled in a production build. The fact that it exposes internal kernel functions and state directly to userspace may constitute a serious security vulnerability if used for any reason other than testing. The header defines: - The FUZZ_TEST() macro for creating test targets. - The data structures required for the binary serialization format, which allows passing complex inputs from userspace. - The metadata structures for test targets, constraints and annotations, which are placed in dedicated ELF sections (.kfuzztest_*) for discovery. This patch only adds the public interface and build integration; no runtime logic is included. Signed-off-by: Ethan Graham Signed-off-by: Ethan Graham Reviewed-by: Alexander Potapenko --- PR v3: - Reorder definitions in kfuzztest.h for better flow and readability. - Introduce __KFUZZTEST_CONSTRAINT macro in preparation for the introduction of the FUZZ_TEST_SIMPLE macro in the following patch, which uses it for manually emitting constraint metadata. PR v1: - Move KFuzzTest metadata definitions to generic vmlinux linkage so that the framework isn't bound to x86_64. - Return -EFAULT when simple_write_to_buffer returns a value not equal to the input length in the main FUZZ_TEST macro. - Enforce a maximum input size of 64KiB in the main FUZZ_TEST macro, returning -EINVAL when it isn't respected. - Refactor KFUZZTEST_ANNOTATION_* macros. - Taint the kernel with TAINT_TEST inside the FUZZ_TEST macro when a fuzz target is invoked for the first time. --- --- include/asm-generic/vmlinux.lds.h | 22 +- include/linux/kfuzztest.h | 486 ++++++++++++++++++++++++++++++ lib/Kconfig.debug | 1 + lib/kfuzztest/Kconfig | 20 ++ 4 files changed, 528 insertions(+), 1 deletion(-) create mode 100644 include/linux/kfuzztest.h create mode 100644 lib/kfuzztest/Kconfig diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h index ae2d2359b79e9e..9afe569d013b6b 100644 --- a/include/asm-generic/vmlinux.lds.h +++ b/include/asm-generic/vmlinux.lds.h @@ -373,7 +373,8 @@ defined(CONFIG_AUTOFDO_CLANG) || defined(CONFIG_PROPELLER_CLANG) TRACE_PRINTKS() \ BPF_RAW_TP() \ TRACEPOINT_STR() \ - KUNIT_TABLE() + KUNIT_TABLE() \ + KFUZZTEST_TABLE() /* * Data section helpers @@ -966,6 +967,25 @@ defined(CONFIG_AUTOFDO_CLANG) || defined(CONFIG_PROPELLER_CLANG) BOUNDED_SECTION_POST_LABEL(.kunit_init_test_suites, \ __kunit_init_suites, _start, _end) +#ifdef CONFIG_KFUZZTEST +#define KFUZZTEST_TABLE() \ + . = ALIGN(PAGE_SIZE); \ + __kfuzztest_targets_start = .; \ + KEEP(*(.kfuzztest_target)); \ + __kfuzztest_targets_end = .; \ + . = ALIGN(PAGE_SIZE); \ + __kfuzztest_constraints_start = .; \ + KEEP(*(.kfuzztest_constraint)); \ + __kfuzztest_constraints_end = .; \ + . = ALIGN(PAGE_SIZE); \ + __kfuzztest_annotations_start = .; \ + KEEP(*(.kfuzztest_annotation)); \ + __kfuzztest_annotations_end = .; + +#else /* CONFIG_KFUZZTEST */ +#define KFUZZTEST_TABLE() +#endif /* CONFIG_KFUZZTEST */ + #ifdef CONFIG_BLK_DEV_INITRD #define INIT_RAM_FS \ . = ALIGN(4); \ diff --git a/include/linux/kfuzztest.h b/include/linux/kfuzztest.h new file mode 100644 index 00000000000000..1839fcfeabf504 --- /dev/null +++ b/include/linux/kfuzztest.h @@ -0,0 +1,486 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * The Kernel Fuzz Testing Framework (KFuzzTest) API for defining fuzz targets + * for internal kernel functions. + * + * For more information please see Documentation/dev-tools/kfuzztest.rst. + * + * Copyright 2025 Google LLC + */ +#ifndef KFUZZTEST_H +#define KFUZZTEST_H + +#include +#include +#include + +#define KFUZZTEST_HEADER_MAGIC (0xBFACE) +#define KFUZZTEST_V0 (0) +#define KFUZZTEST_REGIONID_NULL U32_MAX +#define KFUZZTEST_MAX_INPUT_SIZE (PAGE_SIZE * 16) +/** + * The end of the input should be padded by at least this number of bytes as + * it is poisoned to detect out of bounds accesses at the end of the last + * region. + */ +#define KFUZZTEST_POISON_SIZE 0x8 + +/** + * @brief The KFuzzTest Input Serialization Format + * + * KFuzzTest receives its input from userspace as a single binary blob. This + * format allows for the serialization of complex, pointer-rich C structures + * into a flat buffer that can be safely passed into the kernel. This format + * requires only a single copy from userspace into a kernel buffer, and no + * further kernel allocations. Pointers are patched internally using a "region" + * system where each region corresponds to some pointed-to data. + * + * Regions should be padded to respect alignment constraints of their underlying + * types, and should be followed by at least 8 bytes of padding. These padded + * regions are poisoned by KFuzzTest to ensure that KASAN catches OOB accesses. + * + * The format consists of a header and three main components: + * 1. An 8-byte header: Contains KFUZZTEST_MAGIC in the first 4 bytes, and the + * version number in the subsequent 4 bytes. This ensures backwards + * compatibility in the event of future format changes. + * 2. A reloc_region_array: Defines the memory layout of the target structure + * by partitioning the payload into logical regions. Each logical region + * should contain the byte representation of the type that it represents, + * including any necessary padding. The region descriptors should be + * ordered by offset ascending. + * 3. A reloc_table: Provides "linking" instructions that tell the kernel how + * to patch pointer fields to point to the correct regions. By design, + * the first region (index 0) is passed as input into a FUZZ_TEST. + * 4. A Payload: The raw binary data for the target structure and its associated + * buffers. This should be aligned to the maximum alignment of all + * regions to satisfy alignment requirements of the input types, but this + * isn't checked by the parser. + * + * For a detailed specification of the binary layout see the full documentation + * at: Documentation/dev-tools/kfuzztest.rst + */ + +/** + * struct reloc_region - single contiguous memory region in the payload + * + * @offset: The byte offset of this region from the start of the payload, which + * should be aligned to the alignment requirements of the region's + * underlying type. + * @size: The size of this region in bytes. + */ +struct reloc_region { + uint32_t offset; + uint32_t size; +}; + +/** + * struct reloc_region_array - array of regions in an input + * + * @num_regions: The total number of regions defined. + * @regions: A flexible array of `num_regions` region descriptors. + */ +struct reloc_region_array { + uint32_t num_regions; + struct reloc_region regions[]; +}; + +/** + * struct reloc_entry - a single pointer to be patched in an input + * + * @region_id: The index of the region in the `reloc_region_array` that + * contains the pointer. + * @region_offset: The start offset of the pointer inside of the region. + * @value: contains the index of the pointee region, or KFUZZTEST_REGIONID_NULL + * if the pointer is NULL. + */ +struct reloc_entry { + uint32_t region_id; + uint32_t region_offset; + uint32_t value; +}; + +/** + * struct reloc_table - array of relocations required by an input + * + * @num_entries: the number of pointer relocations. + * @padding_size: the number of padded bytes between the last relocation in + * entries, and the start of the payload data. This should be at least + * 8 bytes, as it is used for poisoning. + * @entries: array of relocations. + */ +struct reloc_table { + uint32_t num_entries; + uint32_t padding_size; + struct reloc_entry entries[]; +}; + +/** + * kfuzztest_parse_and_relocate - validate and relocate a KFuzzTest input + * + * @input: A buffer containing the serialized input for a fuzz target. + * @input_size: the size in bytes of the @input buffer. + * @arg_ret: return pointer for the test case's input structure. + */ +int kfuzztest_parse_and_relocate(void *input, size_t input_size, void **arg_ret); + +enum kfuzztest_constraint_type { + EXPECT_EQ, + EXPECT_NE, + EXPECT_LT, + EXPECT_LE, + EXPECT_GT, + EXPECT_GE, + EXPECT_IN_RANGE, +}; + +/** + * struct kfuzztest_constraint - a metadata record for a domain constraint + * + * Domain constraints are rules about the input data that must be satisfied for + * a fuzz test to proceed. While they are enforced in the kernel with a runtime + * check, they are primarily intended as a discoverable contract for userspace + * fuzzers. + * + * Instances of this struct are generated by the KFUZZTEST_EXPECT_* macros + * and placed into the read-only ".kfuzztest_constraint" ELF section of the + * vmlinux binary. A fuzzer can parse this section to learn about the + * constraints and generate valid inputs more intelligently. + * + * For an example of how these constraints are used within a fuzz test, see the + * documentation for the FUZZ_TEST() macro. + * + * @input_type: The name of the input struct type, without the leading + * "struct ". + * @field_name: The name of the field within the struct that this constraint + * applies to. + * @value1: The primary value used in the comparison (e.g., the upper + * bound for EXPECT_LE). + * @value2: The secondary value, used only for multi-value comparisons + * (e.g., the upper bound for EXPECT_IN_RANGE). + * @type: The type of the constraint. + */ +struct kfuzztest_constraint { + const char *input_type; + const char *field_name; + uintptr_t value1; + uintptr_t value2; + enum kfuzztest_constraint_type type; +} __aligned(64); + + +#define __KFUZZTEST_CONSTRAINT(arg_type, field, val1, val2, tpe) \ + static struct kfuzztest_constraint __constraint_##arg_type##_##field \ + __section(".kfuzztest_constraint") __used = { \ + .input_type = "struct " #arg_type, \ + .field_name = #field, \ + .value1 = (uintptr_t)val1, \ + .value2 = (uintptr_t)val2, \ + .type = tpe, \ + } + +#define __KFUZZTEST_DEFINE_CONSTRAINT(arg_type, field, val1, val2, tpe, predicate) \ + do { \ + __KFUZZTEST_CONSTRAINT(arg_type, field, val1, val2, tpe); \ + if (!(predicate)) \ + return; \ + } while (0) + +/** + * KFUZZTEST_EXPECT_EQ - constrain a field to be equal to a value + * + * @arg_type: name of the input structure, without the leading "struct ". + * @field: some field that is comparable + * @val: a value of the same type as @arg_type.@field + */ +#define KFUZZTEST_EXPECT_EQ(arg_type, field, val) \ + __KFUZZTEST_DEFINE_CONSTRAINT(arg_type, field, val, 0x0, EXPECT_EQ, arg->field == val) + +/** + * KFUZZTEST_EXPECT_NE - constrain a field to be not equal to a value + * + * @arg_type: name of the input structure, without the leading "struct ". + * @field: some field that is comparable. + * @val: a value of the same type as @arg_type.@field. + */ +#define KFUZZTEST_EXPECT_NE(arg_type, field, val) \ + __KFUZZTEST_DEFINE_CONSTRAINT(arg_type, field, val, 0x0, EXPECT_NE, arg->field != val) + +/** + * KFUZZTEST_EXPECT_LT - constrain a field to be less than a value + * + * @arg_type: name of the input structure, without the leading "struct ". + * @field: some field that is comparable. + * @val: a value of the same type as @arg_type.@field. + */ +#define KFUZZTEST_EXPECT_LT(arg_type, field, val) \ + __KFUZZTEST_DEFINE_CONSTRAINT(arg_type, field, val, 0x0, EXPECT_LT, arg->field < val) + +/** + * KFUZZTEST_EXPECT_LE - constrain a field to be less than or equal to a value + * + * @arg_type: name of the input structure, without the leading "struct ". + * @field: some field that is comparable. + * @val: a value of the same type as @arg_type.@field. + */ +#define KFUZZTEST_EXPECT_LE(arg_type, field, val) \ + __KFUZZTEST_DEFINE_CONSTRAINT(arg_type, field, val, 0x0, EXPECT_LE, arg->field <= val) + +/** + * KFUZZTEST_EXPECT_GT - constrain a field to be greater than a value + * + * @arg_type: name of the input structure, without the leading "struct ". + * @field: some field that is comparable. + * @val: a value of the same type as @arg_type.@field. + */ +#define KFUZZTEST_EXPECT_GT(arg_type, field, val) \ + __KFUZZTEST_DEFINE_CONSTRAINT(arg_type, field, val, 0x0, EXPECT_GT, arg->field > val) + +/** + * KFUZZTEST_EXPECT_GE - constrain a field to be greater than or equal to a value + * + * @arg_type: name of the input structure, without the leading "struct ". + * @field: some field that is comparable. + * @val: a value of the same type as @arg_type.@field. + */ +#define KFUZZTEST_EXPECT_GE(arg_type, field, val) \ + __KFUZZTEST_DEFINE_CONSTRAINT(arg_type, field, val, 0x0, EXPECT_GE, arg->field >= val) + +/** + * KFUZZTEST_EXPECT_NOT_NULL - constrain a pointer field to be non-NULL + * + * @arg_type: name of the input structure, without the leading "struct ". + * @field: a pointer field. + */ +#define KFUZZTEST_EXPECT_NOT_NULL(arg_type, field) KFUZZTEST_EXPECT_NE(arg_type, field, NULL) + +/** + * KFUZZTEST_EXPECT_IN_RANGE - constrain a field to be within a range + * + * @arg_type: name of the input structure, without the leading "struct ". + * @field: some field that is comparable. + * @lower_bound: a lower bound of the same type as @arg_type.@field. + * @upper_bound: an upper bound of the same type as @arg_type.@field. + */ +#define KFUZZTEST_EXPECT_IN_RANGE(arg_type, field, lower_bound, upper_bound) \ + __KFUZZTEST_DEFINE_CONSTRAINT(arg_type, field, lower_bound, upper_bound, \ + EXPECT_IN_RANGE, arg->field >= lower_bound && arg->field <= upper_bound) + +/** + * Annotations express attributes about structure fields that can't be easily + * or safely verified at runtime. They are intended as hints to the fuzzing + * engine to help it generate more semantically correct and effective inputs. + * Unlike constraints, annotations do not add any runtime checks and do not + * cause a test to exit early. + * + * For example, a `char *` field could be a raw byte buffer or a C-style + * null-terminated string. A fuzzer that is aware of this distinction can avoid + * creating inputs that would cause trivial, uninteresting crashes from reading + * past the end of a non-null-terminated buffer. + */ +enum kfuzztest_annotation_attribute { + ATTRIBUTE_LEN, + ATTRIBUTE_STRING, + ATTRIBUTE_ARRAY, +}; + +/** + * struct kfuzztest_annotation - a metadata record for a fuzzer hint + * + * This struct captures a single hint about a field in the input structure. + * Instances are generated by the KFUZZTEST_ANNOTATE_* macros and are placed + * into the read-only ".kfuzztest_annotation" ELF section of the vmlinux binary. + * + * A userspace fuzzer can parse this section to understand the semantic + * relationships between fields (e.g., which field is a length for which + * buffer) and the expected format of the data (e.g., a null-terminated + * string). This allows the fuzzer to be much more intelligent during input + * generation and mutation. + * + * For an example of how annotations are used within a fuzz test, see the + * documentation for the FUZZ_TEST() macro. + * + * @input_type: The name of the input struct type. + * @field_name: The name of the field being annotated (e.g., the data + * buffer field). + * @linked_field_name: For annotations that link two fields (like + * ATTRIBUTE_LEN), this is the name of the related field (e.g., the + * length field). For others, this may be unused. + * @attrib: The type of the annotation hint. + */ +struct kfuzztest_annotation { + const char *input_type; + const char *field_name; + const char *linked_field_name; + enum kfuzztest_annotation_attribute attrib; +} __aligned(32); + +#define __KFUZZTEST_ANNOTATE(arg_type, field, linked_field, attribute) \ + static struct kfuzztest_annotation __annotation_##arg_type##_##field __section(".kfuzztest_annotation") \ + __used = { \ + .input_type = "struct " #arg_type, \ + .field_name = #field, \ + .linked_field_name = #linked_field, \ + .attrib = attribute, \ + } + +/** + * KFUZZTEST_ANNOTATE_STRING - annotate a char* field as a C string + * + * We define a C string as a sequence of non-zero characters followed by exactly + * one null terminator. + * + * @arg_type: name of the input structure, without the leading "struct ". + * @field: the name of the field to annotate. + */ +#define KFUZZTEST_ANNOTATE_STRING(arg_type, field) __KFUZZTEST_ANNOTATE(arg_type, field, NULL, ATTRIBUTE_STRING) + +/** + * KFUZZTEST_ANNOTATE_ARRAY - annotate a pointer as an array + * + * We define an array as a contiguous memory region containing zero or more + * elements of the same type. + * + * @arg_type: name of the input structure, without the leading "struct ". + * @field: the name of the field to annotate. + */ +#define KFUZZTEST_ANNOTATE_ARRAY(arg_type, field) __KFUZZTEST_ANNOTATE(arg_type, field, NULL, ATTRIBUTE_ARRAY) + +/** + * KFUZZTEST_ANNOTATE_LEN - annotate a field as the length of another + * + * This expresses the relationship `arg_type.field == len(linked_field)`, where + * `linked_field` is an array. + * + * @arg_type: name of the input structure, without the leading "struct ". + * @field: the name of the field to annotate. + * @linked_field: the name of an array field with length @field. + */ +#define KFUZZTEST_ANNOTATE_LEN(arg_type, field, linked_field) \ + __KFUZZTEST_ANNOTATE(arg_type, field, linked_field, ATTRIBUTE_LEN) + + +/* + * Dump some information on the parsed headers and payload. Can be useful for + * debugging inputs when writing an encoder for the KFuzzTest input format. + */ +__attribute__((unused)) static inline void kfuzztest_debug_header(struct reloc_region_array *regions, + struct reloc_table *rt, void *payload_start, + void *payload_end) +{ + uint32_t i; + + pr_info("regions: { num_regions = %u } @ %px", regions->num_regions, regions); + for (i = 0; i < regions->num_regions; i++) { + pr_info(" region_%u: { start: 0x%x, size: 0x%x }", i, regions->regions[i].offset, + regions->regions[i].size); + } + + pr_info("reloc_table: { num_entries = %u, padding = %u } @ offset 0x%tx", rt->num_entries, rt->padding_size, + (char *)rt - (char *)regions); + for (i = 0; i < rt->num_entries; i++) { + pr_info(" reloc_%u: { src: %u, offset: 0x%x, dst: %u }", i, rt->entries[i].region_id, + rt->entries[i].region_offset, rt->entries[i].value); + } + + pr_info("payload: [0x%lx, 0x%tx)", (char *)payload_start - (char *)regions, + (char *)payload_end - (char *)regions); +} + +/* Increments a global counter after a successful invocation. */ +void record_invocation(void); + +/* Common code for receiving inputs from userspace. */ +int kfuzztest_write_cb_common(struct file *filp, const char __user *buf, size_t len, loff_t *off, void **test_buffer); + +struct kfuzztest_target { + const char *name; + const char *arg_type_name; + ssize_t (*write_input_cb)(struct file *filp, const char __user *buf, size_t len, loff_t *off); +} __aligned(32); + +/** + * FUZZ_TEST - defines a KFuzzTest target + * + * @test_name: The unique identifier for the fuzz test, which is used to name + * the debugfs entry, e.g., /sys/kernel/debug/kfuzztest/@test_name. + * @test_arg_type: The struct type that defines the inputs for the test. This + * must be the full struct type (e.g., "struct my_inputs"), not a typedef. + * + * Context: + * This macro is the primary entry point for the KFuzzTest framework. It + * generates all the necessary boilerplate for a fuzz test, including: + * - A static `struct kfuzztest_target` instance that is placed in a + * dedicated ELF section for discovery by userspace tools. + * - A `debugfs` write callback that handles receiving serialized data from + * a fuzzer, parsing it, and "hydrating" it into a valid C struct. + * - A function stub where the developer places the test logic. + * + * User-Provided Logic: + * The developer must provide the body of the fuzz test logic within the curly + * braces following the macro invocation. Within this scope, the framework + * provides the `arg` variable, which is a pointer of type `@test_arg_type *` + * to the fully hydrated input structure. All pointer fields within this struct + * have been relocated and are valid kernel pointers. This is the primary + * variable to use for accessing fuzzing inputs. + * + * Example Usage: + * + * // 1. The kernel function we want to fuzz. + * int process_data(const char *data, size_t len); + * + * // 2. Define a struct to hold all inputs for the function. + * struct process_data_inputs { + * const char *data; + * size_t len; + * }; + * + * // 3. Define the fuzz test using the FUZZ_TEST macro. + * FUZZ_TEST(process_data_fuzzer, struct process_data_inputs) + * { + * int ret; + * // Use KFUZZTEST_EXPECT_* to enforce preconditions. + * // The test will exit early if data is NULL. + * KFUZZTEST_EXPECT_NOT_NULL(process_data_inputs, data); + * + * // Use KFUZZTEST_ANNOTATE_* to provide hints to the fuzzer. + * // This links the 'len' field to the 'data' buffer. + * KFUZZTEST_ANNOTATE_LEN(process_data_inputs, len, data); + * + * // Call the function under test using the 'arg' variable. OOB memory + * // accesses will be caught by KASAN, but the user can also choose to + * // validate the return value and log any failures. + * ret = process_data(arg->data, arg->len); + * } + */ +#define FUZZ_TEST(test_name, test_arg_type) \ + static ssize_t kfuzztest_write_cb_##test_name(struct file *filp, const char __user *buf, size_t len, \ + loff_t *off); \ + static void kfuzztest_logic_##test_name(test_arg_type *arg); \ + static const struct kfuzztest_target __fuzz_test__##test_name __section(".kfuzztest_target") __used = { \ + .name = #test_name, \ + .arg_type_name = #test_arg_type, \ + .write_input_cb = kfuzztest_write_cb_##test_name, \ + }; \ + static ssize_t kfuzztest_write_cb_##test_name(struct file *filp, const char __user *buf, size_t len, \ + loff_t *off) \ + { \ + test_arg_type *arg; \ + void *buffer; \ + int ret; \ + ret = kfuzztest_write_cb_common(filp, buf, len, off, &buffer); \ + if (ret < 0) \ + goto fail_early; \ + ret = kfuzztest_parse_and_relocate(buffer, len, (void **)&arg); \ + if (ret < 0) \ + goto fail_late; \ + kfuzztest_logic_##test_name(arg); \ + record_invocation(); \ + ret = len; \ +fail_late: \ + kfree(buffer); \ +fail_early: \ + return ret; \ + } \ + static void kfuzztest_logic_##test_name(test_arg_type *arg) + +#endif /* KFUZZTEST_H */ diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug index dc0e0c6ed075e9..49a1748b9f241c 100644 --- a/lib/Kconfig.debug +++ b/lib/Kconfig.debug @@ -1947,6 +1947,7 @@ endmenu menu "Kernel Testing and Coverage" source "lib/kunit/Kconfig" +source "lib/kfuzztest/Kconfig" config NOTIFIER_ERROR_INJECTION tristate "Notifier error injection" diff --git a/lib/kfuzztest/Kconfig b/lib/kfuzztest/Kconfig new file mode 100644 index 00000000000000..f9fb5abf8d27db --- /dev/null +++ b/lib/kfuzztest/Kconfig @@ -0,0 +1,20 @@ +# SPDX-License-Identifier: GPL-2.0-only + +config KFUZZTEST + bool "KFuzzTest - enable support for internal fuzz targets" + depends on DEBUG_FS && DEBUG_KERNEL + help + Enables support for the kernel fuzz testing framework (KFuzzTest), an + interface for exposing internal kernel functions to a userspace fuzzing + engine. KFuzzTest targets are exposed via a debugfs interface that + accepts serialized userspace inputs, and is designed to make it easier + to fuzz deeply nested kernel code that is hard to reach from the system + call boundary. Using a simple macro-based API, developers can add a new + fuzz target with minimal boilerplate code. + + It is strongly recommended to also enable CONFIG_KASAN for byte-accurate + out-of-bounds detection, as KFuzzTest was designed with this in mind. It + is also recommended to enable CONFIG_KCOV for coverage guided fuzzing. + + WARNING: This exposes internal kernel functions directly to userspace + and must NEVER be enabled in production builds. From c06c23c6e8b5c6cac5dbcc4b029264daffd18174 Mon Sep 17 00:00:00 2001 From: Ethan Graham Date: Tue, 2 Dec 2025 22:02:37 +0100 Subject: [PATCH 03/11] kfuzztest: introduce the FUZZ_TEST_SIMPLE macro The serialization format required by a KFuzzTest target defined with the FUZZ_TEST macro is overkill for simpler cases, in particular the very common pattern of kernel interfaces taking a (data, datalen) pair. Introduce the FUZZ_TEST_SIMPLE for defining simple targets that accepts a simpler binary interface without any required serialization. The aim is to make simple targets compatible with a wide variety of userspace fuzzing engines out of the box. A FUZZ_TEST_SIMPLE target also defines an equivalent FUZZ_TEST macro in its expansion maintaining compatibility with the default KFuzzTest interface, using a shared `struct kfuzztest_simple_arg` as input type. In essence, the following equivalence holds: FUZZ_TEST_SIMPLE(test) === FUZZ_TEST(test, struct kfuzztest_simple_arg) Constraints and annotation metadata for `struct kfuzztest_simple_arg` is defined statically in the header file to avoid duplicate definitions in the compiled vmlinux image. Signed-off-by: Ethan Graham --- include/asm-generic/vmlinux.lds.h | 4 ++ include/linux/kfuzztest.h | 87 +++++++++++++++++++++++++++++++ 2 files changed, 91 insertions(+) diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h index 9afe569d013b6b..2736dd41fba082 100644 --- a/include/asm-generic/vmlinux.lds.h +++ b/include/asm-generic/vmlinux.lds.h @@ -974,6 +974,10 @@ defined(CONFIG_AUTOFDO_CLANG) || defined(CONFIG_PROPELLER_CLANG) KEEP(*(.kfuzztest_target)); \ __kfuzztest_targets_end = .; \ . = ALIGN(PAGE_SIZE); \ + __kfuzztest_simple_targets_start = .; \ + KEEP(*(.kfuzztest_simple_target)); \ + __kfuzztest_simple_targets_end = .; \ + . = ALIGN(PAGE_SIZE); \ __kfuzztest_constraints_start = .; \ KEEP(*(.kfuzztest_constraint)); \ __kfuzztest_constraints_end = .; \ diff --git a/include/linux/kfuzztest.h b/include/linux/kfuzztest.h index 1839fcfeabf504..284142fa430020 100644 --- a/include/linux/kfuzztest.h +++ b/include/linux/kfuzztest.h @@ -483,4 +483,91 @@ fail_early: \ } \ static void kfuzztest_logic_##test_name(test_arg_type *arg) +struct kfuzztest_simple_target { + const char *name; + ssize_t (*write_input_cb)(struct file *filp, const char __user *buf, size_t len, loff_t *off); +} __aligned(32); + +struct kfuzztest_simple_arg { + char *data; + size_t datalen; +}; + +/* Define constraint and annotation metadata for reused kfuzztest_simple_arg. */ +__KFUZZTEST_CONSTRAINT(kfuzztest_simple_arg, data, NULL, 0x0, EXPECT_NE); +__KFUZZTEST_ANNOTATE(kfuzztest_simple_arg, data, NULL, ATTRIBUTE_ARRAY); +__KFUZZTEST_ANNOTATE(kfuzztest_simple_arg, datalen, data, ATTRIBUTE_LEN); + +/** + * FUZZ_TEST_SIMPLE - defines a simple KFuzzTest target + * + * @test_name: the unique identifier for the fuzz test, which is used to name + * the debugfs entry. + * + * This macro function nearly identically to the standard FUZZ_TEST target, the + * key difference being that a simple fuzz target is constrained to inputs of + * the form `(char *data, size_t datalen)` - a common pattern in kernel APIs. + * + * The FUZZ_TEST_SIMPLE macro expands to define an equivalent FUZZ_TEST, + * effectively creating two debugfs input files for the fuzz target. In essence, + * on top of creating an input file under kfuzztest/@test_name/input, a new + * simple input file is created under kfuzztest/@test_name/input_simple. This + * debugfs file takes raw byte buffers as input and doesn't require any special + * serialization. + * + * User-provided Logic: + * The developer must provide the body of the fuzz test logic within the curly + * braces following the macro invocation. Within this scope, the framework + * provides the `data` and `datalen` variables, where `datalen == len(data)`. + * + * Example Usage: + * + * // 1. The kernel function that we wnat to fuzz. + * int process_data(const char *data, size_t datalen); + * + * // 2. Define a fuzz target using the FUZZ_TEST_SIMPLE macro. + * FUZZ_TEST_SIMPLE(test_process_data) + * { + * // Call the function under test using the `data` and `datalen` + * // variables. + * process_data(data, datalen); + * } + * + */ +#define FUZZ_TEST_SIMPLE(test_name) \ + static ssize_t kfuzztest_simple_write_cb_##test_name(struct file *filp, const char __user *buf, size_t len, \ + loff_t *off); \ + static void kfuzztest_simple_logic_##test_name(char *data, size_t datalen); \ + static const struct kfuzztest_simple_target __fuzz_test_simple__##test_name __section( \ + ".kfuzztest_simple_target") __used = { \ + .name = #test_name, \ + .write_input_cb = kfuzztest_simple_write_cb_##test_name, \ + }; \ + FUZZ_TEST(test_name, struct kfuzztest_simple_arg) \ + { \ + /* We don't use the KFUZZTEST_EXPECT macro to define the + * non-null constraint on `arg->data` as we only want metadata + * to be emitted once, so we enforce it here manually. */ \ + if (arg->data == NULL) \ + return; \ + kfuzztest_simple_logic_##test_name(arg->data, arg->datalen); \ + } \ + static ssize_t kfuzztest_simple_write_cb_##test_name(struct file *filp, const char __user *buf, size_t len, \ + loff_t *off) \ + { \ + void *buffer; \ + int ret; \ + \ + ret = kfuzztest_write_cb_common(filp, buf, len, off, &buffer); \ + if (ret < 0) \ + goto out; \ + kfuzztest_simple_logic_##test_name(buffer, len); \ + record_invocation(); \ + ret = len; \ + kfree(buffer); \ +out: \ + return ret; \ + } \ + static void kfuzztest_simple_logic_##test_name(char *data, size_t datalen) + #endif /* KFUZZTEST_H */ From 87dfbfa1bac239b23bab04eaaf491c86aa7470f0 Mon Sep 17 00:00:00 2001 From: Ethan Graham Date: Tue, 12 Aug 2025 14:07:58 +0000 Subject: [PATCH 04/11] kfuzztest: implement core module and input processing Add the core runtime implementation for KFuzzTest. This includes the module initialization, and the logic for receiving and processing user-provided inputs through debugfs. On module load, the framework discovers all test targets (FUZZ_TEST) by iterating over the .kfuzztest_target section, creating a corresponding debugfs directory with a write-only 'input' file for each of them. If an equivalent simple fuzz target (FUZZ_TEST_SIMPLE) is also defined, a write-only `input_simple` file is created under the same directory, accepting raw blobs of binary. Writing to an 'input' file triggers the main fuzzing sequence: 1. The serialized input is copied from userspace into a kernel buffer. 2. The buffer is parsed to validate the region array and relocation table. 3. Pointers are patched based on the relocation entries, and in KASAN builds the inter-region padding is poisoned. 4. The resulting struct is passed to the user-defined test logic. Writing to an 'input_simple' file triggers the following fuzzing sequence: 1. The binary input is copied from userspace into a kernel buffer. 2. The buffer and its length are passed into the user-defined test logic. Signed-off-by: Ethan Graham Signed-off-by: Ethan Graham Reviewed-by: Alexander Potapenko --- PR v3: - Handle FUZZ_TEST_SIMPLE targets by creating a write-only 'input_simple' under the fuzz target's directory. - Add implementation for `kfuzztest_write_input_cb`. PR v2: - Fix build issues identified by the kernel test robot . - Address some nits pointed out by Alexander Potapenko. PR v1: - Update kfuzztest/parse.c interfaces to take `unsigned char *` instead of `void *`, reducing the number of pointer casts. - Expose minimum region alignment via a new debugfs file. - Expose number of successful invocations via a new debugfs file. - Refactor module init function, add _config directory with entries containing KFuzzTest state information. - Account for kasan_poison_range() return value in input parsing logic. - Validate alignment of payload end. - Move static sizeof assertions into /lib/kfuzztest/main.c. - Remove the taint in kfuzztest/main.c. We instead taint the kernel as soon as a fuzz test is invoked for the first time, which is done in the primary FUZZ_TEST macro. RFC v2: - The module's init function now taints the kernel with TAINT_TEST. --- --- lib/Makefile | 2 + lib/kfuzztest/Makefile | 4 + lib/kfuzztest/main.c | 278 ++++++++++++++++++ lib/kfuzztest/parse.c | 236 +++++++++++++++ .../testing/kfuzztest-bridge/kfuzztest-bridge | Bin 0 -> 911160 bytes 5 files changed, 520 insertions(+) create mode 100644 lib/kfuzztest/Makefile create mode 100644 lib/kfuzztest/main.c create mode 100644 lib/kfuzztest/parse.c create mode 100755 tools/testing/kfuzztest-bridge/kfuzztest-bridge diff --git a/lib/Makefile b/lib/Makefile index 392ff808c9b902..02789bf8849927 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -325,6 +325,8 @@ obj-$(CONFIG_GENERIC_LIB_CMPDI2) += cmpdi2.o obj-$(CONFIG_GENERIC_LIB_UCMPDI2) += ucmpdi2.o obj-$(CONFIG_OBJAGG) += objagg.o +obj-$(CONFIG_KFUZZTEST) += kfuzztest/ + # pldmfw library obj-$(CONFIG_PLDMFW) += pldmfw/ diff --git a/lib/kfuzztest/Makefile b/lib/kfuzztest/Makefile new file mode 100644 index 00000000000000..142d16007eea98 --- /dev/null +++ b/lib/kfuzztest/Makefile @@ -0,0 +1,4 @@ +# SPDX-License-Identifier: GPL-2.0 + +obj-$(CONFIG_KFUZZTEST) += kfuzztest.o +kfuzztest-objs := main.o parse.o diff --git a/lib/kfuzztest/main.c b/lib/kfuzztest/main.c new file mode 100644 index 00000000000000..bb064fd90a25a3 --- /dev/null +++ b/lib/kfuzztest/main.c @@ -0,0 +1,278 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * KFuzzTest core module initialization and debugfs interface. + * + * Copyright 2025 Google LLC + */ +#include +#include +#include +#include +#include +#include +#include +#include + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Ethan Graham "); +MODULE_AUTHOR("Ethan Graham "); +MODULE_DESCRIPTION("Kernel Fuzz Testing Framework (KFuzzTest)"); + +/* + * Enforce a fixed struct size to ensure a consistent stride when iterating over + * the array of these structs in the dedicated ELF section. + */ +static_assert(sizeof(struct kfuzztest_target) == 32, "struct kfuzztest_target should have size 32"); +static_assert(sizeof(struct kfuzztest_simple_target) == 32, "struct kfuzztest_target should have size 32"); +static_assert(sizeof(struct kfuzztest_constraint) == 64, "struct kfuzztest_constraint should have size 64"); +static_assert(sizeof(struct kfuzztest_annotation) == 32, "struct kfuzztest_annotation should have size 32"); + +extern const struct kfuzztest_target __kfuzztest_targets_start[]; +extern const struct kfuzztest_target __kfuzztest_targets_end[]; +extern const struct kfuzztest_simple_target __kfuzztest_simple_targets_start[]; +extern const struct kfuzztest_simple_target __kfuzztest_simple_targets_end[]; + +struct target_fops { + struct file_operations target; + struct file_operations target_simple; +}; + +/** + * struct kfuzztest_state - global state for the KFuzzTest module + * + * @kfuzztest_dir: The root debugfs directory, /sys/kernel/debug/kfuzztest/. + * @num_invocations: total number of target invocations. + * @num_targets: number of registered targets. + * @target_fops: array of file operations for each registered target. + * @minalign_fops: file operations for the /_config/minalign file. + * @num_invocations_fops: file operations for the /_config/num_invocations file. + */ +struct kfuzztest_state { + struct dentry *kfuzztest_dir; + atomic_t num_invocations; + size_t num_targets; + + struct target_fops *target_fops; + struct file_operations minalign_fops; + struct file_operations num_invocations_fops; +}; + +static struct kfuzztest_state state; + +void record_invocation(void) +{ + atomic_inc(&state.num_invocations); +} + +static void cleanup_kfuzztest_state(struct kfuzztest_state *st) +{ + debugfs_remove_recursive(st->kfuzztest_dir); + st->num_targets = 0; + st->num_invocations = (atomic_t)ATOMIC_INIT(0); + kfree(st->target_fops); + st->target_fops = NULL; +} + +static const umode_t KFUZZTEST_INPUT_PERMS = 0222; +static const umode_t KFUZZTEST_MINALIGN_PERMS = 0444; + +static ssize_t read_cb_integer(struct file *filp, char __user *buf, size_t count, loff_t *f_pos, size_t value) +{ + char buffer[64]; + int len; + + len = scnprintf(buffer, sizeof(buffer), "%zu\n", value); + return simple_read_from_buffer(buf, count, f_pos, buffer, len); +} + +/* + * Callback for /sys/kernel/debug/kfuzztest/_config/minalign. Minalign + * corresponds to the minimum alignment that regions in a KFuzzTest input must + * satisfy. This callback returns that value in string format. + */ +static ssize_t minalign_read_cb(struct file *filp, char __user *buf, size_t count, loff_t *f_pos) +{ + int minalign = MAX(KFUZZTEST_POISON_SIZE, ARCH_KMALLOC_MINALIGN); + return read_cb_integer(filp, buf, count, f_pos, minalign); +} + +/* + * Callback for /sys/kernel/debug/kfuzztest/_config/num_invocations, which + * returns the value in string format. + */ +static ssize_t num_invocations_read_cb(struct file *filp, char __user *buf, size_t count, loff_t *f_pos) +{ + return read_cb_integer(filp, buf, count, f_pos, atomic_read(&state.num_invocations)); +} + +static int create_read_only_file(struct dentry *parent, const char *name, struct file_operations *fops) +{ + struct dentry *file; + int err = 0; + + file = debugfs_create_file(name, KFUZZTEST_MINALIGN_PERMS, parent, NULL, fops); + if (!file) + err = -ENOMEM; + else if (IS_ERR(file)) + err = PTR_ERR(file); + return err; +} + +static int initialize_config_dir(struct kfuzztest_state *st) +{ + struct dentry *dir; + int err = 0; + + dir = debugfs_create_dir("_config", st->kfuzztest_dir); + if (!dir) + err = -ENOMEM; + else if (IS_ERR(dir)) + err = PTR_ERR(dir); + if (err) { + pr_info("kfuzztest: failed to create /_config dir"); + goto out; + } + + st->minalign_fops = (struct file_operations){ + .owner = THIS_MODULE, + .read = minalign_read_cb, + }; + err = create_read_only_file(dir, "minalign", &st->minalign_fops); + if (err) { + pr_info("kfuzztest: failed to create /_config/minalign"); + goto out; + } + + st->num_invocations_fops = (struct file_operations){ + .owner = THIS_MODULE, + .read = num_invocations_read_cb, + }; + err = create_read_only_file(dir, "num_invocations", &st->num_invocations_fops); + if (err) + pr_info("kfuzztest: failed to create /_config/num_invocations"); +out: + return err; +} + +static int initialize_target_dir(struct kfuzztest_state *st, const struct kfuzztest_target *targ, + struct target_fops *fops) +{ + const struct kfuzztest_simple_target *simple_targ; + struct dentry *dir, *input, *input_simple; + int err = 0; + + dir = debugfs_create_dir(targ->name, st->kfuzztest_dir); + if (!dir) + err = -ENOMEM; + else if (IS_ERR(dir)) + err = PTR_ERR(dir); + if (err) { + pr_info("kfuzztest: failed to create /kfuzztest/%s dir", targ->name); + goto out; + } + + input = debugfs_create_file("input", KFUZZTEST_INPUT_PERMS, dir, NULL, &fops->target); + if (!input) + err = -ENOMEM; + else if (IS_ERR(input)) + err = PTR_ERR(input); + if (err) { + pr_info("kfuzztest: failed to create /kfuzztest/%s/input", targ->name); + goto out; + } + + /* Check if a simple target exists for this target. */ + for (simple_targ = __kfuzztest_simple_targets_start; simple_targ < __kfuzztest_simple_targets_end; + simple_targ++) { + if (strcmp(targ->name, simple_targ->name) != 0) + continue; + fops->target_simple = (struct file_operations){ + .owner = THIS_MODULE, + .write = simple_targ->write_input_cb, + }; + input_simple = + debugfs_create_file("input_simple", KFUZZTEST_INPUT_PERMS, dir, NULL, &fops->target_simple); + if (!input_simple) + err = -ENOMEM; + else if (IS_ERR(input_simple)) + err = PTR_ERR(input_simple); + if (err) { + pr_info("kfuzztest: failed to create /kfuzztest/%s/input_simple", targ->name); + goto out; + } + break; + } +out: + return err; +} + +/** + * kfuzztest_init - initializes the debug filesystem for KFuzzTest + * + * Each registered target in the ".kfuzztest_targets" section gets its own + * subdirectory under "/sys/kernel/debug/kfuzztest/" containing one + * write-only "input" and optional "input_simple" files used for receiving + * inputs from userspace. + * Furthermore, a directory "/sys/kernel/debug/kfuzztest/_config" is created, + * containing two read-only files "minalign" and "num_invocations", that return + * the minimum required region alignment and number of successful target + * invocations respectively. + * + * @return 0 on success or an error + */ +static int __init kfuzztest_init(void) +{ + const struct kfuzztest_target *targ; + int err = 0; + int i = 0; + + state.num_targets = __kfuzztest_targets_end - __kfuzztest_targets_start; + state.target_fops = kzalloc(sizeof(struct target_fops) * state.num_targets, GFP_KERNEL); + if (!state.target_fops) + return -ENOMEM; + + /* Create the main "kfuzztest" directory in /sys/kernel/debug. */ + state.kfuzztest_dir = debugfs_create_dir("kfuzztest", NULL); + if (!state.kfuzztest_dir) { + pr_warn("kfuzztest: could not create 'kfuzztest' debugfs directory"); + return -ENOMEM; + } + if (IS_ERR(state.kfuzztest_dir)) { + pr_warn("kfuzztest: could not create 'kfuzztest' debugfs directory"); + err = PTR_ERR(state.kfuzztest_dir); + state.kfuzztest_dir = NULL; + return err; + } + + err = initialize_config_dir(&state); + if (err) + goto cleanup_failure; + + for (targ = __kfuzztest_targets_start; targ < __kfuzztest_targets_end; targ++, i++) { + state.target_fops[i].target = (struct file_operations){ + .owner = THIS_MODULE, + .write = targ->write_input_cb, + }; + err = initialize_target_dir(&state, targ, &state.target_fops[i]); + /* Bail out if a single target fails to initialize. This avoids + * partial setup, and a failure here likely indicates an issue + * with debugfs. */ + if (err) + goto cleanup_failure; + pr_info("kfuzztest: registered target %s", targ->name); + } + return 0; + +cleanup_failure: + cleanup_kfuzztest_state(&state); + return err; +} + +static void __exit kfuzztest_exit(void) +{ + pr_info("kfuzztest: exiting"); + cleanup_kfuzztest_state(&state); +} + +module_init(kfuzztest_init); +module_exit(kfuzztest_exit); diff --git a/lib/kfuzztest/parse.c b/lib/kfuzztest/parse.c new file mode 100644 index 00000000000000..22c00c2380c694 --- /dev/null +++ b/lib/kfuzztest/parse.c @@ -0,0 +1,236 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * KFuzzTest input parsing and validation. + * + * Copyright 2025 Google LLC + */ +#include +#include + +static int kfuzztest_relocate_v0(struct reloc_region_array *regions, struct reloc_table *rt, + unsigned char *payload_start, unsigned char *payload_end) +{ + unsigned char *poison_start, *poison_end; + struct reloc_region reg, src, dst; + uintptr_t *ptr_location; + struct reloc_entry re; + size_t i; + int ret; + + /* Patch pointers. */ + for (i = 0; i < rt->num_entries; i++) { + re = rt->entries[i]; + src = regions->regions[re.region_id]; + ptr_location = (uintptr_t *)(payload_start + src.offset + re.region_offset); + if (re.value == KFUZZTEST_REGIONID_NULL) + *ptr_location = (uintptr_t)NULL; + else if (re.value < regions->num_regions) { + dst = regions->regions[re.value]; + *ptr_location = (uintptr_t)(payload_start + dst.offset); + } else { + return -EINVAL; + } + } + + /* Poison the padding between regions. */ + for (i = 0; i < regions->num_regions; i++) { + reg = regions->regions[i]; + + /* Points to the beginning of the inter-region padding */ + poison_start = payload_start + reg.offset + reg.size; + if (i < regions->num_regions - 1) + poison_end = payload_start + regions->regions[i + 1].offset; + else + poison_end = payload_end; + + if (poison_end > payload_end) + return -EINVAL; + + ret = kasan_poison_range(poison_start, poison_end - poison_start); + if (ret) + return ret; + } + + /* Poison the padded area preceding the payload. */ + return kasan_poison_range(payload_start - rt->padding_size, rt->padding_size); +} + +static bool kfuzztest_input_is_valid(struct reloc_region_array *regions, struct reloc_table *rt, + unsigned char *payload_start, unsigned char *payload_end) +{ + size_t payload_size = payload_end - payload_start; + struct reloc_region reg, next_reg; + size_t usable_payload_size; + uint32_t region_end_offset; + struct reloc_entry reloc; + uint32_t i; + + if (payload_start > payload_end) + return false; + if (payload_size < KFUZZTEST_POISON_SIZE) + return false; + if ((uintptr_t)payload_end % KFUZZTEST_POISON_SIZE) + return false; + usable_payload_size = payload_size - KFUZZTEST_POISON_SIZE; + + for (i = 0; i < regions->num_regions; i++) { + reg = regions->regions[i]; + if (check_add_overflow(reg.offset, reg.size, ®ion_end_offset)) + return false; + if ((size_t)region_end_offset > usable_payload_size) + return false; + + if (i < regions->num_regions - 1) { + next_reg = regions->regions[i + 1]; + if (reg.offset > next_reg.offset) + return false; + /* Enforce the minimum poisonable gap between + * consecutive regions. */ + if (reg.offset + reg.size + KFUZZTEST_POISON_SIZE > next_reg.offset) + return false; + } + } + + if (rt->padding_size < KFUZZTEST_POISON_SIZE) { + pr_info("validation failed because rt->padding_size = %u", rt->padding_size); + return false; + } + + for (i = 0; i < rt->num_entries; i++) { + reloc = rt->entries[i]; + if (reloc.region_id >= regions->num_regions) + return false; + if (reloc.value != KFUZZTEST_REGIONID_NULL && reloc.value >= regions->num_regions) + return false; + + reg = regions->regions[reloc.region_id]; + if (reloc.region_offset % (sizeof(uintptr_t)) || reloc.region_offset + sizeof(uintptr_t) > reg.size) + return false; + } + + return true; +} + +static int kfuzztest_parse_input_v0(unsigned char *input, size_t input_size, struct reloc_region_array **ret_regions, + struct reloc_table **ret_reloc_table, unsigned char **ret_payload_start, + unsigned char **ret_payload_end) +{ + size_t reloc_entries_size, reloc_regions_size; + unsigned char *payload_end, *payload_start; + size_t reloc_table_size, regions_size; + struct reloc_region_array *regions; + struct reloc_table *rt; + size_t curr_offset = 0; + + if (input_size < sizeof(struct reloc_region_array) + sizeof(struct reloc_table)) + return -EINVAL; + + regions = (struct reloc_region_array *)input; + if (check_mul_overflow(regions->num_regions, sizeof(struct reloc_region), &reloc_regions_size)) + return -EINVAL; + if (check_add_overflow(sizeof(*regions), reloc_regions_size, ®ions_size)) + return -EINVAL; + + curr_offset = regions_size; + if (curr_offset > input_size) + return -EINVAL; + if (input_size - curr_offset < sizeof(struct reloc_table)) + return -EINVAL; + + rt = (struct reloc_table *)(input + curr_offset); + + if (check_mul_overflow((size_t)rt->num_entries, sizeof(struct reloc_entry), &reloc_entries_size)) + return -EINVAL; + if (check_add_overflow(sizeof(*rt), reloc_entries_size, &reloc_table_size)) + return -EINVAL; + if (check_add_overflow(reloc_table_size, rt->padding_size, &reloc_table_size)) + return -EINVAL; + + if (check_add_overflow(curr_offset, reloc_table_size, &curr_offset)) + return -EINVAL; + if (curr_offset > input_size) + return -EINVAL; + + payload_start = input + curr_offset; + payload_end = input + input_size; + + if (!kfuzztest_input_is_valid(regions, rt, payload_start, payload_end)) + return -EINVAL; + + *ret_regions = regions; + *ret_reloc_table = rt; + *ret_payload_start = payload_start; + *ret_payload_end = payload_end; + return 0; +} + +static int kfuzztest_parse_and_relocate_v0(unsigned char *input, size_t input_size, void **arg_ret) +{ + unsigned char *payload_start, *payload_end; + struct reloc_region_array *regions; + struct reloc_table *reloc_table; + int ret; + + ret = kfuzztest_parse_input_v0(input, input_size, ®ions, &reloc_table, &payload_start, &payload_end); + if (ret < 0) + return ret; + + ret = kfuzztest_relocate_v0(regions, reloc_table, payload_start, payload_end); + if (ret < 0) + return ret; + *arg_ret = (void *)payload_start; + return 0; +} + +int kfuzztest_parse_and_relocate(void *input, size_t input_size, void **arg_ret) +{ + size_t header_size = 2 * sizeof(u32); + u32 version, magic; + + if (input_size < sizeof(u32) + sizeof(u32)) + return -EINVAL; + + magic = *(u32 *)input; + if (magic != KFUZZTEST_HEADER_MAGIC) + return -EINVAL; + + version = *(u32 *)(input + sizeof(u32)); + switch (version) { + case KFUZZTEST_V0: + return kfuzztest_parse_and_relocate_v0(input + header_size, input_size - header_size, arg_ret); + } + + return -EINVAL; +} + +int kfuzztest_write_cb_common(struct file *filp, const char __user *buf, size_t len, loff_t *off, void **test_buffer) +{ + void *buffer; + ssize_t ret; + + /* + * Taint the kernel on the first fuzzing invocation. The debugfs + * interface provides a high-risk entry point for userspace to + * call kernel functions with untrusted input. + */ + if (!test_taint(TAINT_TEST)) + add_taint(TAINT_TEST, LOCKDEP_STILL_OK); + + if (len >= KFUZZTEST_MAX_INPUT_SIZE) { + pr_warn("kfuzztest: user input of size %zu is too large", len); + return -EINVAL; + } + + buffer = (char *)kzalloc(len, GFP_KERNEL); + if (!buffer) + return -ENOMEM; + + ret = simple_write_to_buffer(buffer, len, off, buf, len); + if (ret != len) { + kfree(buffer); + return -EFAULT; + } + + *test_buffer = buffer; + return 0; +} diff --git a/tools/testing/kfuzztest-bridge/kfuzztest-bridge b/tools/testing/kfuzztest-bridge/kfuzztest-bridge new file mode 100755 index 0000000000000000000000000000000000000000..e15ac6486c667416d2c37b639358d71a00149d76 GIT binary patch literal 911160 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

{+9}bloD5d`8C8B1m$%!Ux7vC zk0zo~;`91$ll^D#J%;n*J_sd=%r%ITI3}=_G<*=g{};qT&>y#ei8JFud2!c z)PFD30|Q$t@)o01Wno~$T_IQZ#;UeiWsS@P4tx&%nw4&MaY)qpZv` zJo#_Ys&OJ6B2Y_zNHmtfO!nPx!&-N(CN}5y1k5q0buy^%(EDPWEbNu|6kvNJ!586@ zFH-T`W!yKX4W!N^7PXp`aq9i{OW?`zrbGOt{{TbtDeo6>A|<(VVY2xoMZ-%HyE zV?_Qc;z;_mvmLWppBGobyz?CZzT8lhw*^NN)ZqJY3y$Osv}6B0X)6d^7kT#GzrjC` z1`NtO?}g(;`~aD4Fgp_4eialM2-b+O{PP(Q8#ZjvcuxW&@2N~W!mc90u8kpf86z+L zIb-C_t0lLo26kS;<9v?oWsBmV0m6~rB7+(Kprkck7- zKtB`^P0bE*gr(pw+gAQ=RmHaN&5Ot06?a**#xJnO@#P;HyZnh%(&Xg0v(j&lOYeup z42A@R$6Fh)2dF1&#XiPqZOE;cr$76x*VFRySXwI$8*1eZ!;5v@PfXcU{t%h7u^t7x z;a8b^C56x?MThBUOcHr5#w71U!ugTkrU*1_>{O6-xP^wtOJQv_)J$D%S+fGG=`RoS z*C6?g^)N6UzQghbX2ZAt@abklER3PqFr=~2z>z3_-*oT^TcHFc?m~?Ex6-RdIS2{Q zeGx>70g(Q>d<`E$U27w|4_C_xv;=$rjSP(uOl{h-<&A-f$|wI8ncCQcLq+R4YZN$zW}bpJ5pcAC zs|EZfCQVSgtjBYpnEx^B(cB*jLj?IkC_GN+c;Fk0`OP#eLhKmWtFoHRaGv~=UQ#-U z@C_oCHS-Gu#$~y2=TCE1UMJx+f63za)x?cKB~RxL1cd2IG<0MAGzO%Y|Bzr@)S&>v zG3Jo~eLA1dLmwSah(0H%w93<9KSrbKv!s*QeMNIL>YJlR8vk*20-T=~eoP#h$vL0y zDXpJvtz6FfXYJ1PE4%Bz%mqHns(5c@ZhZj=s#7UoZ2){+7+r9kd^8U4dCgIDf%x;* zeqEV%x~J00Tqwm%+@f%XuJvSEkl4C|(#;zjcRV=V{FoKap@3maeM#W25^xz>$a#Xm$8BO?a=%T;t4C$4{y{4n7k z{!5@}x`$J{$L?aZe-TjmD_F`p@0Z6(loHbJ5Q+%f_LpiSys=P%_03O(?E6Gewj)S? zb2Jf@qs|u9Aunf0!|(WXxqKSLCl(t@p(ATm4gcy83V84rBd+r8f8sZdaJT}j-~1o zg6Nr2Y1N%6d1HnL`2l<6)$*+}_Ph{DW6)WjEm14X+R z6eWGdhAJp1iQ# zw6tt0aZ6Q+f1ixN3Ceob0VR>(cGK)spbDoEb?dOt5 z>rX|s991lyi?MO2&3)FM5T1YG!P8`99Me8&oZ!>k z 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�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ν09}+VnN~Dppk+mTU`xuz!a2@WoPh{ZuzE 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 literal 0 HcmV?d00001 From a50592a4cdf37f93c2bb880f143596311fbc8526 Mon Sep 17 00:00:00 2001 From: Ethan Graham Date: Fri, 29 Aug 2025 13:27:40 +0000 Subject: [PATCH 05/11] tools: add kfuzztest-bridge utility Introduce the kfuzztest-bridge tool, a userspace utility for sending structured inputs to KFuzzTest harnesses via debugfs. The bridge takes a textual description of the expected input format, a file containing random bytes, and the name of the target fuzz test. It parses the description, encodes the random data into the binary format expected by the kernel, and writes the result to the corresponding debugfs entry. This allows for both simple manual testing and integration with userspace fuzzing engines. For example, it can be used for smoke testing by providing data from /dev/urandom, or act as a bridge for blob-based fuzzers (e.g., AFL) to target KFuzzTest harnesses. Signed-off-by: Ethan Graham Signed-off-by: Ethan Graham Reviewed-by: Alexander Potapenko --- PR v2: - Move kfuzztest-bridge tool under tools/testing, as suggested by SeongJae Park. - Cleanup several resource leaks that were pointed out by Alexander Potapenko. PR v1: - Add additional context in header comment of kfuzztest-bridge/parser.c. - Add some missing NULL checks. - Refactor skip_whitespace() function in input_lexer.c. - Use ctx->minalign to compute correct region alignment, which is read from /sys/kernel/debug/kfuzztest/_config/minalign. --- --- tools/Makefile | 18 +- tools/testing/kfuzztest-bridge/.gitignore | 2 + tools/testing/kfuzztest-bridge/Build | 6 + tools/testing/kfuzztest-bridge/Makefile | 49 ++ tools/testing/kfuzztest-bridge/bridge.c | 115 +++++ tools/testing/kfuzztest-bridge/byte_buffer.c | 85 ++++ tools/testing/kfuzztest-bridge/byte_buffer.h | 31 ++ tools/testing/kfuzztest-bridge/encoder.c | 390 ++++++++++++++++ tools/testing/kfuzztest-bridge/encoder.h | 16 + tools/testing/kfuzztest-bridge/input_lexer.c | 256 +++++++++++ tools/testing/kfuzztest-bridge/input_lexer.h | 58 +++ tools/testing/kfuzztest-bridge/input_parser.c | 423 ++++++++++++++++++ tools/testing/kfuzztest-bridge/input_parser.h | 82 ++++ tools/testing/kfuzztest-bridge/rand_stream.c | 77 ++++ tools/testing/kfuzztest-bridge/rand_stream.h | 57 +++ 15 files changed, 1662 insertions(+), 3 deletions(-) create mode 100644 tools/testing/kfuzztest-bridge/.gitignore create mode 100644 tools/testing/kfuzztest-bridge/Build create mode 100644 tools/testing/kfuzztest-bridge/Makefile create mode 100644 tools/testing/kfuzztest-bridge/bridge.c create mode 100644 tools/testing/kfuzztest-bridge/byte_buffer.c create mode 100644 tools/testing/kfuzztest-bridge/byte_buffer.h create mode 100644 tools/testing/kfuzztest-bridge/encoder.c create mode 100644 tools/testing/kfuzztest-bridge/encoder.h create mode 100644 tools/testing/kfuzztest-bridge/input_lexer.c create mode 100644 tools/testing/kfuzztest-bridge/input_lexer.h create mode 100644 tools/testing/kfuzztest-bridge/input_parser.c create mode 100644 tools/testing/kfuzztest-bridge/input_parser.h create mode 100644 tools/testing/kfuzztest-bridge/rand_stream.c create mode 100644 tools/testing/kfuzztest-bridge/rand_stream.h diff --git a/tools/Makefile b/tools/Makefile index c31cbbd12c456a..dfb0cd19aeb939 100644 --- a/tools/Makefile +++ b/tools/Makefile @@ -21,6 +21,7 @@ help: @echo ' hv - tools used when in Hyper-V clients' @echo ' iio - IIO tools' @echo ' intel-speed-select - Intel Speed Select tool' + @echo ' kfuzztest-bridge - KFuzzTest userspace utility' @echo ' kvm_stat - top-like utility for displaying kvm statistics' @echo ' leds - LEDs tools' @echo ' nolibc - nolibc headers testing and installation' @@ -98,6 +99,9 @@ sched_ext: FORCE selftests: FORCE $(call descend,testing/$@) +kfuzztest-bridge: FORCE + $(call descend,testing/kfuzztest-bridge) + thermal: FORCE $(call descend,lib/$@) @@ -126,7 +130,8 @@ all: acpi counter cpupower gpio hv firewire \ perf selftests bootconfig spi turbostat usb \ virtio mm bpf x86_energy_perf_policy \ tmon freefall iio objtool kvm_stat wmi \ - debugging tracing thermal thermometer thermal-engine ynl + debugging tracing thermal thermometer thermal-engine ynl \ + kfuzztest-bridge acpi_install: $(call descend,power/$(@:_install=),install) @@ -140,6 +145,9 @@ counter_install firewire_install gpio_install hv_install iio_install perf_instal selftests_install: $(call descend,testing/$(@:_install=),install) +kfuzztest-bridge_install: + $(call descend,testing/kfuzztest-bridge,install) + thermal_install: $(call descend,lib/$(@:_install=),install) @@ -170,7 +178,8 @@ install: acpi_install counter_install cpupower_install gpio_install \ virtio_install mm_install bpf_install x86_energy_perf_policy_install \ tmon_install freefall_install objtool_install kvm_stat_install \ wmi_install debugging_install intel-speed-select_install \ - tracing_install thermometer_install thermal-engine_install ynl_install + tracing_install thermometer_install thermal-engine_install ynl_install \ + kfuzztest-bridge_install acpi_clean: $(call descend,power/acpi,clean) @@ -200,6 +209,9 @@ sched_ext_clean: selftests_clean: $(call descend,testing/$(@:_clean=),clean) +kfuzztest-bridge_clean: + $(call descend,testing/kfuzztest-bridge,clean) + thermal_clean: $(call descend,lib/thermal,clean) @@ -230,6 +242,6 @@ clean: acpi_clean counter_clean cpupower_clean hv_clean firewire_clean \ freefall_clean build_clean libbpf_clean libsubcmd_clean \ gpio_clean objtool_clean leds_clean wmi_clean firmware_clean debugging_clean \ intel-speed-select_clean tracing_clean thermal_clean thermometer_clean thermal-engine_clean \ - sched_ext_clean ynl_clean + sched_ext_clean ynl_clean kfuzztest-bridge_clean .PHONY: FORCE diff --git a/tools/testing/kfuzztest-bridge/.gitignore b/tools/testing/kfuzztest-bridge/.gitignore new file mode 100644 index 00000000000000..4aa9fb0d44e292 --- /dev/null +++ b/tools/testing/kfuzztest-bridge/.gitignore @@ -0,0 +1,2 @@ +# SPDX-License-Identifier: GPL-2.0-only +kfuzztest-bridge diff --git a/tools/testing/kfuzztest-bridge/Build b/tools/testing/kfuzztest-bridge/Build new file mode 100644 index 00000000000000..d07341a226d636 --- /dev/null +++ b/tools/testing/kfuzztest-bridge/Build @@ -0,0 +1,6 @@ +kfuzztest-bridge-y += bridge.o +kfuzztest-bridge-y += byte_buffer.o +kfuzztest-bridge-y += encoder.o +kfuzztest-bridge-y += input_lexer.o +kfuzztest-bridge-y += input_parser.o +kfuzztest-bridge-y += rand_stream.o diff --git a/tools/testing/kfuzztest-bridge/Makefile b/tools/testing/kfuzztest-bridge/Makefile new file mode 100644 index 00000000000000..6e110bdeaee51c --- /dev/null +++ b/tools/testing/kfuzztest-bridge/Makefile @@ -0,0 +1,49 @@ +# SPDX-License-Identifier: GPL-2.0 +# Makefile for KFuzzTest-Bridge +include ../../scripts/Makefile.include + +bindir ?= /usr/bin + +ifeq ($(srctree),) +srctree := $(patsubst %/,%,$(dir $(CURDIR))) +srctree := $(patsubst %/,%,$(dir $(srctree))) +srctree := $(patsubst %/,%,$(dir $(srctree))) +endif + +MAKEFLAGS += -r + +override CFLAGS += -O2 -g +override CFLAGS += -Wall -Wextra +override CFLAGS += -D_GNU_SOURCE +override CFLAGS += -I$(OUTPUT)include -I$(srctree)/tools/include + +ALL_TARGETS := kfuzztest-bridge +ALL_PROGRAMS := $(patsubst %,$(OUTPUT)%,$(ALL_TARGETS)) + +KFUZZTEST_BRIDGE_IN := $(OUTPUT)kfuzztest-bridge-in.o +KFUZZTEST_BRIDGE := $(OUTPUT)kfuzztest-bridge + +all: $(ALL_PROGRAMS) + +export srctree OUTPUT CC LD CFLAGS +include $(srctree)/tools/build/Makefile.include + +$(KFUZZTEST_BRIDGE_IN): FORCE + $(Q)$(MAKE) $(build)=kfuzztest-bridge + +$(KFUZZTEST_BRIDGE): $(KFUZZTEST_BRIDGE_IN) + $(QUIET_LINK)$(CC) $(CFLAGS) $< -o $@ $(LDFLAGS) + +clean: + rm -f $(ALL_PROGRAMS) + find $(or $(OUTPUT),.) -name '*.o' -delete -o -name '\.*.d' -delete -o -name '\.*.o.cmd' -delete + +install: $(ALL_PROGRAMS) + install -d -m 755 $(DESTDIR)$(bindir); \ + for program in $(ALL_PROGRAMS); do \ + install $$program $(DESTDIR)$(bindir); \ + done + +FORCE: + +.PHONY: all install clean FORCE prepare diff --git a/tools/testing/kfuzztest-bridge/bridge.c b/tools/testing/kfuzztest-bridge/bridge.c new file mode 100644 index 00000000000000..aec0eb4e9ff73c --- /dev/null +++ b/tools/testing/kfuzztest-bridge/bridge.c @@ -0,0 +1,115 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * KFuzzTest tool for sending inputs into a KFuzzTest harness + * + * Copyright 2025 Google LLC + */ +#include +#include +#include +#include +#include + +#include "byte_buffer.h" +#include "encoder.h" +#include "input_lexer.h" +#include "input_parser.h" +#include "rand_stream.h" + +static int invoke_kfuzztest_target(const char *target_name, const char *data, ssize_t data_size) +{ + ssize_t bytes_written; + char *buf = NULL; + int ret; + int fd; + + if (asprintf(&buf, "/sys/kernel/debug/kfuzztest/%s/input", target_name) < 0) + return -ENOMEM; + + fd = openat(AT_FDCWD, buf, O_WRONLY, 0); + if (fd < 0) { + ret = -errno; + goto out_free; + } + + /* + * A KFuzzTest target's debugfs handler expects the entire input to be + * written in a single contiguous blob. Treat partial writes as errors. + */ + bytes_written = write(fd, data, data_size); + if (bytes_written != data_size) { + ret = (bytes_written < 0) ? -errno : -EIO; + goto out_close; + } + ret = 0; + +out_close: + if (close(fd) != 0 && ret == 0) + ret = -errno; +out_free: + free(buf); + return ret; +} + +static int invoke_one(const char *input_fmt, const char *fuzz_target, const char *input_filepath) +{ + struct ast_node *ast_prog; + struct byte_buffer *bb; + struct rand_stream *rs; + struct token **tokens; + size_t num_tokens; + size_t num_bytes; + int err; + + err = tokenize(input_fmt, &tokens, &num_tokens); + if (err) { + fprintf(stderr, "tokenization failed: %s\n", strerror(-err)); + return err; + } + + err = parse(tokens, num_tokens, &ast_prog); + if (err) { + fprintf(stderr, "parsing failed: %s\n", strerror(-err)); + goto cleanup_tokens; + } + + rs = new_rand_stream(input_filepath, 1024); + if (!rs) { + err = -ENOMEM; + goto cleanup_ast; + } + + err = encode(ast_prog, rs, &num_bytes, &bb); + if (err == STREAM_EOF) { + fprintf(stderr, "encoding failed: reached EOF in %s\n", input_filepath); + err = -EINVAL; + goto cleanup_rs; + } else if (err) { + fprintf(stderr, "encoding failed: %s\n", strerror(-err)); + goto cleanup_rs; + } + + err = invoke_kfuzztest_target(fuzz_target, bb->buffer, (ssize_t)num_bytes); + if (err) + fprintf(stderr, "invocation failed: %s\n", strerror(-err)); + + destroy_byte_buffer(bb); +cleanup_rs: + destroy_rand_stream(rs); +cleanup_ast: + destroy_ast_node(ast_prog); +cleanup_tokens: + destroy_tokens(tokens, num_tokens); + return err; +} + +int main(int argc, char *argv[]) +{ + if (argc != 4) { + printf("Usage: %s \n", argv[0]); + printf("For more detailed information see Documentation/dev-tools/kfuzztest.rst\n"); + return 1; + } + + return invoke_one(argv[1], argv[2], argv[3]); +} diff --git a/tools/testing/kfuzztest-bridge/byte_buffer.c b/tools/testing/kfuzztest-bridge/byte_buffer.c new file mode 100644 index 00000000000000..1974dbf3862e8c --- /dev/null +++ b/tools/testing/kfuzztest-bridge/byte_buffer.c @@ -0,0 +1,85 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * A simple byte buffer implementation for encoding binary data + * + * Copyright 2025 Google LLC + */ +#include +#include +#include + +#include "byte_buffer.h" + +struct byte_buffer *new_byte_buffer(size_t initial_size) +{ + struct byte_buffer *ret; + size_t alloc_size = initial_size >= 8 ? initial_size : 8; + + ret = malloc(sizeof(*ret)); + if (!ret) + return NULL; + + ret->alloc_size = alloc_size; + ret->buffer = malloc(alloc_size); + if (!ret->buffer) { + free(ret); + return NULL; + } + ret->num_bytes = 0; + return ret; +} + +void destroy_byte_buffer(struct byte_buffer *buf) +{ + free(buf->buffer); + free(buf); +} + +int append_bytes(struct byte_buffer *buf, const char *bytes, size_t num_bytes) +{ + size_t req_size; + size_t new_size; + char *new_ptr; + + req_size = buf->num_bytes + num_bytes; + new_size = buf->alloc_size; + + while (req_size > new_size) + new_size *= 2; + if (new_size != buf->alloc_size) { + new_ptr = realloc(buf->buffer, new_size); + if (!new_ptr) + return -ENOMEM; + buf->buffer = new_ptr; + buf->alloc_size = new_size; + } + memcpy(buf->buffer + buf->num_bytes, bytes, num_bytes); + buf->num_bytes += num_bytes; + return 0; +} + +int append_byte(struct byte_buffer *buf, char c) +{ + return append_bytes(buf, &c, 1); +} + +int encode_le(struct byte_buffer *buf, uint64_t value, size_t byte_width) +{ + size_t i; + int ret; + + for (i = 0; i < byte_width; ++i) + if ((ret = append_byte(buf, (uint8_t)((value >> (i * 8)) & 0xFF)))) + return ret; + return 0; +} + +int pad(struct byte_buffer *buf, size_t num_padding) +{ + int ret; + size_t i; + for (i = 0; i < num_padding; i++) + if ((ret = append_byte(buf, 0))) + return ret; + return 0; +} diff --git a/tools/testing/kfuzztest-bridge/byte_buffer.h b/tools/testing/kfuzztest-bridge/byte_buffer.h new file mode 100644 index 00000000000000..6a31bfb5e78f43 --- /dev/null +++ b/tools/testing/kfuzztest-bridge/byte_buffer.h @@ -0,0 +1,31 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * A simple byte buffer implementation for encoding binary data + * + * Copyright 2025 Google LLC + */ +#ifndef KFUZZTEST_BRIDGE_BYTE_BUFFER_H +#define KFUZZTEST_BRIDGE_BYTE_BUFFER_H + +#include +#include + +struct byte_buffer { + char *buffer; + size_t num_bytes; + size_t alloc_size; +}; + +struct byte_buffer *new_byte_buffer(size_t initial_size); + +void destroy_byte_buffer(struct byte_buffer *buf); + +int append_bytes(struct byte_buffer *buf, const char *bytes, size_t num_bytes); + +int append_byte(struct byte_buffer *buf, char c); + +int encode_le(struct byte_buffer *buf, uint64_t value, size_t byte_width); + +int pad(struct byte_buffer *buf, size_t num_padding); + +#endif /* KFUZZTEST_BRIDGE_BYTE_BUFFER_H */ diff --git a/tools/testing/kfuzztest-bridge/encoder.c b/tools/testing/kfuzztest-bridge/encoder.c new file mode 100644 index 00000000000000..11ff5bd589d3f2 --- /dev/null +++ b/tools/testing/kfuzztest-bridge/encoder.c @@ -0,0 +1,390 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Encoder for KFuzzTest binary input format + * + * Copyright 2025 Google LLC + */ +#include +#include +#include +#include +#include + +#include "byte_buffer.h" +#include "input_parser.h" +#include "rand_stream.h" + +#define KFUZZTEST_MAGIC 0xBFACE +#define KFUZZTEST_PROTO_VERSION 0 + +/* + * The KFuzzTest binary input format requires at least 8 bytes of padding + * at the head and tail of every region. + */ +#define KFUZZTEST_POISON_SIZE 8 + +#define BUFSIZE_SMALL 32 +#define BUFSIZE_LARGE 128 + +struct region_info { + const char *name; + uint32_t offset; + uint32_t size; +}; + +struct reloc_info { + uint32_t src_reg; + uint32_t offset; + uint32_t dst_reg; +}; + +struct encoder_ctx { + struct byte_buffer *payload; + struct rand_stream *rand; + + struct region_info *regions; + size_t num_regions; + + struct reloc_info *relocations; + size_t num_relocations; + + size_t minalign; + size_t reg_offset; + int curr_reg; +}; + +static void cleanup_ctx(struct encoder_ctx *ctx) +{ + if (ctx->regions) + free(ctx->regions); + if (ctx->relocations) + free(ctx->relocations); + if (ctx->payload) + destroy_byte_buffer(ctx->payload); +} + +static int read_minalign(struct encoder_ctx *ctx) +{ + const char *minalign_file = "/sys/kernel/debug/kfuzztest/_config/minalign"; + char buffer[64 + 1] = { 0 }; + int ret = 0; + + FILE *f = fopen(minalign_file, "r"); + if (!f) + return -ENOENT; + + fread(&buffer, 1, sizeof(buffer) - 1, f); + if (ferror(f)) + return ferror(f); + + /* + * atoi returns 0 on error. Since we expect a strictly positive + * minalign value on all architectures, any non-positive value + * represents an error. + */ + ret = atoi(buffer); + if (ret <= 0) { + fclose(f); + return -EINVAL; + } + ctx->minalign = ret; + fclose(f); + return 0; +} + +static int pad_payload(struct encoder_ctx *ctx, size_t amount) +{ + int ret; + + if ((ret = pad(ctx->payload, amount))) + return ret; + ctx->reg_offset += amount; + return 0; +} + +static int align_payload(struct encoder_ctx *ctx, size_t alignment) +{ + size_t pad_amount = ROUND_UP_TO_MULTIPLE(ctx->payload->num_bytes, alignment) - ctx->payload->num_bytes; + return pad_payload(ctx, pad_amount); +} + +static int lookup_reg(struct encoder_ctx *ctx, const char *name) +{ + size_t i; + + for (i = 0; i < ctx->num_regions; i++) { + if (strcmp(ctx->regions[i].name, name) == 0) + return i; + } + return -ENOENT; +} + +static int add_reloc(struct encoder_ctx *ctx, struct reloc_info reloc) +{ + void *new_ptr = realloc(ctx->relocations, (ctx->num_relocations + 1) * sizeof(struct reloc_info)); + if (!new_ptr) + return -ENOMEM; + + ctx->relocations = new_ptr; + ctx->relocations[ctx->num_relocations] = reloc; + ctx->num_relocations++; + return 0; +} + +static int build_region_map(struct encoder_ctx *ctx, struct ast_node *top_level) +{ + struct ast_program *prog; + struct ast_node *reg; + size_t i; + + if (top_level->type != NODE_PROGRAM) + return -EINVAL; + + prog = &top_level->data.program; + ctx->regions = malloc(prog->num_members * sizeof(struct region_info)); + if (!ctx->regions) + return -ENOMEM; + + ctx->num_regions = prog->num_members; + for (i = 0; i < ctx->num_regions; i++) { + reg = prog->members[i]; + /* Offset is determined after the second pass. */ + ctx->regions[i] = (struct region_info){ + .name = reg->data.region.name, + .size = node_size(reg), + }; + } + return 0; +} +/** + * Encodes a value node as little-endian. A value node is one that has no + * children, and can therefore be directly written into the payload. + */ +static int encode_value_le(struct encoder_ctx *ctx, struct ast_node *node) +{ + size_t array_size; + char rand_char; + size_t length; + size_t i; + int reg; + int ret; + + switch (node->type) { + case NODE_ARRAY: + array_size = node->data.array.num_elems * node->data.array.elem_size; + for (i = 0; i < array_size; i++) { + if ((ret = next_byte(ctx->rand, &rand_char))) + return ret; + if ((ret = append_byte(ctx->payload, rand_char))) + return ret; + } + ctx->reg_offset += array_size; + if (node->data.array.null_terminated) { + if ((ret = pad_payload(ctx, 1))) + return ret; + ctx->reg_offset++; + } + break; + case NODE_LENGTH: + reg = lookup_reg(ctx, node->data.length.length_of); + if (reg < 0) + return reg; + length = ctx->regions[reg].size; + if ((ret = encode_le(ctx->payload, length, node->data.length.byte_width))) + return ret; + ctx->reg_offset += node->data.length.byte_width; + break; + case NODE_PRIMITIVE: + for (i = 0; i < node->data.primitive.byte_width; i++) { + if ((ret = next_byte(ctx->rand, &rand_char))) + return ret; + if ((ret = append_byte(ctx->payload, rand_char))) + return ret; + } + ctx->reg_offset += node->data.primitive.byte_width; + break; + case NODE_POINTER: + reg = lookup_reg(ctx, node->data.pointer.points_to); + if (reg < 0) + return reg; + if ((ret = add_reloc(ctx, (struct reloc_info){ .src_reg = ctx->curr_reg, + .offset = ctx->reg_offset, + .dst_reg = reg }))) + return ret; + /* Placeholder pointer value, as pointers are patched by KFuzzTest anyways. */ + if ((ret = encode_le(ctx->payload, UINTPTR_MAX, sizeof(uintptr_t)))) + return ret; + ctx->reg_offset += sizeof(uintptr_t); + break; + case NODE_PROGRAM: + case NODE_REGION: + default: + return -EINVAL; + } + return 0; +} + +static int encode_region(struct encoder_ctx *ctx, struct ast_region *reg) +{ + struct ast_node *child; + size_t i; + int ret; + + ctx->reg_offset = 0; + for (i = 0; i < reg->num_members; i++) { + child = reg->members[i]; + if ((ret = align_payload(ctx, node_alignment(child)))) + return ret; + if ((ret = encode_value_le(ctx, child))) + return ret; + } + return 0; +} + +static int encode_payload(struct encoder_ctx *ctx, struct ast_node *top_level) +{ + struct ast_node *reg; + size_t i; + int ret; + + for (i = 0; i < ctx->num_regions; i++) { + reg = top_level->data.program.members[i]; + if ((ret = align_payload(ctx, MAX(ctx->minalign, node_alignment(reg))))) + return ret; + + ctx->curr_reg = i; + ctx->regions[i].offset = ctx->payload->num_bytes; + if ((ret = encode_region(ctx, ®->data.region))) + return ret; + if ((ret = pad_payload(ctx, KFUZZTEST_POISON_SIZE))) + return ret; + } + return align_payload(ctx, ctx->minalign); +} + +static int encode_region_array(struct encoder_ctx *ctx, struct byte_buffer **ret) +{ + struct byte_buffer *reg_array; + struct region_info info; + int retcode; + size_t i; + + reg_array = new_byte_buffer(BUFSIZE_SMALL); + if (!reg_array) + return -ENOMEM; + + if ((retcode = encode_le(reg_array, ctx->num_regions, sizeof(uint32_t)))) + goto fail; + + for (i = 0; i < ctx->num_regions; i++) { + info = ctx->regions[i]; + if ((retcode = encode_le(reg_array, info.offset, sizeof(uint32_t)))) + goto fail; + if ((retcode = encode_le(reg_array, info.size, sizeof(uint32_t)))) + goto fail; + } + *ret = reg_array; + return 0; + +fail: + destroy_byte_buffer(reg_array); + return retcode; +} + +static int encode_reloc_table(struct encoder_ctx *ctx, size_t padding_amount, struct byte_buffer **ret) +{ + struct byte_buffer *reloc_table; + struct reloc_info info; + int retcode; + size_t i; + + reloc_table = new_byte_buffer(BUFSIZE_SMALL); + if (!reloc_table) + return -ENOMEM; + + if ((retcode = encode_le(reloc_table, ctx->num_relocations, sizeof(uint32_t))) || + (retcode = encode_le(reloc_table, padding_amount, sizeof(uint32_t)))) + goto fail; + + for (i = 0; i < ctx->num_relocations; i++) { + info = ctx->relocations[i]; + if ((retcode = encode_le(reloc_table, info.src_reg, sizeof(uint32_t))) || + (retcode = encode_le(reloc_table, info.offset, sizeof(uint32_t))) || + (retcode = encode_le(reloc_table, info.dst_reg, sizeof(uint32_t)))) + goto fail; + } + pad(reloc_table, padding_amount); + *ret = reloc_table; + return 0; + +fail: + destroy_byte_buffer(reloc_table); + return retcode; +} + +static size_t reloc_table_size(struct encoder_ctx *ctx) +{ + return 2 * sizeof(uint32_t) + 3 * ctx->num_relocations * sizeof(uint32_t); +} + +int encode(struct ast_node *top_level, struct rand_stream *r, size_t *num_bytes, struct byte_buffer **ret) +{ + struct byte_buffer *region_array = NULL; + struct byte_buffer *final_buffer = NULL; + struct byte_buffer *reloc_table = NULL; + size_t header_size; + int alignment; + int retcode; + + struct encoder_ctx ctx = { 0 }; + if ((retcode = read_minalign(&ctx))) + return retcode; + + if ((retcode = build_region_map(&ctx, top_level))) + goto fail; + + ctx.rand = r; + ctx.payload = new_byte_buffer(BUFSIZE_SMALL); + if (!ctx.payload) { + retcode = -ENOMEM; + goto fail; + } + if ((retcode = encode_payload(&ctx, top_level))) + goto fail; + + if ((retcode = encode_region_array(&ctx, ®ion_array))) + goto fail; + + header_size = sizeof(uint64_t) + region_array->num_bytes + reloc_table_size(&ctx); + alignment = node_alignment(top_level); + if ((retcode = encode_reloc_table( + &ctx, ROUND_UP_TO_MULTIPLE(header_size + KFUZZTEST_POISON_SIZE, alignment) - header_size, + &reloc_table))) + goto fail; + + final_buffer = new_byte_buffer(BUFSIZE_LARGE); + if (!final_buffer) { + retcode = -ENOMEM; + goto fail; + } + + if ((retcode = encode_le(final_buffer, KFUZZTEST_MAGIC, sizeof(uint32_t))) || + (retcode = encode_le(final_buffer, KFUZZTEST_PROTO_VERSION, sizeof(uint32_t))) || + (retcode = append_bytes(final_buffer, region_array->buffer, region_array->num_bytes)) || + (retcode = append_bytes(final_buffer, reloc_table->buffer, reloc_table->num_bytes)) || + (retcode = append_bytes(final_buffer, ctx.payload->buffer, ctx.payload->num_bytes))) { + destroy_byte_buffer(final_buffer); + goto fail; + } + + *num_bytes = final_buffer->num_bytes; + *ret = final_buffer; + +fail: + if (region_array) + destroy_byte_buffer(region_array); + if (reloc_table) + destroy_byte_buffer(reloc_table); + cleanup_ctx(&ctx); + return retcode; +} diff --git a/tools/testing/kfuzztest-bridge/encoder.h b/tools/testing/kfuzztest-bridge/encoder.h new file mode 100644 index 00000000000000..73f8c4b7893cb8 --- /dev/null +++ b/tools/testing/kfuzztest-bridge/encoder.h @@ -0,0 +1,16 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Encoder for KFuzzTest binary input format + * + * Copyright 2025 Google LLC + */ +#ifndef KFUZZTEST_BRIDGE_ENCODER_H +#define KFUZZTEST_BRIDGE_ENCODER_H + +#include "input_parser.h" +#include "rand_stream.h" +#include "byte_buffer.h" + +int encode(struct ast_node *top_level, struct rand_stream *r, size_t *num_bytes, struct byte_buffer **ret); + +#endif /* KFUZZTEST_BRIDGE_ENCODER_H */ diff --git a/tools/testing/kfuzztest-bridge/input_lexer.c b/tools/testing/kfuzztest-bridge/input_lexer.c new file mode 100644 index 00000000000000..d0a3e352a2654a --- /dev/null +++ b/tools/testing/kfuzztest-bridge/input_lexer.c @@ -0,0 +1,256 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Parser for KFuzzTest textual input format + * + * Copyright 2025 Google LLC + */ +#include +#include +#include +#include +#include +#include + +#include "input_lexer.h" + +struct keyword_map { + const char *keyword; + enum token_type type; +}; + +static struct keyword_map keywords[] = { + { "ptr", TOKEN_KEYWORD_PTR }, { "arr", TOKEN_KEYWORD_ARR }, + { "len", TOKEN_KEYWORD_LEN }, { "str", TOKEN_KEYWORD_STR }, + { "u8", TOKEN_KEYWORD_U8 }, { "u16", TOKEN_KEYWORD_U16 }, + { "u32", TOKEN_KEYWORD_U32 }, { "u64", TOKEN_KEYWORD_U64 }, +}; + +static struct token *make_token(enum token_type type, size_t position) +{ + struct token *ret = calloc(1, sizeof(*ret)); + ret->position = position; + ret->type = type; + return ret; +} + +void destroy_tokens(struct token **tokens, size_t num_tokens) +{ + size_t i; + + if (!tokens) + return; + + for (i = 0; i < num_tokens; i++) + if (tokens[i]) + free(tokens[i]); + free(tokens); +} + +struct lexer { + const char *start; + const char *current; + size_t position; +}; + +static char advance(struct lexer *l) +{ + l->current++; + l->position++; + return l->current[-1]; +} + +static void retreat(struct lexer *l) +{ + l->position--; + l->current--; +} + +static char peek(struct lexer *l) +{ + return *l->current; +} + +static bool is_digit(char c) +{ + return c >= '0' && c <= '9'; +} + +static bool is_alpha(char c) +{ + return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'); +} + +static bool is_whitespace(char c) +{ + switch (c) { + case ' ': + case '\r': + case '\t': + case '\n': + return true; + default: + return false; + } +} + +static void skip_whitespace(struct lexer *l) +{ + while (is_whitespace(peek(l))) + advance(l); +} + +static struct token *number(struct lexer *l) +{ + struct token *tok; + uint64_t value; + while (is_digit(peek(l))) + advance(l); + value = strtoull(l->start, NULL, 10); + tok = make_token(TOKEN_INTEGER, l->position); + tok->data.integer = value; + return tok; +} + +static enum token_type check_keyword(struct lexer *l, const char *keyword, + enum token_type type) +{ + size_t len = strlen(keyword); + + if (((size_t)(l->current - l->start) == len) && + strncmp(l->start, keyword, len) == 0) + return type; + return TOKEN_IDENTIFIER; +} + +static struct token *identifier(struct lexer *l) +{ + enum token_type type = TOKEN_IDENTIFIER; + struct token *tok; + size_t i; + + while (is_digit(peek(l)) || is_alpha(peek(l)) || peek(l) == '_') + advance(l); + + for (i = 0; i < ARRAY_SIZE(keywords); i++) { + if (check_keyword(l, keywords[i].keyword, keywords[i].type) != + TOKEN_IDENTIFIER) { + type = keywords[i].type; + break; + } + } + + tok = make_token(type, l->position); + if (!tok) + return NULL; + if (type == TOKEN_IDENTIFIER) { + tok->data.identifier.start = l->start; + tok->data.identifier.length = l->current - l->start; + } + return tok; +} + +static struct token *scan_token(struct lexer *l) +{ + char c; + skip_whitespace(l); + + l->start = l->current; + c = peek(l); + + if (c == '\0') + return make_token(TOKEN_EOF, l->position); + + advance(l); + switch (c) { + case '{': + return make_token(TOKEN_LBRACE, l->position); + case '}': + return make_token(TOKEN_RBRACE, l->position); + case '[': + return make_token(TOKEN_LBRACKET, l->position); + case ']': + return make_token(TOKEN_RBRACKET, l->position); + case ',': + return make_token(TOKEN_COMMA, l->position); + case ';': + return make_token(TOKEN_SEMICOLON, l->position); + default: + retreat(l); + if (is_digit(c)) + return number(l); + if (is_alpha(c) || c == '_') + return identifier(l); + return make_token(TOKEN_ERROR, l->position); + } +} + +int primitive_byte_width(enum token_type type) +{ + switch (type) { + case TOKEN_KEYWORD_U8: + return 1; + case TOKEN_KEYWORD_U16: + return 2; + case TOKEN_KEYWORD_U32: + return 4; + case TOKEN_KEYWORD_U64: + return 8; + default: + return 0; + } +} + +int tokenize(const char *input, struct token ***tokens, size_t *num_tokens) +{ + struct lexer l = { .start = input, .current = input }; + struct token **ret_tokens; + size_t token_arr_size; + size_t token_count; + struct token *tok; + void *tmp; + int err; + + token_arr_size = 128; + ret_tokens = calloc(token_arr_size, sizeof(struct token *)); + if (!ret_tokens) + return -ENOMEM; + + token_count = 0; + do { + tok = scan_token(&l); + if (!tok) { + err = -ENOMEM; + goto failure; + } + + if (token_count == token_arr_size) { + token_arr_size *= 2; + tmp = realloc(ret_tokens, token_arr_size); + if (!tmp) { + err = -ENOMEM; + goto failure; + } + ret_tokens = tmp; + } + + ret_tokens[token_count] = tok; + if (tok->type == TOKEN_ERROR) { + err = -EINVAL; + goto failure; + } + token_count++; + } while (tok->type != TOKEN_EOF); + + *tokens = ret_tokens; + *num_tokens = token_count; + return 0; + +failure: + destroy_tokens(ret_tokens, token_count); + return err; +} + +bool is_primitive(struct token *tok) +{ + return tok->type >= TOKEN_KEYWORD_U8 && tok->type <= TOKEN_KEYWORD_U64; +} diff --git a/tools/testing/kfuzztest-bridge/input_lexer.h b/tools/testing/kfuzztest-bridge/input_lexer.h new file mode 100644 index 00000000000000..40814493c24de8 --- /dev/null +++ b/tools/testing/kfuzztest-bridge/input_lexer.h @@ -0,0 +1,58 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Lexer for KFuzzTest textual input format + * + * Copyright 2025 Google LLC + */ +#ifndef KFUZZTEST_BRIDGE_INPUT_LEXER_H +#define KFUZZTEST_BRIDGE_INPUT_LEXER_H + +#include +#include +#include + +#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) + +enum token_type { + TOKEN_LBRACE, + TOKEN_RBRACE, + TOKEN_LBRACKET, + TOKEN_RBRACKET, + TOKEN_COMMA, + TOKEN_SEMICOLON, + + TOKEN_KEYWORD_PTR, + TOKEN_KEYWORD_ARR, + TOKEN_KEYWORD_LEN, + TOKEN_KEYWORD_STR, + TOKEN_KEYWORD_U8, + TOKEN_KEYWORD_U16, + TOKEN_KEYWORD_U32, + TOKEN_KEYWORD_U64, + + TOKEN_IDENTIFIER, + TOKEN_INTEGER, + + TOKEN_EOF, + TOKEN_ERROR, +}; + +struct token { + enum token_type type; + union { + uint64_t integer; + struct { + const char *start; + size_t length; + } identifier; + } data; + int position; +}; + +int tokenize(const char *input, struct token ***tokens, size_t *num_tokens); +void destroy_tokens(struct token **tokens, size_t num_tokens); + +bool is_primitive(struct token *tok); +int primitive_byte_width(enum token_type type); + +#endif /* KFUZZTEST_BRIDGE_INPUT_LEXER_H */ diff --git a/tools/testing/kfuzztest-bridge/input_parser.c b/tools/testing/kfuzztest-bridge/input_parser.c new file mode 100644 index 00000000000000..b1fd8ba5217e08 --- /dev/null +++ b/tools/testing/kfuzztest-bridge/input_parser.c @@ -0,0 +1,423 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Parser for the KFuzzTest textual input format + * + * This file implements a parser for a simple DSL used to describe C-like data + * structures. This format allows the kfuzztest-bridge tool to encode a random + * byte stream into the structured binary format expected by a KFuzzTest + * harness. + * + * The format consists of semicolon-separated "regions," which are analogous to + * C structs. For example: + * + * "my_struct { ptr[buf] len[buf, u64] }; buf { arr[u8, 42] };" + * + * This describes a `my_struct` region that contains a pointer to a `buf` region + * and its corresponding length encoded over 8 bytes, where `buf` itself + * contains a 42-byte array. + * + * Copyright 2025 Google LLC + */ +#include +#include +#include + +#include "input_lexer.h" +#include "input_parser.h" + +static struct token *peek(struct parser *p) +{ + return p->tokens[p->curr_token]; +} + +static struct token *advance(struct parser *p) +{ + struct token *tok; + if (p->curr_token >= p->token_count) + return NULL; + tok = peek(p); + p->curr_token++; + return tok; +} + +static struct token *consume(struct parser *p, enum token_type type, const char *err_msg) +{ + if (peek(p)->type != type) { + printf("parser failure at position %d: %s\n", peek(p)->position, err_msg); + return NULL; + } + return advance(p); +} + +static bool match(struct parser *p, enum token_type t) +{ + struct token *tok = peek(p); + return tok->type == t; +} + +static int parse_primitive(struct parser *p, struct ast_node **node_ret) +{ + struct ast_node *ret; + struct token *tok; + int byte_width; + + tok = advance(p); + byte_width = primitive_byte_width(tok->type); + if (!byte_width) + return -EINVAL; + + ret = malloc(sizeof(*ret)); + if (!ret) + return -ENOMEM; + + ret->type = NODE_PRIMITIVE; + ret->data.primitive.byte_width = byte_width; + *node_ret = ret; + return 0; +} + +static int parse_ptr(struct parser *p, struct ast_node **node_ret) +{ + const char *points_to; + struct ast_node *ret; + struct token *tok; + if (!consume(p, TOKEN_KEYWORD_PTR, "expected 'ptr'")) + return -EINVAL; + if (!consume(p, TOKEN_LBRACKET, "expected '['")) + return -EINVAL; + + tok = consume(p, TOKEN_IDENTIFIER, "expected identifier"); + if (!tok) + return -EINVAL; + + if (!consume(p, TOKEN_RBRACKET, "expected ']'")) + return -EINVAL; + + ret = malloc(sizeof(*ret)); + ret->type = NODE_POINTER; + + points_to = strndup(tok->data.identifier.start, tok->data.identifier.length); + if (!points_to) { + free(ret); + return -EINVAL; + } + + ret->data.pointer.points_to = points_to; + *node_ret = ret; + return 0; +} + +static int parse_arr(struct parser *p, struct ast_node **node_ret) +{ + struct token *type, *num_elems; + struct ast_node *ret; + + if (!consume(p, TOKEN_KEYWORD_ARR, "expected 'arr'") || !consume(p, TOKEN_LBRACKET, "expected '['")) + return -EINVAL; + + type = advance(p); + if (!is_primitive(type)) + return -EINVAL; + + if (!consume(p, TOKEN_COMMA, "expected ','")) + return -EINVAL; + + num_elems = consume(p, TOKEN_INTEGER, "expected integer"); + if (!num_elems) + return -EINVAL; + + if (!consume(p, TOKEN_RBRACKET, "expected ']'")) + return -EINVAL; + + ret = malloc(sizeof(*ret)); + if (!ret) + return -ENOMEM; + + ret->type = NODE_ARRAY; + ret->data.array.num_elems = num_elems->data.integer; + ret->data.array.elem_size = primitive_byte_width(type->type); + ret->data.array.null_terminated = false; + *node_ret = ret; + return 0; +} + +static int parse_str(struct parser *p, struct ast_node **node_ret) +{ + struct ast_node *ret; + struct token *len; + + if (!consume(p, TOKEN_KEYWORD_STR, "expected 'str'") || !consume(p, TOKEN_LBRACKET, "expected '['")) + return -EINVAL; + + len = consume(p, TOKEN_INTEGER, "expected integer"); + if (!len) + return -EINVAL; + + if (!consume(p, TOKEN_RBRACKET, "expected ']'")) + return -EINVAL; + + ret = malloc(sizeof(*ret)); + if (!ret) + return -ENOMEM; + + /* A string is the susbet of byte arrays that are null-terminated. */ + ret->type = NODE_ARRAY; + ret->data.array.num_elems = len->data.integer; + ret->data.array.elem_size = sizeof(char); + ret->data.array.null_terminated = true; + *node_ret = ret; + return 0; +} + +static int parse_len(struct parser *p, struct ast_node **node_ret) +{ + struct token *type, *len; + const char *length_of; + struct ast_node *ret; + + if (!consume(p, TOKEN_KEYWORD_LEN, "expected 'len'") || !consume(p, TOKEN_LBRACKET, "expected '['")) + return -EINVAL; + + len = advance(p); + if (len->type != TOKEN_IDENTIFIER) + return -EINVAL; + + if (!consume(p, TOKEN_COMMA, "expected ','")) + return -EINVAL; + + type = advance(p); + if (!is_primitive(type)) + return -EINVAL; + + if (!consume(p, TOKEN_RBRACKET, "expected ']'")) + return -EINVAL; + + ret = malloc(sizeof(*ret)); + if (!ret) + return -ENOMEM; + + length_of = strndup(len->data.identifier.start, len->data.identifier.length); + if (!length_of) { + free(ret); + return -ENOMEM; + } + + ret->type = NODE_LENGTH; + ret->data.length.length_of = length_of; + ret->data.length.byte_width = primitive_byte_width(type->type); + + *node_ret = ret; + return 0; +} + +static int parse_type(struct parser *p, struct ast_node **node_ret) +{ + if (is_primitive(peek(p))) + return parse_primitive(p, node_ret); + + if (peek(p)->type == TOKEN_KEYWORD_PTR) + return parse_ptr(p, node_ret); + + if (peek(p)->type == TOKEN_KEYWORD_ARR) + return parse_arr(p, node_ret); + + if (peek(p)->type == TOKEN_KEYWORD_STR) + return parse_str(p, node_ret); + + if (peek(p)->type == TOKEN_KEYWORD_LEN) + return parse_len(p, node_ret); + + return -EINVAL; +} + +static int parse_region(struct parser *p, struct ast_node **node_ret) +{ + struct token *tok, *identifier; + struct ast_region *region; + struct ast_node *node; + struct ast_node *ret; + void *new_ptr; + int err; + + identifier = consume(p, TOKEN_IDENTIFIER, "expected identifier"); + if (!identifier) + return -EINVAL; + + ret = malloc(sizeof(*ret)); + if (!ret) + return -ENOMEM; + + tok = consume(p, TOKEN_LBRACE, "expected '{'"); + if (!tok) { + err = -EINVAL; + goto fail_early; + } + + region = &ret->data.region; + region->name = strndup(identifier->data.identifier.start, identifier->data.identifier.length); + if (!region->name) { + err = -ENOMEM; + goto fail_early; + } + + region->num_members = 0; + while (!match(p, TOKEN_RBRACE)) { + err = parse_type(p, &node); + if (err) + goto fail; + new_ptr = realloc(region->members, (region->num_members + 1) * sizeof(struct ast_node *)); + if (!new_ptr) { + err = -ENOMEM; + goto fail; + } + region->num_members++; + region->members = new_ptr; + region->members[region->num_members - 1] = node; + } + + if (!consume(p, TOKEN_RBRACE, "expected '}'") || !consume(p, TOKEN_SEMICOLON, "expected ';'")) { + err = -EINVAL; + goto fail; + } + + ret->type = NODE_REGION; + *node_ret = ret; + return 0; + +fail: + destroy_ast_node(ret); + return err; + +fail_early: + free(ret); + return err; +} + +static int parse_program(struct parser *p, struct ast_node **node_ret) +{ + struct ast_program *prog; + struct ast_node *reg; + struct ast_node *ret; + void *new_ptr; + int err; + + ret = malloc(sizeof(*ret)); + if (!ret) + return -ENOMEM; + ret->type = NODE_PROGRAM; + + prog = &ret->data.program; + prog->num_members = 0; + prog->members = NULL; + while (!match(p, TOKEN_EOF)) { + err = parse_region(p, ®); + if (err) + goto fail; + + new_ptr = realloc(prog->members, ++prog->num_members * sizeof(struct ast_node *)); + if (!new_ptr) { + err = -ENOMEM; + goto fail; + } + prog->members = new_ptr; + prog->members[prog->num_members - 1] = reg; + } + + *node_ret = ret; + return 0; + +fail: + destroy_ast_node(ret); + return err; +} + +size_t node_alignment(struct ast_node *node) +{ + size_t max_alignment = 1; + size_t i; + + switch (node->type) { + case NODE_PROGRAM: + for (i = 0; i < node->data.program.num_members; i++) + max_alignment = MAX(max_alignment, node_alignment(node->data.program.members[i])); + return max_alignment; + case NODE_REGION: + for (i = 0; i < node->data.region.num_members; i++) + max_alignment = MAX(max_alignment, node_alignment(node->data.region.members[i])); + return max_alignment; + case NODE_ARRAY: + return node->data.array.elem_size; + case NODE_LENGTH: + return node->data.length.byte_width; + case NODE_PRIMITIVE: + /* Primitives are aligned to their size. */ + return node->data.primitive.byte_width; + case NODE_POINTER: + return sizeof(uintptr_t); + } + + /* Anything should be at least 1-byte-aligned. */ + return 1; +} + +size_t node_size(struct ast_node *node) +{ + size_t total = 0; + size_t i; + + switch (node->type) { + case NODE_PROGRAM: + for (i = 0; i < node->data.program.num_members; i++) + total += node_size(node->data.program.members[i]); + return total; + case NODE_REGION: + for (i = 0; i < node->data.region.num_members; i++) { + /* Account for padding within region. */ + total = ROUND_UP_TO_MULTIPLE(total, node_alignment(node->data.region.members[i])); + total += node_size(node->data.region.members[i]); + } + return total; + case NODE_ARRAY: + return node->data.array.elem_size * node->data.array.num_elems + + (node->data.array.null_terminated ? 1 : 0); + case NODE_LENGTH: + return node->data.length.byte_width; + case NODE_PRIMITIVE: + return node->data.primitive.byte_width; + case NODE_POINTER: + return sizeof(uintptr_t); + } + return 0; +} + +int parse(struct token **tokens, size_t token_count, struct ast_node **node_ret) +{ + struct parser p = { .tokens = tokens, .token_count = token_count, .curr_token = 0 }; + return parse_program(&p, node_ret); +} + +void destroy_ast_node(struct ast_node *node) +{ + size_t i; + + switch (node->type) { + case NODE_PROGRAM: + for (i = 0; i < node->data.program.num_members; i++) + destroy_ast_node(node->data.program.members[i]); + break; + case NODE_REGION: + for (i = 0; i < node->data.region.num_members; i++) + destroy_ast_node(node->data.region.members[i]); + free((void *)node->data.region.name); + break; + case NODE_LENGTH: + free((void *)node->data.length.length_of); + break; + case NODE_POINTER: + free((void *)node->data.pointer.points_to); + break; + default: + break; + } + free(node); +} diff --git a/tools/testing/kfuzztest-bridge/input_parser.h b/tools/testing/kfuzztest-bridge/input_parser.h new file mode 100644 index 00000000000000..5f444b40f672a6 --- /dev/null +++ b/tools/testing/kfuzztest-bridge/input_parser.h @@ -0,0 +1,82 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Parser for KFuzzTest textual input format + * + * Copyright 2025 Google LLC + */ +#ifndef KFUZZTEST_BRIDGE_INPUT_PARSER_H +#define KFUZZTEST_BRIDGE_INPUT_PARSER_H + +#include + +/* Rounds x up to the nearest multiple of n. */ +#define ROUND_UP_TO_MULTIPLE(x, n) (((n) == 0) ? (0) : (((x) + (n) - 1) / (n)) * (n)) + +#define MAX(a, b) ((a) > (b) ? (a) : (b)) + +enum ast_node_type { + NODE_PROGRAM, + NODE_REGION, + NODE_ARRAY, + NODE_LENGTH, + NODE_PRIMITIVE, + NODE_POINTER, +}; + +struct ast_node; /* Forward declaration. */ + +struct ast_program { + struct ast_node **members; + size_t num_members; +}; + +struct ast_region { + const char *name; + struct ast_node **members; + size_t num_members; +}; + +struct ast_array { + int elem_size; + int null_terminated; /* True iff the array should always end with 0. */ + size_t num_elems; +}; + +struct ast_length { + size_t byte_width; + const char *length_of; +}; + +struct ast_primitive { + size_t byte_width; +}; + +struct ast_pointer { + const char *points_to; +}; + +struct ast_node { + enum ast_node_type type; + union { + struct ast_program program; + struct ast_region region; + struct ast_array array; + struct ast_length length; + struct ast_primitive primitive; + struct ast_pointer pointer; + } data; +}; + +struct parser { + struct token **tokens; + size_t token_count; + size_t curr_token; +}; + +int parse(struct token **tokens, size_t token_count, struct ast_node **node_ret); +void destroy_ast_node(struct ast_node *node); + +size_t node_size(struct ast_node *node); +size_t node_alignment(struct ast_node *node); + +#endif /* KFUZZTEST_BRIDGE_INPUT_PARSER_H */ diff --git a/tools/testing/kfuzztest-bridge/rand_stream.c b/tools/testing/kfuzztest-bridge/rand_stream.c new file mode 100644 index 00000000000000..bca6b3de5aadc4 --- /dev/null +++ b/tools/testing/kfuzztest-bridge/rand_stream.c @@ -0,0 +1,77 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Implements a cached file-reader for iterating over a byte stream of + * pseudo-random data + * + * Copyright 2025 Google LLC + */ +#include "rand_stream.h" + +static int refill(struct rand_stream *rs) +{ + rs->valid_bytes = fread(rs->buffer, sizeof(char), rs->buffer_size, rs->source); + rs->buffer_pos = 0; + if (rs->valid_bytes != rs->buffer_size && ferror(rs->source)) + return ferror(rs->source); + return 0; +} + +struct rand_stream *new_rand_stream(const char *path_to_file, size_t cache_size) +{ + struct rand_stream *rs; + + rs = malloc(sizeof(*rs)); + if (!rs) + return NULL; + + rs->valid_bytes = 0; + rs->source = fopen(path_to_file, "rb"); + if (!rs->source) { + free(rs); + return NULL; + } + + if (fseek(rs->source, 0, SEEK_END)) { + fclose(rs->source); + free(rs); + return NULL; + } + rs->source_size = ftell(rs->source); + + if (fseek(rs->source, 0, SEEK_SET)) { + fclose(rs->source); + free(rs); + return NULL; + } + + rs->buffer = malloc(cache_size); + if (!rs->buffer) { + fclose(rs->source); + free(rs); + return NULL; + } + rs->buffer_size = cache_size; + return rs; +} + +void destroy_rand_stream(struct rand_stream *rs) +{ + fclose(rs->source); + free(rs->buffer); + free(rs); +} + +int next_byte(struct rand_stream *rs, char *ret) +{ + int res; + + if (rs->buffer_pos >= rs->valid_bytes) { + res = refill(rs); + if (res) + return res; + if (rs->valid_bytes == 0) + return STREAM_EOF; + } + *ret = rs->buffer[rs->buffer_pos++]; + return 0; +} diff --git a/tools/testing/kfuzztest-bridge/rand_stream.h b/tools/testing/kfuzztest-bridge/rand_stream.h new file mode 100644 index 00000000000000..acb3271d30caa1 --- /dev/null +++ b/tools/testing/kfuzztest-bridge/rand_stream.h @@ -0,0 +1,57 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Implements a cached file-reader for iterating over a byte stream of + * pseudo-random data + * + * Copyright 2025 Google LLC + */ +#ifndef KFUZZTEST_BRIDGE_RAND_STREAM_H +#define KFUZZTEST_BRIDGE_RAND_STREAM_H + +#include +#include + +#define STREAM_EOF 1 + +/** + * struct rand_stream - a buffered bytestream reader + * + * Reads and returns bytes from a file, using buffered pre-fetching to amortize + * the cost of reads. + */ +struct rand_stream { + FILE *source; + size_t source_size; + char *buffer; + size_t buffer_size; + size_t buffer_pos; + size_t valid_bytes; +}; + +/** + * new_rand_stream - return a new struct rand_stream + * + * @path_to_file: source of the output byte stream. + * @cache_size: size of the read-ahead cache in bytes. + */ +struct rand_stream *new_rand_stream(const char *path_to_file, size_t cache_size); + +/** + * destroy_rand_stream - clean up a rand stream's resources + * + * @rs: a struct rand_stream + */ +void destroy_rand_stream(struct rand_stream *rs); + +/** + * next_byte - return the next byte from a struct rand_stream + * + * @rs: an initialized struct rand_stream. + * @ret: return pointer. + * + * @return 0 on success or a negative value on failure. + * + */ +int next_byte(struct rand_stream *rs, char *ret); + +#endif /* KFUZZTEST_BRIDGE_RAND_STREAM_H */ From e70db5e34d1a9c92912880114cfc567309bbc08c Mon Sep 17 00:00:00 2001 From: Ethan Graham Date: Tue, 12 Aug 2025 14:09:37 +0000 Subject: [PATCH 06/11] kfuzztest: add ReST documentation Add Documentation/dev-tools/kfuzztest.rst and reference it in the dev-tools index. Signed-off-by: Ethan Graham Signed-off-by: Ethan Graham Acked-by: Alexander Potapenko --- PR v3: - Document newly introduced FUZZ_TEST_SIMPLE targets. - Rework the flow in several sections. PR v2: - Update documentation to reflect new location of kfuzztest-bridge, under tools/testing. PR v1: - Fix some typos and reword some sections. - Correct kfuzztest-bridge grammar description. - Reference documentation in kfuzztest-bridge/input_parser.c header comment. RFC v2: - Add documentation for kfuzztest-bridge tool introduced in patch 4. --- --- Documentation/dev-tools/index.rst | 1 + Documentation/dev-tools/kfuzztest.rst | 491 ++++++++++++++++++ tools/testing/kfuzztest-bridge/input_parser.c | 2 + 3 files changed, 494 insertions(+) create mode 100644 Documentation/dev-tools/kfuzztest.rst diff --git a/Documentation/dev-tools/index.rst b/Documentation/dev-tools/index.rst index 65c54b27a60b8d..00ccc4da003be7 100644 --- a/Documentation/dev-tools/index.rst +++ b/Documentation/dev-tools/index.rst @@ -32,6 +32,7 @@ Documentation/process/debugging/index.rst kfence kselftest kunit/index + kfuzztest ktap checkuapi gpio-sloppy-logic-analyzer diff --git a/Documentation/dev-tools/kfuzztest.rst b/Documentation/dev-tools/kfuzztest.rst new file mode 100644 index 00000000000000..61f877e8bb10fb --- /dev/null +++ b/Documentation/dev-tools/kfuzztest.rst @@ -0,0 +1,491 @@ +.. SPDX-License-Identifier: GPL-2.0 +.. Copyright 2025 Google LLC + +========================================= +Kernel Fuzz Testing Framework (KFuzzTest) +========================================= + +Overview +======== + +The Kernel Fuzz Testing Framework (KFuzzTest) is a framework designed to expose +internal kernel functions to a userspace fuzzing engine. + +It is intended for testing stateless or low-state functions that are difficult +to reach from the system call interface, such as routines involved in file +format parsing or complex data transformations. This provides a method for +in-situ fuzzing of kernel code without requiring that it be built as a separate +userspace library or that its dependencies be stubbed out. + +The framework consists of four main components: + +1. An API, based on the ``FUZZ_TEST`` and ``FUZZ_TEST_SIMPLE`` macros, for + defining test targets directly in the kernel tree. +2. A binary serialization format for passing complex, pointer-rich data + structures from userspace to the kernel. +3. A ``debugfs`` interface through which a userspace fuzzer submits + serialized test inputs. +4. Metadata embedded in dedicated ELF sections of the ``vmlinux`` binary to + allow for the discovery of available fuzz targets by external tooling. + +.. warning:: + KFuzzTest is a debugging and testing tool. It exposes internal kernel + functions to userspace with minimal sanitization and is designed for + use in controlled test environments only. It must **NEVER** be enabled + in production kernels. + +Supported Architectures +======================= + +KFuzzTest is designed for generic architecture support. It has only been +explicitly tested on x86_64. + +Usage +===== + +To enable KFuzzTest, configure the kernel with:: + + CONFIG_KFUZZTEST=y + +which depends on ``CONFIG_DEBUGFS`` for receiving userspace inputs, and +``CONFIG_DEBUG_KERNEL`` as an additional guardrail for preventing KFuzzTest +from finding its way into a production build accidentally. + +The KFuzzTest sample fuzz targets can be built in with +``CONFIG_SAMPLE_KFUZZTEST``. + +KFuzzTest currently only supports targets that are built into the kernel, as the +core module's startup process discovers fuzz targets from a dedicated ELF +section during startup. Furthermore, constraints and annotations emit metadata +that can be scanned from a ``vmlinux`` binary by a userspace fuzzing engine. + +Declaring a KFuzzTest target +---------------------------- + +A fuzz target should be defined in a .c file. The recommended place to define +this is under the subsystem's ``/tests`` directory in a ``_kfuzz.c`` +file, following the convention used by KUnit. The only strict requirement is +that the function being fuzzed is visible to the fuzz target. + +KFuzzTest provides two macros for defining a target, depending on the complexity +of the input for the function being fuzzed. + +- ``FUZZ_TEST`` for complex, structure-aware fuzzing of functions that take + pointers, nested structures, or other complex inputs. +- ``FUZZ_TEST_SIMPLE`` for the common case of fuzzing a function that accepts + a simple data buffer and length. + +Non-trivial Fuzz Targets (``FUZZ_TEST``) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +For functions with more complex arguments such as nested structs, multiple +pointers, or where fine-grained control over inputs it needed, use the +``FUZZ_TEST`` macro. + +Complex fuzz targets enable structure-aware fuzzing, but require more setup, +including the definition a ``struct`` wrapping its parameters, and optional +metadata for the fuzzer. + +Defining a fuzz target involves three main parts: defining an input structure, +writing the test body using the ``FUZZ_TEST`` macro, and optionally adding +metadata for the fuzzer. + +The following example illustrates the 6-step process for this macro. + +.. code-block:: c + + /* 1. The kernel function that we want to fuzz. */ + int func(const char *str, char *data, size_t datalen); + + /* + * 2. Define a struct to model the inputs for the function under test. + * Each field corresponds to an argument needed by the function. + */ + struct func_inputs { + const char *str; + char *data; + size_t datalen; + }; + + /* + * 3. Define the fuzz target using the FUZZ_TEST macro. + * The first parameter is a unique name for the target. + * The second parameter is the input struct defined above. + */ + FUZZ_TEST(test_func, struct func_inputs) + { + /* + * Within this body, the `arg` variable is a pointer to a + * fully initialized `struct func_inputs`. + */ + + /* + * 4. (Optional) Add constraints to define preconditions. + * This check ensures `arg->str` and `arg->data` are non-NULL. If + * the conditions are not met, the test exits early. This also + * creates metadata to inform the fuzzing engine. + */ + KFUZZTEST_EXPECT_NOT_NULL(func_inputs, str); + KFUZZTEST_EXPECT_NOT_NULL(func_inputs, data); + + /* + * 5. (Optional) Add annotations to provide semantic hints to the + * fuzzer. These annotations inform the fuzzer that `str` is a + * null-terminated string, that `data` is a pointer to an array + * (i.e., not a pointer to a single value), and that the `len` field + * is the length of the buffer pointed to by `data`. + * Annotations do not add any runtime checks. + */ + KFUZZTEST_ANNOTATE_STRING(func_inputs, str); + KFUZZTEST_ANNOTATE_LEN(func_inputs, datalen, data); + KFUZZTEST_ANNOTATE_ARRAY(func_inputs, data); + + /* + * 6. Call the kernel function with the provided inputs. + * Memory errors like out-of-bounds accesses on 'arg->data' will + * be detected by KASAN or other memory error detection tools. + */ + func(arg->str, arg->data, arg->datalen); + } + +A ``FUZZ_TEST`` creates a debugfs file under +`/sys/kernel/debug/kfuzztest//input` that accepts inputs from a +fuzzing engine. + +KFuzzTest provides two families of macros to improve the quality of fuzzing: + +- ``KFUZZTEST_EXPECT_*``: These macros define constraints, which are + preconditions that must be true for the test to proceed. They are enforced + with a runtime check in the kernel. If a check fails, the current test run is + aborted. This metadata helps the userspace fuzzer avoid generating invalid + inputs. + +- ``KFUZZTEST_ANNOTATE_*``: These macros define annotations, which are purely + semantic hints for the fuzzer. They do not add any runtime checks and exist + only to help the fuzzer generate more intelligent and structurally correct + inputs. For example, KFUZZTEST_ANNOTATE_LEN links a size field to a pointer + field, which is a common pattern in C APIs. + +A fuzzing engine that aims to effectively fuzz these targets must implement +the following: + +- Serialized inputs following the format introduced in the + `Input Serialization`_ section. +- ``vmlinux`` metadata parsing to become aware of domain constraints and + annotations. + +Simple Fuzz Targets (``FUZZ_TEST_SIMPLE``) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +For the common case of defining a fuzz target for a function that accepts a +buffer and its length (e.g., ``(const char *data, size_t datalen)``), the +``FUZZ_TEST_SIMPLE`` macro should be used. + +This macro simplifies test creation by providing ``data`` and ``datalen`` +variables to the test body. + +.. code-block:: c + + /* 1. The kernel function that we want to fuzz. */ + int process_data(const char *data, size_t len); + + /* 2. Define the fuzz target with the FUZZ_TEST_SIMPLE macro. */ + FUZZ_TEST_SIMPLE(test_process_data) + { + /* 3. Call the kernel function with the provided input. */ + process_data(data, datalen); + } + +A ``FUZZ_TEST_SIMPLE`` target creates two debugfs files in its directory +(``/sys/kernel/debug/kfuzztest/``): + +- ``input_simple``: A simplified interface. Writing a raw byte blob to this + file will invoke the fuzz target, passing the blob as ``(data, datalen)``. +- ``input``: Accepts the serialization format described in the + `Input Serialization`_ section. + +The ``input_simple`` file makes it much easier to integrate with userspace +fuzzers (e.g., LibFuzzer, AFL++, honggfuzz) without requiring any knowledge +of KFuzzTest's serialization format or constraint system. + +A LibFuzzer harness may look like so: + +.. code-block:: c + + /* Path to the simple target's input file */ + const char *filepath = "/sys/kernel/debug/kfuzztest/test_process_data/input_simple"; + + extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { + FILE *f = fopen(filepath, "w"); + if (!f) { + return 0; /* Fuzzer should not stop. */ + } + /* Write the raw fuzzer input directly. */ + fwrite(Data, 1, Size, f); + fclose(f); + return 0; + } + +Note that despite it being very simple for a fuzzing engine to fuzz simple +KFuzzTest targets, kernel coverage collection is key for the effectiveness +of a coverage-guided fuzzer - this is outside of KFuzzTest's scope. + +Metadata +-------- + +Macros ``FUZZ_TEST``, ``FUZZ_TEST_SIMPLE``, ``KFUZZTEST_EXPECT_*`` and +``KFUZZTEST_ANNOTATE_*`` embed metadata into several sections within the main +``.data`` section of the final ``vmlinux`` binary; ``.kfuzztest_target``, +``.kfuzztest_simple_target``, ``.kfuzztest_constraint`` and +``.kfuzztest_annotation`` respectively. + +Note that simple targets defined with the ``FUZZ_TEST_SIMPLE`` macro implicitly +define a ``FUZZ_TEST`` to maintain compatibility with fuzzers that assume +structured inputs, allowing both target types to be treated as one and the same. + +The metadata regions serve a few purposes: + +1. The core module uses the ``.kfuzztest_target`` section at boot to discover + every ``FUZZ_TEST`` instance and create its ``debugfs`` directory and + ``input`` file. +2. If a ``.kfuzztest_simple_target`` is defined for a given fuzz test, an + additional ``input_simple`` file is created in the target's ``debugfs`` + directory to accept inputs that don't require complex serialization. +3. Userspace fuzzers can read this metadata from the ``vmlinux`` binary to + discover targets and learn about their rules and structure in order to + generate correct and effective inputs. + +The metadata in the ``.kfuzztest_*`` sections consists of arrays of fixed-size C +structs (e.g., ``struct kfuzztest_target``). Fields within these structs that +are pointers, such as ``name`` or ``arg_type_name``, contain addresses that +point to other locations in the ``vmlinux`` binary. A userspace tool that +parses the ``vmlinux`` ELF file must resolve these pointers to read the data +that they reference. For example, to get a target's name, a tool must: + +1. Read the ``struct kfuzztest_target`` from the ``.kfuzztest_target`` section. +2. Read the address in the ``.name`` field. +3. Use that address to locate and read null-terminated string from its position + elsewhere in the binary (e.g., ``.rodata``). + +Tooling Dependencies +-------------------- + +For userspace tools to parse the ``vmlinux`` binary and make use of emitted +KFuzzTest metadata, the kernel must be compiled with DWARF debug information. +This is required for tools to understand the layout of C structs, resolve type +information, and correctly interpret constraints and annotations. + +When using KFuzzTest with automated fuzzing tools, either +``CONFIG_DEBUG_INFO_DWARF4`` or ``CONFIG_DEBUG_INFO_DWARF5`` should be enabled. + +Input Serialization +=================== + +``FUZZ_TEST`` macros accept serialized inputs representing nested data with +pointers. This section describes the input format for non-trivial inputs. + +KFuzzTest targets receive their inputs from userspace via a write to a dedicated +debugfs file ``/sys/kernel/debug/kfuzztest//input``. + +The data written to this file must be a single binary blob that follows a +specific serialization format. This format is designed to allow complex, +pointer-rich C structures to be represented in a flat buffer, requiring only a +single kernel allocation and copy from userspace. + +An input is first prefixed by an 8-byte header containing a magic value in the +first four bytes, defined as ``KFUZZTEST_HEADER_MAGIC`` in +```, and a version number in the subsequent four +bytes. + +Version 0 +--------- + +In version 0 (i.e., when the version number in the 8-byte header is equal to 0), +the input format consists of three main parts laid out sequentially: a region +array, a relocation table, and the payload.:: + + +----------------+---------------------+-----------+----------------+ + | region array | relocation table | padding | payload | + +----------------+---------------------+-----------+----------------+ + +Region Array +^^^^^^^^^^^^ + +This component is a header that describes how the raw data in the Payload is +partitioned into logical memory regions. It consists of a count of regions +followed by an array of ``struct reloc_region``, where each entry defines a +single region with its size and offset from the start of the payload. + +.. code-block:: c + + struct reloc_region { + uint32_t offset; + uint32_t size; + }; + + struct reloc_region_array { + uint32_t num_regions; + struct reloc_region regions[]; + }; + +By convention, region 0 represents the top-level input struct that is passed +as the arg variable to the ``FUZZ_TEST`` body. Subsequent regions typically +represent data buffers or structs pointed to by fields within that struct. +Region array entries must be ordered by ascending offset, and must not overlap +with one another. + +Relocation Table +^^^^^^^^^^^^^^^^ + +The relocation table contains the instructions for the kernel to "hydrate" the +payload by patching pointer fields. It contains an array of +``struct reloc_entry`` items. Each entry acts as a linking instruction, +specifying: + +- The location of a pointer that needs to be patched (identified by a region + ID and an offset within that region). + +- The target region that the pointer should point to (identified by the + target's region ID) or ``KFUZZTEST_REGIONID_NULL`` if the pointer is ``NULL``. + +This table also specifies the amount of padding between its end and the start +of the payload, which should be at least 8 bytes. + +.. code-block:: c + + struct reloc_entry { + uint32_t region_id; + uint32_t region_offset; + uint32_t value; + }; + + struct reloc_table { + uint32_t num_entries; + uint32_t padding_size; + struct reloc_entry entries[]; + }; + +Payload +^^^^^^^ + +The payload contains the raw binary data for all regions, concatenated together +according to their specified offsets. + +- Region specific alignment: The data for each individual region must start at + an offset that is aligned to its own C type's requirements. For example, a + ``uint64_t`` must begin on an 8-byte boundary. + +- Minimum alignment: The offset of each region, as well as the beginning of the + payload, must also be a multiple of the overall minimum alignment value. This + value is determined by the greater of ``ARCH_KMALLOC_MINALIGN`` and + ``KASAN_GRANULE_SIZE`` (which is represented by ``KFUZZTEST_POISON_SIZE`` in + ``/include/linux/kfuzztest.h``). This minimum alignment ensures that all + function inputs respect C calling conventions. + +- Padding: The space between the end of one region's data and the beginning of + the next must be sufficient for padding. The padding must also be at least + the same minimum alignment value mentioned above. This is crucial for KASAN + builds, as it allows KFuzzTest to poison this unused space enabling precise + detection of out-of-bounds memory accesses between adjacent buffers. + +The minimum alignment value is architecture-dependent and is exposed to +userspace via the read-only file +``/sys/kernel/debug/kfuzztest/_config/minalign``. The framework relies on +userspace tooling to construct the payload correctly, adhering to all three of +these rules for every region. + +KFuzzTest Bridge Tool +===================== + +The ``kfuzztest-bridge`` program is a userspace utility that encodes a random +byte stream into the structured binary format expected by a KFuzzTest harness. +It allows users to describe the target's input structure textually, making it +easy to perform smoke tests or connect harnesses to blob-based fuzzing engines. + +This tool is intended to be simple, both in usage and implementation. Its +structure and DSL are sufficient for simpler use-cases. For more advanced +coverage-guided fuzzing it is recommended to use +`syzkaller ` which implements deeper +support for KFuzzTest targets. + +Usage +----- + +The tool can be built with ``make tools/testing/kfuzztest-bridge``. In the case +of libc incompatibilities, the tool will have to be linked statically or built +on the target system. + +Example: + +.. code-block:: sh + + ./tools/testing/kfuzztest-bridge \ + "foo { u32 ptr[bar] }; bar { ptr[data] len[data, u64]}; data { arr[u8, 42] };" \ + "my-fuzz-target" /dev/urandom + +The command takes three arguments + +1. A string describing the input structure (see `Textual Format`_ sub-section). +2. The name of the target test, which corresponds to its directory in + ``/sys/kernel/debug/kfuzztest/``. +3. A path to a file providing a stream of random data, such as + ``/dev/urandom``. + +The structure string in the example corresponds to the following C data +structures: + +.. code-block:: c + + struct foo { + u32 a; + struct bar *b; + }; + + struct bar { + struct data *d; + u64 data_len; /* Equals 42. */ + }; + + struct data { + char arr[42]; + }; + +Textual Format +-------------- + +The textual format is a human-readable representation of the region-based binary +format used by KFuzzTest. It is described by the following grammar: + +.. code-block:: text + + schema ::= region ( ";" region )* [";"] + region ::= identifier "{" type ( " " type )* "}" + type ::= primitive | pointer | array | length | string + primitive ::= "u8" | "u16" | "u32" | "u64" + pointer ::= "ptr" "[" identifier "]" + array ::= "arr" "[" primitive "," integer "]" + length ::= "len" "[" identifier "," primitive "]" + string ::= "str" "[" integer "]" + identifier ::= [a-zA-Z_][a-zA-Z1-9_]* + integer ::= [0-9]+ + +Pointers must reference a named region. + +To fuzz a raw buffer, the buffer must be defined in its own region, as shown +below: + +.. code-block:: c + + struct my_struct { + char *buf; + size_t buflen; + }; + +This would correspond to the following textual description: + +.. code-block:: text + + my_struct { ptr[buf] len[buf, u64] }; buf { arr[u8, n] }; + +Here, ``n`` is some integer value defining the size of the byte array inside of +the ``buf`` region. diff --git a/tools/testing/kfuzztest-bridge/input_parser.c b/tools/testing/kfuzztest-bridge/input_parser.c index b1fd8ba5217e08..feaa59de49d7f4 100644 --- a/tools/testing/kfuzztest-bridge/input_parser.c +++ b/tools/testing/kfuzztest-bridge/input_parser.c @@ -16,6 +16,8 @@ * and its corresponding length encoded over 8 bytes, where `buf` itself * contains a 42-byte array. * + * The full grammar is documented in Documentation/dev-tools/kfuzztest.rst. + * * Copyright 2025 Google LLC */ #include From 22a03df6c99003165750c85163b4ad254ee40650 Mon Sep 17 00:00:00 2001 From: Ethan Graham Date: Tue, 12 Aug 2025 14:10:29 +0000 Subject: [PATCH 07/11] kfuzztest: add KFuzzTest sample fuzz targets Add two simple fuzz target samples to demonstrate the KFuzzTest API and provide basic self-tests for the framework. These examples showcase how a developer can define a fuzz target using the FUZZ_TEST(), constraint, and annotation macros, and serve as runtime sanity checks for the core logic. For example, they test that out-of-bounds memory accesses into poisoned padding regions are correctly detected in a KASAN build. These have been tested by writing syzkaller-generated inputs into their debugfs 'input' files and verifying that the correct KASAN reports were triggered. Signed-off-by: Ethan Graham Signed-off-by: Ethan Graham Acked-by: Alexander Potapenko --- PR v3: - Use the FUZZ_TEST_SIMPLE macro in the `underflow_on_buffer` sample fuzz target instead of FUZZ_TEST. PR v2: - Fix build issues pointed out by the kernel test robot . --- --- samples/Kconfig | 7 ++ samples/Makefile | 1 + samples/kfuzztest/Makefile | 3 + samples/kfuzztest/overflow_on_nested_buffer.c | 71 +++++++++++++++++++ samples/kfuzztest/underflow_on_buffer.c | 51 +++++++++++++ 5 files changed, 133 insertions(+) create mode 100644 samples/kfuzztest/Makefile create mode 100644 samples/kfuzztest/overflow_on_nested_buffer.c create mode 100644 samples/kfuzztest/underflow_on_buffer.c diff --git a/samples/Kconfig b/samples/Kconfig index 6e072a5f1ed86d..5209dd9d7a5cf8 100644 --- a/samples/Kconfig +++ b/samples/Kconfig @@ -320,6 +320,13 @@ config SAMPLE_HUNG_TASK Reading these files with multiple processes triggers hung task detection by holding locks for a long time (256 seconds). +config SAMPLE_KFUZZTEST + bool "Build KFuzzTest sample targets" + depends on KFUZZTEST + help + Build KFuzzTest sample targets that serve as selftests for input + deserialization and inter-region redzone poisoning logic. + source "samples/rust/Kconfig" source "samples/damon/Kconfig" diff --git a/samples/Makefile b/samples/Makefile index 07641e177bd8bb..3a0e7f744f445d 100644 --- a/samples/Makefile +++ b/samples/Makefile @@ -44,4 +44,5 @@ obj-$(CONFIG_SAMPLE_DAMON_WSSE) += damon/ obj-$(CONFIG_SAMPLE_DAMON_PRCL) += damon/ obj-$(CONFIG_SAMPLE_DAMON_MTIER) += damon/ obj-$(CONFIG_SAMPLE_HUNG_TASK) += hung_task/ +obj-$(CONFIG_SAMPLE_KFUZZTEST) += kfuzztest/ obj-$(CONFIG_SAMPLE_TSM_MR) += tsm-mr/ diff --git a/samples/kfuzztest/Makefile b/samples/kfuzztest/Makefile new file mode 100644 index 00000000000000..4f8709876c9e2d --- /dev/null +++ b/samples/kfuzztest/Makefile @@ -0,0 +1,3 @@ +# SPDX-License-Identifier: GPL-2.0-only + +obj-$(CONFIG_SAMPLE_KFUZZTEST) += overflow_on_nested_buffer.o underflow_on_buffer.o diff --git a/samples/kfuzztest/overflow_on_nested_buffer.c b/samples/kfuzztest/overflow_on_nested_buffer.c new file mode 100644 index 00000000000000..2f1c3ff9f750aa --- /dev/null +++ b/samples/kfuzztest/overflow_on_nested_buffer.c @@ -0,0 +1,71 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * This file contains a KFuzzTest example target that ensures that a buffer + * overflow on a nested region triggers a KASAN OOB access report. + * + * Copyright 2025 Google LLC + */ + +/** + * DOC: test_overflow_on_nested_buffer + * + * This test uses a struct with two distinct dynamically allocated buffers. + * It checks that KFuzzTest's memory layout correctly poisons the memory + * regions and that KASAN can detect an overflow when reading one byte past the + * end of the first buffer (`a`). + * + * It can be invoked with kfuzztest-bridge using the following command: + * + * ./kfuzztest-bridge \ + * "nested_buffers { ptr[a] len[a, u64] ptr[b] len[b, u64] }; \ + * a { arr[u8, 64] }; b { arr[u8, 64] };" \ + * "test_overflow_on_nested_buffer" /dev/urandom + * + * The first argument describes the C struct `nested_buffers` and specifies that + * both `a` and `b` are pointers to arrays of 64 bytes. + */ +#include + +static void overflow_on_nested_buffer(const char *a, size_t a_len, const char *b, size_t b_len) +{ + size_t i; + pr_info("a = [%px, %px)", a, a + a_len); + pr_info("b = [%px, %px)", b, b + b_len); + + /* Ensure that all bytes in arg->b are accessible. */ + for (i = 0; i < b_len; i++) + READ_ONCE(b[i]); + /* + * Check that all bytes in arg->a are accessible, and provoke an OOB on + * the first byte to the right of the buffer which will trigger a KASAN + * report. + */ + for (i = 0; i <= a_len; i++) + READ_ONCE(a[i]); +} + +struct nested_buffers { + const char *a; + size_t a_len; + const char *b; + size_t b_len; +}; + +/** + * The KFuzzTest input format specifies that struct nested buffers should + * be expanded as: + * + * | a | b | pad[8] | *a | pad[8] | *b | + * + * where the padded regions are poisoned. We expect to trigger a KASAN report by + * overflowing one byte into the `a` buffer. + */ +FUZZ_TEST(test_overflow_on_nested_buffer, struct nested_buffers) +{ + KFUZZTEST_EXPECT_NOT_NULL(nested_buffers, a); + KFUZZTEST_EXPECT_NOT_NULL(nested_buffers, b); + KFUZZTEST_ANNOTATE_LEN(nested_buffers, a_len, a); + KFUZZTEST_ANNOTATE_LEN(nested_buffers, b_len, b); + + overflow_on_nested_buffer(arg->a, arg->a_len, arg->b, arg->b_len); +} diff --git a/samples/kfuzztest/underflow_on_buffer.c b/samples/kfuzztest/underflow_on_buffer.c new file mode 100644 index 00000000000000..b2f5ff467334e6 --- /dev/null +++ b/samples/kfuzztest/underflow_on_buffer.c @@ -0,0 +1,51 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * This file contains a KFuzzTest example target that ensures that a buffer + * underflow on a region triggers a KASAN OOB access report. + * + * Copyright 2025 Google LLC + */ + +/** + * DOC: test_underflow_on_buffer + * + * This test ensures that the region between the metadata struct and the + * dynamically allocated buffer is poisoned. It provokes a one-byte underflow + * on the buffer, which should be caught by KASAN. + * + * It can be invoked with kfuzztest-bridge using the following command: + * + * ./kfuzztest-bridge \ + * "some_buffer { ptr[buf] len[buf, u64]}; buf { arr[u8, 128] };" \ + * "test_underflow_on_buffer" /dev/urandom + * + * The first argument describes the C struct `some_buffer` and specifies that + * `buf` is a pointer to an array of 128 bytes. The second argument is the test + * name, and the third is a seed file. + */ +#include + +static void underflow_on_buffer(char *buf, size_t buflen) +{ + size_t i; + + pr_info("buf = [%px, %px)", buf, buf + buflen); + + /* First ensure that all bytes in arg->b are accessible. */ + for (i = 0; i < buflen; i++) + READ_ONCE(buf[i]); + /* + * Provoke a buffer overflow on the first byte preceding b, triggering + * a KASAN report. + */ + READ_ONCE(*((char *)buf - 1)); +} + +/** + * Tests that the region between struct some_buffer and the expanded *buf field + * is correctly poisoned by accessing the first byte before *buf. + */ +FUZZ_TEST_SIMPLE(test_underflow_on_buffer) +{ + underflow_on_buffer(data, datalen); +} From d43712f2e55295f795cb404897fe9acbd7ee3440 Mon Sep 17 00:00:00 2001 From: Ethan Graham Date: Tue, 12 Aug 2025 14:12:35 +0000 Subject: [PATCH 08/11] crypto: implement KFuzzTest targets for PKCS7 and RSA parsing Add KFuzzTest targets for pkcs7_parse_message, rsa_parse_pub_key, and rsa_parse_priv_key to serve as real-world examples of how the framework is used. These functions are ideal candidates for KFuzzTest as they perform complex parsing of user-controlled data but are not directly exposed at the syscall boundary. This makes them difficult to exercise with traditional fuzzing tools and showcases the primary strength of the KFuzzTest framework: providing an interface to fuzz internal functions. To validate the effectiveness of the framework on these new targets, we injected two artificial bugs and let syzkaller fuzz the targets in an attempt to catch them. The first of these was calling the asn1 decoder with an incorrect input from pkcs7_parse_message, like so: - ret = asn1_ber_decoder(&pkcs7_decoder, ctx, data, datalen); + ret = asn1_ber_decoder(&pkcs7_decoder, ctx, data, datalen + 1); The second was bug deeper inside of asn1_ber_decoder itself, like so: - for (len = 0; n > 0; n--) + for (len = 0; n >= 0; n--) syzkaller was able to trigger these bugs, and the associated KASAN slab-out-of-bounds reports, within seconds. The targets are defined within crypto/asymmetric-keys/tests. Signed-off-by: Ethan Graham Signed-off-by: Ethan Graham Reviewed-by: Ignat Korchagin --- PR v3: - Use the FUZZ_TEST_SIMPLE macro for all introduced fuzz targets as they each take `(data, datalen)` pairs. This also removes the need for explicit constraints and annotations which become implicit. PR v2: - Make fuzz targets also depend on the KConfig options needed for the functions they are fuzzing, CONFIG_PKCS7_MESSAGE_PARSER and CONFIG_CRYPTO_RSA respectively. - Fix build issues pointed out by the kernel test robot . - Account for return value of pkcs7_parse_message, and free resources if the function call succeeds. PR v1: - Change the fuzz target build to depend on CONFIG_KFUZZTEST=y, eliminating the need for a separate config option for each individual file as suggested by Ignat Korchagin. - Remove KFUZZTEST_EXPECT_LE on the length of the `key` field inside of the fuzz targets. A maximum length is now set inside of the core input parsing logic. RFC v2: - Move KFuzzTest targets outside of the source files into dedicated _kfuzz.c files under /crypto/asymmetric_keys/tests/ as suggested by Ignat Korchagin and Eric Biggers. --- --- crypto/asymmetric_keys/Makefile | 2 ++ crypto/asymmetric_keys/tests/Makefile | 4 ++++ crypto/asymmetric_keys/tests/pkcs7_kfuzz.c | 17 ++++++++++++++++ .../asymmetric_keys/tests/rsa_helper_kfuzz.c | 20 +++++++++++++++++++ 4 files changed, 43 insertions(+) create mode 100644 crypto/asymmetric_keys/tests/Makefile create mode 100644 crypto/asymmetric_keys/tests/pkcs7_kfuzz.c create mode 100644 crypto/asymmetric_keys/tests/rsa_helper_kfuzz.c diff --git a/crypto/asymmetric_keys/Makefile b/crypto/asymmetric_keys/Makefile index bc65d3b98dcbfa..77b825aee6b24f 100644 --- a/crypto/asymmetric_keys/Makefile +++ b/crypto/asymmetric_keys/Makefile @@ -67,6 +67,8 @@ obj-$(CONFIG_PKCS7_TEST_KEY) += pkcs7_test_key.o pkcs7_test_key-y := \ pkcs7_key_type.o +obj-y += tests/ + # # Signed PE binary-wrapped key handling # diff --git a/crypto/asymmetric_keys/tests/Makefile b/crypto/asymmetric_keys/tests/Makefile new file mode 100644 index 00000000000000..023d6a65fb8913 --- /dev/null +++ b/crypto/asymmetric_keys/tests/Makefile @@ -0,0 +1,4 @@ +pkcs7-kfuzz-y := $(and $(CONFIG_KFUZZTEST),$(CONFIG_PKCS7_MESSAGE_PARSER)) +rsa-helper-kfuzz-y := $(and $(CONFIG_KFUZZTEST),$(CONFIG_CRYPTO_RSA)) +obj-$(pkcs7-kfuzz-y) += pkcs7_kfuzz.o +obj-$(rsa-helper-kfuzz-y) += rsa_helper_kfuzz.o diff --git a/crypto/asymmetric_keys/tests/pkcs7_kfuzz.c b/crypto/asymmetric_keys/tests/pkcs7_kfuzz.c new file mode 100644 index 00000000000000..345f99990653bf --- /dev/null +++ b/crypto/asymmetric_keys/tests/pkcs7_kfuzz.c @@ -0,0 +1,17 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * PKCS#7 parser KFuzzTest target + * + * Copyright 2025 Google LLC + */ +#include +#include + +FUZZ_TEST_SIMPLE(test_pkcs7_parse_message) +{ + struct pkcs7_message *msg; + + msg = pkcs7_parse_message(data, datalen); + if (msg && !IS_ERR(msg)) + kfree(msg); +} diff --git a/crypto/asymmetric_keys/tests/rsa_helper_kfuzz.c b/crypto/asymmetric_keys/tests/rsa_helper_kfuzz.c new file mode 100644 index 00000000000000..dd434f1a21ed78 --- /dev/null +++ b/crypto/asymmetric_keys/tests/rsa_helper_kfuzz.c @@ -0,0 +1,20 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * RSA key extract helper KFuzzTest targets + * + * Copyright 2025 Google LLC + */ +#include +#include + +FUZZ_TEST_SIMPLE(test_rsa_parse_pub_key) +{ + struct rsa_key out; + rsa_parse_pub_key(&out, data, datalen); +} + +FUZZ_TEST_SIMPLE(test_rsa_parse_priv_key) +{ + struct rsa_key out; + rsa_parse_priv_key(&out, data, datalen); +} From f7e320d315dadaa2ba1b291647b41a95c32e6cb7 Mon Sep 17 00:00:00 2001 From: Ethan Graham Date: Mon, 8 Sep 2025 20:05:56 +0000 Subject: [PATCH 09/11] drivers/auxdisplay: add a KFuzzTest for parse_xy() Add a KFuzzTest fuzzer for the parse_xy() function, located in a new file under /drivers/auxdisplay/tests. To validate the correctness and effectiveness of this KFuzzTest target, a bug was injected into parse_xy() like so: drivers/auxdisplay/charlcd.c:179 - s = p; + s = p + 1; Although a simple off-by-one bug, it requires a specific input sequence in order to trigger it, thus demonstrating the power of pairing KFuzzTest with a coverage-guided fuzzer like syzkaller. Signed-off-by: Ethan Graham Signed-off-by: Ethan Graham Acked-by: Alexander Potapenko --- PR v3: - Remove conditional inclusion of charlcd_kfuzz.c from charlcd.c, as requested by Andy Shevchenko. - Update auxdisplay Makefile to conditionally build charlcd_kfuzz.c when CONFIG_KFUZZTEST=y, as suggested by Lukas Wunner and Andy Shevchenko. - Foward declare parse_xy in charlcd_kfuzz.c. --- --- drivers/auxdisplay/Makefile | 3 +++ drivers/auxdisplay/tests/charlcd_kfuzz.c | 22 ++++++++++++++++++++++ 2 files changed, 25 insertions(+) create mode 100644 drivers/auxdisplay/tests/charlcd_kfuzz.c diff --git a/drivers/auxdisplay/Makefile b/drivers/auxdisplay/Makefile index f5c13ed1cd4f57..af00b0a173de4c 100644 --- a/drivers/auxdisplay/Makefile +++ b/drivers/auxdisplay/Makefile @@ -6,6 +6,9 @@ obj-$(CONFIG_ARM_CHARLCD) += arm-charlcd.o obj-$(CONFIG_CFAG12864B) += cfag12864b.o cfag12864bfb.o obj-$(CONFIG_CHARLCD) += charlcd.o +ifeq ($(CONFIG_KFUZZTEST),y) +CFLAGS_charlcd.o += -include $(src)/tests/charlcd_kfuzz.c +endif obj-$(CONFIG_HD44780_COMMON) += hd44780_common.o obj-$(CONFIG_HD44780) += hd44780.o obj-$(CONFIG_HT16K33) += ht16k33.o diff --git a/drivers/auxdisplay/tests/charlcd_kfuzz.c b/drivers/auxdisplay/tests/charlcd_kfuzz.c new file mode 100644 index 00000000000000..3adf510f4356f1 --- /dev/null +++ b/drivers/auxdisplay/tests/charlcd_kfuzz.c @@ -0,0 +1,22 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * charlcd KFuzzTest target + * + * Copyright 2025 Google LLC + */ +#include + +struct parse_xy_arg { + const char *s; +}; + +static bool parse_xy(const char *s, unsigned long *x, unsigned long *y); + +FUZZ_TEST(test_parse_xy, struct parse_xy_arg) +{ + unsigned long x, y; + + KFUZZTEST_EXPECT_NOT_NULL(parse_xy_arg, s); + KFUZZTEST_ANNOTATE_STRING(parse_xy_arg, s); + parse_xy(arg->s, &x, &y); +} From 92583d3da64c32337180a9ebe9338dd07104a338 Mon Sep 17 00:00:00 2001 From: Ethan Graham Date: Tue, 9 Sep 2025 08:48:04 +0000 Subject: [PATCH 10/11] fs/binfmt_script: add KFuzzTest target for load_script Add a KFuzzTest target for the load_script function to serve as a real-world example of the framework's usage. The load_script function is responsible for parsing the shebang line (`#!`) of script files. This makes it an excellent candidate for KFuzzTest, as it involves parsing user-controlled data within the binary loading path, which is not directly exposed as a system call. The provided fuzz target in fs/tests/binfmt_script_kfuzz.c illustrates how to fuzz a function that requires more involved setup - here, we only let the fuzzer generate input for the `buf` field of struct linux_bprm, and manually set the other fields with sensible values inside of the FUZZ_TEST body. To demonstrate the effectiveness of the fuzz target, a buffer overflow bug was injected in the load_script function like so: - buf_end = bprm->buf + sizeof(bprm->buf) - 1; + buf_end = bprm->buf + sizeof(bprm->buf) + 1; Which was caught in around 40 seconds by syzkaller simultaneously fuzzing four other targets, a realistic use case where targets are continuously fuzzed. It also requires that the fuzzer be smart enough to generate an input starting with `#!`. While this bug is shallow, the fact that the bug is caught quickly and with minimal additional code can potentially be a source of confidence when modifying existing implementations or writing new functions. Signed-off-by: Ethan Graham Signed-off-by: Ethan Graham Acked-by: Alexander Potapenko --- PR v2: - Introduce cleanup logic in the load_script fuzz target. --- --- fs/binfmt_script.c | 8 +++++ fs/tests/binfmt_script_kfuzz.c | 58 ++++++++++++++++++++++++++++++++++ 2 files changed, 66 insertions(+) create mode 100644 fs/tests/binfmt_script_kfuzz.c diff --git a/fs/binfmt_script.c b/fs/binfmt_script.c index 637daf6e4d4520..c09f224d6d7ecf 100644 --- a/fs/binfmt_script.c +++ b/fs/binfmt_script.c @@ -157,3 +157,11 @@ core_initcall(init_script_binfmt); module_exit(exit_script_binfmt); MODULE_DESCRIPTION("Kernel support for scripts starting with #!"); MODULE_LICENSE("GPL"); + +/* + * When CONFIG_KFUZZTEST is enabled, we include this _kfuzz.c file to ensure + * that KFuzzTest targets are built. + */ +#ifdef CONFIG_KFUZZTEST +#include "tests/binfmt_script_kfuzz.c" +#endif /* CONFIG_KFUZZTEST */ diff --git a/fs/tests/binfmt_script_kfuzz.c b/fs/tests/binfmt_script_kfuzz.c new file mode 100644 index 00000000000000..26397a465270bf --- /dev/null +++ b/fs/tests/binfmt_script_kfuzz.c @@ -0,0 +1,58 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * binfmt_script loader KFuzzTest target + * + * Copyright 2025 Google LLC + */ +#include +#include +#include +#include + +struct load_script_arg { + char buf[BINPRM_BUF_SIZE]; +}; + +FUZZ_TEST(test_load_script, struct load_script_arg) +{ + struct linux_binprm bprm = {}; + char *arg_page; + + arg_page = (char *)get_zeroed_page(GFP_KERNEL); + if (!arg_page) + return; + + memcpy(bprm.buf, arg->buf, sizeof(bprm.buf)); + /* + * `load_script` calls remove_arg_zero, which expects argc != 0. A + * static value of 1 is sufficient for fuzzing. + */ + bprm.argc = 1; + bprm.p = (unsigned long)arg_page + PAGE_SIZE; + bprm.filename = kstrdup("fuzz_script", GFP_KERNEL); + if (!bprm.filename) + goto cleanup; + bprm.interp = kstrdup(bprm.filename, GFP_KERNEL); + if (!bprm.interp) + goto cleanup; + + bprm.mm = mm_alloc(); + if (!bprm.mm) + goto cleanup; + + /* + * Call the target function. We expect it to fail and return an error + * (e.g., at open_exec), which is fine. The goal is to survive the + * initial parsing logic without crashing. + */ + load_script(&bprm); + +cleanup: + if (bprm.mm) + mmput(bprm.mm); + if (bprm.interp) + kfree(bprm.interp); + if (bprm.filename) + kfree(bprm.filename); + free_page((unsigned long)arg_page); +} From f6b682892b73efd5e8971dac55acacb4e1eaa3f4 Mon Sep 17 00:00:00 2001 From: Ethan Graham Date: Mon, 15 Sep 2025 12:36:27 +0000 Subject: [PATCH 11/11] MAINTAINERS: add maintainer information for KFuzzTest Add myself as maintainer and Alexander Potapenko as reviewer for KFuzzTest. Signed-off-by: Ethan Graham Signed-off-by: Ethan Graham Acked-by: Alexander Potapenko --- PR v3: - Update MAINTAINERS to reflect the correct location of kfuzztest-bridge under tools/testing. --- --- MAINTAINERS | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index 6dcfbd11efef87..3ad357477f92c2 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -13641,6 +13641,14 @@ F: include/linux/kfifo.h F: lib/kfifo.c F: samples/kfifo/ +KFUZZTEST +M: Ethan Graham +R: Alexander Potapenko +F: include/linux/kfuzztest.h +F: lib/kfuzztest/ +F: Documentation/dev-tools/kfuzztest.rst +F: tools/testing/kfuzztest-bridge/ + KGDB / KDB /debug_core M: Jason Wessel M: Daniel Thompson