mm/core, x86/mm/pkeys: Add execute-only protection keys support
authorDave Hansen <dave.hansen@linux.intel.com>
Fri, 12 Feb 2016 21:02:40 +0000 (13:02 -0800)
committerIngo Molnar <mingo@kernel.org>
Thu, 18 Feb 2016 18:46:33 +0000 (19:46 +0100)
Protection keys provide new page-based protection in hardware.
But, they have an interesting attribute: they only affect data
accesses and never affect instruction fetches.  That means that
if we set up some memory which is set as "access-disabled" via
protection keys, we can still execute from it.

This patch uses protection keys to set up mappings to do just that.
If a user calls:

mmap(..., PROT_EXEC);
or
mprotect(ptr, sz, PROT_EXEC);

(note PROT_EXEC-only without PROT_READ/WRITE), the kernel will
notice this, and set a special protection key on the memory.  It
also sets the appropriate bits in the Protection Keys User Rights
(PKRU) register so that the memory becomes unreadable and
unwritable.

I haven't found any userspace that does this today.  With this
facility in place, we expect userspace to move to use it
eventually.  Userspace _could_ start doing this today.  Any
PROT_EXEC calls get converted to PROT_READ inside the kernel, and
would transparently be upgraded to "true" PROT_EXEC with this
code.  IOW, userspace never has to do any PROT_EXEC runtime
detection.

This feature provides enhanced protection against leaking
executable memory contents.  This helps thwart attacks which are
attempting to find ROP gadgets on the fly.

But, the security provided by this approach is not comprehensive.
The PKRU register which controls access permissions is a normal
user register writable from unprivileged userspace.  An attacker
who can execute the 'wrpkru' instruction can easily disable the
protection provided by this feature.

The protection key that is used for execute-only support is
permanently dedicated at compile time.  This is fine for now
because there is currently no API to set a protection key other
than this one.

Despite there being a constant PKRU value across the entire
system, we do not set it unless this feature is in use in a
process.  That is to preserve the PKRU XSAVE 'init state',
which can lead to faster context switches.

PKRU *is* a user register and the kernel is modifying it.  That
means that code doing:

pkru = rdpkru()
pkru |= 0x100;
mmap(..., PROT_EXEC);
wrpkru(pkru);

could lose the bits in PKRU that enforce execute-only
permissions.  To avoid this, we suggest avoiding ever calling
mmap() or mprotect() when the PKRU value is expected to be
unstable.

Signed-off-by: Dave Hansen <dave.hansen@linux.intel.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Andy Lutomirski <luto@amacapital.net>
Cc: Andy Lutomirski <luto@kernel.org>
Cc: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Borislav Petkov <bp@suse.de>
Cc: Brian Gerst <brgerst@gmail.com>
Cc: Chen Gang <gang.chen.5i5j@gmail.com>
Cc: Dan Williams <dan.j.williams@intel.com>
Cc: Dave Chinner <david@fromorbit.com>
Cc: Dave Hansen <dave@sr71.net>
Cc: David Hildenbrand <dahi@linux.vnet.ibm.com>
Cc: Denys Vlasenko <dvlasenk@redhat.com>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Cc: Konstantin Khlebnikov <koct9i@gmail.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Piotr Kwapulinski <kwapulinski.piotr@gmail.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Stephen Smalley <sds@tycho.nsa.gov>
Cc: Vladimir Murzin <vladimir.murzin@arm.com>
Cc: Will Deacon <will.deacon@arm.com>
Cc: keescook@google.com
Cc: linux-kernel@vger.kernel.org
Cc: linux-mm@kvack.org
Link: http://lkml.kernel.org/r/20160212210240.CB4BB5CA@viggo.jf.intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
arch/x86/include/asm/pkeys.h
arch/x86/kernel/fpu/xstate.c
arch/x86/mm/Makefile
arch/x86/mm/fault.c
arch/x86/mm/pkeys.c [new file with mode: 0644]
include/linux/pkeys.h
mm/mmap.c
mm/mprotect.c

index 5061aec2ed5ebc8cd06603233ecfdb5ee2ef9e90..7b84565c916c7b0329ac92c79c789748ff9eeb28 100644 (file)
@@ -6,4 +6,29 @@
 extern int arch_set_user_pkey_access(struct task_struct *tsk, int pkey,
                unsigned long init_val);
 
+/*
+ * Try to dedicate one of the protection keys to be used as an
+ * execute-only protection key.
+ */
+#define PKEY_DEDICATED_EXECUTE_ONLY 15
+extern int __execute_only_pkey(struct mm_struct *mm);
+static inline int execute_only_pkey(struct mm_struct *mm)
+{
+       if (!boot_cpu_has(X86_FEATURE_OSPKE))
+               return 0;
+
+       return __execute_only_pkey(mm);
+}
+
+extern int __arch_override_mprotect_pkey(struct vm_area_struct *vma,
+               int prot, int pkey);
+static inline int arch_override_mprotect_pkey(struct vm_area_struct *vma,
+               int prot, int pkey)
+{
+       if (!boot_cpu_has(X86_FEATURE_OSPKE))
+               return 0;
+
+       return __arch_override_mprotect_pkey(vma, prot, pkey);
+}
+
 #endif /*_ASM_X86_PKEYS_H */
index 50813c35e9d969e1008173b6321f850482b09156..1b1981812bb611b0e890a812b2e377d8abd39493 100644 (file)
@@ -877,8 +877,6 @@ int arch_set_user_pkey_access(struct task_struct *tsk, int pkey,
        int pkey_shift = (pkey * PKRU_BITS_PER_PKEY);
        u32 new_pkru_bits = 0;
 
-       if (!validate_pkey(pkey))
-               return -EINVAL;
        /*
         * This check implies XSAVE support.  OSPKE only gets
         * set if we enable XSAVE and we enable PKU in XCR0.
index f9d38a48e3c847f129ddd62c4f6d4e40180711ad..67cf2e1e557bbd247187cfcb4ba188d2fc082ca0 100644 (file)
@@ -34,3 +34,5 @@ obj-$(CONFIG_ACPI_NUMA)               += srat.o
 obj-$(CONFIG_NUMA_EMU)         += numa_emulation.o
 
 obj-$(CONFIG_X86_INTEL_MPX)    += mpx.o
+obj-$(CONFIG_X86_INTEL_MEMORY_PROTECTION_KEYS) += pkeys.o
+
index d81744e6f39f24d3dc36c50f550cebf977533c9c..5877b92ab6f1483f3baf4f3e5b4d4239c73be1e8 100644 (file)
@@ -1108,6 +1108,16 @@ access_error(unsigned long error_code, struct vm_area_struct *vma)
         */
        if (error_code & PF_PK)
                return 1;
+
+       if (!(error_code & PF_INSTR)) {
+               /*
+                * Assume all accesses require either read or execute
+                * permissions.  This is not an instruction access, so
+                * it requires read permissions.
+                */
+               if (!(vma->vm_flags & VM_READ))
+                       return 1;
+       }
        /*
         * Make sure to check the VMA so that we do not perform
         * faults just to hit a PF_PK as soon as we fill in a
diff --git a/arch/x86/mm/pkeys.c b/arch/x86/mm/pkeys.c
new file mode 100644 (file)
index 0000000..e8c4744
--- /dev/null
@@ -0,0 +1,101 @@
+/*
+ * Intel Memory Protection Keys management
+ * Copyright (c) 2015, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ */
+#include <linux/mm_types.h>             /* mm_struct, vma, etc...       */
+#include <linux/pkeys.h>                /* PKEY_*                       */
+#include <uapi/asm-generic/mman-common.h>
+
+#include <asm/cpufeature.h>             /* boot_cpu_has, ...            */
+#include <asm/mmu_context.h>            /* vma_pkey()                   */
+#include <asm/fpu/internal.h>           /* fpregs_active()              */
+
+int __execute_only_pkey(struct mm_struct *mm)
+{
+       int ret;
+
+       /*
+        * We do not want to go through the relatively costly
+        * dance to set PKRU if we do not need to.  Check it
+        * first and assume that if the execute-only pkey is
+        * write-disabled that we do not have to set it
+        * ourselves.  We need preempt off so that nobody
+        * can make fpregs inactive.
+        */
+       preempt_disable();
+       if (fpregs_active() &&
+           !__pkru_allows_read(read_pkru(), PKEY_DEDICATED_EXECUTE_ONLY)) {
+               preempt_enable();
+               return PKEY_DEDICATED_EXECUTE_ONLY;
+       }
+       preempt_enable();
+       ret = arch_set_user_pkey_access(current, PKEY_DEDICATED_EXECUTE_ONLY,
+                       PKEY_DISABLE_ACCESS);
+       /*
+        * If the PKRU-set operation failed somehow, just return
+        * 0 and effectively disable execute-only support.
+        */
+       if (ret)
+               return 0;
+
+       return PKEY_DEDICATED_EXECUTE_ONLY;
+}
+
+static inline bool vma_is_pkey_exec_only(struct vm_area_struct *vma)
+{
+       /* Do this check first since the vm_flags should be hot */
+       if ((vma->vm_flags & (VM_READ | VM_WRITE | VM_EXEC)) != VM_EXEC)
+               return false;
+       if (vma_pkey(vma) != PKEY_DEDICATED_EXECUTE_ONLY)
+               return false;
+
+       return true;
+}
+
+/*
+ * This is only called for *plain* mprotect calls.
+ */
+int __arch_override_mprotect_pkey(struct vm_area_struct *vma, int prot, int pkey)
+{
+       /*
+        * Is this an mprotect_pkey() call?  If so, never
+        * override the value that came from the user.
+        */
+       if (pkey != -1)
+               return pkey;
+       /*
+        * Look for a protection-key-drive execute-only mapping
+        * which is now being given permissions that are not
+        * execute-only.  Move it back to the default pkey.
+        */
+       if (vma_is_pkey_exec_only(vma) &&
+           (prot & (PROT_READ|PROT_WRITE))) {
+               return 0;
+       }
+       /*
+        * The mapping is execute-only.  Go try to get the
+        * execute-only protection key.  If we fail to do that,
+        * fall through as if we do not have execute-only
+        * support.
+        */
+       if (prot == PROT_EXEC) {
+               pkey = execute_only_pkey(vma->vm_mm);
+               if (pkey > 0)
+                       return pkey;
+       }
+       /*
+        * This is a vanilla, non-pkey mprotect (or we failed to
+        * setup execute-only), inherit the pkey from the VMA we
+        * are working on.
+        */
+       return vma_pkey(vma);
+}
index fc325b367bd00180b6898580e8273f7d1c0b58ca..1d405a2b72729e77c068bc2ce44fce737ed682bd 100644 (file)
@@ -13,6 +13,9 @@
 #include <asm/pkeys.h>
 #else /* ! CONFIG_ARCH_HAS_PKEYS */
 #define arch_max_pkey() (1)
+#define execute_only_pkey(mm) (0)
+#define arch_override_mprotect_pkey(vma, prot, pkey) (0)
+#define PKEY_DEDICATED_EXECUTE_ONLY 0
 #endif /* ! CONFIG_ARCH_HAS_PKEYS */
 
 /*
index 784d2d6142a28f9911a2b780b00ccb4bd9f75f44..0175b7d055f0703b1c06f3efe9dfaf1f7479ac30 100644 (file)
--- a/mm/mmap.c
+++ b/mm/mmap.c
@@ -43,6 +43,7 @@
 #include <linux/printk.h>
 #include <linux/userfaultfd_k.h>
 #include <linux/moduleparam.h>
+#include <linux/pkeys.h>
 
 #include <asm/uaccess.h>
 #include <asm/cacheflush.h>
@@ -1270,6 +1271,7 @@ unsigned long do_mmap(struct file *file, unsigned long addr,
                        unsigned long pgoff, unsigned long *populate)
 {
        struct mm_struct *mm = current->mm;
+       int pkey = 0;
 
        *populate = 0;
 
@@ -1309,11 +1311,17 @@ unsigned long do_mmap(struct file *file, unsigned long addr,
        if (offset_in_page(addr))
                return addr;
 
+       if (prot == PROT_EXEC) {
+               pkey = execute_only_pkey(mm);
+               if (pkey < 0)
+                       pkey = 0;
+       }
+
        /* Do simple checking here so the lower-level routines won't have
         * to. we assume access permissions have been handled by the open
         * of the memory object, so we don't do any here.
         */
-       vm_flags |= calc_vm_prot_bits(prot, 0) | calc_vm_flag_bits(flags) |
+       vm_flags |= calc_vm_prot_bits(prot, pkey) | calc_vm_flag_bits(flags) |
                        mm->def_flags | VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC;
 
        if (flags & MAP_LOCKED)
index 3790c8bee3805722b578be6b6d8acdc8a8d239e4..fa37c4cd973aa49b4deb227646fcdb2779f7cb24 100644 (file)
@@ -24,6 +24,7 @@
 #include <linux/migrate.h>
 #include <linux/perf_event.h>
 #include <linux/ksm.h>
+#include <linux/pkeys.h>
 #include <asm/uaccess.h>
 #include <asm/pgtable.h>
 #include <asm/cacheflush.h>
@@ -354,7 +355,7 @@ fail:
 SYSCALL_DEFINE3(mprotect, unsigned long, start, size_t, len,
                unsigned long, prot)
 {
-       unsigned long vm_flags, nstart, end, tmp, reqprot;
+       unsigned long nstart, end, tmp, reqprot;
        struct vm_area_struct *vma, *prev;
        int error = -EINVAL;
        const int grows = prot & (PROT_GROWSDOWN|PROT_GROWSUP);
@@ -380,8 +381,6 @@ SYSCALL_DEFINE3(mprotect, unsigned long, start, size_t, len,
        if ((prot & PROT_READ) && (current->personality & READ_IMPLIES_EXEC))
                prot |= PROT_EXEC;
 
-       vm_flags = calc_vm_prot_bits(prot, 0);
-
        down_write(&current->mm->mmap_sem);
 
        vma = find_vma(current->mm, start);
@@ -411,10 +410,11 @@ SYSCALL_DEFINE3(mprotect, unsigned long, start, size_t, len,
 
        for (nstart = start ; ; ) {
                unsigned long newflags;
+               int pkey = arch_override_mprotect_pkey(vma, prot, -1);
 
                /* Here we know that vma->vm_start <= nstart < vma->vm_end. */
 
-               newflags = vm_flags;
+               newflags = calc_vm_prot_bits(prot, pkey);
                newflags |= (vma->vm_flags & ~(VM_READ | VM_WRITE | VM_EXEC));
 
                /* newflags >> 4 shift VM_MAY% in place of VM_% */