Skip to contentSkip to conversation

AARCH64: Add gcc Shadow Call Stack support

PATCH Superseded Dan Li 5 participants 12 messages Feb 25, 2022 – Mar 1, 2022 arm64

v2 of 3 Superseded Latest is v3 →

lore
Share & tools
lore

Dan Li

author
#0 lore raw

PATCH v2 1/1 AARCH64: Add gcc Shadow Call Stack support

Shadow call stacks will be available in GCC >= 12, this patch makes the corresponding kernel configuration available when compiling the kernel with the gcc.

Note that the implementation in GCC is slightly different from Clang. With SCS enabled, functions will only pop x30 once in the epilogue, like:

str x30, [x18], #8
stp x29, x30, [sp, #-16]!
......

-  ldp     x29, x30, [sp], #16	  //clang
+  ldr     x29, [sp], #16	  //GCC
   ldr     x30, [x18, #-8]!

---
FYI:
This function can be used to test if the shadow call stack works:
//noinline void __noscs scs_test(void)
noinline void scs_test(void)

{
    unsigned long * lr = (unsigned long *)__builtin_frame_address(0) + 1;

    asm volatile("str xzr, [%0]\n\t": : "r"(lr) : "x30");
}                                                         

ffff800008012770 <scs_test>:

ffff800008012770:       d503245f        bti     c
ffff800008012774:       d503233f        paciasp
ffff800008012778:       f800865e        str     x30, [x18], #8
ffff80000801277c:       a9bf7bfd        stp     x29, x30, [sp, #-16]!
ffff800008012780:       910003fd        mov     x29, sp
ffff800008012784:       910023a0        add     x0, x29, #0x8
ffff800008012788:       f900001f        str     xzr, [x0]
ffff80000801278c:       f85f8e5e        ldr     x30, [x18, #-8]!
ffff800008012790:       f84107fd        ldr     x29, [sp], #16
ffff800008012794:       d50323bf        autiasp
ffff800008012798:       d65f03c0        ret

If SCS protection is enabled, this function will return normally. If the function has __noscs attribute (scs disabled), it will crash due to 0 address access.

 arch/Kconfig                 | 19 ++++++++++---------
 arch/arm64/Kconfig           |  2 +-
 include/linux/compiler-gcc.h |  4 ++++
 3 files changed, 15 insertions(+), 10 deletions(-)
arch/Kconfig +10 -9
index 678a80713b21..c92683362ac2 100644
@@ -599,21 +599,22 @@ config STACKPROTECTOR_STRONG
 config ARCH_SUPPORTS_SHADOW_CALL_STACK
 	bool
 	help
-	  An architecture should select this if it supports Clang's Shadow
-	  Call Stack and implements runtime support for shadow stack
+	  An architecture should select this if it supports the compiler's
+	  Shadow Call Stack and implements runtime support for shadow stack
 	  switching.
 
 config SHADOW_CALL_STACK
-	bool "Clang Shadow Call Stack"
-	depends on CC_IS_CLANG && ARCH_SUPPORTS_SHADOW_CALL_STACK
+	bool "Shadow Call Stack"
+	depends on ARCH_SUPPORTS_SHADOW_CALL_STACK
 	depends on DYNAMIC_FTRACE_WITH_REGS || !FUNCTION_GRAPH_TRACER
 	help
-	  This option enables Clang's Shadow Call Stack, which uses a
-	  shadow stack to protect function return addresses from being
-	  overwritten by an attacker. More information can be found in
-	  Clang's documentation:
+	  This option enables the compiler's Shadow Call Stack, which
+	  uses a shadow stack to protect function return addresses from
+	  being overwritten by an attacker. More information can be found
+	  in the compiler's documentation:
 
-	    https://clang.llvm.org/docs/ShadowCallStack.html
+	  - Clang (https://clang.llvm.org/docs/ShadowCallStack.html)
+	  - GCC (https://gcc.gnu.org/onlinedocs/gcc/Instrumentation-Options.html#Instrumentation-Options)
 
 	  Note that security guarantees in the kernel differ from the
 	  ones documented for user space. The kernel must store addresses
arch/arm64/Kconfig +1 -1
index 09b885cc4db5..b7145337efae 100644
@@ -1255,7 +1255,7 @@ config HW_PERF_EVENTS
 config ARCH_HAS_FILTER_PGPROT
 	def_bool y
 
-# Supported by clang >= 7.0
+# Supported by clang >= 7.0 or GCC >= 12.0.0
 config CC_HAVE_SHADOW_CALL_STACK
 	def_bool $(cc-option, -fsanitize=shadow-call-stack -ffixed-x18)
 
include/linux/compiler-gcc.h +4 -0
index ccbbd31b3aae..deff5b308470 100644
@@ -97,6 +97,10 @@
 #define KASAN_ABI_VERSION 4
 #endif
 
+#ifdef CONFIG_SHADOW_CALL_STACK
+#define __noscs __attribute__((__no_sanitize__("shadow-call-stack")))
+#endif
+
 #if __has_attribute(__no_sanitize_address__)
 #define __no_sanitize_address __attribute__((no_sanitize_address))
 #else
Signature · 1 line
2.17.1
#1 lore raw

arch/Kconfig config STACKPROTECTOR_STRONG · line 617

Quoted 3 lines · Dan Li
arch/Kconfig +2 -0
+         - Clang (https://clang.llvm.org/docs/ShadowCallStack.html)
+         - GCC (https://gcc.gnu.org/onlinedocs/gcc/Instrumentation-Options.html#Instrumentation-Options)

Maybe Clang: and GCC: instead of the parenthesis?

include/linux/compiler-gcc.h line 102

Quoted 3 lines
include/linux/compiler-gcc.h +3 -0
+#ifdef CONFIG_SHADOW_CALL_STACK
+#define __noscs __attribute__((__no_sanitize__("shadow-call-stack")))
+#endif

Since both compilers have it, and I guess the #ifdef condition would work for both, could this be moved into compiler_types.h where the empty __noscs definition is, and remove the one from compiler-clang.h?

Cheers,
Miguel

#2 lore raw
Quoted 7 lines · Miguel Ojeda

arch/Kconfig config STACKPROTECTOR_STRONG · line 617

Quoted 3 lines · Dan Li
arch/Kconfig +2 -0
+         - Clang (https://clang.llvm.org/docs/ShadowCallStack.html)
+         - GCC (https://gcc.gnu.org/onlinedocs/gcc/Instrumentation-Options.html#Instrumentation-Options)

Maybe Clang: and GCC: instead of the parenthesis?

Quoted 8 lines

include/linux/compiler-gcc.h line 102

Quoted 3 lines
include/linux/compiler-gcc.h +3 -0
+#ifdef CONFIG_SHADOW_CALL_STACK
+#define __noscs __attribute__((__no_sanitize__("shadow-call-stack")))
+#endif

Since both compilers have it, and I guess the #ifdef condition would work for both, could this be moved into compiler_types.h where the empty __noscs definition is, and remove the one from compiler-clang.h?

I thought about that too, but I think it's less simple due to the __has_feature vs CONFIG differences, etc:
https://lore.kernel.org/lkml/202202251243.1E38256F9@keescook/

But maybe __has_feature doesn't really matter here?

Signature · 1 line
Kees Cook
#3 lore raw
Quoted 6 lines · Kees Cook

I thought about that too, but I think it's less simple due to the __has_feature vs CONFIG differences, etc:
https://lore.kernel.org/lkml/202202251243.1E38256F9@keescook/

But maybe __has_feature doesn't really matter here?

I have not tested it, but I was assuming the CONFIG could do its job, since it comes from testing the compiler flag.

If the __has_feature is actually restricting it more than that, then we should probably get the CONFIG fixed so that it only gets enabled when really it is going to be used.

Cheers,
Miguel

author
#4 lore raw
In reply to Miguel Ojeda
Quoted 7 lines · Miguel Ojeda

arch/Kconfig config STACKPROTECTOR_STRONG · line 617

Quoted 3 lines · Dan Li
arch/Kconfig +2 -0
+         - Clang (https://clang.llvm.org/docs/ShadowCallStack.html)
+         - GCC (https://gcc.gnu.org/onlinedocs/gcc/Instrumentation-Options.html#Instrumentation-Options)

Maybe Clang: and GCC: instead of the parenthesis?

Got it.

Quoted 9 lines

include/linux/compiler-gcc.h line 102

Quoted 3 lines
include/linux/compiler-gcc.h +3 -0
+#ifdef CONFIG_SHADOW_CALL_STACK
+#define __noscs __attribute__((__no_sanitize__("shadow-call-stack")))
+#endif

Since both compilers have it, and I guess the #ifdef condition would work for both, could this be moved into compiler_types.h where the empty __noscs definition is, and remove the one from compiler-clang.h?

In the clang documentation I see __has_feature(shadow_call_stack) is used to check if -fsanitize=shadow-call-stack is enabled, so I think maybe it's fine to use "#ifdef CONFIG_SHADOW_CALL_STACK" instead of "#if __has_attribute(__no_sanitize_address__)" here, then move it to compiler_types.h.

And from the results of my local clang 12 compilation, this doesn't seem to be a problem.

#5 lore raw
Quoted 22 lines · Dan Li
Quoted 7 lines · Miguel Ojeda

arch/Kconfig config STACKPROTECTOR_STRONG · line 617

Quoted 3 lines · Dan Li
arch/Kconfig +2 -0
+         - Clang (https://clang.llvm.org/docs/ShadowCallStack.html)
+         - GCC (https://gcc.gnu.org/onlinedocs/gcc/Instrumentation-Options.html#Instrumentation-Options)

Maybe Clang: and GCC: instead of the parenthesis?

Got it.

Quoted 9 lines

include/linux/compiler-gcc.h line 102

Quoted 3 lines
include/linux/compiler-gcc.h +3 -0
+#ifdef CONFIG_SHADOW_CALL_STACK
+#define __noscs __attribute__((__no_sanitize__("shadow-call-stack")))
+#endif

Since both compilers have it, and I guess the #ifdef condition would work for both, could this be moved into compiler_types.h where the empty __noscs definition is, and remove the one from compiler-clang.h?

Quoted 5 lines

In the clang documentation I see __has_feature(shadow_call_stack) is used to check if -fsanitize=shadow-call-stack is enabled, so I think maybe it's fine to use "#ifdef CONFIG_SHADOW_CALL_STACK" instead of "#if __has_attribute(__no_sanitize_address__)" here, then move it to compiler_types.h.

Or simply add a #define for __noscs to include/linux/compiler-gcc.h with appropriate guard and leave the existing #ifndef in include/linux/compiler_types.h as is. I'd prefer that when the compilers differ in terms of feature detection since it's as explicit as possible.

Quoted 5 lines

And from the results of my local clang 12 compilation, this doesn't seem to be a problem.

Signature · 2 lines
Thanks,
~Nick Desaulniers
author
#6 lore raw
Quoted 16 lines · Nick Desaulniers
Quoted 9 lines · Dan Li
Quoted 9 lines

include/linux/compiler-gcc.h line 102

Quoted 3 lines
include/linux/compiler-gcc.h +3 -0
+#ifdef CONFIG_SHADOW_CALL_STACK
+#define __noscs __attribute__((__no_sanitize__("shadow-call-stack")))
+#endif

Since both compilers have it, and I guess the #ifdef condition would work for both, could this be moved into compiler_types.h where the empty __noscs definition is, and remove the one from compiler-clang.h?

Quoted 5 lines

In the clang documentation I see __has_feature(shadow_call_stack) is used to check if -fsanitize=shadow-call-stack is enabled, so I think maybe it's fine to use "#ifdef CONFIG_SHADOW_CALL_STACK" instead of "#if __has_attribute(__no_sanitize_address__)" here, then move it to compiler_types.h.

Quoted 6 lines

Or simply add a #define for __noscs to include/linux/compiler-gcc.h with appropriate guard and leave the existing #ifndef in include/linux/compiler_types.h as is. I'd prefer that when the compilers differ in terms of feature detection since it's as explicit as possible.

To make sure I understand correctly, that means I should keep the current patch unchanged right?

Thanks,
Dan.

Reviewed-by
#7 lore raw
Quoted 27 lines · Dan Li
Quoted 16 lines · Nick Desaulniers
Quoted 9 lines · Dan Li
Quoted 9 lines

include/linux/compiler-gcc.h line 102

Quoted 3 lines
include/linux/compiler-gcc.h +3 -0
+#ifdef CONFIG_SHADOW_CALL_STACK
+#define __noscs __attribute__((__no_sanitize__("shadow-call-stack")))
+#endif

Since both compilers have it, and I guess the #ifdef condition would work for both, could this be moved into compiler_types.h where the empty __noscs definition is, and remove the one from compiler-clang.h?

Quoted 5 lines

In the clang documentation I see __has_feature(shadow_call_stack) is used to check if -fsanitize=shadow-call-stack is enabled, so I think maybe it's fine to use "#ifdef CONFIG_SHADOW_CALL_STACK" instead of "#if __has_attribute(__no_sanitize_address__)" here, then move it to compiler_types.h.

Quoted 6 lines

Or simply add a #define for __noscs to include/linux/compiler-gcc.h with appropriate guard and leave the existing #ifndef in include/linux/compiler_types.h as is. I'd prefer that when the compilers differ in terms of feature detection since it's as explicit as possible.

Quoted 2 lines

To make sure I understand correctly, that means I should keep the current patch unchanged right?

Yes.

Signature · 2 lines
Thanks,
~Nick Desaulniers
#8 lore raw
In reply to Nick Desaulniers
Quoted 6 lines · Nick Desaulniers

Or simply add a #define for __noscs to include/linux/compiler-gcc.h with appropriate guard and leave the existing #ifndef in include/linux/compiler_types.h as is. I'd prefer that when the compilers differ in terms of feature detection since it's as explicit as possible.

The idea is to avoid differing here to begin with, i.e. to use the same code for both compilers (only whenever that is possible, of course), thus having a single #define in a single file.

Do you think we will have to change in the future for some reason, thus needing to split it again?

Cheers,
Miguel

#9 lore raw

From: Miguel Ojeda

Quoted 11 lines

Sent: 01 March 2022 09:29

Quoted 6 lines · Nick Desaulniers

Or simply add a #define for __noscs to include/linux/compiler-gcc.h with appropriate guard and leave the existing #ifndef in include/linux/compiler_types.h as is. I'd prefer that when the compilers differ in terms of feature detection since it's as explicit as possible.

Quoted 6 lines

The idea is to avoid differing here to begin with, i.e. to use the same code for both compilers (only whenever that is possible, of course), thus having a single #define in a single file.

Do you think we will have to change in the future for some reason, thus needing to split it again?

What happens if an out of tree module is compiled with the other compiler? Surely this is part of the ABI and should be defined for the architecture?

David

-
Registered Address Lakeside, Bramley Road, Mount Farm, Milton Keynes, MK1 1PT, UK Registration No: 1397386 (Wales)

Reviewed-by on v2 1/1
#10 lore raw
In reply to Dan Li
Quoted 15 lines · Dan Li

Shadow call stacks will be available in GCC >= 12, this patch makes the corresponding kernel configuration available when compiling the kernel with the gcc.

Note that the implementation in GCC is slightly different from Clang. With SCS enabled, functions will only pop x30 once in the epilogue, like:

   str     x30, [x18], #8
   stp     x29, x30, [sp, #-16]!
   ......
(quoted diff) +1 -1
-  ldp     x29, x30, [sp], #16	  //clang
+  ldr     x29, [sp], #16	  //GCC
   ldr     x30, [x18, #-8]!
Quoted 3 lines

Thanks for the tweaks!

Quoted 10 lines

---
FYI:
This function can be used to test if the shadow call stack works:
//noinline void __noscs scs_test(void)
noinline void scs_test(void)

{
    unsigned long * lr = (unsigned long *)__builtin_frame_address(0) + 1;

    asm volatile("str xzr, [%0]\n\t": : "r"(lr) : "x30");
}                                                         

Not a big deal, but just FYI, there's a lot of whitespace trailing the "}" above...

Quoted 14 lines

ffff800008012770 <scs_test>:

ffff800008012770:       d503245f        bti     c
ffff800008012774:       d503233f        paciasp
ffff800008012778:       f800865e        str     x30, [x18], #8
ffff80000801277c:       a9bf7bfd        stp     x29, x30, [sp, #-16]!
ffff800008012780:       910003fd        mov     x29, sp
ffff800008012784:       910023a0        add     x0, x29, #0x8
ffff800008012788:       f900001f        str     xzr, [x0]
ffff80000801278c:       f85f8e5e        ldr     x30, [x18, #-8]!
ffff800008012790:       f84107fd        ldr     x29, [sp], #16
ffff800008012794:       d50323bf        autiasp
ffff800008012798:       d65f03c0        ret
Quoted 3 lines

If SCS protection is enabled, this function will return normally. If the function has __noscs attribute (scs disabled), it will crash due to 0 address access.

It would be cool to turn this into an LKDTM test... (see things like the CFI_FORWARD_PROTO test). I imagine this should be CFI_BACKWARD_SHADOW or something...

Also, I assume you're using real hardware to test this? It'd be nice to see if qemu can be convinced to run with the needed features. Whenever I've tried this it becomes impossibly slow. :)

Quoted 60 lines
 arch/Kconfig                 | 19 ++++++++++---------
 arch/arm64/Kconfig           |  2 +-
 include/linux/compiler-gcc.h |  4 ++++
 3 files changed, 15 insertions(+), 10 deletions(-)
arch/Kconfig +10 -9
index 678a80713b21..c92683362ac2 100644
@@ -599,21 +599,22 @@ config STACKPROTECTOR_STRONG
 config ARCH_SUPPORTS_SHADOW_CALL_STACK
 	bool
 	help
-	  An architecture should select this if it supports Clang's Shadow
-	  Call Stack and implements runtime support for shadow stack
+	  An architecture should select this if it supports the compiler's
+	  Shadow Call Stack and implements runtime support for shadow stack
 	  switching.
 
 config SHADOW_CALL_STACK
-	bool "Clang Shadow Call Stack"
-	depends on CC_IS_CLANG && ARCH_SUPPORTS_SHADOW_CALL_STACK
+	bool "Shadow Call Stack"
+	depends on ARCH_SUPPORTS_SHADOW_CALL_STACK
 	depends on DYNAMIC_FTRACE_WITH_REGS || !FUNCTION_GRAPH_TRACER
 	help
-	  This option enables Clang's Shadow Call Stack, which uses a
-	  shadow stack to protect function return addresses from being
-	  overwritten by an attacker. More information can be found in
-	  Clang's documentation:
+	  This option enables the compiler's Shadow Call Stack, which
+	  uses a shadow stack to protect function return addresses from
+	  being overwritten by an attacker. More information can be found
+	  in the compiler's documentation:
 
-	    https://clang.llvm.org/docs/ShadowCallStack.html
+	  - Clang (https://clang.llvm.org/docs/ShadowCallStack.html)
+	  - GCC (https://gcc.gnu.org/onlinedocs/gcc/Instrumentation-Options.html#Instrumentation-Options)
 
 	  Note that security guarantees in the kernel differ from the
 	  ones documented for user space. The kernel must store addresses
arch/arm64/Kconfig +1 -1
index 09b885cc4db5..b7145337efae 100644
@@ -1255,7 +1255,7 @@ config HW_PERF_EVENTS
 config ARCH_HAS_FILTER_PGPROT
 	def_bool y
 
-# Supported by clang >= 7.0
+# Supported by clang >= 7.0 or GCC >= 12.0.0
 config CC_HAVE_SHADOW_CALL_STACK
 	def_bool $(cc-option, -fsanitize=shadow-call-stack -ffixed-x18)
 
include/linux/compiler-gcc.h +0 -0
index ccbbd31b3aae..deff5b308470 100644

include/linux/compiler-gcc.h line 102

Quoted 6 lines
include/linux/compiler-gcc.h +3 -0
@@ -97,6 +97,10 @@
 #define KASAN_ABI_VERSION 4
 #endif
 
+#ifdef CONFIG_SHADOW_CALL_STACK
+#define __noscs __attribute__((__no_sanitize__("shadow-call-stack")))
+#endif

I initially wondered if we need a separate __no_sanitize(STUFF) patch to make the compiler-clang.h macros easier, but I see there are places where we do multiple ("address", "hwaddress") and have specialized macros, so I think this is fine. And since GCC doesn't support "__has_feature", I think this is the correct location for this.

Quoted 7 lines
include/linux/compiler-gcc.h +1 -0
+
 #if __has_attribute(__no_sanitize_address__)
 #define __no_sanitize_address __attribute__((no_sanitize_address))
 #else
Signature · 1 line
2.17.1
Signature · 1 line
Kees Cook
author
#11 lore raw
Quoted 13 lines · Kees Cook
Quoted 1 line · Dan Li

Thanks for the tweaks!

Quoted 8 lines

---
FYI:
This function can be used to test if the shadow call stack works:
//noinline void __noscs scs_test(void)
noinline void scs_test(void)

{
     unsigned long * lr = (unsigned long *)__builtin_frame_address(0) + 1;
Quoted 6 lines
Quoted 2 lines
     asm volatile("str xzr, [%0]\n\t": : "r"(lr) : "x30");
}

Not a big deal, but just FYI, there's a lot of whitespace trailing the "}" above...

Ah, sorry for the mistake.

Quoted 9 lines
Quoted 4 lines

If SCS protection is enabled, this function will return normally. If the function has __noscs attribute (scs disabled), it will crash due to 0 address access.

It would be cool to turn this into an LKDTM test... (see things like the CFI_FORWARD_PROTO test). I imagine this should be CFI_BACKWARD_SHADOW or something...

OK, I'll add it in the next version.

Quoted 4 lines

Also, I assume you're using real hardware to test this? It'd be nice to see if qemu can be convinced to run with the needed features. Whenever I've tried this it becomes impossibly slow. :)

I also use qemu to test the patch (qemu 6.1.0 with command "-cpu max"), and can feel the performance drop.

Maybe because my test environment only has simple busybox and ltp, the feeling of a slow system running is not that strong for me :)

For comparison, I simply tested the difference in kernel boot time in my test environment:
//run qemu with "-cpu cortex-a57",

[    1.254481] Run /linuxrc as init process
//run qemu with "-cpu max"
[    3.566091] Run /linuxrc as init process
Quoted 8 lines
Quoted 8 lines
include/linux/compiler-gcc.h +0 -0
index ccbbd31b3aae..deff5b308470 100644
@@ -97,6 +97,10 @@
  #define KASAN_ABI_VERSION 4
  #endif
 
Quoted 10 lines

include/linux/compiler-gcc.h line 102

Quoted 3 lines
include/linux/compiler-gcc.h +3 -0
+#ifdef CONFIG_SHADOW_CALL_STACK
+#define __noscs __attribute__((__no_sanitize__("shadow-call-stack")))
+#endif

I initially wondered if we need a separate __no_sanitize(STUFF) patch to make the compiler-clang.h macros easier, but I see there are places where we do multiple ("address", "hwaddress") and have specialized macros, so I think this is fine. And since GCC doesn't support "__has_feature", I think this is the correct location for this.

As in:
https://lore.kernel.org/all/[email protected]/

I think maybe we could use "#ifdef CONFIG_SHADOW_CALL_STACK" instead of "#if __has_attribute(__no_sanitize_address__)" here, then move it to compiler_types.h.

From my current test results, __noscs seems to work fine in clang compilation.

Thanks,
Dan.