Skip to contentSkip to conversation

x86/entry/64: wipe KASAN stack shadow in rewind_stack_do_exit()

PATCH Superseded Jann Horn 4 participants 7 messages Aug 24, 2018 – Aug 28, 2018

Subsystems (2)

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore

Jann Horn

author
#0 lore raw

PATCH 1/1 x86/entry/64: wipe KASAN stack shadow in rewind_stack_do_exit()

Reset the KASAN shadow state of the task stack when rewinding RSP. Without this, a kernel oops will leave parts of the stack poisoned, and code running under do_exit() can trip over such poisoned regions and cause nonsensical false-positive KASAN reports about stack-out-of-bounds bugs.

This patch is 64-bit only because KASAN doesn't exist on 32-bit.

This patch does not wipe exception stacks; if you oops on an exception stack, you might get random KASAN false-positives from other tasks afterwards. This is probably relatively uninteresting, since if you're oopsing on an exception stack, you likely have bigger things to worry about. It'd be more interesting if vmapped stacks and KASAN were compatible, since then handle_stack_overflow() would oops from exception stack context.

Fixes 2deb4be28077 ("x86/dumpstack: When OOPSing, rewind the stack before do_exit()")

---
I have manually tested that an oops that previously triggered this bug doesn't trigger it anymore.

It would be possible to rewrite this assembly to use fewer instructions in non-KASAN builds, but I think it's clearer this way.

If anyone thinks that this thing should also be wiping exception stacks:
I did write some (entirely untested) code that should take care of that (before realizing that it's rather unlikely to occur in practice because vmapped stacks and KASAN are mutually exclusive), but I'm not sure whether it's worth complicating this code for that.
In case anyone's curious how that would look:
https://gist.github.com/thejh/c91f9b4e3cc4c58659bb3cd056c4fa40

 arch/x86/entry/entry_64.S | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)
arch/x86/entry/entry_64.S +17 -1
index 957dfb693ecc..92d3ad5bd365 100644
@@ -1673,9 +1673,25 @@ ENTRY(rewind_stack_do_exit)
 	/* Prevent any naive code from trying to unwind to our caller. */
 	xorl	%ebp, %ebp
 
+	movq	%rdi, %r14
+
 	movq	PER_CPU_VAR(cpu_current_top_of_stack), %rax
-	leaq	-PTREGS_SIZE(%rax), %rsp
+	leaq	-PTREGS_SIZE(%rax), %r15
+
+#ifdef CONFIG_KASAN
+	/*
+	 * Remove stack poisons left behind by our old stack.
+	 * Do this before updating RSP to avoid problems in case we get some
+	 * interrupt that is not handled on an exception stack before we're done
+	 * with the unpoisoning.
+	 */
+	movq	%r15, %rdi
+	call	kasan_unpoison_task_stack_below
+#endif
+
+	movq	%r15, %rsp
 	UNWIND_HINT_FUNC sp_offset=PTREGS_SIZE
 
+	movq	%r14, %rdi
 	call	do_exit
 END(rewind_stack_do_exit)
Signature · 1 line
2.19.0.rc0.228.g281dcd1b4d0-goog
Acked-by on v1 1/1
#1 lore raw
Quoted 15 lines · Jann Horn

Reset the KASAN shadow state of the task stack when rewinding RSP. Without this, a kernel oops will leave parts of the stack poisoned, and code running under do_exit() can trip over such poisoned regions and cause nonsensical false-positive KASAN reports about stack-out-of-bounds bugs.

This patch is 64-bit only because KASAN doesn't exist on 32-bit.

This patch does not wipe exception stacks; if you oops on an exception stack, you might get random KASAN false-positives from other tasks afterwards. This is probably relatively uninteresting, since if you're oopsing on an exception stack, you likely have bigger things to worry about. It'd be more interesting if vmapped stacks and KASAN were compatible, since then handle_stack_overflow() would oops from exception stack context.

Quoted 2 lines
Fixes 2deb4be28077 ("x86/dumpstack: When OOPSing, rewind the stack before do_exit()")
Quoted 52 lines

---
I have manually tested that an oops that previously triggered this bug doesn't trigger it anymore.

It would be possible to rewrite this assembly to use fewer instructions in non-KASAN builds, but I think it's clearer this way.

If anyone thinks that this thing should also be wiping exception stacks:
I did write some (entirely untested) code that should take care of that (before realizing that it's rather unlikely to occur in practice because vmapped stacks and KASAN are mutually exclusive), but I'm not sure whether it's worth complicating this code for that.
In case anyone's curious how that would look:
https://gist.github.com/thejh/c91f9b4e3cc4c58659bb3cd056c4fa40

 arch/x86/entry/entry_64.S | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)
arch/x86/entry/entry_64.S +17 -2
index 957dfb693ecc..92d3ad5bd365 100644
@@ -1673,9 +1673,25 @@ ENTRY(rewind_stack_do_exit)
        /* Prevent any naive code from trying to unwind to our caller. */
        xorl    %ebp, %ebp
 
+       movq    %rdi, %r14
+
        movq    PER_CPU_VAR(cpu_current_top_of_stack), %rax
-       leaq    -PTREGS_SIZE(%rax), %rsp
+       leaq    -PTREGS_SIZE(%rax), %r15
+
+#ifdef CONFIG_KASAN
+       /*
+        * Remove stack poisons left behind by our old stack.
+        * Do this before updating RSP to avoid problems in case we get some
+        * interrupt that is not handled on an exception stack before we're done
+        * with the unpoisoning.
+        */
+       movq    %r15, %rdi
+       call    kasan_unpoison_task_stack_below
+#endif
+
+       movq    %r15, %rsp
        UNWIND_HINT_FUNC sp_offset=PTREGS_SIZE
 
+       movq    %r14, %rdi
        call    do_exit
 END(rewind_stack_do_exit)
--

2.19.0.rc0.228.g281dcd1b4d0-goog

#2 lore raw
In reply to Jann Horn
Quoted 49 lines · Jann Horn

Reset the KASAN shadow state of the task stack when rewinding RSP. Without this, a kernel oops will leave parts of the stack poisoned, and code running under do_exit() can trip over such poisoned regions and cause nonsensical false-positive KASAN reports about stack-out-of-bounds bugs.

This patch is 64-bit only because KASAN doesn't exist on 32-bit.

This patch does not wipe exception stacks; if you oops on an exception stack, you might get random KASAN false-positives from other tasks afterwards. This is probably relatively uninteresting, since if you're oopsing on an exception stack, you likely have bigger things to worry about. It'd be more interesting if vmapped stacks and KASAN were compatible, since then handle_stack_overflow() would oops from exception stack context.

Fixes 2deb4be28077 ("x86/dumpstack: When OOPSing, rewind the stack before do_exit()")

---
I have manually tested that an oops that previously triggered this bug doesn't trigger it anymore.

It would be possible to rewrite this assembly to use fewer instructions in non-KASAN builds, but I think it's clearer this way.

If anyone thinks that this thing should also be wiping exception stacks:
I did write some (entirely untested) code that should take care of that (before realizing that it's rather unlikely to occur in practice because vmapped stacks and KASAN are mutually exclusive), but I'm not sure whether it's worth complicating this code for that.
In case anyone's curious how that would look:
https://gist.github.com/thejh/c91f9b4e3cc4c58659bb3cd056c4fa40

 arch/x86/entry/entry_64.S | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)
arch/x86/entry/entry_64.S +4 -1
index 957dfb693ecc..92d3ad5bd365 100644
@@ -1673,9 +1673,25 @@ ENTRY(rewind_stack_do_exit)
 	/* Prevent any naive code from trying to unwind to our caller. */
 	xorl	%ebp, %ebp
 
+	movq	%rdi, %r14
+
 	movq	PER_CPU_VAR(cpu_current_top_of_stack), %rax
-	leaq	-PTREGS_SIZE(%rax), %rsp
+	leaq	-PTREGS_SIZE(%rax), %r15
+

arch/x86/entry/entry_64.S ENTRY(rewind_stack_do_exit) · line 1690

Quoted 10 lines
arch/x86/entry/entry_64.S +10 -0
+#ifdef CONFIG_KASAN
+	/*
+	 * Remove stack poisons left behind by our old stack.
+	 * Do this before updating RSP to avoid problems in case we get some
+	 * interrupt that is not handled on an exception stack before we're done
+	 * with the unpoisoning.
+	 */
+	movq	%r15, %rdi
+	call	kasan_unpoison_task_stack_below
+#endif

Why this has to be done in the rewind_stack_do_exit()?
Are there any problems with calling the kasan_unpoison_task_stack(current) from oops_end(), before the rewind_stack_do_exit()?

Quoted 8 lines
arch/x86/entry/entry_64.S +3 -0
+
+	movq	%r15, %rsp
 	UNWIND_HINT_FUNC sp_offset=PTREGS_SIZE
 
+	movq	%r14, %rdi
 	call	do_exit
 END(rewind_stack_do_exit)
author
#3 lore raw
Quoted 57 lines · Andrey Ryabinin
Quoted 55 lines · Jann Horn

Reset the KASAN shadow state of the task stack when rewinding RSP. Without this, a kernel oops will leave parts of the stack poisoned, and code running under do_exit() can trip over such poisoned regions and cause nonsensical false-positive KASAN reports about stack-out-of-bounds bugs.

This patch is 64-bit only because KASAN doesn't exist on 32-bit.

This patch does not wipe exception stacks; if you oops on an exception stack, you might get random KASAN false-positives from other tasks afterwards. This is probably relatively uninteresting, since if you're oopsing on an exception stack, you likely have bigger things to worry about. It'd be more interesting if vmapped stacks and KASAN were compatible, since then handle_stack_overflow() would oops from exception stack context.

Fixes 2deb4be28077 ("x86/dumpstack: When OOPSing, rewind the stack before do_exit()")

---
I have manually tested that an oops that previously triggered this bug doesn't trigger it anymore.

It would be possible to rewrite this assembly to use fewer instructions in non-KASAN builds, but I think it's clearer this way.

If anyone thinks that this thing should also be wiping exception stacks:
I did write some (entirely untested) code that should take care of that (before realizing that it's rather unlikely to occur in practice because vmapped stacks and KASAN are mutually exclusive), but I'm not sure whether it's worth complicating this code for that.
In case anyone's curious how that would look:
https://gist.github.com/thejh/c91f9b4e3cc4c58659bb3cd056c4fa40

 arch/x86/entry/entry_64.S | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)
arch/x86/entry/entry_64.S +10 -1
index 957dfb693ecc..92d3ad5bd365 100644
@@ -1673,9 +1673,25 @@ ENTRY(rewind_stack_do_exit)
      /* Prevent any naive code from trying to unwind to our caller. */
      xorl    %ebp, %ebp
 
+     movq    %rdi, %r14
+
      movq    PER_CPU_VAR(cpu_current_top_of_stack), %rax
-     leaq    -PTREGS_SIZE(%rax), %rsp
+     leaq    -PTREGS_SIZE(%rax), %r15
+
+#ifdef CONFIG_KASAN
+     /*
+      * Remove stack poisons left behind by our old stack.
+      * Do this before updating RSP to avoid problems in case we get some
+      * interrupt that is not handled on an exception stack before we're done
+      * with the unpoisoning.
Quoted 8 lines

arch/x86/entry/entry_64.S ENTRY(rewind_stack_do_exit) · line 1690

Quoted 4 lines
arch/x86/entry/entry_64.S +4 -0
+      */
+     movq    %r15, %rdi
+     call    kasan_unpoison_task_stack_below
+#endif

Why this has to be done in the rewind_stack_do_exit()?
Are there any problems with calling the kasan_unpoison_task_stack(current) from oops_end(), before the rewind_stack_do_exit()?

Ooh, good point! I didn't see that KASAN instrumentation is disabled for dumpstack.c. So I guess I'll send a new patch that does it from oops_end().

Quoted 8 lines
Quoted 8 lines
arch/x86/entry/entry_64.S +3 -0
+
+     movq    %r15, %rsp
      UNWIND_HINT_FUNC sp_offset=PTREGS_SIZE
 
+     movq    %r14, %rdi
      call    do_exit
 END(rewind_stack_do_exit)
#4 lore raw
Quoted 7 lines · Jann Horn
Quoted 4 lines

Why this has to be done in the rewind_stack_do_exit()?
Are there any problems with calling the kasan_unpoison_task_stack(current) from oops_end(), before the rewind_stack_do_exit()?

Ooh, good point! I didn't see that KASAN instrumentation is disabled for dumpstack.c.

It doesn't really matter. This would work with instrumented oops_end() as well. kasan_unpoison_task_stack() will unpoison everything including oops_end's stack.
It would be also ok if kasan_unpoison_task_stack() instrumented, or calling any number of instrumented functions in between kasan_unpoison_task_stack() and rewind_stack_do_exit(). As long as we return from these functions before the rewind_stack_do_exit(), the stack will be unpoisoned on return.

author
#5 lore raw
Quoted 10 lines · Andrey Ryabinin
Quoted 5 lines · Jann Horn
Quoted 2 lines

Why this has to be done in the rewind_stack_do_exit()?
Are there any problems with calling the kasan_unpoison_task_stack(current) from oops_end(), before the rewind_stack_do_exit()?

Ooh, good point! I didn't see that KASAN instrumentation is disabled for dumpstack.c.

It doesn't really matter. This would work with instrumented oops_end() as well. kasan_unpoison_task_stack() will unpoison everything including oops_end's stack. It would be also ok if kasan_unpoison_task_stack() instrumented,

But then that would rely on ASAN implementation details, so I'd be hesitant to do that.

Quoted 3 lines

or calling any number of instrumented functions
in between kasan_unpoison_task_stack() and rewind_stack_do_exit(). As long as we return from these functions before the rewind_stack_do_exit(), the stack will be unpoisoned on return.

Yeah, I understand that. :)

#6 lore raw
In reply to Andrey Ryabinin
Quoted 13 lines · Andrey Ryabinin
Quoted 5 lines · Jann Horn
Quoted 4 lines

Why this has to be done in the rewind_stack_do_exit()?
Are there any problems with calling the kasan_unpoison_task_stack(current) from oops_end(), before the rewind_stack_do_exit()?

Quoted 8 lines
Quoted 2 lines

Ooh, good point! I didn't see that KASAN instrumentation is disabled for dumpstack.c.

It doesn't really matter. This would work with instrumented oops_end() as well. kasan_unpoison_task_stack() will unpoison everything including oops_end's stack.
It would be also ok if kasan_unpoison_task_stack() instrumented, or calling any number of instrumented functions in between kasan_unpoison_task_stack() and rewind_stack_do_exit(). As long as we return from these functions before the rewind_stack_do_exit(), the stack will be unpoisoned on return.

I think that, if all this is in C, we need rewind_stack_do_exit()’s caller to be uninstrumented. Which it is.