gcc-plugins: structleak: Generalize to all variable types
Subsystems (3)
cover gcc-plugins: structleak: Generalize to all variable types
Instead of a new plugin for stack initialization[1], this improves structleak to handle initialization of all variable types. Since the instrumentation happens at a different point, the "switch" statement changes from the earlier posting[2] are no longer needed. As before, this also introduces a stack initialization regression testing module to validate various kinds of stack variable usage vs compiler instrumentation for initialization. See the individual patches for more details.
Thanks!
-Kees
[1] https://lkml.kernel.org/r/CA+55aFykZL+cSBJjBBts7ebEFfyGPdMzTmLSxKnT_29=j942dA@mail.gmail.com
[2] https://lkml.kernel.org/r/[email protected]
Kees Cook (2):
gcc-plugins: structleak: Generalize to all variable types
lib: Introduce test_stackinit module
lib/Kconfig.debug | 10 + lib/Makefile | 1 + lib/test_stackinit.c | 378 ++++++++++++++++++++++++ scripts/Makefile.gcc-plugins | 2 + scripts/gcc-plugins/Kconfig | 58 +++- scripts/gcc-plugins/structleak_plugin.c | 36 ++- 6 files changed, 463 insertions(+), 22 deletions(-) create mode 100644 lib/test_stackinit.c
Signature · 1 line
2.17.1
PATCH 1/2 gcc-plugins: structleak: Generalize to all variable types
This adjusts structleak to also work with non-struct types when they are passed by reference, since those variables may leak just like anything else. This is exposed via an improved set of Kconfig options. (This does mean structleak is slightly misnamed now.)
Building with CONFIG_GCC_PLUGIN_STRUCTLEAK_BYREF_ALL should give the kernel complete initialization coverage of all stack variables passed by reference, including padding (see lib/test_stackinit.c).
Using CONFIG_GCC_PLUGIN_STRUCTLEAK_VERBOSE to count added initializations under defconfig:
..._BYREF: 5945 added initializations ..._BYREF_ALL: 16606 added initializations
There is virtually no change to text+data size (both have less than 0.05% growth):
text data bss dec hex filename
19502103 5051456 1917000 26470559 193e89f vmlinux.stock 19513412 5051456 1908808 26473676 193f4cc vmlinux.byref 19516974 5047360 1900616 26464950 193d2b6 vmlinux.byref_all
The measured performance difference is in the noise for hackbench and kernel build benchmarks:
Stock:
5x hackbench -g 20 -l 1000 Mean: 10.649s Std Dev: 0.339 5x kernel build (4-way parallel) Mean: 261.98s Std Dev: 1.53
CONFIG_GCC_PLUGIN_STRUCTLEAK_BYREF:
5x hackbench -g 20 -l 1000 Mean: 10.540s Std Dev: 0.233 5x kernel build (4-way parallel) Mean: 260.52s Std Dev: 1.31
CONFIG_GCC_PLUGIN_STRUCTLEAK_BYREF_ALL:
5x hackbench -g 20 -l 1000 Mean: 10.320 Std Dev: 0.413 5x kernel build (4-way parallel) Mean: 260.10 Std Dev: 0.86
This does not yet solve missing padding initialization for structures on the stack that are never passed by reference (which should be a tiny minority). Hopefully this will be more easily addressed by upstream compiler fixes after clarifying the C11 padding initialization specification.
--- scripts/Makefile.gcc-plugins | 2 + scripts/gcc-plugins/Kconfig | 58 ++++++++++++++++++++----- scripts/gcc-plugins/structleak_plugin.c | 36 ++++++++++----- 3 files changed, 74 insertions(+), 22 deletions(-)
scripts/Makefile.gcc-plugins +2 -0
@@ -15,6 +15,8 @@ gcc-plugin-$(CONFIG_GCC_PLUGIN_SANCOV) += sancov_plugin.so gcc-plugin-$(CONFIG_GCC_PLUGIN_STRUCTLEAK) += structleak_plugin.so gcc-plugin-cflags-$(CONFIG_GCC_PLUGIN_STRUCTLEAK_VERBOSE) \ += -fplugin-arg-structleak_plugin-verbose +gcc-plugin-cflags-$(CONFIG_GCC_PLUGIN_STRUCTLEAK_BYREF) \ + += -fplugin-arg-structleak_plugin-byref gcc-plugin-cflags-$(CONFIG_GCC_PLUGIN_STRUCTLEAK_BYREF_ALL) \ += -fplugin-arg-structleak_plugin-byref-all gcc-plugin-cflags-$(CONFIG_GCC_PLUGIN_STRUCTLEAK) \
scripts/gcc-plugins/Kconfig +47 -11
74 lines not on this page · raw message
scripts/gcc-plugins/structleak_plugin.c +25 -11
@@ -16,6 +16,7 @@* Options: * -fplugin-arg-structleak_plugin-disable * -fplugin-arg-structleak_plugin-verbose +* -fplugin-arg-structleak_plugin-byref * -fplugin-arg-structleak_plugin-byref-all * * Usage:
@@ -26,7 +27,6 @@* $ gcc -fplugin=./structleak_plugin.so test.c -O2 * * TODO: eliminate redundant initializers -* increase type coverage */ #include "gcc-common.h"
@@ -37,13 +37,18 @@ __visible int plugin_is_GPL_compatible;static struct plugin_info structleak_plugin_info = { - .version ="201607271510vanilla" , + .version ="20190125vanilla" , .help ="disable\tdo not activate plugin\n" -"verbose\tprint all initialized variables\n" , +"byref\tinit structs passed by reference\n" +"byref-all\tinit anything passed by reference\n" +"verbose\tprint all initialized variables\n" , }; +#define BYREF_STRUCT 1 +#define BYREF_ALL 2 +static bool verbose; -static bool byref_all; +static int byref;static tree handle_user_attribute (tree *node,tree name,tree args,int flags,bool *no_add_attrs) {
@@ -118,6 +123,7 @@ static void initialize(tree var)gimple_stmt_iterator gsi;tree initializer;gimple init_stmt; +tree type;/* this is the original entry bb before the forced split */ bb =single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun));
@@ -148,11 +154,15 @@ static void initialize(tree var)if (verbose)inform (DECL_SOURCE_LOCATION (var),"%s variable will be forcibly initialized" , - (byref_all &&TREE_ADDRESSABLE (var)) ?"byref" - :"userspace" ); + (byref &&TREE_ADDRESSABLE (var)) ?"byref" + :"userspace" );/* build the initializer expression */ - initializer =build_constructor (TREE_TYPE (var),NULL ); + type =TREE_TYPE (var); +if (AGGREGATE_TYPE_P (type)) + initializer =build_constructor (type,NULL ); +else + initializer =fold_convert (type, integer_zero_node);/* build the initializer stmt */ init_stmt =gimple_build_assign (var, initializer);
@@ -184,13 +194,13 @@ static unsigned int structleak_execute(void)if (!auto_var_in_fn_p (var, current_function_decl))continue ; -/* only care about structure types */ -if (TREE_CODE (type) !=RECORD_TYPE &&TREE_CODE (type) !=UNION_TYPE ) +/* only care about structure types unless byref-all */ +if (byref !=BYREF_ALL &&TREE_CODE (type) !=RECORD_TYPE &&TREE_CODE (type) !=UNION_TYPE )continue ;/* if the type is of interest, examine the variable */ if (TYPE_USERSPACE (type) || - (byref_all &&TREE_ADDRESSABLE (var))) + (byref &&TREE_ADDRESSABLE (var)))initialize (var); }
@@ -232,8 +242,12 @@ __visible int plugin_init(struct plugin_name_args *plugin_info, struct plugin_gc verbose = true;continue ; } +if (!strcmp (argv[i].key,"byref" )) { + byref =BYREF_STRUCT ; +continue ; + }if (!strcmp (argv[i].key,"byref-all" )) { - byref_all = true; + byref =BYREF_ALL ;continue ; }error (G_ ("unknown option '-fplugin-arg-%s-%s'" ), plugin_name, argv[i].key);
Signature · 1 line
2.17.1
Quoted 10 lines · Kees Cook
This adjusts structleak to also work with non-struct types when they are passed by reference, since those variables may leak just like anything else. This is exposed via an improved set of
Kconfigoptions. (This does mean structleak is slightly misnamed now.)Building with
CONFIG_GCC_PLUGIN_STRUCTLEAK_BYREF_ALLshould give the kernel complete initialization coverage of all stack variables passed by reference, including padding (seelib/test_stackinit.c).
Quoted 8 lines
Using
CONFIG_GCC_PLUGIN_STRUCTLEAK_VERBOSEto count added initializations under defconfig:..._BYREF: 5945 added initializations
..._BYREF_ALL: 16606 added initializationsThere is virtually no change to text+data size (both have less than 0.05% growth):
I just resumed my randconfig build testing after a longer break, and found a regression for stack usage that I bisected to your change. It shows up in a variety of files depending on the configuration, so far the worst one is the configuration at https://pastebin.com/UK54qbKa that leads to
../drivers/media/dvb-frontends/stv090x.c: In function 'stv090x_start_search':../drivers/media/dvb-frontends/stv090x.c:1595:1: error: the frame size of 5320 bytes is larger than 2048 bytes [-Werror=frame-larger-than=] ../drivers/media/dvb-frontends/stv090x.c: In function 'stv090x_optimize_track':../drivers/media/dvb-frontends/stv090x.c:3090:1: error: the frame size of 5872 bytes is larger than 2048 bytes [-Werror=frame-larger-than=] ../drivers/media/dvb-frontends/stv090x.c: In function 'stv090x_algo':../drivers/media/dvb-frontends/stv090x.c:3431:1: error: the frame size of 5144 bytes is larger than 2048 bytes [-Werror=frame-larger-than=]
}
At least for this specific file, I also see a significant (though not alarming) increase in code size:
text data bss dec hex filename
179196 4632 256 184084 2cf14obj-x86/drivers/media/dvb-frontends/stv090x-before.o
216740 4632 256 221628 361bcobj-x86/drivers/media/dvb-frontends/stv090x-after.o
Part of the problem here is definitely interaction with the asan-stack sanitizer. Changing asan-stack=1 to asan-stack=0, it looks a lot better:
../drivers/media/dvb-frontends/stv090x.c: In function 'stv090x_start_search':../drivers/media/dvb-frontends/stv090x.c:1595:1: warning: the frame size of 120 bytes is larger than 20 bytes [-Wframe-larger-than=] ../drivers/media/dvb-frontends/stv090x.c: In function 'stv090x_optimize_track':../drivers/media/dvb-frontends/stv090x.c:3090:1: warning: the frame size of 168 bytes is larger than 20 bytes [-Wframe-larger-than=] ../drivers/media/dvb-frontends/stv090x.c: In function 'stv090x_algo':../drivers/media/dvb-frontends/stv090x.c:3431:1: warning: the frame size of 192 bytes is larger than 20 bytes [-Wframe-larger-than=]
text data bss dec hex filename
184061 4632 256 188949 2e215obj-x86/drivers/media/dvb-frontends/stv090x.o
I get similar results with asan-stack=1 but without your plugin, only the combination of the two has the explosive stack size growth.
I can help analyze this further, but maybe you can have a look first, there might be something obvious when you read the input to the plugin.
Arnd
Quoted 64 lines · Arnd Bergmann
Quoted 10 lines · Kees Cook
This adjusts structleak to also work with non-struct types when they are passed by reference, since those variables may leak just like anything else. This is exposed via an improved set of
Kconfigoptions. (This does mean structleak is slightly misnamed now.)Building with
CONFIG_GCC_PLUGIN_STRUCTLEAK_BYREF_ALLshould give the kernel complete initialization coverage of all stack variables passed by reference, including padding (seelib/test_stackinit.c).Quoted 8 lines
Using
CONFIG_GCC_PLUGIN_STRUCTLEAK_VERBOSEto count added initializations under defconfig:..._BYREF: 5945 added initializations
..._BYREF_ALL: 16606 added initializationsThere is virtually no change to text+data size (both have less than 0.05% growth):
I just resumed my randconfig build testing after a longer break, and found a regression for stack usage that I bisected to your change. It shows up in a variety of files depending on the configuration, so far the worst one is the configuration at https://pastebin.com/UK54qbKa that leads to
../drivers/media/dvb-frontends/stv090x.c: In function 'stv090x_start_search':../drivers/media/dvb-frontends/stv090x.c:1595:1: error: the frame size of 5320 bytes is larger than 2048 bytes [-Werror=frame-larger-than=]../drivers/media/dvb-frontends/stv090x.c: In function 'stv090x_optimize_track':../drivers/media/dvb-frontends/stv090x.c:3090:1: error: the frame size of 5872 bytes is larger than 2048 bytes [-Werror=frame-larger-than=]../drivers/media/dvb-frontends/stv090x.c: In function 'stv090x_algo':../drivers/media/dvb-frontends/stv090x.c:3431:1: error: the frame size of 5144 bytes is larger than 2048 bytes [-Werror=frame-larger-than=]
}At least for this specific file, I also see a significant (though not alarming) increase in code size:
text data bss dec hex filename
179196 4632 256 184084 2cf14obj-x86/drivers/media/dvb-frontends/stv090x-before.o
216740 4632 256 221628 361bcobj-x86/drivers/media/dvb-frontends/stv090x-after.oPart of the problem here is definitely interaction with the asan-stack sanitizer. Changing asan-stack=1 to asan-stack=0, it looks a lot better:
../drivers/media/dvb-frontends/stv090x.c: In function 'stv090x_start_search':../drivers/media/dvb-frontends/stv090x.c:1595:1: warning: the frame size of 120 bytes is larger than 20 bytes [-Wframe-larger-than=]../drivers/media/dvb-frontends/stv090x.c: In function 'stv090x_optimize_track':../drivers/media/dvb-frontends/stv090x.c:3090:1: warning: the frame size of 168 bytes is larger than 20 bytes [-Wframe-larger-than=]../drivers/media/dvb-frontends/stv090x.c: In function 'stv090x_algo':../drivers/media/dvb-frontends/stv090x.c:3431:1: warning: the frame size of 192 bytes is larger than 20 bytes [-Wframe-larger-than=]text data bss dec hex filename
184061 4632 256 188949 2e215obj-x86/drivers/media/dvb-frontends/stv090x.o
Quoted 7 lines
I get similar results with asan-stack=1 but without your plugin, only the combination of the two has the explosive stack size growth.
I can help analyze this further, but maybe you can have a look first, there might be something obvious when you read the input to the plugin.
Is this before or after use-after-scope was disabled entirely?
Quoted 4 lines · Ard Biesheuvel
Quoted 2 lines · Arnd Bergmann
I get similar results with asan-stack=1 but without your plugin, only the combination of the two has the explosive stack size growth.
I can look more closely, but I'm not sure it's entirely worth it:
these two may not make sense to build at the same time. (e.g. the use-after-scope config was disallowed to work with this plugin.)
Quoted 6 lines
Quoted 4 lines
I can help analyze this further, but maybe you can have a look first, there might be something obvious when you read the input to the plugin.
Is this before or after use-after-scope was disabled entirely?
I was wondering the same thing, but I assumed it didn't matter: it wasn't possible to use both before it was entirely disabled.
Signature · 1 line
Kees Cook
Quoted 10 lines · Kees Cook
Quoted 4 lines · Ard Biesheuvel
Quoted 2 lines · Arnd Bergmann
I get similar results with asan-stack=1 but without your plugin, only the combination of the two has the explosive stack size growth.
I can look more closely, but I'm not sure it's entirely worth it:
these two may not make sense to build at the same time. (e.g. the use-after-scope config was disallowed to work with this plugin.)
Well, I still want to make sure all 'randconfig' builds complete without warnings, and without having to turn off the otherwise useful stack overflow warnings.
One thing I noticed is that your patch removes the 'depends on !COMPILE_TEST' check for GCC_PLUGIN_STRUCTLEAK_BYREF_ALL, so if we add that back in, it would at least take care of the allmodconfig and randconfig cases.
Quoted 9 lines
Quoted 6 lines
Quoted 4 lines
I can help analyze this further, but maybe you can have a look first, there might be something obvious when you read the input to the plugin.
Is this before or after use-after-scope was disabled entirely?
I was wondering the same thing, but I assumed it didn't matter: it wasn't possible to use both before it was entirely disabled.
Right. I already had the use-after-scope stuff disabled for build testing, using the same 'depends on !COMPILE_TEST' check, so one more reason it did not make a difference.
Arnd
Quoted 13 lines · Arnd Bergmann
Quoted 10 lines · Kees Cook
Quoted 4 lines · Ard Biesheuvel
Quoted 2 lines · Arnd Bergmann
I get similar results with asan-stack=1 but without your plugin, only the combination of the two has the explosive stack size growth.
I can look more closely, but I'm not sure it's entirely worth it:
these two may not make sense to build at the same time. (e.g. the use-after-scope config was disallowed to work with this plugin.)
Quoted 8 lines
Well, I still want to make sure all 'randconfig' builds complete without warnings, and without having to turn off the otherwise useful stack overflow warnings.
One thing I noticed is that your patch removes the 'depends on !COMPILE_TEST' check for
GCC_PLUGIN_STRUCTLEAK_BYREF_ALL, so if we add that back in, it would at least take care of the allmodconfig and randconfig cases.
Okay, I'll add this back in the next few days.
Signature · 1 line
Kees Cook
Hello Kees, hello everyone,
Quoted 3 lines · Kees Cook
Building with
CONFIG_GCC_PLUGIN_STRUCTLEAK_BYREF_ALLshould give the kernel complete initialization coverage of all stack variables passed by reference, including padding (seelib/test_stackinit.c).
I would like to note that new STRUCTLEAK_BYREF_ALL initializes *less* stack variables than STACKINIT, that was introduced earlier:
https://www.openwall.com/lists/kernel-hardening/2019/01/23/3
Citing the patches:
- the STACKINIT plugin "attempts to perform unconditional initialization of all stack variables";
- the STRUCTLEAK_BYREF_ALL feature "gives the kernel complete initialization coverage of all stack variables passed by reference".
I.e. stack variables not passed by reference are not initialized by STRUCTLEAK_BYREF_ALL.
Kees, what do you think about adding such cases to your lib/test_stackinit.c? This simple example demonstrates the idea:
lib/test_stackinit.c +9 -0
@@ -320,9 +320,18 @@ static noinline __init int leaf_switch_2_none(unsigned long sp, bool fill,DEFINE_TEST_DRIVER (switch_1_none, uint64_t,SCALAR );DEFINE_TEST_DRIVER (switch_2_none, uint64_t,SCALAR ); +struct x { +int x1; +int x2; +int x3; +}; +static int __init test_stackinit_init (void ) {unsigned int failures =0 ; +struct x _x; + +printk ("uninitialized struct fields sum: %d\n" , _x.x1 + _x.x2 + _x.x3);#define test_scalars (init) do { \ failures += test_u8_ ## init (); \
Kernel output:
root@vm:~# insmod /lib/modules/5.0.0+/kernel/lib/test_stackinit.ko [ 40.534622] uninitialized struct fields sum: -727800841
Best regards,
Alexander
Quoted 11 lines · Alexander Popov
Hello Kees, hello everyone,
Quoted 3 lines · Kees Cook
Building with
CONFIG_GCC_PLUGIN_STRUCTLEAK_BYREF_ALLshould give the kernel complete initialization coverage of all stack variables passed by reference, including padding (seelib/test_stackinit.c).I would like to note that new
STRUCTLEAK_BYREF_ALLinitializes *less* stack variables than STACKINIT, that was introduced earlier:
https://www.openwall.com/lists/kernel-hardening/2019/01/23/3
Quoted 5 lines
Citing the patches:
- the STACKINIT plugin "attempts to perform unconditional initialization of all stack variables";
- theSTRUCTLEAK_BYREF_ALLfeature "gives the kernel complete initialization coverage of all stack variables passed by reference".
That's true, yes. STACKINIT was a port of Florian's patch to gcc which looked only for missing initialization. However, this collides with warnings about missing initialization. :)
So, given the case that the kernel builds with -Wuninitialized and -Wmaybe-uninitialized, the preferred method of dealing with non-by-reference missed initializations is to fix the code itself. (i.e. kernel builds are expected to build without warnings.) It's only the byref cases that there is no warning (and most authors refuse to initialize such cases). Have there been security flaws where gcc failed to warn a missed initialization that wasn't a byref case?
Quoted 2 lines
I.e. stack variables not passed by reference are not initialized by
STRUCTLEAK_BYREF_ALL.
Correct.
Quoted 14 lines
Kees, what do you think about adding such cases to your
lib/test_stackinit.c? This simple example demonstrates the idea:lib/test_stackinit.c +2
-0@@ -320,9 +320,18 @@ static noinline __init int leaf_switch_2_none(unsigned long sp, bool fill,DEFINE_TEST_DRIVER (switch_1_none, uint64_t,SCALAR );DEFINE_TEST_DRIVER (switch_2_none, uint64_t,SCALAR ); +struct x { +int x1;
lib/test_stackinit.c static noinline __init int leaf_switch_2_none(unsigned long sp, bool fill, · line 334
Quoted 10 lines
lib/test_stackinit.c +7
-0+int x2; +int x3; +}; +static int __init test_stackinit_init (void ) {unsigned int failures =0 ; +struct x _x; + +printk ("uninitialized struct fields sum: %d\n" , _x.x1 + _x.x2 + _x.x3);
This would trip the build warnings:
In file included from ./include/linux/kernel.h:15:0,
from lib/test_stackinit.c:9:lib/test_stackinit.c: In function ‘test_stackinit_init’:./include/linux/printk.h:309:2: warning: ‘__x.x1’ is used uninitialized in this function [-Wuninitialized]
printk(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__) ^~~~~~
but those could be silenced for this object specifically if we really wanted to add it. I think it'd be fine to add this to the test, but it's a known state, though, so I hadn't bothered with it.
Signature · 1 line
Kees Cook
PATCH 2/2 lib: Introduce test_stackinit module
In reply to Kees CookAdds test for stack initialization coverage. We have several build options that control the level of stack variable initialization. This test lets us visualize which options cover which cases, and provide tests for some of the pathological padding conditions the compiler will sometimes fail to initialize.
All options pass the explicit initialization cases and the partial initializers (even with padding):
test_stackinit: u8_zero oktest_stackinit: u16_zero oktest_stackinit: u32_zero oktest_stackinit: u64_zero oktest_stackinit: char_array_zero oktest_stackinit: small_hole_zero oktest_stackinit: big_hole_zero oktest_stackinit: trailing_hole_zero oktest_stackinit: packed_zero oktest_stackinit: small_hole_dynamic_partial oktest_stackinit: big_hole_dynamic_partial oktest_stackinit: trailing_hole_dynamic_partial oktest_stackinit: packed_dynamic_partial oktest_stackinit: small_hole_static_partial oktest_stackinit: big_hole_static_partial oktest_stackinit: trailing_hole_static_partial oktest_stackinit: packed_static_partial oktest_stackinit: packed_static_all oktest_stackinit: packed_dynamic_all oktest_stackinit: packed_runtime_all ok
The results of the other tests (which contain no explicit initialization), change based on the build's configured compiler instrumentation.
No options:
test_stackinit: small_hole_static_all FAIL (uninit bytes: 3)test_stackinit: big_hole_static_all FAIL (uninit bytes: 61)test_stackinit: trailing_hole_static_all FAIL (uninit bytes: 7)test_stackinit: small_hole_dynamic_all FAIL (uninit bytes: 3)test_stackinit: big_hole_dynamic_all FAIL (uninit bytes: 61)test_stackinit: trailing_hole_dynamic_all FAIL (uninit bytes: 7)test_stackinit: small_hole_runtime_partial FAIL (uninit bytes: 23)test_stackinit: big_hole_runtime_partial FAIL (uninit bytes: 127)test_stackinit: trailing_hole_runtime_partial FAIL (uninit bytes: 24)test_stackinit: packed_runtime_partial FAIL (uninit bytes: 24)test_stackinit: small_hole_runtime_all FAIL (uninit bytes: 3)test_stackinit: big_hole_runtime_all FAIL (uninit bytes: 61)test_stackinit: trailing_hole_runtime_all FAIL (uninit bytes: 7)test_stackinit: u8_none FAIL (uninit bytes: 1)test_stackinit: u16_none FAIL (uninit bytes: 2)test_stackinit: u32_none FAIL (uninit bytes: 4)test_stackinit: u64_none FAIL (uninit bytes: 8)test_stackinit: char_array_none FAIL (uninit bytes: 16)test_stackinit: switch_1_none FAIL (uninit bytes: 8)test_stackinit: switch_2_none FAIL (uninit bytes: 8)test_stackinit: small_hole_none FAIL (uninit bytes: 24)test_stackinit: big_hole_none FAIL (uninit bytes: 128)test_stackinit: trailing_hole_none FAIL (uninit bytes: 32)test_stackinit: packed_none FAIL (uninit bytes: 32)test_stackinit: user FAIL (uninit bytes: 32)test_stackinit: failures: 25
CONFIG_GCC_PLUGIN_STRUCTLEAK_USER=y
This only tries to initialize structs with __user markings, so only the difference from above is now the "user" test passes:
test_stackinit: small_hole_static_all FAIL (uninit bytes: 3)test_stackinit: big_hole_static_all FAIL (uninit bytes: 61)test_stackinit: trailing_hole_static_all FAIL (uninit bytes: 7)test_stackinit: small_hole_dynamic_all FAIL (uninit bytes: 3)test_stackinit: big_hole_dynamic_all FAIL (uninit bytes: 61)test_stackinit: trailing_hole_dynamic_all FAIL (uninit bytes: 7)test_stackinit: small_hole_runtime_partial FAIL (uninit bytes: 23)test_stackinit: big_hole_runtime_partial FAIL (uninit bytes: 127)test_stackinit: trailing_hole_runtime_partial FAIL (uninit bytes: 24)test_stackinit: packed_runtime_partial FAIL (uninit bytes: 24)test_stackinit: small_hole_runtime_all FAIL (uninit bytes: 3)test_stackinit: big_hole_runtime_all FAIL (uninit bytes: 61)test_stackinit: trailing_hole_runtime_all FAIL (uninit bytes: 7)test_stackinit: u8_none FAIL (uninit bytes: 1)test_stackinit: u16_none FAIL (uninit bytes: 2)test_stackinit: u32_none FAIL (uninit bytes: 4)test_stackinit: u64_none FAIL (uninit bytes: 8)test_stackinit: char_array_none FAIL (uninit bytes: 16)test_stackinit: switch_1_none FAIL (uninit bytes: 8)test_stackinit: switch_2_none FAIL (uninit bytes: 8)test_stackinit: small_hole_none FAIL (uninit bytes: 24)test_stackinit: big_hole_none FAIL (uninit bytes: 128)test_stackinit: trailing_hole_none FAIL (uninit bytes: 32)test_stackinit: packed_none FAIL (uninit bytes: 32)test_stackinit: user oktest_stackinit: failures: 24
CONFIG_GCC_PLUGIN_STRUCTLEAK_BYREF=y
This initializes all structures passed by reference (scalars and strings remain uninitialized):
test_stackinit: small_hole_static_all oktest_stackinit: big_hole_static_all oktest_stackinit: trailing_hole_static_all oktest_stackinit: small_hole_dynamic_all oktest_stackinit: big_hole_dynamic_all oktest_stackinit: trailing_hole_dynamic_all oktest_stackinit: small_hole_runtime_partial oktest_stackinit: big_hole_runtime_partial oktest_stackinit: trailing_hole_runtime_partial oktest_stackinit: packed_runtime_partial oktest_stackinit: small_hole_runtime_all oktest_stackinit: big_hole_runtime_all oktest_stackinit: trailing_hole_runtime_all oktest_stackinit: u8_none FAIL (uninit bytes: 1)test_stackinit: u16_none FAIL (uninit bytes: 2)test_stackinit: u32_none FAIL (uninit bytes: 4)test_stackinit: u64_none FAIL (uninit bytes: 8)test_stackinit: char_array_none FAIL (uninit bytes: 16)test_stackinit: switch_1_none FAIL (uninit bytes: 8)test_stackinit: switch_2_none FAIL (uninit bytes: 8)test_stackinit: small_hole_none oktest_stackinit: big_hole_none oktest_stackinit: trailing_hole_none oktest_stackinit: packed_none oktest_stackinit: user oktest_stackinit: failures: 7
CONFIG_GCC_PLUGIN_STRUCTLEAK_BYREF_ALL=y
This initializes all variables, so it matches above with the scalars and arrays included:
test_stackinit: small_hole_static_all oktest_stackinit: big_hole_static_all oktest_stackinit: trailing_hole_static_all oktest_stackinit: small_hole_dynamic_all oktest_stackinit: big_hole_dynamic_all oktest_stackinit: trailing_hole_dynamic_all oktest_stackinit: small_hole_runtime_partial oktest_stackinit: big_hole_runtime_partial oktest_stackinit: trailing_hole_runtime_partial oktest_stackinit: packed_runtime_partial oktest_stackinit: small_hole_runtime_all oktest_stackinit: big_hole_runtime_all oktest_stackinit: trailing_hole_runtime_all oktest_stackinit: u8_none oktest_stackinit: u16_none oktest_stackinit: u32_none oktest_stackinit: u64_none oktest_stackinit: char_array_none oktest_stackinit: switch_1_none oktest_stackinit: switch_2_none oktest_stackinit: small_hole_none oktest_stackinit: big_hole_none oktest_stackinit: trailing_hole_none oktest_stackinit: packed_none oktest_stackinit: user oktest_stackinit: all tests passed!
--- lib/Kconfig.debug | 10 ++ lib/Makefile | 1 + lib/test_stackinit.c | 378 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 389 insertions(+) create mode 100644 lib/test_stackinit.c
lib/Kconfig.debug +10 -0
@@ -2001,6 +2001,16 @@ config TEST_OBJAGG If unsure, say N. +config TEST_STACKINIT + tristate "Test level of stack variable initialization" + help + Test if the kernel is zero-initializing stack variables and + padding. Coverage is controlled by compiler flags, + CONFIG_GCC_PLUGIN_STRUCTLEAK, CONFIG_GCC_PLUGIN_STRUCTLEAK_BYREF, + or CONFIG_GCC_PLUGIN_STRUCTLEAK_BYREF_ALL. + + If unsure, say N. + endif # RUNTIME_TESTING_MENU config MEMTEST
lib/Makefile +1 -0
@@ -76,6 +76,7 @@ obj-$(CONFIG_TEST_KMOD) += test_kmod.o obj-$(CONFIG_TEST_DEBUG_VIRTUAL) += test_debug_virtual.o obj-$(CONFIG_TEST_MEMCAT_P) += test_memcat_p.o obj-$(CONFIG_TEST_OBJAGG) += test_objagg.o +obj-$(CONFIG_TEST_STACKINIT) += test_stackinit.o ifeq ($(CONFIG_DEBUG_KOBJECT),y) CFLAGS_kobject.o += -DDEBUG
lib/test_stackinit.c new file +378 -0
378 lines not on this page · raw message
Signature · 1 line
2.17.1
Re: [PATCH 2/2] lib: Introduce test_stackinit module
Hi Kees,
Quoted 5 lines · Kees Cook
Adds test for stack initialization coverage. We have several build options that control the level of stack variable initialization. This test lets us visualize which options cover which cases, and provide tests for some of the pathological padding conditions the compiler will sometimes fail to initialize.
With current upstream, using gcc Ubuntu 8.2.0-1ubuntu2~18.04, I get on m68k:
test_stackinit: u8_zero: stack fill missed target!?test_stackinit: u8_zero: fill 1 widetest_stackinit: u8_zero: target offset by 20test_stackinit: u16_zero: stack fill missed target!?test_stackinit: u16_zero: fill 2 widetest_stackinit: u16_zero: target offset by 20test_stackinit: u32_zero: stack fill missed target!?test_stackinit: u32_zero: fill 4 widetest_stackinit: u32_zero: target offset by 20test_stackinit: u64_zero: stack fill missed target!?test_stackinit: u64_zero: fill 8 widetest_stackinit: u64_zero: target offset by 20test_stackinit: char_array_zero: stack fill missed target!?test_stackinit: char_array_zero: fill 16 widetest_stackinit: char_array_zero: target offset by -12test_stackinit: small_hole_zero: stack fill missed target!?test_stackinit: small_hole_zero: fill 14 widetest_stackinit: small_hole_zero: target offset by -12test_stackinit: big_hole_zero oktest_stackinit: trailing_hole_zero: stack fill missed target!?test_stackinit: trailing_hole_zero: fill 14 widetest_stackinit: trailing_hole_zero: target offset by -12test_stackinit: packed_zero: stack fill missed target!?test_stackinit: packed_zero: fill 16 widetest_stackinit: packed_zero: target offset by -12test_stackinit: small_hole_dynamic_partial: stack fill missed target!?test_stackinit: small_hole_dynamic_partial: fill 14 widetest_stackinit: small_hole_dynamic_partial: target offset by -12test_stackinit: big_hole_dynamic_partial oktest_stackinit: trailing_hole_dynamic_partial: stack fill missed target!?test_stackinit: trailing_hole_dynamic_partial: fill 14 widetest_stackinit: trailing_hole_dynamic_partial: target offset by -12test_stackinit: packed_dynamic_partial: stack fill missed target!?test_stackinit: packed_dynamic_partial: fill 16 widetest_stackinit: packed_dynamic_partial: target offset by -12test_stackinit: small_hole_static_partial: stack fill missed target!?test_stackinit: small_hole_static_partial: fill 14 widetest_stackinit: small_hole_static_partial: target offset by -12test_stackinit: big_hole_static_partial oktest_stackinit: trailing_hole_static_partial: stack fill missed target!?test_stackinit: trailing_hole_static_partial: fill 14 widetest_stackinit: trailing_hole_static_partial: target offset by -12test_stackinit: packed_static_partial: stack fill missed target!?test_stackinit: packed_static_partial: fill 16 widetest_stackinit: packed_static_partial: target offset by -12test_stackinit: small_hole_static_all: stack fill missed target!?test_stackinit: small_hole_static_all: fill 14 widetest_stackinit: small_hole_static_all: target offset by -12test_stackinit: big_hole_static_all FAIL (uninit bytes: 61)test_stackinit: trailing_hole_static_all: stack fill missed target!?test_stackinit: trailing_hole_static_all: fill 14 widetest_stackinit: trailing_hole_static_all: target offset by -12test_stackinit: packed_static_all: stack fill missed target!?test_stackinit: packed_static_all: fill 16 widetest_stackinit: packed_static_all: target offset by -12test_stackinit: small_hole_dynamic_all: stack fill missed target!?test_stackinit: small_hole_dynamic_all: fill 14 widetest_stackinit: small_hole_dynamic_all: target offset by -12test_stackinit: big_hole_dynamic_all FAIL (uninit bytes: 61)test_stackinit: trailing_hole_dynamic_all: stack fill missed target!?test_stackinit: trailing_hole_dynamic_all: fill 14 widetest_stackinit: trailing_hole_dynamic_all: target offset by -12test_stackinit: packed_dynamic_all: stack fill missed target!?test_stackinit: packed_dynamic_all: fill 16 widetest_stackinit: packed_dynamic_all: target offset by -12test_stackinit: small_hole_runtime_partial: stack fill missed target!?test_stackinit: small_hole_runtime_partial: fill 14 widetest_stackinit: small_hole_runtime_partial: target offset by -12test_stackinit: big_hole_runtime_partial FAIL (uninit bytes: 127)test_stackinit: trailing_hole_runtime_partial: stack fill missed target!?test_stackinit: trailing_hole_runtime_partial: fill 14 widetest_stackinit: trailing_hole_runtime_partial: target offset by -12test_stackinit: packed_runtime_partial: stack fill missed target!?test_stackinit: packed_runtime_partial: fill 16 widetest_stackinit: packed_runtime_partial: target offset by -12test_stackinit: small_hole_runtime_all: stack fill missed target!?test_stackinit: small_hole_runtime_all: fill 14 widetest_stackinit: small_hole_runtime_all: target offset by -12test_stackinit: big_hole_runtime_all FAIL (uninit bytes: 61)test_stackinit: trailing_hole_runtime_all: stack fill missed target!?test_stackinit: trailing_hole_runtime_all: fill 14 widetest_stackinit: trailing_hole_runtime_all: target offset by -12test_stackinit: packed_runtime_all: stack fill missed target!?test_stackinit: packed_runtime_all: fill 16 widetest_stackinit: packed_runtime_all: target offset by -12test_stackinit: u8_none: stack fill missed target!?test_stackinit: u8_none: fill 1 widetest_stackinit: u8_none: target offset by 20test_stackinit: u16_none: stack fill missed target!?test_stackinit: u16_none: fill 2 widetest_stackinit: u16_none: target offset by 20test_stackinit: u32_none: stack fill missed target!?test_stackinit: u32_none: fill 4 widetest_stackinit: u32_none: target offset by 20test_stackinit: u64_none: stack fill missed target!?test_stackinit: u64_none: fill 8 widetest_stackinit: u64_none: target offset by 20test_stackinit: char_array_none: stack fill missed target!?test_stackinit: char_array_none: fill 16 widetest_stackinit: char_array_none: target offset by -12test_stackinit: switch_1_none: stack fill missed target!?test_stackinit: switch_1_none: fill 8 widetest_stackinit: switch_1_none: target offset by 16test_stackinit: switch_2_none: stack fill missed target!?test_stackinit: switch_2_none: fill 8 widetest_stackinit: switch_2_none: target offset by 16test_stackinit: small_hole_none: stack fill missed target!?test_stackinit: small_hole_none: fill 14 widetest_stackinit: small_hole_none: target offset by -12test_stackinit: big_hole_none FAIL (uninit bytes: 128)test_stackinit: trailing_hole_none: stack fill missed target!?test_stackinit: trailing_hole_none: fill 14 widetest_stackinit: trailing_hole_none: target offset by -12test_stackinit: packed_none: stack fill missed target!?test_stackinit: packed_none: fill 16 widetest_stackinit: packed_none: target offset by -12test_stackinit: user: stack fill missed target!?test_stackinit: user: fill 14 widetest_stackinit: user: target offset by -12test_stackinit: failures: 42
Any idea what is wrong? I find the test code a bit hard to understand...
Also, I see comments making assumptions that are not true:
struct test_small_hole {
size_t one;
char two;
/* 3 byte padding hole here. */
int three;
unsigned long four;
};On m68k (and a few other architectures), integrals of 16-bit and larger are aligned to a 2-byte address, so the padding may be only a single byte.
Thanks!
Gr{oetje,eeting}s,
Geert
Signature · 5 lines
Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- [email protected] In personal conversations with technical people, I call myself a hacker. But when I'm talking to journalists I just say "programmer" or something like that. -- Linus Torvalds
Re: [PATCH 2/2] lib: Introduce test_stackinit module
Quoted 4 lines · Geert Uytterhoeven
Hi Kees,
On Tue, Feb 12, 2019 at 7:08 PM Kees Cook <[email protected]> wrote:
Quoted 8 lines
Quoted 5 lines
Adds test for stack initialization coverage. We have several build options that control the level of stack variable initialization. This test lets us visualize which options cover which cases, and provide tests for some of the pathological padding conditions the compiler will sometimes fail to initialize.
With current upstream, using gcc Ubuntu 8.2.0-1ubuntu2~18.04, I get on m68k:
Thanks for testing this on other architectures!
Quoted 1 line
test_stackinit:u8_zero: stack fill missed target!?
Hmpf. That's frustrating. That implies that the leaf function is assembled in such a way that the "leaking" memory address and the "controlled" memory address on the stack end up in different locations. I had a lot of problems with this before I unified my leaf function. I wonder if some inlining is happening with the m68k compiler that I haven't accounted for?
Quoted 1 line
Any idea what is wrong? I find the test code a bit hard to understand...
Yeah, there was a lot of repetition, so I tried to save my sanity and build macros. The particular problem above is with the "test_..."'s call of the "leaf_..." functions:
/* Fill stack with 0xFF. */ \
ignored = leaf_ ##name((unsigned long)&ignored, 1, \
FETCH_ARG_ ## which(zero)); \
/* Clear entire check buffer for later bit tests. */ \
memset(check_buf, 0x00, sizeof(check_buf)); \
/* Extract stack-defined variable contents. */ \
ignored = leaf_ ##name((unsigned long)&ignored, 0, \
FETCH_ARG_ ## which(zero)); \those two leaf_* invocations should produce stack variables at the same location on the stack:
var_type var INIT_ ## which ## _ ## init_level; \
\
target_start = &var; \
target_size = sizeof(var); \
/* \
* Keep this buffer around to make sure we've got a \
* stack frame of SOME kind... \
*/ \
memset(buf, (char)(sp && 0xff), sizeof(buf)); \
/* Fill variable with 0xFF. */ \
if (fill) { \
fill_start = &var; \
fill_size = sizeof(var); \(note "target_start" and "fill_start" being assigned the location of (in theory) the same stack location)
This gets checked later:
/* Validate that compiler lined up fill and target. */ \
if (!range_contains(fill_start, fill_size, \
target_start, target_size)) { \
pr_err(#name ": stack fill missed target!?\n"); \
pr_err(#name ": fill %zu wide\n", fill_size); \
pr_err(#name ": target offset by %d\n", \
(int)((ssize_t)(uintptr_t)fill_start - \
(ssize_t)(uintptr_t)target_start)); \
return 1; \which is where you're seeing the report.
Quoted 10 lines
Also, I see comments making assumptions that are not true:
struct test_small_hole { size_t one; char two; /* 3 byte padding hole here. */ int three; unsigned long four; };
Quoted 2 lines
On m68k (and a few other architectures), integrals of 16-bit and larger are aligned to a 2-byte address, so the padding may be only a single byte.
Ah! Good point. I can update the comments, but the test should still be valid (it just has a smaller hole).
Thanks again!
Signature · 1 line
Kees Cook
Quoted 9 lines · Kees Cook
Instead of a new plugin for stack initialization[1], this improves structleak to handle initialization of all variable types. Since the instrumentation happens at a different point, the "switch" statement changes from the earlier posting[2] are no longer needed. As before, this also introduces a stack initialization regression testing module to validate various kinds of stack variable usage vs compiler instrumentation for initialization. See the individual patches for more details.
For the series,
(although I reviewed 2/2 only cursorily)
Quoted 19 lines
[1] https://lkml.kernel.org/r/CA+55aFykZL+cSBJjBBts7ebEFfyGPdMzTmLSxKnT_29=j942dA@mail.gmail.com
[2] https://lkml.kernel.org/r/[email protected]Kees Cook (2):
gcc-plugins: structleak: Generalize to all variable types
lib: Introducetest_stackinitmodulelib/Kconfig.debug | 10 + lib/Makefile | 1 + lib/test_stackinit.c | 378 ++++++++++++++++++++++++ scripts/Makefile.gcc-plugins | 2 + scripts/gcc-plugins/Kconfig | 58 +++- scripts/gcc-plugins/structleak_plugin.c | 36 ++- 6 files changed, 463 insertions(+), 22 deletions(-) create mode 100644 lib/test_stackinit.c--
2.17.1