Rust KASAN Support
Subsystems (5)
v3 cover Rust KASAN Support
Right now, if we turn on KASAN, Rust code will cause violations because it's not enabled properly.
This series:
1. Adds flag probe macros for Rust - now that we're setting a minimum rustc version instead of an exact one, these could be useful in general. We need them in this patch because we don't set a restriction on which LLVM rustc is using, which is what KASAN actually cares about.
2. Makes rustc enable the relevant KASAN sanitizer flags when C does.
3. Adds a smoke test to the kasan_test KUnit suite to check basic integration.
This patch series requires the target.json array support patch [1] as the x86_64 target.json file currently produced does not mark itself as KASAN capable, and is rebased on top of the KASAN Makefile rewrite [2].
Differences from v2 [3]:
1. Rebased on top of the maintainer's cleanup of the Makefile.
2. Cleaned up the UaF test based on feedback.
3. Calls out that KASAN_SW_TAGS is not yet supported in the config.
The notable piece of feedback I have not followed is in the renaming of kasan_test.c to kasan_test_c.c - this was done in order to allow the module to be named kasan_test but consist of two .o files. The other options I see are renaming the test suite or creating a separate Rust test suite, but both of those seemed more invasive than the rename. Let me know if you have another approach you'd prefer there.
[1] https://lore.kernel.org/lkml/[email protected]/
[2] https://lore.kernel.org/all/[email protected]
[3] https://lore.kernel.org/all/[email protected]/
Matthew Maurer (4):
kbuild: rust: Define probing macros for rustc
kbuild: rust: Enable KASAN support
rust: kasan: Rust does not support KHWASAN
kasan: rust: Add KASAN smoke test via UAF
init/Kconfig | 1 +
mm/kasan/Makefile | 9 +++-
mm/kasan/kasan.h | 1 +
mm/kasan/{kasan_test.c => kasan_test_c.c} | 11 +++++
mm/kasan/kasan_test_rust.rs | 19 ++++++++
scripts/Kconfig.include | 8 ++++
scripts/Makefile.compiler | 15 +++++++
scripts/Makefile.kasan | 54 ++++++++++++++++-------
scripts/Makefile.lib | 3 ++
scripts/generate_rust_target.rs | 1 +
10 files changed, 105 insertions(+), 17 deletions(-)
rename mm/kasan/{kasan_test.c => kasan_test_c.c} (99%)
create mode 100644 mm/kasan/kasan_test_rust.rsSignature · 1 line
2.46.0.184.g6999bdac58-goog
PATCH v3 1/4 kbuild: rust: Define probing macros for rustc
Creates flag probe macro variants for rustc. These are helpful because:
1. rustc support will soon be a minimum rather than a pinned version.
2. We already support multiple LLVMs linked into rustc, and these are needed to probe what LLVM parameters rustc will accept.
--- scripts/Kconfig.include | 8 ++++++++ scripts/Makefile.compiler | 15 +++++++++++++++ 2 files changed, 23 insertions(+)
scripts/Kconfig.include +8 -0
@@ -63,3 +63,11 @@ ld-version := $(shell,set -- $(ld-info) && echo $2) cc-option-bit = $(if-success,$(CC) -Werror $(1) -E -x c /dev/null -o /dev/null,$(1)) m32-flag := $(cc-option-bit,-m32) m64-flag := $(cc-option-bit,-m64) + +# $(rustc-option,<flag>) +# Return y if the Rust compiler supports <flag>, n otherwise +# Calls to this should be guarded so that they are not evaluated if +# CONFIG_HAVE_RUST is not set. +# If you are testing for unstable features, consider `rustc-min-version` +# instead, as features may have different completeness while available. +rustc-option = $(success,trap "rm -rf .tmp_$$" EXIT; mkdir .tmp_$$; $(RUSTC) $(1) --crate-type=rlib /dev/null -o .tmp_$$/tmp.rlib)
scripts/Makefile.compiler +15 -0
@@ -72,3 +72,18 @@ clang-min-version = $(call test-ge, $(CONFIG_CLANG_VERSION), $1) # ld-option # Usage: KBUILD_LDFLAGS += $(call ld-option, -X, -Y) ld-option = $(call try-run, $(LD) $(KBUILD_LDFLAGS) $(1) -v,$(1),$(2),$(3)) + +# __rustc-option +# Usage: MY_RUSTFLAGS += $(call __rustc-option,$(RUSTC),$(MY_RUSTFLAGS),-Cinstrument-coverage,-Zinstrument-coverage) +__rustc-option = $(call try-run,\ + $(1) $(2) $(3) --crate-type=rlib /dev/null -o "$$TMP",$(3),$(4)) + +# rustc-option +# Usage: rustflags-y += $(call rustc-option,-Cinstrument-coverage,-Zinstrument-coverage) +rustc-option = $(call __rustc-option, $(RUSTC),\ + $(KBUILD_RUSTFLAGS),$(1),$(2)) + +# rustc-option-yn +# Usage: flag := $(call rustc-option-yn,-Cinstrument-coverage) +rustc-option-yn = $(call try-run,\ + $(RUSTC) $(KBUILD_RUSTFLAGS) $(1) --crate-type=rlib /dev/null -o "$$TMP",y,n)
Signature · 1 line
2.46.0.184.g6999bdac58-goog
Re: [PATCH v3 1/4] kbuild: rust: Define probing macros for rustc
Hi Matthew,
Quoted 9 lines · Matthew Maurer
Creates flag probe macro variants for
rustc. These are helpful because:1.
rustcsupport will soon be a minimum rather than a pinned version.
2. We already support multiple LLVMs linked intorustc, and these are needed to probe what LLVM parametersrustcwill accept.Signed-off-by Matthew Maurer <[email protected]>
I had some feedback on v2 -- was it missed?
https://lore.kernel.org/rust-for-linux/CANiq72khUrha-a+59KYZgc63w-3P9=Dp_fs=+sgmV_A17q+PTA@mail.gmail.com/
Thanks!
Cheers,
Miguel
Re: [PATCH v3 1/4] kbuild: rust: Define probing macros for rustc
Quoted 4 lines · Miguel Ojeda
I had some feedback on v2 -- was it missed?
https://lore.kernel.org/rust-for-linux/CANiq72khUrha-a+59KYZgc63w-3P9=Dp_fs=+sgmV_A17q+PTA@mail.gmail.com/
Sorry, I did miss that in the refresh. To respond to a few points before I send up a replacement for this patch:
Quoted 3 lines
Quoted 2 lines
1.
rustcsupport will soon be a minimum rather than a pinned version.In the meantime, this happened, so we should update this sentence.
Will update.
Quoted 3 lines
Quoted 1 line
2. We already support multiple LLVMs linked into
rustc, and these areI guess you mean
rustcis able to use multiple major versions of LLVM -- or what do you mean by "multiple LLVMs linked"?
I meant that the rustc consumed by the kernel build may use a wide range of different LLVMs, including unreleased ones. This means that which options are valid fundamentally needs to be probed - there's not necessarily a clean "LLVM version" for us to use. I'll rephrase.
Quoted 6 lines
scripts/Kconfig.include ld-version := $(shell,set -- $(ld-info) && echo $2) · line 70
Quoted 4 lines
scripts/Kconfig.include +4
-0+# $(rustc-option,<flag>) +# Return y if the Rust compiler supports <flag>, n otherwise +# Calls to this should be guarded so that they are not evaluated if +# CONFIG_HAVE_RUST is not set.Hmm... why
HAVE_RUST? Should that beRUST_IS_AVAILABLE? Or what is
t>he intention? Perhaps a comment would help here -- e.g. something
Quoted 2 lines
like the comment I used in the original approach [1]. Otherwise we will forget... :)
Yes, this should be RUST_IS_AVAILABLE, will update.
Quoted 3 lines
Also, I guess you wanted to relax the precondition as much as possible, which is great, just to double check, do we expect a case outside
RUST=y?
I expect this to be potentially used for whether you're *allowed* to set RUST=y - for example, if a particular sanitizer is enabled, you may need to probe whether Rust+LLVM supports that sanitizer before allowing RUST to be set to y.
Quoted 5 lines
Quoted 1 line
rustc-option = $(success,trap "rm -rf .tmp_$$" EXIT; mkdir .tmp_$$; $(RUSTC) $(1) --crate-type=rlib
/dev/null-o .tmp_$$/tmp.rlib)I also had
out-dir[1] since, if I remember correctly,rustcmay create temporary files in a potentially read-only location even in this case.
OK, I will add that.
Quoted 1 line
Quoted 1 line
Also, should we do
-Dwarningshere?
I don't think so - I can't think of a case where we'd want to error on a warning from an empty crate (though that may be a failure of imagination.) Do you have an example of a warning we might trip that we'd want to make the build reject an option's availability?
Quoted 5 lines
Thanks!
Cheers,
Miguel
Re: [PATCH v3 1/4] kbuild: rust: Define probing macros for rustc
Quoted 3 lines · Matthew Maurer
Sorry, I did miss that in the refresh. To respond to a few points before I send up a replacement for this patch:
No problem at all -- thanks!
Quoted 4 lines
I expect this to be potentially used for whether you're *allowed* to set
RUST=y- for example, if a particular sanitizer is enabled, you may need to probe whether Rust+LLVM supports that sanitizer before allowing RUST to be set to y.
Yeah, makes sense if we do the dependency that way.
Quoted 4 lines
I don't think so - I can't think of a case where we'd want to error on a warning from an empty crate (though that may be a failure of imagination.) Do you have an example of a warning we might trip that we'd want to make the build reject an option's availability?
IIRC back then I was thinking about something like the "unknown target feature forwarded to backend" one, i.e. to identify whether a target feature was supported or not. However, that is not a warning even under -Dwarnings (https://github.com/rust-lang/rust/issues/91262)
unless something recently changed.
We can add it if/when we need it.
Cheers,
Miguel
PATCH v3 2/4 kbuild: rust: Enable KASAN support
In reply to Matthew MaurerRust supports KASAN via LLVM, but prior to this patch, the flags aren't set properly.
Rust hasn't yet enabled software-tagged KWHASAN (only regular HWASAN), so explicitly prevent Rust from being selected when it is enabled.
--- scripts/Makefile.kasan | 54 +++++++++++++++++++++++---------- scripts/Makefile.lib | 3 ++ scripts/generate_rust_target.rs | 1 + 3 files changed, 42 insertions(+), 16 deletions(-)
scripts/Makefile.kasan +38 -16
@@ -12,6 +12,11 @@ endif KASAN_SHADOW_OFFSET ?= $(CONFIG_KASAN_SHADOW_OFFSET) cc-param = $(call cc-option, -mllvm -$(1), $(call cc-option, --param $(1))) +rustc-param = $(call rustc-option, -Cllvm-args=-$(1),) + +check-args = $(foreach arg,$(2),$(call $(1),$(arg))) + +kasan_params := ifdef CONFIG_KASAN_STACK stack_enable := 1
@@ -41,39 +46,56 @@ CFLAGS_KASAN := $(call cc-option, -fsanitize=kernel-address \ $(call cc-option, -fsanitize=kernel-address \ -mllvm -asan-mapping-offset=$(KASAN_SHADOW_OFFSET))) -# Now, add other parameters enabled similarly in both GCC and Clang. -# As some of them are not supported by older compilers, use cc-param. -CFLAGS_KASAN += $(call cc-param,asan-instrumentation-with-call-threshold=$(call_threshold)) \ - $(call cc-param,asan-stack=$(stack_enable)) \ - $(call cc-param,asan-instrument-allocas=1) \ - $(call cc-param,asan-globals=1) +# The minimum supported `rustc` version has a minimum supported LLVM +# version late enough that we can assume support for -asan-mapping-offset +RUSTFLAGS_KASAN := -Zsanitizer=kernel-address \ + -Zsanitizer-recover=kernel-address \ + -Cllvm-args=-asan-mapping-offset=$(KASAN_SHADOW_OFFSET) + +# Now, add other parameters enabled similarly in GCC, Clang, and rustc. +# As some of them are not supported by older compilers, these will be filtered +# through `cc-param` or `rust-param` as applicable. +kasan_params += asan-instrumentation-with-call-threshold=$(call_threshold) \ + asan-stack=$(stack_enable) \ + asan-instrument-allocas=1 \ + asan-globals=1 # Instrument memcpy/memset/memmove calls by using instrumented __asan_mem*() # instead. With compilers that don't support this option, compiler-inserted # memintrinsics won't be checked by KASAN on GENERIC_ENTRY architectures. -CFLAGS_KASAN += $(call cc-param,asan-kernel-mem-intrinsic-prefix=1) +kasan_params += asan-kernel-mem-intrinsic-prefix=1 endif # CONFIG_KASAN_GENERIC ifdef CONFIG_KASAN_SW_TAGS ifdef CONFIG_KASAN_INLINE - instrumentation_flags := $(call cc-param,hwasan-mapping-offset=$(KASAN_SHADOW_OFFSET)) + kasan_params += hwasan-mapping-offset=$(KASAN_SHADOW_OFFSET) else - instrumentation_flags := $(call cc-param,hwasan-instrument-with-calls=1) + kasan_params += hwasan-instrument-with-calls=1 endif -CFLAGS_KASAN := -fsanitize=kernel-hwaddress \ - $(call cc-param,hwasan-instrument-stack=$(stack_enable)) \ - $(call cc-param,hwasan-use-short-granules=0) \ - $(call cc-param,hwasan-inline-all-checks=0) \ - $(instrumentation_flags) +kasan_params += hwasan-instrument-stack=$(stack_enable) \ + hwasan-use-short-granules=0 \ + hwasan-inline-all-checks=0 + +CFLAGS_KASAN := -fsanitize=kernel-hwaddress +RUSTFLAGS_KASAN := -Zsanitizer=kernel-hwaddress \ + -Zsanitizer-recover=kernel-hwaddress # Instrument memcpy/memset/memmove calls by using instrumented __hwasan_mem*(). ifeq ($(call clang-min-version, 150000)$(call gcc-min-version, 130000),y) - CFLAGS_KASAN += $(call cc-param,hwasan-kernel-mem-intrinsic-prefix=1) + kasan_params += hwasan-kernel-mem-intrinsic-prefix=1 endif endif # CONFIG_KASAN_SW_TAGS -export CFLAGS_KASAN CFLAGS_KASAN_NOSANITIZE +# Add all as-supported KASAN LLVM parameters requested by the configuration +CFLAGS_KASAN += $(call check-args, cc-param, $(kasan_params)) + +ifdef CONFIG_RUST + # Avoid calling `rustc-param` unless Rust is enabled. + RUSTFLAGS_KASAN += $(call check-args, rustc-param, $(kasan_params)) +endif # CONFIG_RUST + +export CFLAGS_KASAN CFLAGS_KASAN_NOSANITIZE RUSTFLAGS_KASAN
scripts/Makefile.lib +3 -0
@@ -167,6 +167,9 @@ ifneq ($(CONFIG_KASAN_HW_TAGS),y) _c_flags += $(if $(patsubst n%,, \ $(KASAN_SANITIZE_$(target-stem).o)$(KASAN_SANITIZE)$(is-kernel-object)), \ $(CFLAGS_KASAN), $(CFLAGS_KASAN_NOSANITIZE)) +_rust_flags += $(if $(patsubst n%,, \ + $(KASAN_SANITIZE_$(target-stem).o)$(KASAN_SANITIZE)$(is-kernel-object)), \ + $(RUSTFLAGS_KASAN)) endif endif
scripts/generate_rust_target.rs +1 -0
@@ -192,6 +192,7 @@ fn main() { } ts.push ("features" , features); ts.push ("llvm-target" ,"x86_64-linux-gnu" ); + ts.push ("supported-sanitizers" , ["kernel-address" ]); ts.push ("target-pointer-width" ,"64" ); }else if cfg.has ("LOONGARCH" ) {panic! ("loongarch uses the builtin rustc loongarch64-unknown-none-softfloat target" );
Signature · 1 line
2.46.0.184.g6999bdac58-goog
Andrey Konovalov
reviewerRe: [PATCH v3 2/4] kbuild: rust: Enable KASAN support
Quoted 6 lines · Matthew Maurer
Rust supports KASAN via LLVM, but prior to this patch, the flags aren't set properly.
Rust hasn't yet enabled software-tagged KWHASAN (only regular HWASAN), so explicitly prevent Rust from being selected when it is enabled.
This is done in the next patch, not in this one.
Quoted 26 lines
Suggested-by Miguel Ojeda <[email protected]>Signed-off-by Matthew Maurer <[email protected]>--- scripts/Makefile.kasan | 54 +++++++++++++++++++++++---------- scripts/Makefile.lib | 3 ++ scripts/generate_rust_target.rs | 1 + 3 files changed, 42 insertions(+), 16 deletions(-)scripts/Makefile.kasan +5
-0@@ -12,6 +12,11 @@ endif KASAN_SHADOW_OFFSET ?= $(CONFIG_KASAN_SHADOW_OFFSET) cc-param = $(call cc-option, -mllvm -$(1), $(call cc-option, --param $(1))) +rustc-param = $(call rustc-option, -Cllvm-args=-$(1),) + +check-args = $(foreach arg,$(2),$(call $(1),$(arg))) + +kasan_params := ifdef CONFIG_KASAN_STACK stack_enable := 1@@ -41,39 +46,56 @@ CFLAGS_KASAN := $(call cc-option, -fsanitize=kernel-address \ $(call cc-option, -fsanitize=kernel-address \
scripts/Makefile.kasan CFLAGS_KASAN := $(call cc-option, -fsanitize=kernel-address \ · line 50
Quoted 10 lines
scripts/Makefile.kasan +2
-6-mllvm -asan-mapping-offset=$(KASAN_SHADOW_OFFSET))) -# Now, add other parameters enabled similarly in both GCC and Clang. -# As some of them are not supported by older compilers, use cc-param. -CFLAGS_KASAN += $(call cc-param,asan-instrumentation-with-call-threshold=$(call_threshold)) \ - $(call cc-param,asan-stack=$(stack_enable)) \ - $(call cc-param,asan-instrument-allocas=1) \ - $(call cc-param,asan-globals=1) +# The minimum supported `rustc` version has a minimum supported LLVM +# version late enough that we can assume support for -asan-mapping-offset
Nit: dot at the end.
Quoted 28 lines
scripts/Makefile.kasan +14
-3+RUSTFLAGS_KASAN := -Zsanitizer=kernel-address \ + -Zsanitizer-recover=kernel-address \ + -Cllvm-args=-asan-mapping-offset=$(KASAN_SHADOW_OFFSET) + +# Now, add other parameters enabled similarly in GCC, Clang, and rustc. +# As some of them are not supported by older compilers, these will be filtered +# through `cc-param` or `rust-param` as applicable. +kasan_params += asan-instrumentation-with-call-threshold=$(call_threshold) \ + asan-stack=$(stack_enable) \ + asan-instrument-allocas=1 \ + asan-globals=1 # Instrument memcpy/memset/memmove calls by using instrumented __asan_mem*() # instead. With compilers that don't support this option, compiler-inserted # memintrinsics won't be checked by KASAN on GENERIC_ENTRY architectures. -CFLAGS_KASAN += $(call cc-param,asan-kernel-mem-intrinsic-prefix=1) +kasan_params += asan-kernel-mem-intrinsic-prefix=1 endif # CONFIG_KASAN_GENERIC ifdef CONFIG_KASAN_SW_TAGS ifdef CONFIG_KASAN_INLINE - instrumentation_flags := $(call cc-param,hwasan-mapping-offset=$(KASAN_SHADOW_OFFSET)) + kasan_params += hwasan-mapping-offset=$(KASAN_SHADOW_OFFSET) else - instrumentation_flags := $(call cc-param,hwasan-instrument-with-calls=1) + kasan_params += hwasan-instrument-with-calls=1
scripts/Makefile.kasan CFLAGS_KASAN := $(call cc-option, -fsanitize=kernel-address \ · line 80
Quoted 10 lines
scripts/Makefile.kasan +3
-5endif -CFLAGS_KASAN := -fsanitize=kernel-hwaddress \ - $(call cc-param,hwasan-instrument-stack=$(stack_enable)) \ - $(call cc-param,hwasan-use-short-granules=0) \ - $(call cc-param,hwasan-inline-all-checks=0) \ - $(instrumentation_flags) +kasan_params += hwasan-instrument-stack=$(stack_enable) \ + hwasan-use-short-granules=0 \ + hwasan-inline-all-checks=0
Let's put these kasan_params parts after CFLAGS_KASAN.
scripts/Makefile.kasan CFLAGS_KASAN := $(call cc-option, -fsanitize=kernel-address \ · line 84
Quoted 4 lines
scripts/Makefile.kasan +4
-0+ +CFLAGS_KASAN := -fsanitize=kernel-hwaddress +RUSTFLAGS_KASAN := -Zsanitizer=kernel-hwaddress \ + -Zsanitizer-recover=kernel-hwaddress
What's the intention of defining RUSTFLAGS_KASAN for SW_TAGS if it's not supported by Rust? Should this be removed?
If this is just a foundation for potential future support of Rust+SW_TAGS, please add a comment explaining this. And also please put the patch that disallows Rust+SW_TAGS before this one, if you keep RUSTFLAGS_KASAN.
scripts/Makefile.kasan CFLAGS_KASAN := $(call cc-option, -fsanitize=kernel-address \ · line 93
Quoted 10 lines
scripts/Makefile.kasan +2
-2# Instrument memcpy/memset/memmove calls by using instrumented __hwasan_mem*(). ifeq ($(call clang-min-version, 150000)$(call gcc-min-version, 130000),y) - CFLAGS_KASAN += $(call cc-param,hwasan-kernel-mem-intrinsic-prefix=1) + kasan_params += hwasan-kernel-mem-intrinsic-prefix=1 endif endif # CONFIG_KASAN_SW_TAGS -export CFLAGS_KASAN CFLAGS_KASAN_NOSANITIZE +# Add all as-supported KASAN LLVM parameters requested by the configuration
Nit: dot at the end.
Quoted 37 lines
scripts/Makefile.kasan +8
-0+CFLAGS_KASAN += $(call check-args, cc-param, $(kasan_params)) + +ifdef CONFIG_RUST + # Avoid calling `rustc-param` unless Rust is enabled. + RUSTFLAGS_KASAN += $(call check-args, rustc-param, $(kasan_params)) +endif # CONFIG_RUST + +export CFLAGS_KASAN CFLAGS_KASAN_NOSANITIZE RUSTFLAGS_KASANscripts/Makefile.lib +3
-0@@ -167,6 +167,9 @@ ifneq ($(CONFIG_KASAN_HW_TAGS),y) _c_flags += $(if $(patsubst n%,, \ $(KASAN_SANITIZE_$(target-stem).o)$(KASAN_SANITIZE)$(is-kernel-object)), \ $(CFLAGS_KASAN), $(CFLAGS_KASAN_NOSANITIZE)) +_rust_flags += $(if $(patsubst n%,, \ + $(KASAN_SANITIZE_$(target-stem).o)$(KASAN_SANITIZE)$(is-kernel-object)), \ + $(RUSTFLAGS_KASAN)) endif endifscripts/generate_rust_target.rs +1
-1@@ -192,6 +192,7 @@ fn main() { } ts.push ("features" , features); ts.push ("llvm-target" ,"x86_64-linux-gnu" ); + ts.push ("supported-sanitizers" , ["kernel-address" ]); ts.push ("target-pointer-width" ,"64" ); }else if cfg.has ("LOONGARCH" ) {panic! ("loongarch uses the builtin rustc loongarch64-unknown-none-softfloat target" ); --2.46.0.184.g6999bdac58-goog
PATCH v3 3/4 rust: kasan: Rust does not support KHWASAN
In reply to Matthew MaurerRust does not yet have support for software tags. Prevent RUST from being selected if KASAN_SW_TAGS is enabled.
--- init/Kconfig | 1 + 1 file changed, 1 insertion(+)
init/Kconfig +1 -0
@@ -1907,6 +1907,7 @@ config RUST depends on !GCC_PLUGINS depends on !RANDSTRUCT depends on !DEBUG_INFO_BTF || PAHOLE_HAS_LANG_EXCLUDE + depends on !KASAN_SW_TAGS help Enables Rust support in the kernel.
Signature · 1 line
2.46.0.184.g6999bdac58-goog
Re: [PATCH v3 3/4] rust: kasan: Rust does not support KHWASAN
Quoted 22 lines · Matthew Maurer
Rust does not yet have support for software tags. Prevent RUST from being selected if
KASAN_SW_TAGSis enabled.Signed-off-by Matthew Maurer <[email protected]>--- init/Kconfig | 1 + 1 file changed, 1 insertion(+)init/Kconfig +1
-1@@ -1907,6 +1907,7 @@ config RUST depends on !GCC_PLUGINS depends on !RANDSTRUCT depends on !DEBUG_INFO_BTF || PAHOLE_HAS_LANG_EXCLUDE + depends on !KASAN_SW_TAGS help Enables Rust support in the kernel. --
Quoted 2 lines
2.46.0.184.g6999bdac58-goog
PATCH v3 4/4 kasan: rust: Add KASAN smoke test via UAF
In reply to Matthew MaurerAdds a smoke test to ensure that KASAN in Rust is actually detecting a Rust-native UAF. There is significant room to expand this test suite, but this will at least ensure that flags are having the intended effect.
---
mm/kasan/Makefile | 9 ++++++++-
mm/kasan/kasan.h | 1 +
mm/kasan/{kasan_test.c => kasan_test_c.c} | 11 +++++++++++
mm/kasan/kasan_test_rust.rs | 19 +++++++++++++++++++
4 files changed, 39 insertions(+), 1 deletion(-)
rename mm/kasan/{kasan_test.c => kasan_test_c.c} (99%)
create mode 100644 mm/kasan/kasan_test_rust.rsmm/kasan/Makefile +8 -1
@@ -44,7 +44,8 @@ ifndef CONFIG_CC_HAS_KASAN_MEMINTRINSIC_PREFIX CFLAGS_KASAN_TEST += -fno-builtin endif -CFLAGS_kasan_test.o := $(CFLAGS_KASAN_TEST) +CFLAGS_kasan_test_c.o := $(CFLAGS_KASAN_TEST) +RUSTFLAGS_kasan_test_rust.o := $(RUSTFLAGS_KASAN) CFLAGS_kasan_test_module.o := $(CFLAGS_KASAN_TEST) obj-y := common.o report.o
@@ -54,3 +55,9 @@ obj-$(CONFIG_KASAN_SW_TAGS) += init.o report_sw_tags.o shadow.o sw_tags.o tags.o obj-$(CONFIG_KASAN_KUNIT_TEST) += kasan_test.o obj-$(CONFIG_KASAN_MODULE_TEST) += kasan_test_module.o + +kasan_test-objs := kasan_test_c.o + +ifdef CONFIG_RUST +kasan_test-objs += kasan_test_rust.o +endif
mm/kasan/kasan.h +1 -0
@@ -566,6 +566,7 @@ static inline void kasan_kunit_test_suite_end(void) { }bool kasan_save_enable_multi_shot (void );void kasan_restore_multi_shot (bool enabled); +char kasan_test_rust_uaf (void );#endif
mm/kasan/kasan_test_c.c renamed from mm/kasan/kasan_test.c +11 -0
@@ -1899,6 +1899,16 @@ static void match_all_mem_tag(struct kunit *test)kfree (ptr); } +/* +* Check that Rust performing a use-after-free using `unsafe` is detected. +* This is a smoke test to make sure that Rust is being sanitized properly. +*/ +static void rust_uaf (struct kunit *test) +{ +KUNIT_EXPECT_KASAN_FAIL (test,kasan_test_rust_uaf ()); +} + +static struct kunit_case kasan_kunit_test_cases[] = {KUNIT_CASE (kmalloc_oob_right),KUNIT_CASE (kmalloc_oob_left),
@@ -1971,6 +1981,7 @@ static struct kunit_case kasan_kunit_test_cases[] = {KUNIT_CASE (match_all_not_assigned),KUNIT_CASE (match_all_ptr_tag),KUNIT_CASE (match_all_mem_tag), + KUNIT_CASE(rust_uaf), {} };
mm/kasan/kasan_test_rust.rs new file +19 -0
@@ -0,0 +1,19 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! Helper crate for KASAN testing +//! Provides behavior to check the sanitization of Rust code. +use kernel::prelude::*; +use core::ptr::addr_of_mut; + +/// Trivial UAF - allocate a big vector, grab a pointer partway through, +/// drop the vector, and touch it. +#[no_mangle] +pub extern "C" fn kasan_test_rust_uaf () ->u8 { +let mut v:Vec <u8 > =Vec ::new (); +for _in 0 ..4096 { + v.push (0x42 ,GFP_KERNEL ).unwrap (); + } +let ptr: *mut u8 =addr_of_mut! (v[2048 ]); +drop (v); +unsafe { *ptr } +}
Signature · 1 line
2.46.0.184.g6999bdac58-goog
Andrey Konovalov
reviewerRe: [PATCH v3 4/4] kasan: rust: Add KASAN smoke test via UAF
Quoted 30 lines · Matthew Maurer
Adds a smoke test to ensure that KASAN in Rust is actually detecting a Rust-native UAF. There is significant room to expand this test suite, but this will at least ensure that flags are having the intended effect.
Signed-off-by Matthew Maurer <[email protected]>--- mm/kasan/Makefile | 9 ++++++++- mm/kasan/kasan.h | 1 + mm/kasan/{kasan_test.c => kasan_test_c.c} | 11 +++++++++++ mm/kasan/kasan_test_rust.rs | 19 +++++++++++++++++++ 4 files changed, 39 insertions(+), 1 deletion(-) rename mm/kasan/{kasan_test.c => kasan_test_c.c} (99%) create mode 100644 mm/kasan/kasan_test_rust.rsmm/kasan/Makefile +2
-1@@ -44,7 +44,8 @@ ifndef CONFIG_CC_HAS_KASAN_MEMINTRINSIC_PREFIX CFLAGS_KASAN_TEST += -fno-builtin endif -CFLAGS_kasan_test.o := $(CFLAGS_KASAN_TEST) +CFLAGS_kasan_test_c.o := $(CFLAGS_KASAN_TEST) +RUSTFLAGS_kasan_test_rust.o := $(RUSTFLAGS_KASAN) CFLAGS_kasan_test_module.o := $(CFLAGS_KASAN_TEST) obj-y := common.o report.o
mm/kasan/Makefile obj-$(CONFIG_KASAN_SW_TAGS) += init.o report_sw_tags.o shadow.o sw_tags.o tags.o · line 63
Quoted 9 lines
mm/kasan/Makefile +6
-0@@ -54,3 +55,9 @@ obj-$(CONFIG_KASAN_SW_TAGS) += init.o report_sw_tags.o shadow.o sw_tags.o tags.o obj-$(CONFIG_KASAN_KUNIT_TEST) += kasan_test.o obj-$(CONFIG_KASAN_MODULE_TEST) += kasan_test_module.o + +kasan_test-objs := kasan_test_c.o + +ifdef CONFIG_RUST +kasan_test-objs += kasan_test_rust.o +endif
Let's put the kasan_test-objs directives before obj-$(CONFIG_KASAN_KUNIT_TEST): they come first logically.
Also, I wonder, if something like kasan_test-objs-$(CONFIG_RUST) += kasan_test_rust.o would work to make this shorter?
mm/kasan/kasan.h static inline void kasan_kunit_test_suite_end(void) { } · line 569
Quoted 9 lines
mm/kasan/kasan.h +1
-0@@ -566,6 +566,7 @@ static inline void kasan_kunit_test_suite_end(void) { }bool kasan_save_enable_multi_shot (void );void kasan_restore_multi_shot (bool enabled); +char kasan_test_rust_uaf (void );
You need ifdef CONFIG_RUST checks here and an empty definition when !CONFIG_RUST.
Please build-test and run the KASAN test suite without CONFIG_RUST before sending the patches.
Also, I think it's better to put this declaration next to kasan_kunit_test_suite_end: CONFIG_KASAN_MODULE_TEST is not tied to the added KASAN test.
Quoted 11 lines
mm/kasan/kasan.h +0
-0#endif mm/kasan/kasan_test_c.c renamed from mm/kasan/kasan_test.c +0
-0
mm/kasan/kasan_test_c.c static void match_all_mem_tag(struct kunit *test) · line 1907
Quoted 9 lines
mm/kasan/kasan_test_c.c renamed from mm/kasan/kasan_test.c +6
-0@@ -1899,6 +1899,16 @@ static void match_all_mem_tag(struct kunit *test)kfree (ptr); } +/* +* Check that Rust performing a use-after-free using `unsafe` is detected. +* This is a smoke test to make sure that Rust is being sanitized properly. +*/ +static void rust_uaf (struct kunit *test) +{
KASAN_TEST_NEEDS_CONFIG_ON(test, CONFIG_RUST);
Quoted 43 lines
mm/kasan/kasan_test_c.c renamed from mm/kasan/kasan_test.c +5
-0+KUNIT_EXPECT_KASAN_FAIL (test,kasan_test_rust_uaf ()); +} + +static struct kunit_case kasan_kunit_test_cases[] = {KUNIT_CASE (kmalloc_oob_right),KUNIT_CASE (kmalloc_oob_left),@@ -1971,6 +1981,7 @@ static struct kunit_case kasan_kunit_test_cases[] = {KUNIT_CASE (match_all_not_assigned),KUNIT_CASE (match_all_ptr_tag),KUNIT_CASE (match_all_mem_tag), + KUNIT_CASE(rust_uaf), {} };mm/kasan/kasan_test_rust.rs new file +19
-1@@ -0,0 +1,19 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! Helper crate for KASAN testing +//! Provides behavior to check the sanitization of Rust code. +use kernel::prelude::*; +use core::ptr::addr_of_mut; + +/// Trivial UAF - allocate a big vector, grab a pointer partway through, +/// drop the vector, and touch it. +#[no_mangle] +pub extern "C" fn kasan_test_rust_uaf () ->u8 { +let mut v:Vec <u8 > =Vec ::new (); +for _in 0 ..4096 { + v.push (0x42 ,GFP_KERNEL ).unwrap (); + } +let ptr: *mut u8 =addr_of_mut! (v[2048 ]); +drop (v); +unsafe { *ptr } +} --2.46.0.184.g6999bdac58-goog
Quoted 7 lines · Matthew Maurer
This patch series requires the target.json array support patch [1] as the
x86_64target.json file currently produced does not mark itself as KASAN capable, and is rebased on top of the KASANMakefilerewrite [2].Differences from v2 [3]:
1. Rebased on top of the maintainer's cleanup of theMakefile.
Andrey/KASAN: whenever you are happy with this series, assuming it happens for this cycle, do you have a preference/constraint where to land this through? I am asking since we will likely need the target.json patch for another series that may land this cycle too (Rust KCFI). I asked Masahiro as well what he preferred to do, e.g. if he wants to take everything (KCFI, KASAN, SCS) through Kbuild, that is great too.
Thanks!
Cheers,
Miguel
Andrey Konovalov
reviewerQuoted 10 lines · Miguel Ojeda
Quoted 7 lines · Matthew Maurer
This patch series requires the target.json array support patch [1] as the
x86_64target.json file currently produced does not mark itself as KASAN capable, and is rebased on top of the KASANMakefilerewrite [2].Differences from v2 [3]:
1. Rebased on top of the maintainer's cleanup of theMakefile.
Quoted 7 lines
Andrey/KASAN: whenever you are happy with this series, assuming it happens for this cycle, do you have a preference/constraint where to land this through? I am asking since we will likely need the target.json patch for another series that may land this cycle too (Rust KCFI). I asked Masahiro as well what he preferred to do, e.g. if he wants to take everything (KCFI, KASAN, SCS) through
Kbuild, that is great too.
No preferences, feel free to take this through any tree. Thanks!
Quoted 6 lines · Matthew Maurer
The notable piece of feedback I have not followed is in the renaming of
kasan_test.ctokasan_test_c.c- this was done in order to allow the module to be namedkasan_testbut consist of two .o files. The other options I see are renaming the test suite or creating a separate Rust test suite, but both of those seemed more invasive than the rename. Let me know if you have another approach you'd prefer there.
If you're sending another version anyway, then it would make sense to mention why the file is renamed in the commit message of that patch.
Alice