Skip to contentSkip to conversation

Prevent write to read-only pages (text, PLT/GOT

RFC PATCH In review Lev Olshvang 2 participants 9 messages Apr 6, 2020 – Apr 7, 2020

Subsystems (5)
lore
Share & tools
lore
#0 lore raw

cover Prevent write to read-only pages (text, PLT/GOT

The purpose of this patch is produce hardened kernel for Embedded or Production systems.

Typically debuggers, such as gdb, write to read-only code [text] sections of target process.(ptrace)
This kind of page protectiion violation raises minor page fault, but kernel's fault handler allows it by default.
This is clearly attack surface for adversary.

The proposed kernel hardening configuration option checks the type of protection of the foreign vma and blocks writes to read only vma.

When enabled, it will stop attacks modifying code or jump tables, etc.

Lev Olshvang (5):
security : hardening : prevent write to proces's read-only pages from
another process
Prevent write to read-only pages (text, PLT/GOT tables from another
process
Prevent write to read-only pages (text, PLT/GOT tables from another
process
X86:Prevent write to read-only pages (text, PLT/GOT tables from
another process
UM:Prevent write to read-only pages (text, PLT/GOT tables from another
process

 arch/powerpc/include/asm/mmu_context.h   |  7 ++++++-
 arch/powerpc/mm/book3s64/pkeys.c         |  5 +++++
 arch/um/include/asm/mmu_context.h        | 11 ++++++++---
 arch/unicore32/include/asm/mmu_context.h |  7 ++++++-
 arch/x86/include/asm/mmu_context.h       |  9 ++++++++-
 include/asm-generic/mm_hooks.h           |  5 +++++
 security/Kconfig                         | 10 ++++++++++
 7 files changed, 48 insertions(+), 6 deletions(-)

--
2.17.1

#1 lore raw

RFC PATCH 1/5 security : hardening : prevent write to proces's read-only pages from another process

The purpose of this patch is produce hardened kernel for Embedded or Production systems.

Typically debuggers, such as gdb, write to read-only code [text] sections of target process.(ptrace)
This kind of page protectiion violation raises minor page fault, but kernel's fault handler allows it by default.
This is clearly attack surface for adversary.

The proposed kernel hardening configuration option checks the type of protection of the foreign vma and blocks writes to read only vma.

When enabled, it will stop attacks modifying code or jump tables, etc.

Code of arch_vma_access_permitted() function was extended to check foreign vma flags.

Tested on x86_64 and ARM(QEMU) with dd command which writes to /proc/PID/mem in r--p or r--xp of vma area addresses range

dd reports IO failure when tries to write to adress taken from from /proc/PID/maps (PLT or code section)

---
 include/asm-generic/mm_hooks.h |  5 +++++
 security/Kconfig               | 10 ++++++++++
 2 files changed, 15 insertions(+)
include/asm-generic/mm_hooks.h +5 -0
index 4dbb177d1150..6e1fcce44cc2 100644
@@ -25,6 +25,11 @@ static inline void arch_unmap(struct mm_struct *mm,
 static inline bool arch_vma_access_permitted(struct vm_area_struct *vma,
 		bool write, bool execute, bool foreign)
 {
+#ifdef CONFIG_PROTECT_READONLY_USER_MEMORY
+	/* Forbid write to PROT_READ pages of foreign process */
+	if (write && foreign && (!(vma->vm_flags & VM_WRITE)))
+		return false;
+#endif
 	/* by default, allow everything */
 	return true;
 }
security/Kconfig +10 -0
index cd3cc7da3a55..d92e79c90d67 100644
@@ -143,6 +143,16 @@ config LSM_MMAP_MIN_ADDR
 	  this low address space will need the permission specific to the
 	  systems running LSM.
 
+config PROTECT_READONLY_USER_MEMORY
+	bool "Protect read only process memory"
+	help
+	  Protects read only memory of process code and PLT table
+	  from possible attack through /proc/PID/mem or through /dev/mem.
+	  Refuses to insert and stop at debuggers breakpoints (prtace,gdb)
+	  Mostly advised for embedded and production system.
+	  Stops attempts of the malicious process to modify read only memory of another process
+
+
 config HAVE_HARDENED_USERCOPY_ALLOCATOR
 	bool
 	help
Signature · 1 line
2.17.1
#2 lore raw

Re: [RFC PATCH 1/5] security : hardening : prevent write to proces's read-only pages from another process

Quoted 14 lines · Lev Olshvang

The purpose of this patch is produce hardened kernel for Embedded or Production systems.

Typically debuggers, such as gdb, write to read-only code [text] sections of target process.(ptrace)
This kind of page protectiion violation raises minor page fault, but kernel's fault handler allows it by default.
This is clearly attack surface for adversary.

The proposed kernel hardening configuration option checks the type of protection of the foreign vma and blocks writes to read only vma.

When enabled, it will stop attacks modifying code or jump tables, etc.

Quoted 8 lines

Code of arch_vma_access_permitted() function was extended to check foreign vma flags.

Tested on x86_64 and ARM(QEMU) with dd command which writes to /proc/PID/mem in r--p or r--xp of vma area addresses range

dd reports IO failure when tries to write to adress taken from from /proc/PID/maps (PLT or code section)

So, just to give some background here: the reason for this behavior is so debuggers can insert software breakpoints in the .text section (0xcc) etc. This is implemented with the "FOLL_FORCE" flag, and an attempt to remove it was made here:
https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=8ee74a91ac30
but it was later reverted (see below).

There have been many prior discussions about this behavior, and a good thread (which I link from https://github.com/KSPP/linux/issues/37
"Block process from writing to its own /proc/$pid/mem") is this one:
https://lore.kernel.org/lkml/CAGXu5j+PHzDwnJxJwMJ=WuhacDn_vJWe9xZx+Kbsh28vxOGRiA@mail.gmail.com/

For details on the revert see:
https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=f511c0b17b08

All this said, I think this feature would still be nice to have, available with some kind of knob to control it. Do you get the results you were expecting from just re-applying 8ee74a91ac30? If so, that's a much smaller change, and a single place to apply a knob. It would likely be best implemented with a sysctl and a static_branch(). A possible example for this can be seen here:
https://lore.kernel.org/lkml/[email protected]/
Though it doesn't use a sysctl. (And perhaps this feature needs to be a per-process setting like "dumpable", but let's start simple with a system-wide control.)

Can you test the FOLL_FORCE removal and refactor things to use a static_branch() instead?

-Kees

Quoted 46 lines
---
 include/asm-generic/mm_hooks.h |  5 +++++
 security/Kconfig               | 10 ++++++++++
 2 files changed, 15 insertions(+)
include/asm-generic/mm_hooks.h +5 -0
index 4dbb177d1150..6e1fcce44cc2 100644
@@ -25,6 +25,11 @@ static inline void arch_unmap(struct mm_struct *mm,
 static inline bool arch_vma_access_permitted(struct vm_area_struct *vma,
 		bool write, bool execute, bool foreign)
 {
+#ifdef CONFIG_PROTECT_READONLY_USER_MEMORY
+	/* Forbid write to PROT_READ pages of foreign process */
+	if (write && foreign && (!(vma->vm_flags & VM_WRITE)))
+		return false;
+#endif
 	/* by default, allow everything */
 	return true;
 }
security/Kconfig +10 -0
index cd3cc7da3a55..d92e79c90d67 100644
@@ -143,6 +143,16 @@ config LSM_MMAP_MIN_ADDR
 	  this low address space will need the permission specific to the
 	  systems running LSM.
 
+config PROTECT_READONLY_USER_MEMORY
+	bool "Protect read only process memory"
+	help
+	  Protects read only memory of process code and PLT table
+	  from possible attack through /proc/PID/mem or through /dev/mem.
+	  Refuses to insert and stop at debuggers breakpoints (prtace,gdb)
+	  Mostly advised for embedded and production system.
+	  Stops attempts of the malicious process to modify read only memory of another process
+
+
 config HAVE_HARDENED_USERCOPY_ALLOCATOR
 	bool
 	help
Signature · 1 line
2.17.1
Signature · 1 line
Kees Cook
#3 lore raw

Re: [RFC PATCH 1/5] security : hardening : prevent write to proces's read-only pages from another process

Hi Kees,

The patch you referred to is scoped in /proc fs.

There is a chance that hackers may use other attack methods except procfs. There is process_vm_writev syscall , /dev/mem.
An attacker can also hijack one of the process threads and write to read-only pages.
I admit that I am the newbie and lack knowledge, but I think my solution is more generic and protects from more possible attacks. Second, you suggested to control it in run-time with a knob.
I think that configuration option I propose better fit embedded system needs. There is no need in an embedded system to turn it on/off since there is no gdb. (the same argument for a production system), These systems are locked down, and perhaps the proper place to put this option is in lockdown LSM.
Thank you for your response.
Lev

Quoted 105 lines · Kees Cook
Quoted 14 lines · Lev Olshvang

The purpose of this patch is produce hardened kernel for Embedded or Production systems.

Typically debuggers, such as gdb, write to read-only code [text] sections of target process.(ptrace)
This kind of page protectiion violation raises minor page fault, but kernel's fault handler allows it by default.
This is clearly attack surface for adversary.

The proposed kernel hardening configuration option checks the type of protection of the foreign vma and blocks writes to read only vma.

When enabled, it will stop attacks modifying code or jump tables, etc.

Quoted 8 lines

Code of arch_vma_access_permitted() function was extended to check foreign vma flags.

Tested on x86_64 and ARM(QEMU) with dd command which writes to /proc/PID/mem in r--p or r--xp of vma area addresses range

dd reports IO failure when tries to write to adress taken from from /proc/PID/maps (PLT or code section)

So, just to give some background here: the reason for this behavior is so debuggers can insert software breakpoints in the .text section (0xcc) etc. This is implemented with the "FOLL_FORCE" flag, and an attempt to remove it was made here:
https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=8ee74a91ac30
but it was later reverted (see below).

There have been many prior discussions about this behavior, and a good thread (which I link from https://github.com/KSPP/linux/issues/37
"Block process from writing to its own /proc/$pid/mem") is this one:
https://lore.kernel.org/lkml/CAGXu5j+PHzDwnJxJwMJ=WuhacDn_vJWe9xZx+Kbsh28vxOGRiA@mail.gmail.com/

For details on the revert see:
https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=f511c0b17b08

All this said, I think this feature would still be nice to have, available with some kind of knob to control it. Do you get the results you were expecting from just re-applying 8ee74a91ac30? If so, that's a much smaller change, and a single place to apply a knob. It would likely be best implemented with a sysctl and a static_branch(). A possible example for this can be seen here:
https://lore.kernel.org/lkml/[email protected]/
Though it doesn't use a sysctl. (And perhaps this feature needs to be a per-process setting like "dumpable", but let's start simple with a system-wide control.)

Can you test the FOLL_FORCE removal and refactor things to use a static_branch() instead?

-Kees

Quoted 44 lines
---
 include/asm-generic/mm_hooks.h |  5 +++++
 security/Kconfig               | 10 ++++++++++
 2 files changed, 15 insertions(+)
include/asm-generic/mm_hooks.h +5 -0
index 4dbb177d1150..6e1fcce44cc2 100644
@@ -25,6 +25,11 @@ static inline void arch_unmap(struct mm_struct *mm,
 static inline bool arch_vma_access_permitted(struct vm_area_struct *vma,
              bool write, bool execute, bool foreign)
 {
+#ifdef CONFIG_PROTECT_READONLY_USER_MEMORY
+     /* Forbid write to PROT_READ pages of foreign process */
+     if (write && foreign && (!(vma->vm_flags & VM_WRITE)))
+             return false;
+#endif
      /* by default, allow everything */
      return true;
 }
security/Kconfig +10 -1
index cd3cc7da3a55..d92e79c90d67 100644
@@ -143,6 +143,16 @@ config LSM_MMAP_MIN_ADDR
        this low address space will need the permission specific to the
        systems running LSM.
 
+config PROTECT_READONLY_USER_MEMORY
+     bool "Protect read only process memory"
+     help
+       Protects read only memory of process code and PLT table
+       from possible attack through /proc/PID/mem or through /dev/mem.
+       Refuses to insert and stop at debuggers breakpoints (prtace,gdb)
+       Mostly advised for embedded and production system.
+       Stops attempts of the malicious process to modify read only memory of another process
+
+
 config HAVE_HARDENED_USERCOPY_ALLOCATOR
      bool
      help
--
Quoted 2 lines

2.17.1

--
Kees Cook

#4 lore raw

Re: [RFC PATCH 1/5] security : hardening : prevent write to proces's read-only pages from another process

(Please avoid top-posting
https://www.kernel.org/doc/html/latest/process/2.Process.html#mailing-lists)

Quoted 54 lines · Lev R. Oshvang .
Quoted 51 lines · Kees Cook
Quoted 14 lines · Lev Olshvang

The purpose of this patch is produce hardened kernel for Embedded or Production systems.

Typically debuggers, such as gdb, write to read-only code [text] sections of target process.(ptrace)
This kind of page protectiion violation raises minor page fault, but kernel's fault handler allows it by default.
This is clearly attack surface for adversary.

The proposed kernel hardening configuration option checks the type of protection of the foreign vma and blocks writes to read only vma.

When enabled, it will stop attacks modifying code or jump tables, etc.

Quoted 8 lines

Code of arch_vma_access_permitted() function was extended to check foreign vma flags.

Tested on x86_64 and ARM(QEMU) with dd command which writes to /proc/PID/mem in r--p or r--xp of vma area addresses range

dd reports IO failure when tries to write to adress taken from from /proc/PID/maps (PLT or code section)

So, just to give some background here: the reason for this behavior is so debuggers can insert software breakpoints in the .text section (0xcc) etc. This is implemented with the "FOLL_FORCE" flag, and an attempt to remove it was made here:
https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=8ee74a91ac30
but it was later reverted (see below).

There have been many prior discussions about this behavior, and a good thread (which I link from https://github.com/KSPP/linux/issues/37
"Block process from writing to its own /proc/$pid/mem") is this one:
https://lore.kernel.org/lkml/CAGXu5j+PHzDwnJxJwMJ=WuhacDn_vJWe9xZx+Kbsh28vxOGRiA@mail.gmail.com/

For details on the revert see:
https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=f511c0b17b08

All this said, I think this feature would still be nice to have, available with some kind of knob to control it. Do you get the results you were expecting from just re-applying 8ee74a91ac30? If so, that's a much smaller change, and a single place to apply a knob. It would likely be best implemented with a sysctl and a static_branch(). A possible example for this can be seen here:
https://lore.kernel.org/lkml/[email protected]/
Though it doesn't use a sysctl. (And perhaps this feature needs to be a per-process setting like "dumpable", but let's start simple with a system-wide control.)

Quoted 6 lines
Quoted 2 lines

Can you test the FOLL_FORCE removal and refactor things to use a static_branch() instead?

Hi Kees,

The patch you referred to is scoped in /proc fs.

Ah yes, good point. Is FOLL_FORCE used in the other places as well? I'd really like to find way to make this change architecture-agnostic.

Quoted 4 lines

There is a chance that hackers may use other attack methods except procfs. There is process_vm_writev syscall , /dev/mem.
An attacker can also hijack one of the process threads and write to read-only pages.

Quoted 8 lines

I admit that I am the newbie and lack knowledge, but I think my solution is more generic and protects from more possible attacks. Second, you suggested to control it in run-time with a knob.
I think that configuration option I propose better fit embedded system needs. There is no need in an embedded system to turn it on/off since there is no gdb. (the same argument for a production system), These systems are locked down, and perhaps the proper place to put this option is in lockdown LSM.

This is mainly about upstream acceptability: using CONFIGs for these kinds of things is frowned upon because it means that distro kernel users can't use the feature (since distros won't enable the CONFIG since it absolutely breaks known userspace workflows). So a static branch (with its default controlled by CONFIG) means that everyone can use it, embedded or not.

Quoted 1 line

Thank you for your response.

Thanks for chasing this problem down! If you comment on the bug, I can mark it as assigned to you, if want?
https://github.com/KSPP/linux/issues/37

-Kees

Quoted 53 lines

Lev

Quoted 52 lines

-Kees

Quoted 44 lines
---
 include/asm-generic/mm_hooks.h |  5 +++++
 security/Kconfig               | 10 ++++++++++
 2 files changed, 15 insertions(+)
include/asm-generic/mm_hooks.h +5 -0
index 4dbb177d1150..6e1fcce44cc2 100644
@@ -25,6 +25,11 @@ static inline void arch_unmap(struct mm_struct *mm,
 static inline bool arch_vma_access_permitted(struct vm_area_struct *vma,
              bool write, bool execute, bool foreign)
 {
+#ifdef CONFIG_PROTECT_READONLY_USER_MEMORY
+     /* Forbid write to PROT_READ pages of foreign process */
+     if (write && foreign && (!(vma->vm_flags & VM_WRITE)))
+             return false;
+#endif
      /* by default, allow everything */
      return true;
 }
security/Kconfig +10 -1
index cd3cc7da3a55..d92e79c90d67 100644
@@ -143,6 +143,16 @@ config LSM_MMAP_MIN_ADDR
        this low address space will need the permission specific to the
        systems running LSM.
 
+config PROTECT_READONLY_USER_MEMORY
+     bool "Protect read only process memory"
+     help
+       Protects read only memory of process code and PLT table
+       from possible attack through /proc/PID/mem or through /dev/mem.
+       Refuses to insert and stop at debuggers breakpoints (prtace,gdb)
+       Mostly advised for embedded and production system.
+       Stops attempts of the malicious process to modify read only memory of another process
+
+
 config HAVE_HARDENED_USERCOPY_ALLOCATOR
      bool
      help
--
Quoted 2 lines

2.17.1

--
Kees Cook

Signature · 1 line
Kees Cook
#5 lore raw

RFC PATCH 2/5 Prevent write to read-only pages from another process

In reply to Lev Olshvang
---
 arch/unicore32/include/asm/mmu_context.h | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)
arch/unicore32/include/asm/mmu_context.h +6 -1
index 388c0c811c68..caf240b8a748 100644
@@ -92,7 +92,12 @@ static inline void arch_unmap(struct mm_struct *mm,
 static inline bool arch_vma_access_permitted(struct vm_area_struct *vma,
 		bool write, bool execute, bool foreign)
 {
+#ifdef CONFIG_PROTECT_READONLY_USER_MEMORY
+	/* Forbid write to PROT_READ pages of foreign process */
+	if (write && foreign && (!(vma->vm_flags & VM_WRITE)))
+		return false;
+#endif
 	/* by default, allow everything */
 	return true;
 }
-#endif
+#endif /*__UNICORE_MMU_CONTEXT_H__*/

--
2.17.1

#6 lore raw

RFC PATCH 3/5 Prevent write to read-only pages text, PLT/GOT tables from another process

In reply to Lev Olshvang
---
 arch/powerpc/include/asm/mmu_context.h | 7 ++++++-
 arch/powerpc/mm/book3s64/pkeys.c       | 5 +++++
 2 files changed, 11 insertions(+), 1 deletion(-)
arch/powerpc/include/asm/mmu_context.h +6 -1
index 360367c579de..b25e5726fa99 100644
@@ -246,10 +246,15 @@ void arch_dup_pkeys(struct mm_struct *oldmm, struct mm_struct *mm);
 static inline bool arch_vma_access_permitted(struct vm_area_struct *vma,
 		bool write, bool execute, bool foreign)
 {
+#ifdef CONFIG_PROTECT_READONLY_USER_MEMORY
+	/* Forbid write to PROT_READ pages of foreign process */
+	if (write && foreign && (!(vma->vm_flags & VM_WRITE)))
+		return false;
+#endif
 	/* by default, allow everything */
 	return true;
 }
-
+#endif
 #define pkey_mm_init(mm)
 #define thread_pkey_regs_save(thread)
 #define thread_pkey_regs_restore(new_thread, old_thread)
arch/powerpc/mm/book3s64/pkeys.c +5 -0
index 07527f1ed108..230058a52009 100644
@@ -384,6 +384,11 @@ bool arch_pte_access_permitted(u64 pte, bool write, bool execute)
 bool arch_vma_access_permitted(struct vm_area_struct *vma, bool write,
 			       bool execute, bool foreign)
 {
+#ifdef CONFIG_PROTECT_READONLY_USER_MEMORY
+	/* Forbid write to PROT_READ pages of foreign process */
+	if (write && foreign && (!(vma->vm_flags & VM_WRITE)))
+		return false;
+#endif
 	if (static_branch_likely(&pkey_disabled))
 		return true;
 	/*

--
2.17.1

#7 lore raw

RFC PATCH 4/5 X86:Prevent write to read-only pages :text, PLT/GOT tables from another process

In reply to Lev Olshvang
---
 arch/x86/include/asm/mmu_context.h | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)
arch/x86/include/asm/mmu_context.h +8 -1
index 4e55370e48e8..708135112d95 100644
@@ -216,12 +216,19 @@ static inline void arch_unmap(struct mm_struct *mm, unsigned long start,
 static inline bool arch_vma_access_permitted(struct vm_area_struct *vma,
 		bool write, bool execute, bool foreign)
 {
-	/* pkeys never affect instruction fetches */
+#ifdef CONFIG_PROTECT_READONLY_USER_MEMORY
+	/* Forbid write to PROT_READ pages of foreign process */
+	if (write && foreign && (!(vma->vm_flags & VM_WRITE)))
+		return false;
+#endif
+	/* Don't check PKRU since pkeys never affect instruction fetches */
 	if (execute)
 		return true;
+
 	/* allow access if the VMA is not one from this process */
 	if (foreign || vma_is_foreign(vma))
 		return true;
+
 	return __pkru_allows_pkey(vma_pkey(vma), write);
 }
 

--
2.17.1

#8 lore raw

RFC PATCH 5/5 UM:Prevent write to read-only pages :text, PLT/GOT tables from another process

In reply to Lev Olshvang
---
 arch/um/include/asm/mmu_context.h | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)
arch/um/include/asm/mmu_context.h +8 -3
index b4deb1bfbb68..2de21d52bd60 100644
@@ -1,5 +1,5 @@
 /* SPDX-License-Identifier: GPL-2.0 */
-/*
+/*
  * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
  */
 
@@ -28,6 +28,11 @@ static inline void arch_unmap(struct mm_struct *mm,
 static inline bool arch_vma_access_permitted(struct vm_area_struct *vma,
 		bool write, bool execute, bool foreign)
 {
+	#ifdef CONFIG_PROTECT_READONLY_USER_MEMORY
+	/* Forbid write to PROT_READ pages of foreign process */
+	if (write && foreign && (!(vma->vm_flags & VM_WRITE)))
+	return false;
+	#endif
 	/* by default, allow everything */
 	return true;
 }
@@ -52,7 +57,7 @@ static inline void activate_mm(struct mm_struct *old, struct mm_struct *new)
 	up_write(&new->mmap_sem);
 }
 
-static inline void switch_mm(struct mm_struct *prev, struct mm_struct *next,
+static inline void switch_mm(struct mm_struct *prev, struct mm_struct *next,
 			     struct task_struct *tsk)
 {
 	unsigned cpu = smp_processor_id();
@@ -65,7 +70,7 @@ static inline void switch_mm(struct mm_struct *prev, struct mm_struct *next,
 	}
 }
 
-static inline void enter_lazy_tlb(struct mm_struct *mm,
+static inline void enter_lazy_tlb(struct mm_struct *mm,
 				  struct task_struct *tsk)
 {
 }

--
2.17.1