arm64: Implement WXN using MDWE hook
cover arm64: Implement WXN using MDWE hook
From: Ard Biesheuvel <[email protected]>
While the patches to implement WXN support were under review, the kernel grew another hook in the mmap()/mprotect() code that is more suitable for introducing a check against an arch-defined policy whether mappings that are both writable and executable are permitted at all.
So add this hook, and wire up WXN support on top of it.
This supersedes
cb1a393c40ee mm: add arch hook to validate mmap() prot flag 50e3ed0f93f4 arm64: mm: add support for WXN memory translation attribute
which have been reverted in the arm64/for-next core tree.
Catalin raised the question how this is supposed to interoperate with Permission Indirection and Permission Overlays, and -while those new CPU features are entirely undocumented as of yet- the conclusion seems to be that WXN is only useful on cores that lack those new features, as they are mutually exclusive with WXN, and disabling them just in favor of WXN seems unwise. Given that WXN is too coarse grained to honour the existing user space ABI seamlessly, PIE/POE seem better suited to harden the use of RW vs RX mappings in user space (but WXN would seem more appropriate for the kernel if it were limited to EL1 only).
However, Linux/arm64 is deployed widely on systems running vertically integrated software stacks, where the ability to harden both the kernel and user space in this manner is believed to be a useful feature.
Ard Biesheuvel (2):
mm: Add arch hook to map_deny_write_exec()
arm64: mm: add support for WXN memory translation attribute
arch/arm64/Kconfig | 11 +++++++ arch/arm64/include/asm/cpufeature.h | 8 +++++ arch/arm64/include/asm/mman.h | 16 ++++++++++ arch/arm64/include/asm/mmu_context.h | 30 +++++++++++++++++- arch/arm64/kernel/pi/idreg-override.c | 4 ++- arch/arm64/kernel/pi/map_kernel.c | 23 ++++++++++++++ arch/arm64/mm/proc.S | 6 ++++ include/linux/mman.h | 32 ++++++++++++++------ 8 files changed, 119 insertions(+), 11 deletions(-)
Signature · 7 lines
2.44.0.278.ge034bb2e1d-goog _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH 1/2 mm: Add arch hook to map_deny_write_exec()
From: Ard Biesheuvel <[email protected]>
Prepare for WXN support on arm64, which disallows mappings that are both writable and executable at the same time altogether. This is less strict than MemoryDenyWriteExecute [which disallows any transition that adds PROT_EXEC], and is not configurable per-process so it is not a seamless fit.
So reorganize the map_deny_write_exec() check so that we can deny W+X mappings based on an arch defined policy, while only disallowing other +X transitions if MDWE is really enabled for the process.
--- include/linux/mman.h | 32 ++++++++++++++------ 1 file changed, 23 insertions(+), 9 deletions(-)
include/linux/mman.h +23 -9
@@ -162,6 +162,14 @@ calc_vm_flag_bits(unsigned long flags)unsigned long vm_commit_limit (void ); +#ifndef arch_deny_write_exec +static inline bool arch_deny_write_exec (void ) +{ +return false; +} +#define arch_deny_write_exec arch_deny_write_exec +#endif +/* * Denies creating a writable executable mapping or gaining executable permissions. *
@@ -180,19 +188,25 @@ unsigned long vm_commit_limit(void);* * d) mmap(PROT_READ | PROT_EXEC) * mmap(PROT_READ | PROT_EXEC | PROT_BTI) +* +* In addition, permit the arch to implement a strict policy regarding +* PROT_WRITE|PROT_EXEC even if the MDWE prctl() is not in use. */ static inline bool map_deny_write_exec (struct vm_area_struct *vma,unsigned long vm_flags) { -if (!test_bit (MMF_HAS_MDWE , ¤t->mm->flags)) +switch (vm_flags & (VM_WRITE |VM_EXEC )) { +case VM_EXEC : +if (vma->vm_flags &VM_EXEC ) +return false; +break ; +case VM_WRITE |VM_EXEC : +if (arch_deny_write_exec ()) +return true; +break ; +default :return false; - -if ((vm_flags &VM_EXEC ) && (vm_flags &VM_WRITE )) -return true; - -if (!(vma->vm_flags &VM_EXEC ) && (vm_flags &VM_EXEC )) -return true; - -return false; + } +return test_bit (MMF_HAS_MDWE , ¤t->mm->flags); }#endif /* _LINUX_MMAN_H */
Signature · 7 lines
2.44.0.278.ge034bb2e1d-goog _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH 2/2 arm64: mm: add support for WXN memory translation attribute
In reply to Ard BiesheuvelFrom: Ard Biesheuvel <[email protected]>
The AArch64 virtual memory system supports a global WXN control, which can be enabled to make all writable mappings implicitly no-exec. This is a useful hardening feature, as it prevents mistakes in managing page table permissions from being exploited to attack the system.
When enabled at EL1, the restrictions apply to both EL1 and EL0. EL1 is completely under our control, and has been cleaned up to allow WXN to be enabled from boot onwards. So as far as EL1 is concerned, there is no reason not to enable this.
Since there is no practical way to make this restriction apply to EL1 only, or selectively to some user processes and not others, this will apply to the kernel and all of user space when it is enabled. This constitutes an ABI change and is therefore not recommended in general.
Note that mmap()/mprotect() calls requesting writable executable mappings will fail gracefully under this policy, and many software components and libraries have already been updated to deal with this limitation, given that hardening schemes such as PaX or SeLinux have already been imposing such restrictions for years.
--- arch/arm64/Kconfig | 11 +++++++ arch/arm64/include/asm/cpufeature.h | 8 ++++++ arch/arm64/include/asm/mman.h | 16 +++++++++++ arch/arm64/include/asm/mmu_context.h | 30 +++++++++++++++++++- arch/arm64/kernel/pi/idreg-override.c | 4 ++- arch/arm64/kernel/pi/map_kernel.c | 23 +++++++++++++++ arch/arm64/mm/proc.S | 6 ++++ 7 files changed, 96 insertions(+), 2 deletions(-)
arch/arm64/Kconfig +11 -0
@@ -1606,6 +1606,17 @@ config RODATA_FULL_DEFAULT_ENABLED This requires the linear region to be mapped down to pages, which may adversely affect performance in some cases. +config ARM64_WXN + bool "Enable WXN attribute so all writable mappings are non-exec" + help + Set the WXN bit in the SCTLR system register so that all writable + mappings are treated as if the PXN/UXN bit is set as well. + If this is set to Y, it can still be disabled at runtime by + passing 'arm64.nowxn' on the kernel command line. + + This should only be set if no software needs to be supported that + relies on being able to execute from writable mappings. + config ARM64_SW_TTBR0_PAN bool "Emulate Privileged Access Never using TTBR0_EL1 switching" help
arch/arm64/include/asm/cpufeature.h +8 -0
@@ -18,6 +18,7 @@#define ARM64_SW_FEATURE_OVERRIDE_NOKASLR 0#define ARM64_SW_FEATURE_OVERRIDE_HVHE 4#define ARM64_SW_FEATURE_OVERRIDE_RODATA_OFF 8 +#define ARM64_SW_FEATURE_OVERRIDE_NOWXN 12#ifndef __ASSEMBLY__
@@ -967,6 +968,13 @@ static inline bool kaslr_disabled_cmdline(void)return arm64_test_sw_feature_override (ARM64_SW_FEATURE_OVERRIDE_NOKASLR ); } +static inline bool arm64_wxn_enabled (void ) +{ +if (!IS_ENABLED (CONFIG_ARM64_WXN )) +return false; +return !arm64_test_sw_feature_override (ARM64_SW_FEATURE_OVERRIDE_NOWXN ); +} +u32 get_kvm_ipa_limit (void );void dump_cpu_features (void );
arch/arm64/include/asm/mman.h +16 -0
@@ -35,6 +35,22 @@ static inline unsigned long arch_calc_vm_flag_bits(unsigned long flags) }#define arch_calc_vm_flag_bits (flags) arch_calc_vm_flag_bits(flags) +static inline bool arch_deny_write_exec (void ) +{ +if (!arm64_wxn_enabled ()) +return false; + +/* +* When we are running with SCTLR_ELx.WXN==1, writable mappings are +* implicitly non-executable. This means we should reject such mappings +* when user space attempts to create them using mmap() or mprotect(). +*/ +pr_info_ratelimited ("process %s (%d) attempted to create PROT_WRITE+PROT_EXEC mapping\n" , + current->comm, current->pid); +return true; +} +#define arch_deny_write_exec arch_deny_write_exec +static inline bool arch_validate_prot (unsigned long prot,unsigned long addr__always_unused ) {
arch/arm64/include/asm/mmu_context.h +29 -1
@@ -20,13 +20,41 @@#include <asm/cpufeature.h> #include <asm/daifflags.h> #include <asm/proc-fns.h> -#include <asm-generic/mm_hooks.h> #include <asm/cputype.h> #include <asm/sysreg.h> #include <asm/tlbflush.h> extern bool rodata_full; +static inline int arch_dup_mmap (struct mm_struct *oldmm, +struct mm_struct *mm) +{ +return 0 ; +} + +static inline void arch_exit_mmap (struct mm_struct *mm) +{ +} + +static inline void arch_unmap (struct mm_struct *mm, +unsigned long start,unsigned long end) +{ +} + +static inline bool arch_vma_access_permitted (struct vm_area_struct *vma, +bool write,bool execute,bool foreign) +{ +if (IS_ENABLED (CONFIG_ARM64_WXN ) && execute && + (vma->vm_flags & (VM_WRITE |VM_EXEC )) == (VM_WRITE |VM_EXEC )) { +pr_warn_ratelimited ( +"process %s (%d) attempted to execute from writable memory\n" , + current->comm, current->pid); +/* disallow unless the nowxn override is set */ +return !arm64_wxn_enabled (); + } +return true; +} +static inline void contextidr_thread_switch (struct task_struct *next) {if (!IS_ENABLED (CONFIG_PID_IN_CONTEXTIDR ))
arch/arm64/kernel/pi/idreg-override.c +3 -1
@@ -189,6 +189,7 @@ static const struct ftr_set_desc sw_features __prel64_initconst = { FIELD("nokaslr", ARM64_SW_FEATURE_OVERRIDE_NOKASLR, NULL), FIELD("hvhe", ARM64_SW_FEATURE_OVERRIDE_HVHE, hvhe_filter), FIELD("rodataoff", ARM64_SW_FEATURE_OVERRIDE_RODATA_OFF, NULL), + FIELD("nowxn", ARM64_SW_FEATURE_OVERRIDE_NOWXN, NULL), {} }, };
@@ -221,8 +222,9 @@ static const struct { { "arm64.nomops", "id_aa64isar2.mops=0" }, { "arm64.nomte", "id_aa64pfr1.mte=0" }, { "nokaslr", "arm64_sw.nokaslr=1" }, - { "rodata=off", "arm64_sw.rodataoff=1" }, + { "rodata=off", "arm64_sw.rodataoff=1 arm64_sw.nowxn=1" }, { "arm64.nolva", "id_aa64mmfr2.varange=0" }, + { "arm64.nowxn", "arm64_sw.nowxn=1" }, };static int __init parse_hexdigit (const char *p,u64 *v)
arch/arm64/kernel/pi/map_kernel.c +23 -0
@@ -132,6 +132,25 @@ static void __init map_kernel(u64 kaslr_offset, u64 va_offset, int root_level)idmap_cpu_replace_ttbr1 (swapper_pg_dir); } +static void noinline __section(".idmap.text") disable_wxn(void) +{ +u64 sctlr =read_sysreg (sctlr_el1) & ~SCTLR_ELx_WXN; + +/* +* We cannot safely clear the WXN bit while the MMU and caches are on, +* so turn the MMU off, flush the TLBs and turn it on again but with +* the WXN bit cleared this time. +*/ + asm(" msr sctlr_el1, %0 ;" +" isb ;" +" tlbi vmalle1 ;" +" dsb nsh ;" +" isb ;" +" msr sctlr_el1, %1 ;" +" isb ;" + ::"r" (sctlr & ~SCTLR_ELx_M),"r" (sctlr)); +} + static void noinline __section(".idmap.text") set_ttbr0_for_lpa2(u64 ttbr) {u64 sctlr =read_sysreg (sctlr_el1);
@@ -229,6 +248,10 @@ asmlinkage void __init early_map_kernel(u64 boot_status, void *fdt)if (va_bits >VA_BITS_MIN )sysreg_clear_set (tcr_el1,TCR_T1SZ_MASK ,TCR_T1SZ (va_bits)); +if (IS_ENABLED (CONFIG_ARM64_WXN ) && +arm64_test_sw_feature_override (ARM64_SW_FEATURE_OVERRIDE_NOWXN )) +disable_wxn (); +/* * The virtual KASLR displacement modulo 2MiB is decided by the * physical placement of the image, as otherwise, we might not be able
arch/arm64/mm/proc.S +6 -0
@@ -546,6 +546,12 @@ alternative_else_nop_endif * Prepare SCTLR */ mov_q x0, INIT_SCTLR_EL1_MMU_ON +#ifdef CONFIG_ARM64_WXN + ldr_l x1, arm64_sw_feature_override + FTR_OVR_VAL_OFFSET + tst x1, #0xf << ARM64_SW_FEATURE_OVERRIDE_NOWXN + orr x1, x0, #SCTLR_ELx_WXN + csel x0, x0, x1, ne +#endif ret // return to head.S .unreq mair
Signature · 7 lines
2.44.0.278.ge034bb2e1d-goog _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel