riscv: abstract envcfg CSR
Subsystems (10)
PATCH 1/28 riscv: abstract envcfg CSR
This patch abstracts envcfg CSR in kernel (as is done for other homonyn CSRs). CSR_ENVCFG is used as alias for CSR_SENVCFG or CSR_MENVCFG depending on how kernel is compiled.
Additionally it changes CBZE enabling to start using CSR_ENVCFG instead of CSR_SENVCFG.
--- arch/riscv/include/asm/csr.h | 2 ++ arch/riscv/kernel/cpufeature.c | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-)
arch/riscv/include/asm/csr.h +2 -0
@@ -415,6 +415,7 @@# define CSR_STATUS CSR_MSTATUS# define CSR_IE CSR_MIE# define CSR_TVEC CSR_MTVEC +# define CSR_ENVCFG CSR_MENVCFG# define CSR_SCRATCH CSR_MSCRATCH# define CSR_EPC CSR_MEPC# define CSR_CAUSE CSR_MCAUSE
@@ -439,6 +440,7 @@# define CSR_STATUS CSR_SSTATUS# define CSR_IE CSR_SIE# define CSR_TVEC CSR_STVEC +# define CSR_ENVCFG CSR_SENVCFG# define CSR_SCRATCH CSR_SSCRATCH# define CSR_EPC CSR_SEPC# define CSR_CAUSE CSR_SCAUSE
arch/riscv/kernel/cpufeature.c +1 -1
@@ -725,7 +725,7 @@ arch_initcall(check_unaligned_access_all_cpus);void riscv_user_isa_enable (void ) {if (riscv_cpu_has_extension_unlikely (smp_processor_id (),RISCV_ISA_EXT_ZICBOZ )) -csr_set (CSR_SENVCFG ,ENVCFG_CBZE ); +csr_set (CSR_ENVCFG ,ENVCFG_CBZE ); }#ifdef CONFIG_RISCV_ALTERNATIVE
Signature · 23 lines
2.43.0 From e097eed364b4ef5f9d5e6c7ef22685bf34021555 Mon Sep 17 00:00:00 2001 From: Deepak Gupta <[email protected]> Date: Tue, 12 Dec 2023 14:28:59 -0800 Subject: [PATCH 02/28] riscv: envcfg save and restore on trap entry/exit envcfg CSR defines enabling bits for cache management instructions and soon will control enabling for control flow integrity and pointer masking features. Control flow integrity enabling for forward cfi and backward cfi is controlled via envcfg and thus need to be enabled on per thread basis. This patch creates a place holder for envcfg CSR in `thread_info` and adds logic to save and restore on trap entry and exits. Signed-off-by: Deepak Gupta <[email protected]> --- arch/riscv/include/asm/thread_info.h | 1 + arch/riscv/kernel/asm-offsets.c | 1 + arch/riscv/kernel/entry.S | 4 ++++ 3 files changed, 6 insertions(+)
arch/riscv/include/asm/thread_info.h +1 -0
@@ -57,6 +57,7 @@ struct thread_info {long user_sp;/* User stack pointer */ int cpu;unsigned long syscall_work;/* SYSCALL_WORK_ flags */ +unsigned long envcfg;#ifdef CONFIG_SHADOW_CALL_STACK void *scs_base;void *scs_sp;
arch/riscv/kernel/asm-offsets.c +1 -0
@@ -39,6 +39,7 @@ void asm_offsets(void)OFFSET (TASK_TI_PREEMPT_COUNT , task_struct, thread_info.preempt_count);OFFSET (TASK_TI_KERNEL_SP , task_struct, thread_info.kernel_sp);OFFSET (TASK_TI_USER_SP , task_struct, thread_info.user_sp); +OFFSET (TASK_TI_ENVCFG , task_struct, thread_info.envcfg);#ifdef CONFIG_SHADOW_CALL_STACK OFFSET (TASK_TI_SCS_SP , task_struct, thread_info.scs_sp);#endif
arch/riscv/kernel/entry.S +4 -0
@@ -129,6 +129,10 @@ SYM_CODE_START_NOALIGN(ret_from_exception) addi s0, sp, PT_SIZE_ON_STACK REG_S s0, TASK_TI_KERNEL_SP(tp) + /* restore envcfg bits for current thread */ + REG_L s0, TASK_TI_ENVCFG(tp) + csrw CSR_ENVCFG, s0 + /* Save the kernel shadow call stack pointer */ scs_save_current
Signature · 17 lines
2.43.0 From 00561993452d050e19bd386d6d03a2a8aeb92ea2 Mon Sep 17 00:00:00 2001 From: Deepak Gupta <[email protected]> Date: Fri, 29 Dec 2023 18:22:25 -0800 Subject: [PATCH 03/28] riscv: define default value for envcfg Defines a base default value for envcfg per task. By default all tasks should have cache zeroing capability. Any future capabilities can be turned on. Signed-off-by: Deepak Gupta <[email protected]> --- arch/riscv/include/asm/csr.h | 2 ++ arch/riscv/kernel/process.c | 1 + 2 files changed, 3 insertions(+)
arch/riscv/include/asm/csr.h +2 -0
@@ -202,6 +202,8 @@#define ENVCFG_CBIE_FLUSH _AC(0x1, UL)#define ENVCFG_CBIE_INV _AC(0x3, UL)#define ENVCFG_FIOM _AC(0x1, UL) +/* by default all threads should be able to zero cache */ +#define ENVCFG_BASE ENVCFG_CBZE/* Smstateen bits */ #define SMSTATEEN0_AIA_IMSIC_SHIFT 58
arch/riscv/kernel/process.c +1 -0
@@ -152,6 +152,7 @@ void start_thread(struct pt_regs *regs, unsigned long pc, else regs->status |= SR_UXL_64;#endif + current->thread_info.envcfg =ENVCFG_BASE ; }void flush_thread (void )
Signature · 17 lines
2.43.0 From 87902dd95726e86bcd9d791cc73ca0a88f66d24a Mon Sep 17 00:00:00 2001 From: Deepak Gupta <[email protected]> Date: Fri, 15 Dec 2023 16:58:07 -0800 Subject: [PATCH 04/28] riscv/Kconfig: enable HAVE_EXIT_THREAD for riscv riscv will need an implementation for exit_thread to clean up shadow stack when thread exits. If current thread had shadow stack enabled, shadow stack is allocated by default for any new thread. Signed-off-by: Deepak Gupta <[email protected]> --- arch/riscv/Kconfig | 1 + arch/riscv/kernel/process.c | 5 +++++ 2 files changed, 6 insertions(+)
arch/riscv/Kconfig +1 -0
@@ -142,6 +142,7 @@ config RISCV select HAVE_RSEQ select HAVE_STACKPROTECTOR select HAVE_SYSCALL_TRACEPOINTS + select HAVE_EXIT_THREAD select HOTPLUG_CORE_SYNC_DEAD if HOTPLUG_CPU select IRQ_DOMAIN select IRQ_FORCED_THREADING
arch/riscv/kernel/process.c +5 -0
@@ -192,6 +192,11 @@ int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)return 0 ; } +void exit_thread (struct task_struct *tsk) +{ +return ; +} +int copy_thread (struct task_struct *p,const struct kernel_clone_args *args) {unsigned long clone_flags = args->flags;
Signature · 24 lines
2.43.0 From bc80126c6b94228de149d767eb21d2e8d98f08df Mon Sep 17 00:00:00 2001 From: Deepak Gupta <[email protected]> Date: Sun, 15 Jan 2023 23:28:54 -0800 Subject: [PATCH 05/28] riscv: zicfiss/zicfilp enumeration This patch adds support for detecting zicfiss and zicfilp. zicfiss and zicfilp stands for unprivleged integer spec extension for shadow stack and branch tracking on indirect branches, respectively. This patch looks for zicfiss and zicfilp in device tree and accordinlgy lights up bit in cpu feature bitmap. Furthermore this patch adds detection utility functions to return whether shadow stack or landing pads are supported by cpu. Signed-off-by: Deepak Gupta <[email protected]> --- arch/riscv/include/asm/cpufeature.h | 18 ++++++++++++++++++ arch/riscv/include/asm/hwcap.h | 2 ++ arch/riscv/include/asm/processor.h | 1 + arch/riscv/kernel/cpufeature.c | 2 ++ 4 files changed, 23 insertions(+)
arch/riscv/include/asm/cpufeature.h +18 -0
@@ -133,4 +133,22 @@ static __always_inline bool riscv_cpu_has_extension_unlikely(int cpu, const unsi return __riscv_isa_extension_available(hart_isa[cpu].isa, ext); } +static inline bool cpu_supports_shadow_stack (void ) +{ +#ifdef CONFIG_RISCV_USER_CFI +return riscv_isa_extension_available (NULL ,ZICFISS ); +#else +return false; +#endif +} + +static inline bool cpu_supports_indirect_br_lp_instr (void ) +{ +#ifdef CONFIG_RISCV_USER_CFI +return riscv_isa_extension_available (NULL ,ZICFILP ); +#else +return false; +#endif +} +#endif
arch/riscv/include/asm/hwcap.h +2 -0
@@ -57,6 +57,8 @@#define RISCV_ISA_EXT_ZIHPM 42#define RISCV_ISA_EXT_SMSTATEEN 43#define RISCV_ISA_EXT_ZICOND 44 +#define RISCV_ISA_EXT_ZICFISS 45 +#define RISCV_ISA_EXT_ZICFILP 46#define RISCV_ISA_EXT_MAX 64
arch/riscv/include/asm/processor.h +1 -0
@@ -13,6 +13,7 @@#include <vdso/processor.h> #include <asm/ptrace.h> +#include <asm/hwcap.h> #ifdef CONFIG_64BIT #define DEFAULT_MAP_WINDOW (UL(1) << (MMAP_VA_BITS - 1))
arch/riscv/kernel/cpufeature.c +2 -0
@@ -185,6 +185,8 @@ const struct riscv_isa_ext_data riscv_isa_ext[] = {__RISCV_ISA_EXT_DATA (svinval,RISCV_ISA_EXT_SVINVAL ),__RISCV_ISA_EXT_DATA (svnapot,RISCV_ISA_EXT_SVNAPOT ),__RISCV_ISA_EXT_DATA (svpbmt,RISCV_ISA_EXT_SVPBMT ), +__RISCV_ISA_EXT_DATA (zicfiss,RISCV_ISA_EXT_ZICFISS ), + __RISCV_ISA_EXT_DATA(zicfilp, RISCV_ISA_EXT_ZICFILP), };const size_t riscv_isa_ext_count =ARRAY_SIZE (riscv_isa_ext);
Signature · 25 lines
2.43.0 From f5c0949f18a5458498486b332d97121d4f3def27 Mon Sep 17 00:00:00 2001 From: Deepak Gupta <[email protected]> Date: Mon, 16 Jan 2023 00:08:32 -0800 Subject: [PATCH 06/28] riscv: zicfiss/zicfilp extension csr and bit definitions zicfiss and zicfilp extension gets enabled via b3 and b2 in xenvcfg CSR. menvcfg controls enabling for S/HS mode. henvcfg control enabling for VS while senvcfg controls enabling for U/VU mode. zicfilp extension extends xstatus CSR to hold `expected landing pad` bit. A trap or interrupt can occur between an indirect jmp/call and target instr. `expected landing pad` bit from CPU is recorded into xstatus CSR so that when supervisor performs xret, `expected landing pad` state of CPU can be restored. zicfiss adds one new CSR - CSR_SSP: CSR_SSP contains current shadow stack pointer. Signed-off-by: Deepak Gupta <[email protected]> --- arch/riscv/include/asm/csr.h | 16 ++++++++++++++++ 1 file changed, 16 insertions(+)
arch/riscv/include/asm/csr.h +16 -0
@@ -18,6 +18,15 @@#define SR_MPP _AC(0x00001800, UL)/* Previously Machine */ #define SR_SUM _AC(0x00040000, UL)/* Supervisor User Memory Access */ +/* zicfilp landing pad status bit */ +#define SR_SPELP _AC(0x00800000, UL) +#define SR_MPELP _AC(0x020000000000, UL) +#ifdef CONFIG_RISCV_M_MODE +#define SR_ELP SR_MPELP +#else +#define SR_ELP SR_SPELP +#endif +#define SR_FS _AC(0x00006000, UL)/* Floating-point Status */ #define SR_FS_OFF _AC(0x00000000, UL)#define SR_FS_INITIAL _AC(0x00002000, UL)
@@ -196,6 +205,8 @@#define ENVCFG_PBMTE (_AC(1, ULL) << 62)#define ENVCFG_CBZE (_AC(1, UL) << 7)#define ENVCFG_CBCFE (_AC(1, UL) << 6) +#define ENVCFG_LPE (_AC(1, UL) << 2) +#define ENVCFG_SSE (_AC(1, UL) << 3)#define ENVCFG_CBIE_SHIFT 4#define ENVCFG_CBIE (_AC(0x3, UL) << ENVCFG_CBIE_SHIFT)#define ENVCFG_CBIE_ILL _AC(0x0, UL)
@@ -216,6 +227,11 @@#define SMSTATEEN0_HSENVCFG (_ULL(1) << SMSTATEEN0_HSENVCFG_SHIFT)#define SMSTATEEN0_SSTATEEN0_SHIFT 63#define SMSTATEEN0_SSTATEEN0 (_ULL(1) << SMSTATEEN0_SSTATEEN0_SHIFT) +/* +* zicfiss user mode csr +* CSR_SSP holds current shadow stack pointer. +*/ +#define CSR_SSP 0x011/* symbolic CSR names: */ #define CSR_CYCLE 0xc00
Signature · 27 lines
2.43.0 From 0551775c478b9643a7d801e9ed56fe47554e1ba9 Mon Sep 17 00:00:00 2001 From: Deepak Gupta <[email protected]> Date: Mon, 16 Jan 2023 03:34:04 -0800 Subject: [PATCH 07/28] riscv: kernel handling on trap entry/exit for user cfi Carves out space in arch specific thread struct for cfi status and shadow stack in usermode on riscv. This patch does following - defines a new structure cfi_status with status bit for cfi feature - defines shadow stack pointer, base and size in cfi_status structure - defines offsets to new member fields in thread in asm-offsets.c - Saves and restore shadow stack pointer on trap entry (U --> S) and exit (S --> U) Signed-off-by: Deepak Gupta <[email protected]> --- arch/riscv/include/asm/processor.h | 1 + arch/riscv/include/asm/thread_info.h | 3 +++ arch/riscv/include/asm/usercfi.h | 24 ++++++++++++++++++++++++ arch/riscv/kernel/asm-offsets.c | 5 ++++- arch/riscv/kernel/entry.S | 25 +++++++++++++++++++++++++ 5 files changed, 57 insertions(+), 1 deletion(-) create mode 100644 arch/riscv/include/asm/usercfi.h
arch/riscv/include/asm/processor.h +1 -0
@@ -14,6 +14,7 @@#include <asm/ptrace.h> #include <asm/hwcap.h> +#include <asm/usercfi.h> #ifdef CONFIG_64BIT #define DEFAULT_MAP_WINDOW (UL(1) << (MMAP_VA_BITS - 1))
arch/riscv/include/asm/thread_info.h +3 -0
@@ -58,6 +58,9 @@ struct thread_info {int cpu;unsigned long syscall_work;/* SYSCALL_WORK_ flags */ unsigned long envcfg; +#ifdef CONFIG_RISCV_USER_CFI +struct cfi_status user_cfi_state; +#endif #ifdef CONFIG_SHADOW_CALL_STACK void *scs_base;void *scs_sp;
arch/riscv/include/asm/usercfi.h new file +24 -0
@@ -0,0 +1,24 @@ +/* SPDX-License-Identifier: GPL-2.0 +* Copyright (C) 2023 Rivos, Inc. +* Deepak Gupta <[email protected]> +*/ +#ifndef _ASM_RISCV_USERCFI_H +#define _ASM_RISCV_USERCFI_H + +#ifndef __ASSEMBLY__ +#include <linux/types.h> + +#ifdef CONFIG_RISCV_USER_CFI +struct cfi_status { +unsigned long ubcfi_en :1 ;/* Enable for backward cfi. */ +unsigned long rsvd : ((sizeof (unsigned long )*8 ) -1 ); +unsigned long user_shdw_stk;/* Current user shadow stack pointer */ +unsigned long shdw_stk_base;/* Base address of shadow stack */ +unsigned long shdw_stk_size;/* size of shadow stack */ +}; + +#endif /* CONFIG_RISCV_USER_CFI */ + +#endif /* __ASSEMBLY__ */ + +#endif /* _ASM_RISCV_USERCFI_H */
arch/riscv/kernel/asm-offsets.c +4 -1
@@ -43,8 +43,11 @@ void asm_offsets(void)#ifdef CONFIG_SHADOW_CALL_STACK OFFSET (TASK_TI_SCS_SP , task_struct, thread_info.scs_sp);#endif -OFFSET (TASK_TI_CPU_NUM , task_struct, thread_info.cpu); +#ifdef CONFIG_RISCV_USER_CFI +OFFSET (TASK_TI_CFI_STATUS , task_struct, thread_info.user_cfi_state); +OFFSET (TASK_TI_USER_SSP , task_struct, thread_info.user_cfi_state.user_shdw_stk); +#endif OFFSET (TASK_THREAD_F0 , task_struct, thread.fstate.f[0 ]);OFFSET (TASK_THREAD_F1 , task_struct, thread.fstate.f[1 ]);OFFSET (TASK_THREAD_F2 , task_struct, thread.fstate.f[2 ]);
arch/riscv/kernel/entry.S +25 -0
@@ -49,6 +49,21 @@ SYM_CODE_START(handle_exception) REG_S x5, PT_T0(sp) save_from_x6_to_x31 +#ifdef CONFIG_RISCV_USER_CFI + /* + * we need to save cfi status only when previous mode was U + */ + csrr s2, CSR_STATUS + andi s2, s2, SR_SPP + bnez s2, skip_bcfi_save + /* load cfi status word */ + lw s3, TASK_TI_CFI_STATUS(tp) + andi s3, s3, 1 + beqz s3, skip_bcfi_save + csrr s3, CSR_SSP + REG_S s3, TASK_TI_USER_SSP(tp) /* save user ssp in thread_info */ +skip_bcfi_save: +#endif /* * Disable user-mode memory access as it should only be set in the * actual user copy routines.
@@ -141,6 +156,16 @@ SYM_CODE_START_NOALIGN(ret_from_exception) * structures again. */ csrw CSR_SCRATCH, tp + +#ifdef CONFIG_RISCV_USER_CFI + lw s3, TASK_TI_CFI_STATUS(tp) + andi s3, s3, 1 + beqz s3, skip_bcfi_resume + REG_L s3, TASK_TI_USER_SSP(tp) /* restore user ssp from thread struct */ + csrw CSR_SSP, s3 +skip_bcfi_resume: +#endif + 1: REG_L a0, PT_STATUS(sp) /*
Signature · 24 lines
2.43.0 From 78a8bd18df45b83011353c24a75bd6bc00bf84c7 Mon Sep 17 00:00:00 2001 From: Deepak Gupta <[email protected]> Date: Wed, 6 Dec 2023 17:37:49 -0800 Subject: [PATCH 08/28] mm: Define VM_SHADOW_STACK for RISC-V VM_SHADOW_STACK is defined by x86 as vm flag to mark a shadow stack vma. x86 uses VM_HIGH_ARCH_5 bit but that limits shadow stack vma to 64bit only. arm64 follows same path https://lore.kernel.org/lkml/[email protected]/#r On RISC-V, write-only page table encodings are shadow stack pages. This patch re-defines VM_WRITE only to be VM_SHADOW_STACK. Next set of patches will set guard rail that no other mm flow can set VM_WRITE only in vma except when specifically creating shadow stack. Signed-off-by: Deepak Gupta <[email protected]> --- include/linux/mm.h | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-)
include/linux/mm.h +13 -1
@@ -352,7 +352,19 @@ extern unsigned int kobjsize(const void *objp);* for more details on the guard size. */ # define VM_SHADOW_STACK VM_HIGH_ARCH_5 -#else +#endif + +#ifdef CONFIG_RISCV_USER_CFI +/* +* On RISC-V pte encodings for shadow stack is R=0, W=1, X=0 and thus RISCV +* choosing to use similar mechanism on vm_flags where VM_WRITE only means +* VM_SHADOW_STACK. RISCV as well doesn't support VM_SHADOW_STACK to be set +* with VM_SHARED. +*/ +#define VM_SHADOW_STACK VM_WRITE +#endif + +#ifndef VM_SHADOW_STACK # define VM_SHADOW_STACK VM_NONE#endif
Signature · 27 lines
2.43.0 From 0d6de4bf12ec3349f8b3f96760575f8f660f0ae9 Mon Sep 17 00:00:00 2001 From: Deepak Gupta <[email protected]> Date: Fri, 29 Dec 2023 18:32:53 -0800 Subject: [PATCH 09/28] mm: abstract shadow stack vma behind `arch_is_shadow_stack` x86 has used VM_SHADOW_STACK (alias to VM_HIGH_ARCH_5) to encode shadow stack VMA. VM_SHADOW_STACK is thus not possible on 32bit. Some arches may need a way to encode shadow stack on 32bit and 64bit both and they may encode this information differently in VMAs. This patch changes checks of VM_SHADOW_STACK flag in generic code to call to a function `arch_is_shadow_stack` which will return true if arch supports shadow stack and vma is shadow stack else stub returns false. There was a suggestion to name it as `vma_is_shadow_stack`. I preferred to keep `arch` prefix in there because it's each arch specific. Signed-off-by: Deepak Gupta <[email protected]> --- include/linux/mm.h | 18 +++++++++++++++++- mm/gup.c | 5 +++-- mm/internal.h | 2 +- 3 files changed, 21 insertions(+), 4 deletions(-)
include/linux/mm.h +17 -1
@@ -352,6 +352,10 @@ extern unsigned int kobjsize(const void *objp);* for more details on the guard size. */ # define VM_SHADOW_STACK VM_HIGH_ARCH_5 +static inline bool arch_is_shadow_stack (vm_flags_t vm_flags) +{ +return (vm_flags &VM_SHADOW_STACK ); +}#endif #ifdef CONFIG_RISCV_USER_CFI
@@ -362,10 +366,22 @@ extern unsigned int kobjsize(const void *objp);* with VM_SHARED. */ #define VM_SHADOW_STACK VM_WRITE + +static inline bool arch_is_shadow_stack (vm_flags_t vm_flags) +{ +return ((vm_flags & (VM_WRITE |VM_READ |VM_EXEC )) ==VM_WRITE ); +} +#endif #ifndef VM_SHADOW_STACK # define VM_SHADOW_STACK VM_NONE + +static inline bool arch_is_shadow_stack (vm_flags_t vm_flags) +{ +return false; +} +#endif #if defined(CONFIG_X86 )
@@ -3464,7 +3480,7 @@ static inline unsigned long stack_guard_start_gap(struct vm_area_struct *vma)return stack_guard_gap;/* See reasoning around the VM_SHADOW_STACK definition */ -if (vma->vm_flags &VM_SHADOW_STACK ) +if (vma->vm_flags &&arch_is_shadow_stack (vma->vm_flags))return PAGE_SIZE ;return 0 ;
mm/gup.c +3 -2
@@ -1051,7 +1051,7 @@ static int check_vma_flags(struct vm_area_struct *vma, unsigned long gup_flags) !writable_file_mapping_allowed(vma, gup_flags))return -EFAULT ; -if (!(vm_flags &VM_WRITE ) || (vm_flags &VM_SHADOW_STACK )) { +if (!(vm_flags &VM_WRITE ) ||arch_is_shadow_stack (vm_flags)) {if (!(gup_flags &FOLL_FORCE ))return -EFAULT ;/* hugetlb does not support FOLL_FORCE|FOLL_WRITE. */
@@ -1069,7 +1069,8 @@ static int check_vma_flags(struct vm_area_struct *vma, unsigned long gup_flags)if (!is_cow_mapping (vm_flags))return -EFAULT ; } - }else if (!(vm_flags &VM_READ )) { + }else if (!(vm_flags &VM_READ ) && !arch_is_shadow_stack (vm_flags)) { +/* reads allowed if its shadow stack vma */ if (!(gup_flags &FOLL_FORCE ))return -EFAULT ;/*
mm/internal.h +1 -1
@@ -572,7 +572,7 @@ static inline bool is_exec_mapping(vm_flags_t flags)*/ static inline bool is_stack_mapping (vm_flags_t flags) { -return ((flags &VM_STACK ) ==VM_STACK ) || (flags &VM_SHADOW_STACK ); +return ((flags &VM_STACK ) ==VM_STACK ) ||arch_is_shadow_stack (flags); }/*
Signature · 31 lines
2.43.0 From 5511cd8dc11f00e3ec604b8fc5afdb0f632bda9e Mon Sep 17 00:00:00 2001 From: Deepak Gupta <[email protected]> Date: Thu, 19 Jan 2023 06:13:49 -0800 Subject: [PATCH 10/28] riscv/mm : Introducing new protection flag "PROT_SHADOWSTACK" x86 and arm64 are using VM_SHADOW_STACK (which actually is VM_HIGH_ARCH_5) vma flag and thus restrict it to 64bit implementation only. RISC-V is choosing to encode presence of only VM_WRITE in vma flags as shadow stack vma. This allows 32bit RISC-V ecosystem leverage shadow stack as well. This means that existing users of `do_mmap` who had been using `VM_WRITE` and expecting read and write permissions will break. Thus introducing `PROT_SHADOWSTACK` to allow `do_mmap` disambiguate between read write v/s shadow stack mappings. Thus any kernel driver/module using `do_mmap` and only passing `VM_WRITE` would still get read-write mappings. Although any user of `do_mmap` intending to map a shaodw stack should pass `PROT_SHADOWSTACK` to get a shadow stack mapping. Although for userspace still want to rely on `map_shadow_stack` and not expose `PROT_SHADOWSTACK` to userspace and that's why this prot flag is not exposed in uapi headers. Signed-off-by: Deepak Gupta <[email protected]> --- arch/riscv/include/asm/mman.h | 25 +++++++++++++++++++++++++ mm/mmap.c | 1 + 2 files changed, 26 insertions(+) create mode 100644 arch/riscv/include/asm/mman.h
arch/riscv/include/asm/mman.h new file +25 -0
@@ -0,0 +1,25 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef __ASM_MMAN_H__ +#define __ASM_MMAN_H__ + +#include <linux/compiler.h> +#include <linux/types.h> +#include <uapi/asm/mman.h> + +/* +* Major architectures (x86, aarch64, riscv) have shadow stack now. x86 and +* arm64 choose to use VM_SHADOW_STACK (which actually is VM_HIGH_ARCH_5) vma +* flag, however that restrict it to 64bit implementation only. risc-v shadow +* stack encodings in page tables is PTE.R=0, PTE.W=1, PTE.D=1 which used to be +* reserved until now. risc-v is choosing to encode presence of only VM_WRITE in +* vma flags as shadow stack vma. However this means that existing users of mmap +* (and do_mmap) who were relying on passing only PROT_WRITE (or VM_WRITE from +* kernel driver) but still getting read and write mappings, should still work. +* x86 and arm64 followed the direction of a new system call `map_shadow_stack`. +* risc-v would like to converge on that so that shadow stacks flows are as much +* arch agnostic. Thus a conscious decision to define PROT_XXX definition for +* shadow stack here (and not exposed to uapi) +*/ +#define PROT_SHADOWSTACK 0x40 + +#endif /* ! __ASM_MMAN_H__ */
mm/mmap.c +1 -0
@@ -47,6 +47,7 @@#include <linux/oom.h> #include <linux/sched/mm.h> #include <linux/ksm.h> +#include <linux/processor.h> #include <linux/uaccess.h> #include <asm/cacheflush.h>
Signature · 39 lines
2.43.0 From a3d7e7e08612681c4980091bfebba930b733eef0 Mon Sep 17 00:00:00 2001 From: Deepak Gupta <[email protected]> Date: Thu, 19 Jan 2023 06:28:08 -0800 Subject: [PATCH 11/28] riscv: Implementing "PROT_SHADOWSTACK" on riscv This patch implements new risc-v specific protection flag `PROT_SHADOWSTACK` (only for kernel) on riscv. `PROT_SHADOWSTACK` protection flag is only limited to kernel and not exposed to userspace. Shadow stack is a security construct to prevent against ROP attacks. `map_shadow_stack` is a new syscall to manufacture shadow stack. In order to avoid multiple methods to create shadow stack, `PROT_SHADOWSTACK` is not allowed for user space `mmap` call. `mprotect` wouldn't allow because `arch_validate_prot` already takes care of this for risc-v. `arch_calc_vm_prot_bits` is implemented on risc-v to return VM_SHADOW_STACK (alias for VM_WRITE) if PROT_SHADOWSTACK is supplied (such as call to `do_mmap` will) and underlying CPU supports shadow stack. `PROT_WRITE` will be converted to `VM_READ | `VM_WRITE` so that existing case where `PROT_WRITE` is specified keep working but don't collide with `VM_WRITE` only encoding which now denotes a shadow stack. risc-v `mmap` wrapper enforces if PROT_WRITE is specified and PROT_READ is left out then PROT_READ is enforced. Earlier `protection_map[VM_WRITE]` used to pick read-write (and copy on write) PTE encodings. Now all non-shadow stack writeable mappings will pick `protection_map[VM_WRITE | VM_READ] PTE encodings. `protection[VM_WRITE]` are programmed to pick PAGE_SHADOWSTACK PTE encordings. Signed-off-by: Deepak Gupta <[email protected]> --- arch/riscv/include/asm/mman.h | 17 +++++++++++++++++ arch/riscv/include/asm/pgtable.h | 1 + arch/riscv/kernel/sys_riscv.c | 19 +++++++++++++++++++ arch/riscv/mm/init.c | 2 +- 4 files changed, 38 insertions(+), 1 deletion(-)
arch/riscv/include/asm/mman.h +17 -0
@@ -22,4 +22,21 @@*/ #define PROT_SHADOWSTACK 0x40 +static inline unsigned long arch_calc_vm_prot_bits (unsigned long prot, +unsigned long pkey__always_unused ) +{ +unsigned long ret =0 ; + +if (cpu_supports_shadow_stack ()) + ret = (prot &PROT_SHADOWSTACK ) ?VM_SHADOW_STACK :0 ; +/* +* If PROT_WRITE was specified, force it to VM_READ | VM_WRITE. +* Only VM_WRITE means shadow stack. +*/ +if (prot &PROT_WRITE ) + ret = (VM_READ |VM_WRITE ); +return ret; +} +#define arch_calc_vm_prot_bits (prot, pkey) arch_calc_vm_prot_bits(prot, pkey) +#endif /* ! __ASM_MMAN_H__ */
arch/riscv/include/asm/pgtable.h +1 -0
@@ -184,6 +184,7 @@ extern struct pt_alloc_ops pt_ops __initdata;#define PAGE_READ_EXEC __pgprot(_PAGE_BASE | _PAGE_READ | _PAGE_EXEC)#define PAGE_WRITE_EXEC __pgprot(_PAGE_BASE | _PAGE_READ | \ _PAGE_EXEC | _PAGE_WRITE) +#define PAGE_SHADOWSTACK __pgprot(_PAGE_BASE | _PAGE_WRITE)#define PAGE_COPY PAGE_READ#define PAGE_COPY_EXEC PAGE_READ_EXEC
arch/riscv/kernel/sys_riscv.c +19 -0
@@ -16,6 +16,7 @@#include <asm/unistd.h> #include <asm-generic/mman-common.h> #include <vdso/vsyscall.h> +#include <asm/mman.h> static long riscv_sys_mmap(unsigned long addr, unsigned long len, unsigned long prot, unsigned long flags,
@@ -25,6 +26,24 @@ static long riscv_sys_mmap(unsigned long addr, unsigned long len,if (unlikely (offset & (~PAGE_MASK >> page_shift_offset)))return -EINVAL ; +/* +* If only PROT_WRITE is specified then extend that to PROT_READ +* protection_map[VM_WRITE] is now going to select shadow stack encodings. +* So specifying PROT_WRITE actually should select protection_map [VM_WRITE | VM_READ] +* If user wants to create shadow stack then they should use `map_shadow_stack` syscall. +*/ +if (unlikely ((prot &PROT_WRITE ) && !(prot &PROT_READ ))) + prot |=PROT_READ ; + +/* +* PROT_SHADOWSTACK is a kernel only protection flag on risc-v. +* mmap doesn't expect PROT_SHADOWSTACK to be set by user space. +* User space can rely on `map_shadow_stack` syscall to create +* shadow stack pages. +*/ +if (unlikely (prot &PROT_SHADOWSTACK )) +return -EINVAL ; +return ksys_mmap_pgoff (addr, len, prot, flags, fd, offset >> (PAGE_SHIFT - page_shift_offset)); }
arch/riscv/mm/init.c +1 -1
@@ -296,7 +296,7 @@ pgd_t early_pg_dir[PTRS_PER_PGD] __initdata __aligned(PAGE_SIZE);static const pgprot_t protection_map[16 ] = { [VM_NONE ] =PAGE_NONE , [VM_READ ] =PAGE_READ , - [VM_WRITE ] =PAGE_COPY , + [VM_WRITE ] =PAGE_SHADOWSTACK , [VM_WRITE |VM_READ ] =PAGE_COPY , [VM_EXEC ] =PAGE_EXEC , [VM_EXEC |VM_READ ] =PAGE_READ_EXEC ,
Signature · 15 lines
2.43.0 From e7bf650a2d0bb03e189d0077be51515c4ecaf50d Mon Sep 17 00:00:00 2001 From: Deepak Gupta <[email protected]> Date: Thu, 19 Jan 2023 09:38:32 -0800 Subject: [PATCH 12/28] riscv mm: manufacture shadow stack pte This patch implements creating shadow stack pte (on riscv). Creating shadow stack PTE on riscv means that clearing RWX and then setting W=1. Signed-off-by: Deepak Gupta <[email protected]> --- arch/riscv/include/asm/pgtable.h | 12 ++++++++++++ 1 file changed, 12 insertions(+)
arch/riscv/include/asm/pgtable.h +12 -0
@@ -408,6 +408,12 @@ static inline pte_t pte_mkwrite_novma(pte_t pte)return __pte (pte_val (pte) | _PAGE_WRITE); } +static inline pte_t pte_mkwrite_shstk (pte_t pte) +{ +/* shadow stack on risc-v is XWR = 010. Clear everything and only set _PAGE_WRITE */ +return __pte ((pte_val (pte) & ~(_PAGE_LEAF)) | _PAGE_WRITE); +} +/* static inline pte_t pte_mkexec(pte_t pte) */ static inline pte_t pte_mkdirty (pte_t pte)
@@ -705,6 +711,12 @@ static inline pmd_t pmd_mkwrite_novma(pmd_t pmd)return pte_pmd (pte_mkwrite_novma (pmd_pte (pmd))); } +static inline pmd_t pmd_mkwrite_shstk (pmd_t pte) +{ +/* shadow stack on risc-v is XWR = 010. Clear everything and only set _PAGE_WRITE */ +return __pmd ((pmd_val (pte) & ~(_PAGE_LEAF)) | _PAGE_WRITE); +} +static inline pmd_t pmd_wrprotect (pmd_t pmd) {return pte_pmd (pte_wrprotect (pmd_pte (pmd)));
Signature · 28 lines
2.43.0 From e5d2f0f05004e8f14cde361a5649177ce8a082f0 Mon Sep 17 00:00:00 2001 From: Deepak Gupta <[email protected]> Date: Thu, 19 Jan 2023 09:17:54 -0800 Subject: [PATCH 13/28] riscv mmu: teach pte_mkwrite to manufacture shadow stack PTEs pte_mkwrite creates PTEs with WRITE encodings for underlying arch. Underlying arch can have two types of writeable mappings. One that can be written using regular store instructions. Another one that can only be written using specialized store instructions (like shadow stack stores). pte_mkwrite can select write PTE encoding based on VMA range. On riscv, presence of only VM_WRITE in vma->vm_flags means it's a shadow stack. Signed-off-by: Deepak Gupta <[email protected]> rebase with a30f0ca0fa31cdb2ac3d24b7b5be9e3ae75f4175 Implementation of pte_mkwrite and pmd_mkwrite on riscv Signed-off-by: Deepak Gupta <[email protected]> --- arch/riscv/include/asm/pgtable.h | 7 +++++++ arch/riscv/mm/pgtable.c | 21 +++++++++++++++++++++ 2 files changed, 28 insertions(+)
arch/riscv/include/asm/pgtable.h +7 -0
@@ -403,6 +403,10 @@ static inline pte_t pte_wrprotect(pte_t pte)/* static inline pte_t pte_mkread(pte_t pte) */ +struct vm_area_struct ; +pte_t pte_mkwrite (pte_t pte,struct vm_area_struct *vma); +#define pte_mkwrite pte_mkwrite +static inline pte_t pte_mkwrite_novma (pte_t pte) {return __pte (pte_val (pte) | _PAGE_WRITE);
@@ -706,6 +710,9 @@ static inline pmd_t pmd_mkyoung(pmd_t pmd)return pte_pmd (pte_mkyoung (pmd_pte (pmd))); } +pmd_t pmd_mkwrite (pmd_t pmd,struct vm_area_struct *vma); +#define pmd_mkwrite pmd_mkwrite +static inline pmd_t pmd_mkwrite_novma (pmd_t pmd) {return pte_pmd (pte_mkwrite_novma (pmd_pte (pmd)));
arch/riscv/mm/pgtable.c +21 -0
@@ -101,3 +101,24 @@ pmd_t pmdp_collapse_flush(struct vm_area_struct *vma, return pmd; }#endif /* CONFIG_TRANSPARENT_HUGEPAGE */ + +pte_t pte_mkwrite (pte_t pte,struct vm_area_struct *vma) +{ +if (arch_is_shadow_stack (vma->vm_flags)) +return pte_mkwrite_shstk (pte); + + pte =pte_mkwrite_novma (pte); + +return pte; +} + +pmd_t pmd_mkwrite (pmd_t pmd,struct vm_area_struct *vma) +{ +if (arch_is_shadow_stack (vma->vm_flags)) +return pmd_mkwrite_shstk (pmd); + + pmd =pmd_mkwrite_novma (pmd); + +return pmd; +} +
Signature · 30 lines
2.43.0 From 217876b4c2848c78595d9e870a41ca0f2e1c2ea2 Mon Sep 17 00:00:00 2001 From: Deepak Gupta <[email protected]> Date: Tue, 17 Jan 2023 09:35:13 -0800 Subject: [PATCH 14/28] riscv mmu: write protect and shadow stack `fork` implements copy on write (COW) by making pages readonly in child and parent both. ptep_set_wrprotect and pte_wrprotect clears _PAGE_WRITE in PTE. Assumption is that page is readable and on fault copy on write happens. To implement COW on such pages, clearing up W bit makes them XWR = 000. This will result in wrong PTE setting which says no perms but V=1 and PFN field pointing to final page. Instead desired behavior is to turn it into a readable page, take an access (load/store) fault on sspush/sspop (shadow stack) and then perform COW on such pages. This way regular reads would still be allowed and not lead to COW maintaining current behavior of COW on non-shadow stack but writeable memory. On the other hand it doesn't interfere with existing COW for read-write memory. Assumption is always that _PAGE_READ must have been set and thus setting _PAGE_READ is harmless. Signed-off-by: Deepak Gupta <[email protected]> --- arch/riscv/include/asm/pgtable.h | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-)
arch/riscv/include/asm/pgtable.h +10 -2
@@ -398,7 +398,7 @@ static inline int pte_special(pte_t pte)static inline pte_t pte_wrprotect (pte_t pte) { -return __pte (pte_val (pte) & ~(_PAGE_WRITE)); +return __pte ((pte_val (pte) & ~(_PAGE_WRITE)) | (_PAGE_READ)); }/* static inline pte_t pte_mkread(pte_t pte) */
@@ -594,7 +594,15 @@ static inline int ptep_test_and_clear_young(struct vm_area_struct *vma,static inline void ptep_set_wrprotect (struct mm_struct *mm,unsigned long address,pte_t *ptep) { -atomic_long_and (~(unsigned long )_PAGE_WRITE, (atomic_long_t *)ptep); +volatile pte_t read_pte = *ptep; +/* +* ptep_set_wrprotect can be called for shadow stack ranges too. +* shadow stack memory is XWR = 010 and thus clearing _PAGE_WRITE will lead to +* encoding 000b which is wrong encoding with V = 1. This should lead to page fault +* but we dont want this wrong configuration to be set in page tables. +*/ +atomic_long_set ((atomic_long_t *)ptep, + ((pte_val (read_pte) & ~(unsigned long )_PAGE_WRITE) | _PAGE_READ)); }#define __HAVE_ARCH_PTEP_CLEAR_YOUNG_FLUSH
Signature · 29 lines
2.43.0 From 1527cdb4739ae3884160eb8824b187717f9d0960 Mon Sep 17 00:00:00 2001 From: Deepak Gupta <[email protected]> Date: Fri, 15 Dec 2023 11:39:14 -0800 Subject: [PATCH 15/28] riscv/mm: Implement map_shadow_stack() syscall As discussed extensively in the changelog for the addition of this syscall on x86 ("x86/shstk: Introduce map_shadow_stack syscall") the existing mmap() and madvise() syscalls do not map entirely well onto the security requirements for guarded control stacks since they lead to windows where memory is allocated but not yet protected or stacks which are not properly and safely initialised. Instead a new syscall map_shadow_stack() has been defined which allocates and initialises a shadow stack page. This patch implements this syscall for riscv. riscv doesn't require token to be setup by kernel because user mode can do that by itself. However to provide compatiblity and portability with other architectues, user mode can specify token set flag. Signed-off-by: Deepak Gupta <[email protected]> --- arch/riscv/kernel/Makefile | 2 + arch/riscv/kernel/usercfi.c | 150 ++++++++++++++++++++++++++++++++ include/uapi/asm-generic/mman.h | 1 + 3 files changed, 153 insertions(+) create mode 100644 arch/riscv/kernel/usercfi.c
arch/riscv/kernel/Makefile +2 -0
@@ -102,3 +102,5 @@ obj-$(CONFIG_COMPAT) += compat_vdso/ obj-$(CONFIG_64BIT) += pi/ obj-$(CONFIG_ACPI) += acpi.o + +obj-$(CONFIG_RISCV_USER_CFI) += usercfi.o
arch/riscv/kernel/usercfi.c new file +150 -0
150 lines not on this page · raw message
include/uapi/asm-generic/mman.h +1 -0
@@ -19,4 +19,5 @@#define MCL_FUTURE 2/* lock all future mappings */ #define MCL_ONFAULT 4/* lock all pages that are faulted in */ +#define SHADOW_STACK_SET_TOKEN (1ULL << 0)/* Set up a restore token in the shadow stack */ #endif /* __ASM_GENERIC_MMAN_H */
Signature · 29 lines
2.43.0 From 2f73f707afb839a7146833ca8bf13e8a11b26eca Mon Sep 17 00:00:00 2001 From: Deepak Gupta <[email protected]> Date: Fri, 15 Dec 2023 13:14:46 -0800 Subject: [PATCH 16/28] riscv/shstk: If needed allocate a new shadow stack on clone Userspace specifies VM_CLONE to share address space and spawn new thread. `clone` allow userspace to specify a new stack for new thread. However there is no way to specify new shadow stack base address without changing API. This patch allocates a new shadow stack whenever VM_CLONE is given. In case of VM_FORK, parent is suspended until child finishes and thus can child use parent shadow stack. In case of !VM_CLONE, COW kicks in because entire address space is copied from parent to child. `clone3` is extensible and can provide mechanisms using which shadow stack as an input parameter can be provided. This is not settled yet and being extensively discussed on mailing list. Once that's settled, this commit will adapt to that. Signed-off-by: Deepak Gupta <[email protected]> --- arch/riscv/include/asm/usercfi.h | 39 ++++++++++ arch/riscv/kernel/process.c | 10 +++ arch/riscv/kernel/usercfi.c | 121 +++++++++++++++++++++++++++++++ 3 files changed, 170 insertions(+)
arch/riscv/include/asm/usercfi.h +39 -0
@@ -8,6 +8,9 @@ #ifndef __ASSEMBLY__ #include <linux/types.h> +struct task_struct; +struct kernel_clone_args; + #ifdef CONFIG_RISCV_USER_CFI struct cfi_status { unsigned long ubcfi_en : 1; /* Enable for backward cfi. */
@@ -17,6 +20,42 @@ struct cfi_status {unsigned long shdw_stk_size;/* size of shadow stack */ }; +unsigned long shstk_alloc_thread_stack (struct task_struct *tsk, +const struct kernel_clone_args *args); +void shstk_release (struct task_struct *tsk); +void set_shstk_base (struct task_struct *task,unsigned long shstk_addr,unsigned long size); +void set_active_shstk (struct task_struct *task,unsigned long shstk_addr); +bool is_shstk_enabled (struct task_struct *task); + +#else + +static inline unsigned long shstk_alloc_thread_stack (struct task_struct *tsk, +const struct kernel_clone_args *args) +{ +return 0 ; +} + +static inline void shstk_release (struct task_struct *tsk) +{ + +} + +static inline void set_shstk_base (struct task_struct *task,unsigned long shstk_addr, +unsigned long size) +{ + +} + +static inline void set_active_shstk (struct task_struct *task,unsigned long shstk_addr) +{ + +} + +static inline bool is_shstk_enabled (struct task_struct *task) +{ +return false; +} +#endif /* CONFIG_RISCV_USER_CFI */ #endif /* __ASSEMBLY__ */
arch/riscv/kernel/process.c +10 -0
@@ -26,6 +26,7 @@#include <asm/cpuidle.h> #include <asm/vector.h> #include <asm/cpufeature.h> +#include <asm/usercfi.h> registerunsigned long gp_in_global __asm__("gp" );
@@ -194,6 +195,7 @@ int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)void exit_thread (struct task_struct *tsk) { +shstk_release (tsk);return ; }
@@ -202,6 +204,7 @@ int copy_thread(struct task_struct *p, const struct kernel_clone_args *args)unsigned long clone_flags = args->flags;unsigned long usp = args->stack;unsigned long tls = args->tls; +unsigned long ssp =0 ;struct pt_regs *childregs =task_pt_regs (p);memset (&p->thread.s,0 ,sizeof (p->thread.s));
@@ -217,11 +220,18 @@ int copy_thread(struct task_struct *p, const struct kernel_clone_args *args) p->thread.s[0 ] = (unsigned long )args->fn; p->thread.s[1 ] = (unsigned long )args->fn_arg; }else { +/* allocate new shadow stack if needed. In case of CLONE_VM we have to */ + ssp =shstk_alloc_thread_stack (p, args); +if (IS_ERR_VALUE (ssp)) +return PTR_ERR ((void *)ssp); + *childregs = *(current_pt_regs ());/* Turn off status.VS */ riscv_v_vstate_off (childregs);if (usp)/* User fork */ childregs->sp = usp; +if (ssp)/* if needed, set new ssp */ +set_active_shstk (p, ssp);if (clone_flags &CLONE_SETTLS ) childregs->tp = tls; childregs->a0 =0 ;/* Return value of fork() */
arch/riscv/kernel/usercfi.c +121 -0
130 lines not on this page · raw message
Signature · 40 lines
2.43.0 From 5d9631f58cb41a3a682d1d646b24c04f512c06eb Mon Sep 17 00:00:00 2001 From: Mark Brown <[email protected]> Date: Mon, 9 Oct 2023 13:08:36 +0100 Subject: [PATCH 17/28] prctl: arch-agnostic prctl for shadow stack Three architectures (x86, aarch64, riscv) have announced support for shadow stacks with fairly similar functionality. While x86 is using arch_prctl() to control the functionality neither arm64 nor riscv uses that interface so this patch adds arch-agnostic prctl() support to get and set status of shadow stacks and lock the current configuation to prevent further changes, with support for turning on and off individual subfeatures so applications can limit their exposure to features that they do not need. The features are: - PR_SHADOW_STACK_ENABLE: Tracking and enforcement of shadow stacks, including allocation of a shadow stack if one is not already allocated. - PR_SHADOW_STACK_WRITE: Writes to specific addresses in the shadow stack. - PR_SHADOW_STACK_PUSH: Push additional values onto the shadow stack. - PR_SHADOW_STACK_DISABLE: Allow to disable shadow stack. Note once locked, disable must fail. These features are expected to be inherited by new threads and cleared on exec(), unknown features should be rejected for enable but accepted for locking (in order to allow for future proofing). This is based on a patch originally written by Deepak Gupta but later modified by Mark Brown for arm's GCS patch series. Signed-off-by: Mark Brown <[email protected]> Co-developed-by: Deepak Gupta <[email protected]> --- include/linux/mm.h | 3 +++ include/uapi/linux/prctl.h | 22 ++++++++++++++++++++++ kernel/sys.c | 30 ++++++++++++++++++++++++++++++ 3 files changed, 55 insertions(+)
include/linux/mm.h +3 -0
@@ -4170,5 +4170,8 @@ static inline bool pfn_is_unaccepted_memory(unsigned long pfn) return range_contains_unaccepted_memory(paddr, paddr + PAGE_SIZE); } +int arch_get_shadow_stack_status (struct task_struct *t,unsigned long __user *status); +int arch_set_shadow_stack_status (struct task_struct *t,unsigned long status); +int arch_lock_shadow_stack_status (struct task_struct *t,unsigned long status);#endif /* _LINUX_MM_H */
include/uapi/linux/prctl.h +22 -0
@@ -306,4 +306,26 @@ struct prctl_mm_map {# define PR_RISCV_V_VSTATE_CTRL_NEXT_MASK 0xc# define PR_RISCV_V_VSTATE_CTRL_MASK 0x1f +/* +* Get the current shadow stack configuration for the current thread, +* this will be the value configured via PR_SET_SHADOW_STACK_STATUS. +*/ +#define PR_GET_SHADOW_STACK_STATUS 71 + +/* +* Set the current shadow stack configuration. Enabling the shadow +* stack will cause a shadow stack to be allocated for the thread. +*/ +#define PR_SET_SHADOW_STACK_STATUS 72 +# define PR_SHADOW_STACK_ENABLE (1UL << 0) +# define PR_SHADOW_STACK_WRITE (1UL << 1) +# define PR_SHADOW_STACK_PUSH (1UL << 2) + +/* +* Prevent further changes to the specified shadow stack +* configuration. All bits may be locked via this call, including +* undefined bits. +*/ +#define PR_LOCK_SHADOW_STACK_STATUS 73 +#endif /* _LINUX_PRCTL_H */
kernel/sys.c +30 -0
@@ -2301,6 +2301,21 @@ int __weak arch_prctl_spec_ctrl_set(struct task_struct *t, unsigned long which,return -EINVAL ; } +int __weak arch_get_shadow_stack_status (struct task_struct *t,unsigned long __user *status) +{ +return -EINVAL ; +} + +int __weak arch_set_shadow_stack_status (struct task_struct *t,unsigned long status) +{ +return -EINVAL ; +} + +int __weak arch_lock_shadow_stack_status (struct task_struct *t,unsigned long status) +{ +return -EINVAL ; +} +#define PR_IO_FLUSHER (PF_MEMALLOC_NOIO | PF_LOCAL_THROTTLE)#ifdef CONFIG_ANON_VMA_NAME
@@ -2743,6 +2758,21 @@ SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3,case PR_RISCV_V_GET_CONTROL : error =RISCV_V_GET_CONTROL ();break ; +case PR_GET_SHADOW_STACK_STATUS : +if (arg3 || arg4 || arg5) +return -EINVAL ; + error =arch_get_shadow_stack_status (me, (unsigned long __user *) arg2); +break ; +case PR_SET_SHADOW_STACK_STATUS : +if (arg3 || arg4 || arg5) +return -EINVAL ; + error =arch_set_shadow_stack_status (me, arg2); +break ; +case PR_LOCK_SHADOW_STACK_STATUS : +if (arg3 || arg4 || arg5) +return -EINVAL ; + error =arch_lock_shadow_stack_status (me, arg2); +break ;default : error = -EINVAL ;break ;
Signature · 40 lines
2.43.0 From a4fbd367bc8d3ce589cbda16534d274a109b3666 Mon Sep 17 00:00:00 2001 From: Deepak Gupta <[email protected]> Date: Tue, 12 Dec 2023 11:59:55 -0800 Subject: [PATCH 18/28] prctl: arch-agnostic prtcl for indirect branch tracking Three architectures (x86, aarch64, riscv) have support for indirect branch tracking feature in a very similar fashion. On a very high level, indirect branch tracking is a CPU feature where CPU tracks branches which uses memory operand to perform control transfer in program. As part of this tracking on indirect branches, CPU goes in a state where it expects a landing pad instr on target and if not found then CPU raises some fault (architecture dependent) x86 landing pad instr - `ENDBRANCH` aarch64 landing pad instr - `BTI` riscv landing instr - `lpad` Given that three major arches have support for indirect branch tracking, This patch makes `prctl` for indirect branch tracking arch agnostic. To allow userspace to enable this feature for itself, following prtcls are defined: - PR_GET_INDIR_BR_LP_STATUS: Gets current configured status for indirect branch tracking. - PR_SET_INDIR_BR_LP_STATUS: Sets a configuration for indirect branch tracking Following status options are allowed - PR_INDIR_BR_LP_ENABLE: Enables indirect branch tracking on user thread. - PR_INDIR_BR_LP_DISABLE; Disables indirect branch tracking on user thread. - PR_LOCK_INDIR_BR_LP_STATUS: Locks configured status for indirect branch tracking for user thread. Signed-off-by: Deepak Gupta <[email protected]> --- include/uapi/linux/prctl.h | 27 +++++++++++++++++++++++++++ kernel/sys.c | 30 ++++++++++++++++++++++++++++++ 2 files changed, 57 insertions(+)
include/uapi/linux/prctl.h +27 -0
@@ -328,4 +328,31 @@ struct prctl_mm_map {*/ #define PR_LOCK_SHADOW_STACK_STATUS 73 +/* +* Get the current indirect branch tracking configuration for the current +* thread, this will be the value configured via PR_SET_INDIR_BR_LP_STATUS. +*/ +#define PR_GET_INDIR_BR_LP_STATUS 74 + +/* +* Set the indirect branch tracking configuration. PR_INDIR_BR_LP_ENABLE will +* enable cpu feature for user thread, to track all indirect branches and ensure +* they land on arch defined landing pad instruction. +* x86 - If enabled, an indirect branch must land on `ENDBRANCH` instruction. +* arch64 - If enabled, an indirect branch must land on `BTI` instruction. +* riscv - If enabled, an indirect branch must land on `lpad` instruction. +* PR_INDIR_BR_LP_DISABLE will disable feature for user thread and indirect +* branches will no more be tracked by cpu to land on arch defined landing pad +* instruction. +*/ +#define PR_SET_INDIR_BR_LP_STATUS 75 +# define PR_INDIR_BR_LP_ENABLE (1UL << 0) + +/* +* Prevent further changes to the specified indirect branch tracking +* configuration. All bits may be locked via this call, including +* undefined bits. +*/ +#define PR_LOCK_INDIR_BR_LP_STATUS 76 +#endif /* _LINUX_PRCTL_H */
kernel/sys.c +30 -0
@@ -2316,6 +2316,21 @@ int __weak arch_lock_shadow_stack_status(struct task_struct *t, unsigned long streturn -EINVAL ; } +int __weak arch_get_indir_br_lp_status (struct task_struct *t,unsigned long __user *status) +{ +return -EINVAL ; +} + +int __weak arch_set_indir_br_lp_status (struct task_struct *t,unsigned long __user *status) +{ +return -EINVAL ; +} + +int __weak arch_lock_indir_br_lp_status (struct task_struct *t,unsigned long __user *status) +{ +return -EINVAL ; +} +#define PR_IO_FLUSHER (PF_MEMALLOC_NOIO | PF_LOCAL_THROTTLE)#ifdef CONFIG_ANON_VMA_NAME
@@ -2773,6 +2788,21 @@ SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3,return -EINVAL ; error =arch_lock_shadow_stack_status (me, arg2);break ; +case PR_GET_INDIR_BR_LP_STATUS : +if (arg3 || arg4 || arg5) +return -EINVAL ; + error =arch_get_indir_br_lp_status (me, (unsigned long __user *) arg2); +break ; +case PR_SET_INDIR_BR_LP_STATUS : +if (arg3 || arg4 || arg5) +return -EINVAL ; + error =arch_set_indir_br_lp_status (me, (unsigned long __user *) arg2); +break ; +case PR_LOCK_INDIR_BR_LP_STATUS : +if (arg3 || arg4 || arg5) +return -EINVAL ; + error =arch_lock_indir_br_lp_status (me, (unsigned long __user *) arg2); +break ;default : error = -EINVAL ;break ;
Signature · 29 lines
2.43.0 From f2375f9a41e02e9ad8fa6910e12dfae84acbc9ae Mon Sep 17 00:00:00 2001 From: Deepak Gupta <[email protected]> Date: Thu, 19 Jan 2023 10:28:35 -0800 Subject: [PATCH 19/28] riscv: Implements arch agnostic shadow stack prctls Implement architecture agnostic prctls() interface for setting and getting shadow stack status. prctls implemented are PR_GET_SHADOW_STACK_STATUS, PR_SET_SHADOW_STACK_STATUS and PR_LOCK_SHADOW_STACK_STATUS. As part of PR_SET_SHADOW_STACK_STATUS/PR_GET_SHADOW_STACK_STATUS, only PR_SHADOW_STACK_ENABLE is implemented because RISCV allows each mode to write to their own shadow stack using `sspush` or `ssamoswap`. PR_LOCK_SHADOW_STACK_STATUS locks current configuration of shadow stack enabling Following is not supported "Enable shadow stack, then disable and enable again." It's not sure whether providing such semantics are useful. It's better to return error code when such situation arises. Signed-off-by: Deepak Gupta <[email protected]> --- arch/riscv/include/asm/usercfi.h | 12 +++- arch/riscv/kernel/usercfi.c | 105 +++++++++++++++++++++++++++++++ 2 files changed, 116 insertions(+), 1 deletion(-)
arch/riscv/include/asm/usercfi.h +11 -1
@@ -7,6 +7,7 @@#ifndef __ASSEMBLY__#include <linux/types.h> +#include <linux/prctl.h> struct task_struct ;struct kernel_clone_args ;
@@ -14,7 +15,8 @@ struct kernel_clone_args; #ifdef CONFIG_RISCV_USER_CFI struct cfi_status { unsigned long ubcfi_en : 1; /* Enable for backward cfi. */ - unsigned long rsvd : ((sizeof(unsigned long)*8) - 1); + unsigned long ubcfi_locked : 1; + unsigned long rsvd : ((sizeof(unsigned long)*8) - 2); unsigned long user_shdw_stk; /* Current user shadow stack pointer */ unsigned long shdw_stk_base; /* Base address of shadow stack */ unsigned long shdw_stk_size; /* size of shadow stack */
@@ -26,6 +28,9 @@ void shstk_release(struct task_struct *tsk);void set_shstk_base (struct task_struct *task,unsigned long shstk_addr,unsigned long size);void set_active_shstk (struct task_struct *task,unsigned long shstk_addr);bool is_shstk_enabled (struct task_struct *task); +bool is_shstk_locked (struct task_struct *task); + +#define PR_SHADOW_STACK_SUPPORTED_STATUS_MASK (PR_SHADOW_STACK_ENABLE)#else
@@ -56,6 +61,11 @@ static inline bool is_shstk_enabled(struct task_struct *task)return false; } +static inline bool is_shstk_locked (struct task_struct *task) +{ +return false; +} +#endif /* CONFIG_RISCV_USER_CFI */ #endif /* __ASSEMBLY__ */
arch/riscv/kernel/usercfi.c +105 -0
120 lines not on this page · raw message
Signature · 17 lines
2.43.0 From 8805582b1d18fb5488c9c8ed650f957c08697cfa Mon Sep 17 00:00:00 2001 From: Deepak Gupta <[email protected]> Date: Tue, 19 Dec 2023 07:58:08 -0800 Subject: [PATCH 20/28] riscv: Implements arch argnostic indirect branch tracking prctls prctls implemented are PR_SET_INDIR_BR_LP_STATUS / PR_GET_INDIR_BR_LP_STATUS and PR_LOCK_INDIR_BR_LP_STATUS. Signed-off-by: Deepak Gupta <[email protected]> --- arch/riscv/include/asm/usercfi.h | 17 +++++++- arch/riscv/kernel/usercfi.c | 74 ++++++++++++++++++++++++++++++++ 2 files changed, 90 insertions(+), 1 deletion(-)
arch/riscv/include/asm/usercfi.h +16 -1
@@ -16,7 +16,9 @@ struct kernel_clone_args;struct cfi_status {unsigned long ubcfi_en :1 ;/* Enable for backward cfi. */ unsigned long ubcfi_locked :1 ; -unsigned long rsvd : ((sizeof (unsigned long )*8 ) -2 ); +unsigned long ufcfi_en :1 ;/* Enable for forward cfi. Note that ELP goes in sstatus */ +unsigned long ufcfi_locked :1 ; +unsigned long rsvd : ((sizeof (unsigned long )*8 ) -4 );unsigned long user_shdw_stk;/* Current user shadow stack pointer */ unsigned long shdw_stk_base;/* Base address of shadow stack */ unsigned long shdw_stk_size;/* size of shadow stack */
@@ -29,6 +31,8 @@ void set_shstk_base(struct task_struct *task, unsigned long shstk_addr, unsignedvoid set_active_shstk (struct task_struct *task,unsigned long shstk_addr);bool is_shstk_enabled (struct task_struct *task);bool is_shstk_locked (struct task_struct *task); +bool is_indir_lp_enabled (struct task_struct *task); +bool is_indir_lp_locked (struct task_struct *task);#define PR_SHADOW_STACK_SUPPORTED_STATUS_MASK (PR_SHADOW_STACK_ENABLE)
@@ -66,6 +70,17 @@ static inline bool is_shstk_locked(struct task_struct *task)return false; } +static inline bool is_indir_lp_enabled (struct task_struct *task) +{ +return false; +} + +static inline bool is_indir_lp_locked (struct task_struct *task) + +{ +return false; +} +#endif /* CONFIG_RISCV_USER_CFI */ #endif /* __ASSEMBLY__ */
arch/riscv/kernel/usercfi.c +74 -0
83 lines not on this page · raw message
Signature · 27 lines
2.43.0 From 5b7ab396ec70d3e830acc7c9229c040f87db1ae8 Mon Sep 17 00:00:00 2001 From: Deepak Gupta <[email protected]> Date: Mon, 11 Dec 2023 20:41:17 -0800 Subject: [PATCH 21/28] riscv/traps: Introduce software check exception zicfiss / zicfilp introduces a new exception to priv isa `software check exception` with cause code = 18. This patch implements software check exception. Additionally it implements a cfi violation handler which checks for code in xtval If xtval=2, it means that sw check exception happened because of an indirect branch not landing on 4 byte aligned PC or not landing on `lpad` instruction or label value embedded in `lpad` not matching label value setup in `x7`. If xtval=3, it means that sw check exception happened because of mismatch between link register (x1 or x5) and top of shadow stack (on execution of `sspopchk`) In case of cfi violation, SIGSEGV is raised with code=SEGV_CPERR. SEGV_CPERR was introduced by x86 shadow stack patches. Signed-off-by: Deepak Gupta <[email protected]> --- arch/riscv/include/asm/asm-prototypes.h | 1 + arch/riscv/kernel/entry.S | 3 ++ arch/riscv/kernel/traps.c | 38 +++++++++++++++++++++++++ 3 files changed, 42 insertions(+)
arch/riscv/include/asm/asm-prototypes.h +1 -0
@@ -24,6 +24,7 @@ DECLARE_DO_ERROR_INFO(do_trap_ecall_u);DECLARE_DO_ERROR_INFO (do_trap_ecall_s);DECLARE_DO_ERROR_INFO (do_trap_ecall_m);DECLARE_DO_ERROR_INFO (do_trap_break); +DECLARE_DO_ERROR_INFO (do_trap_software_check); asmlinkage void handle_bad_stack(struct pt_regs *regs); asmlinkage void do_page_fault(struct pt_regs *regs);
arch/riscv/kernel/entry.S +3 -0
@@ -369,6 +369,9 @@ SYM_DATA_START_LOCAL(excp_vect_table) RISCV_PTR do_page_fault /* load page fault */ RISCV_PTR do_trap_unknown RISCV_PTR do_page_fault /* store page fault */ + RISCV_PTR do_trap_unknown /* cause=16 */ + RISCV_PTR do_trap_unknown /* cause=17 */ + RISCV_PTR do_trap_software_check /* cause=18 is sw check exception */ SYM_DATA_END_LABEL(excp_vect_table, SYM_L_LOCAL, excp_vect_table_end) #ifndef CONFIG_MMU
arch/riscv/kernel/traps.c +38 -0
@@ -339,6 +339,44 @@ asmlinkage __visible __trap_section void do_trap_ecall_u(struct pt_regs *regs) } +#define CFI_TVAL_FCFI_CODE 2 +#define CFI_TVAL_BCFI_CODE 3 +/* handle cfi violations */ +bool handle_user_cfi_violation (struct pt_regs *regs) +{ +bool ret = false; +unsigned long tval =csr_read (CSR_TVAL ); + +if (((tval ==CFI_TVAL_FCFI_CODE ) &&cpu_supports_indirect_br_lp_instr ()) || + ((tval ==CFI_TVAL_BCFI_CODE ) &&cpu_supports_shadow_stack ())) { +do_trap_error (regs,SIGSEGV ,SEGV_CPERR , regs->epc, +"Oops - control flow violation" ); + ret = true; + } + +return ret; +} +/* +* software check exception is defined with risc-v cfi spec. Software check +* exception is raised when:- +* a) An indirect branch doesn't land on 4 byte aligned PC or `lpad` +* instruction or `label` value programmed in `lpad` instr doesn't +* match with value setup in `x7`. reported code in `xtval` is 2. +* b) `sspopchk` instruction finds a mismatch between top of shadow stack (ssp) +* and x1/x5. reported code in `xtval` is 3. +*/ +asmlinkage __visible __trap_section void do_trap_software_check(struct pt_regs *regs) +{ +if (user_mode (regs)) { +/* not a cfi violation, then merge into flow of unknown trap handler */ +if (!handle_user_cfi_violation (regs)) +do_trap_unknown (regs); + }else { +/* sw check exception coming from kernel is a bug in kernel */ +die (regs,"Kernel BUG" ); + } +} +#ifdef CONFIG_MMU asmlinkage __visible noinstr void do_page_fault(struct pt_regs *regs) {
Signature · 19 lines
2.43.0 From a825cd99de13621b7e6e45cafa202f11cb3c3596 Mon Sep 17 00:00:00 2001 From: Deepak Gupta <[email protected]> Date: Wed, 4 Jan 2023 19:20:09 -0800 Subject: [PATCH 22/28] riscv sigcontext: adding cfi state field in sigcontext Shadow stack needs to be saved and restored on signal delivery and signal return. sigcontext embedded in ucontext is extendible. Adding cfi state in there which can be used to save cfi state before signal delivery and restore cfi state on sigreturn Signed-off-by: Deepak Gupta <[email protected]> --- arch/riscv/include/uapi/asm/sigcontext.h | 5 +++++ 1 file changed, 5 insertions(+)
arch/riscv/include/uapi/asm/sigcontext.h +5 -0
@@ -21,6 +21,10 @@ struct __sc_riscv_v_state {struct __riscv_v_ext_state v_state; } __attribute__((aligned(16))); +struct __sc_riscv_cfi_state { +unsigned long ss_ptr;/* shadow stack pointer */ +unsigned long rsvd;/* keeping another word reserved in case we need it */ +};/* * Signal context structure *
@@ -29,6 +33,7 @@ struct __sc_riscv_v_state {*/ struct sigcontext {struct user_regs_struct sc_regs; +struct __sc_riscv_cfi_state sc_cfi_state;union {union __riscv_fp_state sc_fpregs;struct __riscv_extra_ext_header sc_extdesc;
Signature · 18 lines
2.43.0 From 463c2e77fb9a1cf3bb75f1e359c55f1792b88349 Mon Sep 17 00:00:00 2001 From: Deepak Gupta <[email protected]> Date: Sat, 14 Jan 2023 17:45:54 -0800 Subject: [PATCH 23/28] riscv signal: Save and restore of shadow stack for signal Save shadow stack pointer in sigcontext structure while delivering signal. Restore shadow stack pointer from sigcontext on sigreturn. Signed-off-by: Deepak Gupta <[email protected]> --- arch/riscv/include/asm/usercfi.h | 18 ++++++++++++ arch/riscv/kernel/signal.c | 45 ++++++++++++++++++++++++++++++ arch/riscv/kernel/usercfi.c | 47 ++++++++++++++++++++++++++++++++ 3 files changed, 110 insertions(+)
arch/riscv/include/asm/usercfi.h +18 -0
@@ -33,6 +33,9 @@ bool is_shstk_enabled(struct task_struct *task);bool is_shstk_locked (struct task_struct *task);bool is_indir_lp_enabled (struct task_struct *task);bool is_indir_lp_locked (struct task_struct *task); +unsigned long get_active_shstk (struct task_struct *task); +int restore_user_shstk (struct task_struct *tsk,unsigned long shstk_ptr); +int save_user_shstk (struct task_struct *tsk,unsigned long *saved_shstk_ptr);#define PR_SHADOW_STACK_SUPPORTED_STATUS_MASK (PR_SHADOW_STACK_ENABLE)
@@ -70,6 +73,16 @@ static inline bool is_shstk_locked(struct task_struct *task)return false; } +int restore_user_shstk (struct task_struct *tsk,unsigned long shstk_ptr) +{ +return -EINVAL ; +} + +int save_user_shstk (struct task_struct *tsk,unsigned long *saved_shstk_ptr) +{ +return -EINVAL ; +} +static inline bool is_indir_lp_enabled (struct task_struct *task) {return false;
@@ -81,6 +94,11 @@ static inline bool is_indir_lp_locked(struct task_struct *task)return false; } +static inline unsigned long get_active_shstk (struct task_struct *task) +{ +return 0 ; +} +#endif /* CONFIG_RISCV_USER_CFI */ #endif /* __ASSEMBLY__ */
arch/riscv/kernel/signal.c +45 -0
81 lines not on this page · raw message
arch/riscv/kernel/usercfi.c +47 -0
59 lines not on this page · raw message
Signature · 19 lines
2.43.0 From fe9611befe43cded39d708768e56ecaed14be37c Mon Sep 17 00:00:00 2001 From: Deepak Gupta <[email protected]> Date: Thu, 19 Jan 2023 10:47:15 -0800 Subject: [PATCH 24/28] riscv: select config for shadow stack and landing pad instr support This patch selects config shadow stack support and landing pad instr support. Shadow stack support and landing instr support is hidden behind `CONFIG_RISCV_USER_CFI`. Selecting `CONFIG_RISCV_USER_CFI` wires up path to enumerate CPU support and if cpu support exists, kernel will support cpu assisted user mode cfi. Signed-off-by: Deepak Gupta <[email protected]> --- arch/riscv/Kconfig | 15 +++++++++++++++ 1 file changed, 15 insertions(+)
arch/riscv/Kconfig +15 -0
@@ -163,6 +163,7 @@ config RISCV select SYSCTL_EXCEPTION_TRACE select THREAD_INFO_IN_TASK select TRACE_IRQFLAGS_SUPPORT + select RISCV_USER_CFI select UACCESS_MEMCPY if !MMU select ZONE_DMA32 if 64BIT
@@ -182,6 +183,20 @@ config HAVE_SHADOW_CALL_STACK # https://github.com/riscv-non-isa/riscv-elf-psabi-doc/commit/a484e843e6eeb51f0cb7b8819e50da6d2444d769 depends on $(ld-option,--no-relax-gp) +config RISCV_USER_CFI + bool "riscv userspace control flow integrity" + help + Provides CPU assisted control flow integrity to userspace tasks. + Control flow integrity is provided by implementing shadow stack for + backward edge and indirect branch tracking for forward edge in program. + Shadow stack protection is a hardware feature that detects function + return address corruption. This helps mitigate ROP attacks. + Indirect branch tracking enforces that all indirect branches must land + on a landing pad instruction else CPU will fault. This mitigates against + JOP / COP attacks. Applications must be enabled to use it, and old user- + space does not get protection "for free". + default y + config ARCH_MMAP_RND_BITS_MIN default 18 if 64BIT default 8
Signature · 24 lines
2.43.0 From 1b49d1810f8447ee58fc09c0f9ca467dff51181d Mon Sep 17 00:00:00 2001 From: Deepak Gupta <[email protected]> Date: Wed, 17 Jan 2024 10:27:13 -0800 Subject: [PATCH 25/28] riscv/ptrace: riscv cfi status and state via ptrace and in core files Expose a new register type NT_RISCV_USER_CFI for risc-v cfi status and state. Intentionally both landing pad and shadow stack status and state are rolled into cfi state. Creating two different NT_RISCV_USER_XXX would not be useful and wastage of a note type. Enabling or disabling of feature is not allowed via ptrace set interface. However setting `elp` state or setting shadow stack pointer are allowed via ptrace set interface. It is expected `gdb` might have use to fixup `elp` state or `shadow stack` pointer. Signed-off-by: Deepak Gupta <[email protected]> --- arch/riscv/include/uapi/asm/ptrace.h | 18 ++++++ arch/riscv/kernel/ptrace.c | 83 ++++++++++++++++++++++++++++ include/uapi/linux/elf.h | 1 + 3 files changed, 102 insertions(+)
arch/riscv/include/uapi/asm/ptrace.h +18 -0
@@ -127,6 +127,24 @@ struct __riscv_v_regset_state {*/ #define RISCV_MAX_VLENB (8192) +struct __cfi_status { +/* indirect branch tracking state */ +__u64 lp_en :1 ; +__u64 lp_lock :1 ; +__u64 elp_state :1 ; + +/* shadow stack status */ +__u64 shstk_en :1 ; +__u64 shstk_lock :1 ; + +__u64 rsvd :sizeof (__u64) -5 ; +}; + +struct user_cfi_state { +struct __cfi_status cfi_status; +__u64 shstk_ptr; +}; +#endif /* __ASSEMBLY__ */ #endif /* _UAPI_ASM_RISCV_PTRACE_H */
arch/riscv/kernel/ptrace.c +83 -0
107 lines not on this page · raw message
include/uapi/linux/elf.h +1 -0
@@ -447,6 +447,7 @@ typedef struct elf64_shdr {#define NT_MIPS_MSA 0x802/* MIPS SIMD registers */ #define NT_RISCV_CSR 0x900/* RISC-V Control and Status Registers */ #define NT_RISCV_VECTOR 0x901/* RISC-V vector registers */ +#define NT_RISCV_USER_CFI 0x902/* RISC-V shadow stack state */ #define NT_LOONGARCH_CPUCFG 0xa00/* LoongArch CPU config registers */ #define NT_LOONGARCH_CSR 0xa01/* LoongArch control and status registers */ #define NT_LOONGARCH_LSX 0xa02/* LoongArch Loongson SIMD Extension registers */
Signature · 17 lines
2.43.0 From 59a6070ad5808df72eb638b8886c29f4dd0e7290 Mon Sep 17 00:00:00 2001 From: Deepak Gupta <[email protected]> Date: Fri, 12 Jan 2024 10:11:04 -0800 Subject: [PATCH 26/28] riscv: Documentation for landing pad / indirect branch tracking Adding documentation on landing pad aka indirect branch tracking on riscv and kernel interfaces exposed so that user tasks can enable it. Signed-off-by: Deepak Gupta <[email protected]> --- Documentation/arch/riscv/zicfilp.rst | 104 +++++++++++++++++++++++++++ 1 file changed, 104 insertions(+) create mode 100644 Documentation/arch/riscv/zicfilp.rst
Documentation/arch/riscv/zicfilp.rst new file +104 -0
104 lines not on this page · raw message
Signature · 16 lines
2.43.0 From 31d400d5299f01b457fd082e32786c25ee4a9491 Mon Sep 17 00:00:00 2001 From: Deepak Gupta <[email protected]> Date: Fri, 12 Jan 2024 10:14:29 -0800 Subject: [PATCH 27/28] riscv: Documentation for shadow stack on riscv Adding documentation on shadow stack for user mode on riscv and kernel interfaces exposed so that user tasks can enable it. Signed-off-by: Deepak Gupta <[email protected]> --- Documentation/arch/riscv/zicfiss.rst | 169 +++++++++++++++++++++++++++ 1 file changed, 169 insertions(+) create mode 100644 Documentation/arch/riscv/zicfiss.rst
Documentation/arch/riscv/zicfiss.rst new file +169 -0
169 lines not on this page · raw message
Signature · 40 lines
2.43.0 From 93a6c741f2881cddeeeba28f1bbd2f06ca070fcc Mon Sep 17 00:00:00 2001 From: Deepak Gupta <[email protected]> Date: Wed, 24 Jan 2024 08:50:40 -0800 Subject: [PATCH 28/28] kselftest/riscv: kselftest for user mode cfi Adds kselftest for RISC-V control flow integrity implementation for user mode. There is not a lot going on in kernel for enabling landing pad for user mode. Thus kselftest simply enables landing pad for the binary and a signal handler is registered for SIGSEGV. Any control flow violation are reported as SIGSEGV with si_code = SEGV_CPERR. Test will fail on recieving any SEGV_CPERR. Shadow stack part has more changes in kernel and thus there are separate tests for that - enable and disable - Exercise `map_shadow_stack` syscall - `fork` test to make sure COW works for shadow stack pages - gup tests As of today kernel uses FOLL_FORCE when access happens to memory via /proc/<pid>/mem. Not breaking that for shadow stack - signal test. Make sure signal delivery results in token creation on shadow stack and consumes (and verifies) token on sigreturn - shadow stack protection test. attempts to write using regular store instruction on shadow stack memory must result in access faults Signed-off-by: Deepak Gupta <[email protected]> --- tools/testing/selftests/riscv/Makefile | 2 +- tools/testing/selftests/riscv/cfi/Makefile | 10 + .../testing/selftests/riscv/cfi/cfi_rv_test.h | 85 ++++ .../selftests/riscv/cfi/riscv_cfi_test.c | 91 +++++ .../testing/selftests/riscv/cfi/shadowstack.c | 376 ++++++++++++++++++ .../testing/selftests/riscv/cfi/shadowstack.h | 39 ++ 6 files changed, 602 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/riscv/cfi/Makefile create mode 100644 tools/testing/selftests/riscv/cfi/cfi_rv_test.h create mode 100644 tools/testing/selftests/riscv/cfi/riscv_cfi_test.c create mode 100644 tools/testing/selftests/riscv/cfi/shadowstack.c create mode 100644 tools/testing/selftests/riscv/cfi/shadowstack.h
tools/testing/selftests/riscv/Makefile +1 -1
@@ -5,7 +5,7 @@ ARCH ?= $(shell uname -m 2>/dev/null || echo not) ifneq (,$(filter $(ARCH),riscv)) -RISCV_SUBTARGETS ?= hwprobe vector mm +RISCV_SUBTARGETS ?= hwprobe vector mm cfi else RISCV_SUBTARGETS := endif
tools/testing/selftests/riscv/cfi/Makefile new file +10 -0
@@ -0,0 +1,10 @@ +CFLAGS += -I$(top_srcdir)/tools/include + +CFLAGS += -march=rv64gc_zicfilp_zicfiss + +TEST_GEN_PROGS := cfitests + +include ../../lib.mk + +$(OUTPUT)/cfitests: riscv_cfi_test.c shadowstack.c + $(CC) -static -o$@ $(CFLAGS) $(LDFLAGS) $^
tools/testing/selftests/riscv/cfi/cfi_rv_test.h new file +85 -0
85 lines not on this page · raw message
tools/testing/selftests/riscv/cfi/riscv_cfi_test.c new file +91 -0
91 lines not on this page · raw message
tools/testing/selftests/riscv/cfi/shadowstack.c new file +376 -0
376 lines not on this page · raw message
tools/testing/selftests/riscv/cfi/shadowstack.h new file +39 -0
@@ -0,0 +1,39 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ + +#ifndef SELFTEST_SHADOWSTACK_TEST_H +#define SELFTEST_SHADOWSTACK_TEST_H +#include <stddef.h> +#include <linux/prctl.h> + +/* +* a cfi test returns true for success or false for fail +* takes a number for test number to index into array and void pointer. +*/ +typedef bool (*shstk_test_func )(unsigned long test_num,void *); + +struct shadow_stack_tests { +char *name; +shstk_test_func t_func; +}; + +bool enable_disable_check (unsigned long test_num,void *ctx); +bool shadow_stack_fork_test (unsigned long test_num,void *ctx); +bool shadow_stack_map_test (unsigned long test_num,void *ctx); +bool shadow_stack_protection_test (unsigned long test_num,void *ctx); +bool shadow_stack_gup_tests (unsigned long test_num,void *ctx); +bool shadow_stack_signal_test (unsigned long test_num,void *ctx); + +static struct shadow_stack_tests shstk_tests[] = { + {"enable disable\n" , enable_disable_check }, + {"shstk fork test\n" , shadow_stack_fork_test }, + {"map shadow stack syscall\n" , shadow_stack_map_test }, + {"shadow stack gup tests\n" , shadow_stack_gup_tests }, + {"shadow stack signal tests\n" , shadow_stack_signal_test}, + {"memory protections of shadow stack memory\n" , shadow_stack_protection_test } +}; + +#define RISCV_SHADOW_STACK_TESTS ARRAY_SIZE(shstk_tests) + +int execute_shadow_stack_tests (void ); + +#endif
Signature · 1 line
2.43.0