| Message ID | 20240802061318.2140081-2-aruna.ramakrishna@oracle.com (mailing list archive) |
|---|---|
| State | New |
| Headers | show |
| Series | x86/pkeys: update PKRU to enable all pkeys before XSAVE | expand |
Hi Aruna, On Thu, Aug 1, 2024 at 11:13 PM Aruna Ramakrishna <aruna.ramakrishna@oracle.com> wrote: > > Problem description: > Let's assume there's a multithreaded application that runs untrusted > user code. Each thread has its stack/code protected by a non-zero pkey, > and the PKRU register is set up such that only that particular non-zero > pkey is enabled. Each thread also sets up an alternate signal stack to > handle signals, which is protected by pkey zero. The pkeys man page > documents that the PKRU will be reset to init_pkru when the signal > handler is invoked, which means that pkey zero access will be enabled. > But this reset happens after the kernel attempts to push fpu state > to the alternate stack, which is not (yet) accessible by the kernel, > which leads to a new SIGSEGV being sent to the application, terminating > it. > > Enabling both the non-zero pkey (for the thread) and pkey zero in > userspace will not work for this use case. We cannot have the alt stack > writeable by all - the rationale here is that the code running in that > thread (using a non-zero pkey) is untrusted and should not have access > to the alternate signal stack (that uses pkey zero), to prevent the > return address of a function from being changed. The expectation is that > kernel should be able to set up the alternate signal stack and deliver > the signal to the application even if pkey zero is explicitly disabled > by the application. The signal handler accessibility should not be > dictated by whatever PKRU value the thread sets up. > While the above use case is correct, there are also other use cases that can benefit from this patch: Setup: The thread's normal operation has RW permission to PKEY 0, and RO or None to PKEY 1. The Thread uses sigaltstack() to register a mapping which has PKEY1 assigned. Before this patch: When the kernel is dispatching the signal, the thread will get SIGSEGV inside get_sigframe, because the thread either doesn't have read access or write access to the mapping which is protected by PKEY1. Because of SIGSEGV, the signal is not delivered to userspace. After this patch: There won't be SIGSEGV and the signal is delivered to userspace. The scenario is useful to protect signal stack: Jann Horn had this idea originally, and Chrome is planning to use it in V8 [1]. There were discussions in the past to enable this feature [2] Is that possible to include above in the cover letter to support this patch series for upstream? (upstream does like to see there are multiple user cases) Thanks -Jeff [1] https://docs.google.com/document/d/1DjPhBq-5gRKtTeaknQDTWfvqRBCONmYqkU1I6k-3Ai8/edit?resourcekey=0-GGQta3_yhKqK7xV5SxIrVQ&tab=t.0 [2] https://lore.kernel.org/lkml/202208221331.71C50A6F@keescook/ > Solution: > The PKRU register is managed by XSAVE, which means the sigframe contents > must match the register contents - which is not the case here. We want > the sigframe to contain the user-defined PKRU value (so that it is > restored correctly from sigcontext) but the actual register must be > reset to init_pkru so that the alt stack is accessible and the signal > can be delivered to the application. It seems that the proper fix here > would be to remove PKRU from the XSAVE framework and manage it > separately, which is quite complicated. As a workaround, do this: > > orig_pkru = rdpkru(); > wrpkru(orig_pkru & init_pkru_value); > xsave_to_user_sigframe(); > put_user(pkru_sigframe_addr, orig_pkru) > > This change is split over multiple patches. > > In preparation for writing PKRU to sigframe in a later patch, pass in > PKRU as an additional parameter down the chain from get_sigframe(): > get_sigframe() > copy_fpstate_to_sigframe() > copy_fpregs_to_sigframe() > > There are no functional changes in this patch. > > Signed-off-by: Aruna Ramakrishna <aruna.ramakrishna@oracle.com> > --- > arch/x86/include/asm/fpu/signal.h | 2 +- > arch/x86/kernel/fpu/signal.c | 6 +++--- > arch/x86/kernel/signal.c | 3 ++- > 3 files changed, 6 insertions(+), 5 deletions(-) > > diff --git a/arch/x86/include/asm/fpu/signal.h b/arch/x86/include/asm/fpu/signal.h > index 611fa41711af..eccc75bc9c4f 100644 > --- a/arch/x86/include/asm/fpu/signal.h > +++ b/arch/x86/include/asm/fpu/signal.h > @@ -29,7 +29,7 @@ fpu__alloc_mathframe(unsigned long sp, int ia32_frame, > > unsigned long fpu__get_fpstate_size(void); > > -extern bool copy_fpstate_to_sigframe(void __user *buf, void __user *fp, int size); > +extern bool copy_fpstate_to_sigframe(void __user *buf, void __user *fp, int size, u32 pkru); > extern void fpu__clear_user_states(struct fpu *fpu); > extern bool fpu__restore_sig(void __user *buf, int ia32_frame); > > diff --git a/arch/x86/kernel/fpu/signal.c b/arch/x86/kernel/fpu/signal.c > index 247f2225aa9f..2b3b9e140dd4 100644 > --- a/arch/x86/kernel/fpu/signal.c > +++ b/arch/x86/kernel/fpu/signal.c > @@ -156,7 +156,7 @@ static inline bool save_xstate_epilog(void __user *buf, int ia32_frame, > return !err; > } > > -static inline int copy_fpregs_to_sigframe(struct xregs_state __user *buf) > +static inline int copy_fpregs_to_sigframe(struct xregs_state __user *buf, u32 pkru) > { > if (use_xsave()) > return xsave_to_user_sigframe(buf); > @@ -185,7 +185,7 @@ static inline int copy_fpregs_to_sigframe(struct xregs_state __user *buf) > * For [f]xsave state, update the SW reserved fields in the [f]xsave frame > * indicating the absence/presence of the extended state to the user. > */ > -bool copy_fpstate_to_sigframe(void __user *buf, void __user *buf_fx, int size) > +bool copy_fpstate_to_sigframe(void __user *buf, void __user *buf_fx, int size, u32 pkru) > { > struct task_struct *tsk = current; > struct fpstate *fpstate = tsk->thread.fpu.fpstate; > @@ -228,7 +228,7 @@ bool copy_fpstate_to_sigframe(void __user *buf, void __user *buf_fx, int size) > fpregs_restore_userregs(); > > pagefault_disable(); > - ret = copy_fpregs_to_sigframe(buf_fx); > + ret = copy_fpregs_to_sigframe(buf_fx, pkru); > pagefault_enable(); > fpregs_unlock(); > > diff --git a/arch/x86/kernel/signal.c b/arch/x86/kernel/signal.c > index 31b6f5dddfc2..1f1e8e0ac5a3 100644 > --- a/arch/x86/kernel/signal.c > +++ b/arch/x86/kernel/signal.c > @@ -84,6 +84,7 @@ get_sigframe(struct ksignal *ksig, struct pt_regs *regs, size_t frame_size, > unsigned long math_size = 0; > unsigned long sp = regs->sp; > unsigned long buf_fx = 0; > + u32 pkru = read_pkru(); > > /* redzone */ > if (!ia32_frame) > @@ -139,7 +140,7 @@ get_sigframe(struct ksignal *ksig, struct pt_regs *regs, size_t frame_size, > } > > /* save i387 and extended state */ > - if (!copy_fpstate_to_sigframe(*fpstate, (void __user *)buf_fx, math_size)) > + if (!copy_fpstate_to_sigframe(*fpstate, (void __user *)buf_fx, math_size, pkru)) > return (void __user *)-1L; > > return (void __user *)sp; > -- > 2.39.3 >
diff --git a/arch/x86/include/asm/fpu/signal.h b/arch/x86/include/asm/fpu/signal.h index 611fa41711af..eccc75bc9c4f 100644 --- a/arch/x86/include/asm/fpu/signal.h +++ b/arch/x86/include/asm/fpu/signal.h @@ -29,7 +29,7 @@ fpu__alloc_mathframe(unsigned long sp, int ia32_frame, unsigned long fpu__get_fpstate_size(void); -extern bool copy_fpstate_to_sigframe(void __user *buf, void __user *fp, int size); +extern bool copy_fpstate_to_sigframe(void __user *buf, void __user *fp, int size, u32 pkru); extern void fpu__clear_user_states(struct fpu *fpu); extern bool fpu__restore_sig(void __user *buf, int ia32_frame); diff --git a/arch/x86/kernel/fpu/signal.c b/arch/x86/kernel/fpu/signal.c index 247f2225aa9f..2b3b9e140dd4 100644 --- a/arch/x86/kernel/fpu/signal.c +++ b/arch/x86/kernel/fpu/signal.c @@ -156,7 +156,7 @@ static inline bool save_xstate_epilog(void __user *buf, int ia32_frame, return !err; } -static inline int copy_fpregs_to_sigframe(struct xregs_state __user *buf) +static inline int copy_fpregs_to_sigframe(struct xregs_state __user *buf, u32 pkru) { if (use_xsave()) return xsave_to_user_sigframe(buf); @@ -185,7 +185,7 @@ static inline int copy_fpregs_to_sigframe(struct xregs_state __user *buf) * For [f]xsave state, update the SW reserved fields in the [f]xsave frame * indicating the absence/presence of the extended state to the user. */ -bool copy_fpstate_to_sigframe(void __user *buf, void __user *buf_fx, int size) +bool copy_fpstate_to_sigframe(void __user *buf, void __user *buf_fx, int size, u32 pkru) { struct task_struct *tsk = current; struct fpstate *fpstate = tsk->thread.fpu.fpstate; @@ -228,7 +228,7 @@ bool copy_fpstate_to_sigframe(void __user *buf, void __user *buf_fx, int size) fpregs_restore_userregs(); pagefault_disable(); - ret = copy_fpregs_to_sigframe(buf_fx); + ret = copy_fpregs_to_sigframe(buf_fx, pkru); pagefault_enable(); fpregs_unlock(); diff --git a/arch/x86/kernel/signal.c b/arch/x86/kernel/signal.c index 31b6f5dddfc2..1f1e8e0ac5a3 100644 --- a/arch/x86/kernel/signal.c +++ b/arch/x86/kernel/signal.c @@ -84,6 +84,7 @@ get_sigframe(struct ksignal *ksig, struct pt_regs *regs, size_t frame_size, unsigned long math_size = 0; unsigned long sp = regs->sp; unsigned long buf_fx = 0; + u32 pkru = read_pkru(); /* redzone */ if (!ia32_frame) @@ -139,7 +140,7 @@ get_sigframe(struct ksignal *ksig, struct pt_regs *regs, size_t frame_size, } /* save i387 and extended state */ - if (!copy_fpstate_to_sigframe(*fpstate, (void __user *)buf_fx, math_size)) + if (!copy_fpstate_to_sigframe(*fpstate, (void __user *)buf_fx, math_size, pkru)) return (void __user *)-1L; return (void __user *)sp;
Problem description: Let's assume there's a multithreaded application that runs untrusted user code. Each thread has its stack/code protected by a non-zero pkey, and the PKRU register is set up such that only that particular non-zero pkey is enabled. Each thread also sets up an alternate signal stack to handle signals, which is protected by pkey zero. The pkeys man page documents that the PKRU will be reset to init_pkru when the signal handler is invoked, which means that pkey zero access will be enabled. But this reset happens after the kernel attempts to push fpu state to the alternate stack, which is not (yet) accessible by the kernel, which leads to a new SIGSEGV being sent to the application, terminating it. Enabling both the non-zero pkey (for the thread) and pkey zero in userspace will not work for this use case. We cannot have the alt stack writeable by all - the rationale here is that the code running in that thread (using a non-zero pkey) is untrusted and should not have access to the alternate signal stack (that uses pkey zero), to prevent the return address of a function from being changed. The expectation is that kernel should be able to set up the alternate signal stack and deliver the signal to the application even if pkey zero is explicitly disabled by the application. The signal handler accessibility should not be dictated by whatever PKRU value the thread sets up. Solution: The PKRU register is managed by XSAVE, which means the sigframe contents must match the register contents - which is not the case here. We want the sigframe to contain the user-defined PKRU value (so that it is restored correctly from sigcontext) but the actual register must be reset to init_pkru so that the alt stack is accessible and the signal can be delivered to the application. It seems that the proper fix here would be to remove PKRU from the XSAVE framework and manage it separately, which is quite complicated. As a workaround, do this: orig_pkru = rdpkru(); wrpkru(orig_pkru & init_pkru_value); xsave_to_user_sigframe(); put_user(pkru_sigframe_addr, orig_pkru) This change is split over multiple patches. In preparation for writing PKRU to sigframe in a later patch, pass in PKRU as an additional parameter down the chain from get_sigframe(): get_sigframe() copy_fpstate_to_sigframe() copy_fpregs_to_sigframe() There are no functional changes in this patch. Signed-off-by: Aruna Ramakrishna <aruna.ramakrishna@oracle.com> --- arch/x86/include/asm/fpu/signal.h | 2 +- arch/x86/kernel/fpu/signal.c | 6 +++--- arch/x86/kernel/signal.c | 3 ++- 3 files changed, 6 insertions(+), 5 deletions(-)