Allow to exclude specific file types in LoadPin
Subsystems (3)
PATCH 1/1 Allow to exclude specific file types in LoadPin
Linux kernel already provide MODULE_SIG and KEXEC_VERIFY_SIG to make sure loaded kernel module and kernel image are trusted. This patch adds a kernel command line option "loadpin.exclude" which allows to exclude specific file types from LoadPin. This is useful when people want to use different mechanisms to verify module and kernel image while still use LoadPin to protect the integrity of other files kernel loads.
--- Documentation/admin-guide/LSM/LoadPin.rst | 10 ++++++ security/loadpin/loadpin.c | 37 +++++++++++++++++++++++ 2 files changed, 47 insertions(+)
Documentation/admin-guide/LSM/LoadPin.rst +10 -0
@@ -19,3 +19,13 @@ block device backing the filesystem is not read-only, a sysctl is created to toggle pinning: ``/proc/sys/kernel/loadpin/enabled``. (Having a mutable filesystem means pinning is mutable too, but having the sysctl allows for easy testing on systems with a mutable filesystem.) + +It's also possible to exclude specific file types from LoadPin using kernel +command line option "``loadpin.exclude``". By default, all files are +included, but they can be excluded using kernel command line option such +as "``loadpin.exclude=kernel-module,kexec-image``". This allows to use +different mechanisms such as ``CONFIG_MODULE_SIG`` and +``CONFIG_KEXEC_VERIFY_SIG`` to verify kernel module and kernel image while +still use LoadPin to protect the integrity of other files kernel loads. The +full list of valid file types can be found in ``kernel_read_file_str`` +defined in ``include/linux/fs.h``.
security/loadpin/loadpin.c +37 -0
@@ -45,6 +45,8 @@ static void report_load(const char *origin, struct file *file, char *operation) }static int enforce =IS_ENABLED (CONFIG_SECURITY_LOADPIN_ENFORCE ); +static char *exclude_read_files[READING_MAX_ID ]; +static int ignore_read_file_id[READING_MAX_ID ];static struct super_block *pinned_root;static DEFINE_SPINLOCK (pinned_root_spinlock);
@@ -129,6 +131,12 @@ static int loadpin_read_file(struct file *file, enum kernel_read_file_id id)struct super_block *load_root;const char *origin =kernel_read_file_id_str (id); +/* If the file id is excluded, ignore the pinning. */ +if ((unsigned int )id <READING_MAX_ID && ignore_read_file_id[id]) { +report_load (origin, file,"pinning-excluded" ); +return 0 ; + } +/* This handles the older init_module API that has a NULL file. */ if (!file) {if (!enforce) {
@@ -187,10 +195,37 @@ static struct security_hook_list loadpin_hooks[] __lsm_ro_after_init = { LSM_HOOK_INIT(kernel_load_data, loadpin_load_data), }; +static void parse_exclude (void ) +{ +int i, j; +char *cur; + +for (i =0 ; i <ARRAY_SIZE (exclude_read_files); i++) { + cur = exclude_read_files[i]; +if (!cur) +break ; +if (*cur =='\0' ) +continue ; + +for (j =0 ; j <ARRAY_SIZE (kernel_read_file_str); j++) { +if (strcmp (cur, kernel_read_file_str[j]) ==0 ) { +pr_info ("excluding: %s\n" , + kernel_read_file_str[j]); + ignore_read_file_id[j] =1 ; +/* +* Can not break, because one read_file_str +* may map to more than on read_file_id. +*/ + } + } + } +} +static int __init loadpin_init (void ) {pr_info ("ready to pin (currently %senforcing)\n" , enforce ?"" :"not " ); +parse_exclude ();security_add_hooks (loadpin_hooks,ARRAY_SIZE (loadpin_hooks),"loadpin" );return 0 ; }
@@ -203,3 +238,5 @@ DEFINE_LSM(loadpin) = {/* Should not be mutable after boot, so not listed in sysfs (perm == 0). */ module_param (enforce, int,0 );MODULE_PARM_DESC (enforce,"Enforce module/firmware pinning" ); +module_param_array_named (exclude, exclude_read_files, charp,NULL ,0 ); +MODULE_PARM_DESC (exclude,"Exclude pinning specific read file types" );
Signature · 1 line
2.22.0.rc1.257.g3120a18244-goog
Quoted 7 lines · Ke Wu
Linux kernel already provide
MODULE_SIGandKEXEC_VERIFY_SIGto make sure loaded kernel module and kernel image are trusted. This patch adds a kernel command line option "loadpin.exclude" which allows to exclude specific file types from LoadPin. This is useful when people want to use different mechanisms to verify module and kernel image while still use LoadPin to protect the integrity of other files kernel loads.
Cool; I like this. A few thoughts below...
Quoted 30 lines
Signed-off-by Ke Wu <[email protected]>--- Documentation/admin-guide/LSM/LoadPin.rst | 10 ++++++ security/loadpin/loadpin.c | 37 +++++++++++++++++++++++ 2 files changed, 47 insertions(+)Documentation/admin-guide/LSM/LoadPin.rst +10
-0@@ -19,3 +19,13 @@ block device backing the filesystem is not read-only, a sysctl is created to toggle pinning: ``/proc/sys/kernel/loadpin/enabled``. (Having a mutable filesystem means pinning is mutable too, but having the sysctl allows for easy testing on systems with a mutable filesystem.) + +It's also possible to exclude specific file types from LoadPin using kernel +command line option "``loadpin.exclude``". By default, all files are +included, but they can be excluded using kernel command line option such +as "``loadpin.exclude=kernel-module,kexec-image``". This allows to use +different mechanisms such as ``CONFIG_MODULE_SIG`` and +``CONFIG_KEXEC_VERIFY_SIG`` to verify kernel module and kernel image while +still use LoadPin to protect the integrity of other files kernel loads. The +full list of valid file types can be found in ``kernel_read_file_str`` +defined in ``include/linux/fs.h``.security/loadpin/loadpin.c +0
-0
security/loadpin/loadpin.c static void report_load(const char *origin, struct file *file, char *operation) · line 49
Quoted 5 lines
security/loadpin/loadpin.c +2
-0@@ -45,6 +45,8 @@ static void report_load(const char *origin, struct file *file, char *operation) }static int enforce =IS_ENABLED (CONFIG_SECURITY_LOADPIN_ENFORCE ); +static char *exclude_read_files[READING_MAX_ID ]; +static int ignore_read_file_id[READING_MAX_ID ];
Since this is set up at init, let's mark ignore_read_file_id with __ro_after_init.
security/loadpin/loadpin.c static int loadpin_read_file(struct file *file, enum kernel_read_file_id id) · line 135
Quoted 9 lines
security/loadpin/loadpin.c +2
-0static struct super_block *pinned_root;static DEFINE_SPINLOCK (pinned_root_spinlock);@@ -129,6 +131,12 @@ static int loadpin_read_file(struct file *file, enum kernel_read_file_id id)struct super_block *load_root;const char *origin =kernel_read_file_id_str (id); +/* If the file id is excluded, ignore the pinning. */ +if ((unsigned int )id <READING_MAX_ID && ignore_read_file_id[id]) {
Can you use ARRAY_SIZE(ignore_read_file_id) here instead of READING_MAX_ID?
security/loadpin/loadpin.c static struct security_hook_list loadpin_hooks[] __lsm_ro_after_init = { · line 198
Quoted 12 lines
security/loadpin/loadpin.c +5
-0+report_load (origin, file,"pinning-excluded" ); +return 0 ; + } +/* This handles the older init_module API that has a NULL file. */ if (!file) {if (!enforce) {@@ -187,10 +195,37 @@ static struct security_hook_list loadpin_hooks[] __lsm_ro_after_init = { LSM_HOOK_INIT(kernel_load_data, loadpin_load_data), }; +static void parse_exclude (void )
Please mark this __init (since it's called from another __init function).
Quoted 42 lines
security/loadpin/loadpin.c +28
-0+{ +int i, j; +char *cur; + +for (i =0 ; i <ARRAY_SIZE (exclude_read_files); i++) { + cur = exclude_read_files[i]; +if (!cur) +break ; +if (*cur =='\0' ) +continue ; + +for (j =0 ; j <ARRAY_SIZE (kernel_read_file_str); j++) { +if (strcmp (cur, kernel_read_file_str[j]) ==0 ) { +pr_info ("excluding: %s\n" , + kernel_read_file_str[j]); + ignore_read_file_id[j] =1 ; +/* +* Can not break, because one read_file_str +* may map to more than on read_file_id. +*/ + } + } + } +} +static int __init loadpin_init (void ) {pr_info ("ready to pin (currently %senforcing)\n" , enforce ?"" :"not " ); +parse_exclude ();security_add_hooks (loadpin_hooks,ARRAY_SIZE (loadpin_hooks),"loadpin" );return 0 ; }@@ -203,3 +238,5 @@ DEFINE_LSM(loadpin) = {/* Should not be mutable after boot, so not listed in sysfs (perm == 0). */ module_param (enforce, int,0 );MODULE_PARM_DESC (enforce,"Enforce module/firmware pinning" ); +module_param_array_named (exclude, exclude_read_files, charp,NULL ,0 ); +MODULE_PARM_DESC (exclude,"Exclude pinning specific read file types" );Signature · 1 line
2.22.0.rc1.257.g3120a18244-goog
Everything else looks good; thanks!
Signature · 1 line
Kees Cook
PATCH v2 1/1 Allow to exclude specific file types in LoadPin
In reply to Ke WuLinux kernel already provide MODULE_SIG and KEXEC_VERIFY_SIG to make sure loaded kernel module and kernel image are trusted. This patch adds a kernel command line option "loadpin.exclude" which allows to exclude specific file types from LoadPin. This is useful when people want to use different mechanisms to verify module and kernel image while still use LoadPin to protect the integrity of other files kernel loads.
---
Changelog since v1:
- Mark ignore_read_file_id with __ro_after_init.
- Mark parse_exclude() with __init.
- Use ARRAY_SIZE(ignore_read_file_id) instead of READING_MAX_ID.
Documentation/admin-guide/LSM/LoadPin.rst | 10 ++++++ security/loadpin/loadpin.c | 38 +++++++++++++++++++++++ 2 files changed, 48 insertions(+)
Documentation/admin-guide/LSM/LoadPin.rst +10 -0
@@ -19,3 +19,13 @@ block device backing the filesystem is not read-only, a sysctl is created to toggle pinning: ``/proc/sys/kernel/loadpin/enabled``. (Having a mutable filesystem means pinning is mutable too, but having the sysctl allows for easy testing on systems with a mutable filesystem.) + +It's also possible to exclude specific file types from LoadPin using kernel +command line option "``loadpin.exclude``". By default, all files are +included, but they can be excluded using kernel command line option such +as "``loadpin.exclude=kernel-module,kexec-image``". This allows to use +different mechanisms such as ``CONFIG_MODULE_SIG`` and +``CONFIG_KEXEC_VERIFY_SIG`` to verify kernel module and kernel image while +still use LoadPin to protect the integrity of other files kernel loads. The +full list of valid file types can be found in ``kernel_read_file_str`` +defined in ``include/linux/fs.h``.
security/loadpin/loadpin.c +38 -0
@@ -45,6 +45,8 @@ static void report_load(const char *origin, struct file *file, char *operation) }static int enforce =IS_ENABLED (CONFIG_SECURITY_LOADPIN_ENFORCE ); +static char *exclude_read_files[READING_MAX_ID ]; +static int ignore_read_file_id[READING_MAX_ID ]__ro_after_init ;static struct super_block *pinned_root;static DEFINE_SPINLOCK (pinned_root_spinlock);
@@ -129,6 +131,13 @@ static int loadpin_read_file(struct file *file, enum kernel_read_file_id id)struct super_block *load_root;const char *origin =kernel_read_file_id_str (id); +/* If the file id is excluded, ignore the pinning. */ +if ((unsigned int )id <ARRAY_SIZE (ignore_read_file_id) && + ignore_read_file_id[id]) { +report_load (origin, file,"pinning-excluded" ); +return 0 ; + } +/* This handles the older init_module API that has a NULL file. */ if (!file) {if (!enforce) {
@@ -187,10 +196,37 @@ static struct security_hook_list loadpin_hooks[] __lsm_ro_after_init = { LSM_HOOK_INIT(kernel_load_data, loadpin_load_data), }; +static void __init parse_exclude (void ) +{ +int i, j; +char *cur; + +for (i =0 ; i <ARRAY_SIZE (exclude_read_files); i++) { + cur = exclude_read_files[i]; +if (!cur) +break ; +if (*cur =='\0' ) +continue ; + +for (j =0 ; j <ARRAY_SIZE (kernel_read_file_str); j++) { +if (strcmp (cur, kernel_read_file_str[j]) ==0 ) { +pr_info ("excluding: %s\n" , + kernel_read_file_str[j]); + ignore_read_file_id[j] =1 ; +/* +* Can not break, because one read_file_str +* may map to more than on read_file_id. +*/ + } + } + } +} +static int __init loadpin_init (void ) {pr_info ("ready to pin (currently %senforcing)\n" , enforce ?"" :"not " ); +parse_exclude ();security_add_hooks (loadpin_hooks,ARRAY_SIZE (loadpin_hooks),"loadpin" );return 0 ; }
@@ -203,3 +239,5 @@ DEFINE_LSM(loadpin) = {/* Should not be mutable after boot, so not listed in sysfs (perm == 0). */ module_param (enforce, int,0 );MODULE_PARM_DESC (enforce,"Enforce module/firmware pinning" ); +module_param_array_named (exclude, exclude_read_files, charp,NULL ,0 ); +MODULE_PARM_DESC (exclude,"Exclude pinning specific read file types" );
Signature · 1 line
2.22.0.rc1.257.g3120a18244-goog
Quoted 8 lines · Ke Wu
Linux kernel already provide
MODULE_SIGandKEXEC_VERIFY_SIGto make sure loaded kernel module and kernel image are trusted. This patch adds a kernel command line option "loadpin.exclude" which allows to exclude specific file types from LoadPin. This is useful when people want to use different mechanisms to verify module and kernel image while still use LoadPin to protect the integrity of other files kernel loads.
Quoted 6 lines
Signed-off-by Ke Wu <[email protected]>---
Changelog since v1:
- Markignore_read_file_idwith__ro_after_init.
- Markparse_exclude()with__init.
- UseARRAY_SIZE(ignore_read_file_id)instead ofREADING_MAX_ID.
Looks good!
Signature · 2 lines
James Morris <[email protected]>
Kees Cook
AppliedQuoted 17 lines · James Morris
Quoted 8 lines · Ke Wu
Linux kernel already provide
MODULE_SIGandKEXEC_VERIFY_SIGto make sure loaded kernel module and kernel image are trusted. This patch adds a kernel command line option "loadpin.exclude" which allows to exclude specific file types from LoadPin. This is useful when people want to use different mechanisms to verify module and kernel image while still use LoadPin to protect the integrity of other files kernel loads.Quoted 6 lines
Signed-off-by Ke Wu <[email protected]>---
Changelog since v1:
- Markignore_read_file_idwith__ro_after_init.
- Markparse_exclude()with__init.
- UseARRAY_SIZE(ignore_read_file_id)instead ofREADING_MAX_ID.
Quoted 3 lines
Looks good!
Reviewed-by James Morris <[email protected]>
Thanks! Applied to my for-next/loadpin branch atgit://git.kernel.org/pub/scm/linux/kernel/git/kees/linux.git
and should be visible in linux-next in a few days.
Signature · 1 line
Kees Cook
Thanks for pushing the patch!
Quoted 29 lines · Kees Cook
Quoted 17 lines · James Morris
Quoted 8 lines · Ke Wu
Linux kernel already provide
MODULE_SIGandKEXEC_VERIFY_SIGto make sure loaded kernel module and kernel image are trusted. This patch adds a kernel command line option "loadpin.exclude" which allows to exclude specific file types from LoadPin. This is useful when people want to use different mechanisms to verify module and kernel image while still use LoadPin to protect the integrity of other files kernel loads.Quoted 6 lines
Signed-off-by Ke Wu <[email protected]>---
Changelog since v1:
- Markignore_read_file_idwith__ro_after_init.
- Markparse_exclude()with__init.
- UseARRAY_SIZE(ignore_read_file_id)instead ofREADING_MAX_ID.Quoted 3 lines
Looks good!
Reviewed-by James Morris <[email protected]>Thanks! Applied to my for-next/loadpin branch at
git://git.kernel.org/pub/scm/linux/kernel/git/kees/linux.git
and should be visible in linux-next in a few days.--
Kees Cook
Signature · 1 line
Ke Wu | Software Engineer | [email protected] | Google Inc.
Quoted 9 lines · Ke Wu
Linux kernel already provide
MODULE_SIGandKEXEC_VERIFY_SIGto make sure loaded kernel module and kernel image are trusted. This patch adds a kernel command line option "loadpin.exclude" which allows to exclude specific file types from LoadPin. This is useful when people want to use different mechanisms to verify module and kernel image while still use LoadPin to protect the integrity of other files kernel loads.Signed-off-by Ke Wu <[email protected]>
Thanks for the updates!
James, I don't have anything else planned for loadpin this cycle. Do you want me to push this to Linus in the next cycle, or do you want to take it into one of your trees?
Thanks!
-Kees
Quoted 103 lines
---
Changelog since v1:
- Markignore_read_file_idwith__ro_after_init.
- Markparse_exclude()with__init.
- UseARRAY_SIZE(ignore_read_file_id)instead ofREADING_MAX_ID.Documentation/admin-guide/LSM/LoadPin.rst | 10 ++++++ security/loadpin/loadpin.c | 38 +++++++++++++++++++++++ 2 files changed, 48 insertions(+)Documentation/admin-guide/LSM/LoadPin.rst +10
-0@@ -19,3 +19,13 @@ block device backing the filesystem is not read-only, a sysctl is created to toggle pinning: ``/proc/sys/kernel/loadpin/enabled``. (Having a mutable filesystem means pinning is mutable too, but having the sysctl allows for easy testing on systems with a mutable filesystem.) + +It's also possible to exclude specific file types from LoadPin using kernel +command line option "``loadpin.exclude``". By default, all files are +included, but they can be excluded using kernel command line option such +as "``loadpin.exclude=kernel-module,kexec-image``". This allows to use +different mechanisms such as ``CONFIG_MODULE_SIG`` and +``CONFIG_KEXEC_VERIFY_SIG`` to verify kernel module and kernel image while +still use LoadPin to protect the integrity of other files kernel loads. The +full list of valid file types can be found in ``kernel_read_file_str`` +defined in ``include/linux/fs.h``.security/loadpin/loadpin.c +38
-0@@ -45,6 +45,8 @@ static void report_load(const char *origin, struct file *file, char *operation) }static int enforce =IS_ENABLED (CONFIG_SECURITY_LOADPIN_ENFORCE ); +static char *exclude_read_files[READING_MAX_ID ]; +static int ignore_read_file_id[READING_MAX_ID ]__ro_after_init ;static struct super_block *pinned_root;static DEFINE_SPINLOCK (pinned_root_spinlock);@@ -129,6 +131,13 @@ static int loadpin_read_file(struct file *file, enum kernel_read_file_id id)struct super_block *load_root;const char *origin =kernel_read_file_id_str (id); +/* If the file id is excluded, ignore the pinning. */ +if ((unsigned int )id <ARRAY_SIZE (ignore_read_file_id) && + ignore_read_file_id[id]) { +report_load (origin, file,"pinning-excluded" ); +return 0 ; + } +/* This handles the older init_module API that has a NULL file. */ if (!file) {if (!enforce) {@@ -187,10 +196,37 @@ static struct security_hook_list loadpin_hooks[] __lsm_ro_after_init = { LSM_HOOK_INIT(kernel_load_data, loadpin_load_data), }; +static void __init parse_exclude (void ) +{ +int i, j; +char *cur; + +for (i =0 ; i <ARRAY_SIZE (exclude_read_files); i++) { + cur = exclude_read_files[i]; +if (!cur) +break ; +if (*cur =='\0' ) +continue ; + +for (j =0 ; j <ARRAY_SIZE (kernel_read_file_str); j++) { +if (strcmp (cur, kernel_read_file_str[j]) ==0 ) { +pr_info ("excluding: %s\n" , + kernel_read_file_str[j]); + ignore_read_file_id[j] =1 ; +/* +* Can not break, because one read_file_str +* may map to more than on read_file_id. +*/ + } + } + } +} +static int __init loadpin_init (void ) {pr_info ("ready to pin (currently %senforcing)\n" , enforce ?"" :"not " ); +parse_exclude ();security_add_hooks (loadpin_hooks,ARRAY_SIZE (loadpin_hooks),"loadpin" );return 0 ; }@@ -203,3 +239,5 @@ DEFINE_LSM(loadpin) = {/* Should not be mutable after boot, so not listed in sysfs (perm == 0). */ module_param (enforce, int,0 );MODULE_PARM_DESC (enforce,"Enforce module/firmware pinning" ); +module_param_array_named (exclude, exclude_read_files, charp,NULL ,0 ); +MODULE_PARM_DESC (exclude,"Exclude pinning specific read file types" );Signature · 1 line
2.22.0.rc1.257.g3120a18244-goog
Signature · 1 line
Kees Cook
James Morris
maintainerQuoted 11 lines · Kees Cook
Quoted 9 lines · Ke Wu
Linux kernel already provide
MODULE_SIGandKEXEC_VERIFY_SIGto make sure loaded kernel module and kernel image are trusted. This patch adds a kernel command line option "loadpin.exclude" which allows to exclude specific file types from LoadPin. This is useful when people want to use different mechanisms to verify module and kernel image while still use LoadPin to protect the integrity of other files kernel loads.Signed-off-by Ke Wu <[email protected]>
Quoted 7 lines
Thanks for the updates!
Acked-by Kees Cook <[email protected]>James, I don't have anything else planned for loadpin this cycle. Do you want me to push this to Linus in the next cycle, or do you want to take it into one of your trees?
You should push it directly to Linus.
Quoted 110 lines
Thanks!
-Kees
Quoted 103 lines
---
Changelog since v1:
- Markignore_read_file_idwith__ro_after_init.
- Markparse_exclude()with__init.
- UseARRAY_SIZE(ignore_read_file_id)instead ofREADING_MAX_ID.Documentation/admin-guide/LSM/LoadPin.rst | 10 ++++++ security/loadpin/loadpin.c | 38 +++++++++++++++++++++++ 2 files changed, 48 insertions(+)Documentation/admin-guide/LSM/LoadPin.rst +10
-0@@ -19,3 +19,13 @@ block device backing the filesystem is not read-only, a sysctl is created to toggle pinning: ``/proc/sys/kernel/loadpin/enabled``. (Having a mutable filesystem means pinning is mutable too, but having the sysctl allows for easy testing on systems with a mutable filesystem.) + +It's also possible to exclude specific file types from LoadPin using kernel +command line option "``loadpin.exclude``". By default, all files are +included, but they can be excluded using kernel command line option such +as "``loadpin.exclude=kernel-module,kexec-image``". This allows to use +different mechanisms such as ``CONFIG_MODULE_SIG`` and +``CONFIG_KEXEC_VERIFY_SIG`` to verify kernel module and kernel image while +still use LoadPin to protect the integrity of other files kernel loads. The +full list of valid file types can be found in ``kernel_read_file_str`` +defined in ``include/linux/fs.h``.security/loadpin/loadpin.c +38
-0@@ -45,6 +45,8 @@ static void report_load(const char *origin, struct file *file, char *operation) }static int enforce =IS_ENABLED (CONFIG_SECURITY_LOADPIN_ENFORCE ); +static char *exclude_read_files[READING_MAX_ID ]; +static int ignore_read_file_id[READING_MAX_ID ]__ro_after_init ;static struct super_block *pinned_root;static DEFINE_SPINLOCK (pinned_root_spinlock);@@ -129,6 +131,13 @@ static int loadpin_read_file(struct file *file, enum kernel_read_file_id id)struct super_block *load_root;const char *origin =kernel_read_file_id_str (id); +/* If the file id is excluded, ignore the pinning. */ +if ((unsigned int )id <ARRAY_SIZE (ignore_read_file_id) && + ignore_read_file_id[id]) { +report_load (origin, file,"pinning-excluded" ); +return 0 ; + } +/* This handles the older init_module API that has a NULL file. */ if (!file) {if (!enforce) {@@ -187,10 +196,37 @@ static struct security_hook_list loadpin_hooks[] __lsm_ro_after_init = { LSM_HOOK_INIT(kernel_load_data, loadpin_load_data), }; +static void __init parse_exclude (void ) +{ +int i, j; +char *cur; + +for (i =0 ; i <ARRAY_SIZE (exclude_read_files); i++) { + cur = exclude_read_files[i]; +if (!cur) +break ; +if (*cur =='\0' ) +continue ; + +for (j =0 ; j <ARRAY_SIZE (kernel_read_file_str); j++) { +if (strcmp (cur, kernel_read_file_str[j]) ==0 ) { +pr_info ("excluding: %s\n" , + kernel_read_file_str[j]); + ignore_read_file_id[j] =1 ; +/* +* Can not break, because one read_file_str +* may map to more than on read_file_id. +*/ + } + } + } +} +static int __init loadpin_init (void ) {pr_info ("ready to pin (currently %senforcing)\n" , enforce ?"" :"not " ); +parse_exclude ();security_add_hooks (loadpin_hooks,ARRAY_SIZE (loadpin_hooks),"loadpin" );return 0 ; }@@ -203,3 +239,5 @@ DEFINE_LSM(loadpin) = {/* Should not be mutable after boot, so not listed in sysfs (perm == 0). */ module_param (enforce, int,0 );MODULE_PARM_DESC (enforce,"Enforce module/firmware pinning" ); +module_param_array_named (exclude, exclude_read_files, charp,NULL ,0 ); +MODULE_PARM_DESC (exclude,"Exclude pinning specific read file types" );Signature · 1 line
2.22.0.rc1.257.g3120a18244-goog
Signature · 2 lines
James Morris <[email protected]>
PATCH v3 1/1 Allow to exclude specific file types in LoadPin
In reply to Ke WuLinux kernel already provide MODULE_SIG and KEXEC_VERIFY_SIG to make sure loaded kernel module and kernel image are trusted. This patch adds a kernel command line option "loadpin.exclude" which allows to exclude specific file types from LoadPin. This is useful when people want to use different mechanisms to verify module and kernel image while still use LoadPin to protect the integrity of other files kernel loads.
---
Changelog since v2:
- Make size of exclude_read_files and ignore_read_file_id to be equal to the size of kernel_read_file_str.
Changelog since v1:
- Mark ignore_read_file_id with __ro_after_init.
- Mark parse_exclude() with __init.
- Use ARRAY_SIZE(ignore_read_file_id) instead of READING_MAX_ID.
Documentation/admin-guide/LSM/LoadPin.rst | 10 ++++++ security/loadpin/loadpin.c | 42 +++++++++++++++++++++++ 2 files changed, 52 insertions(+)
Documentation/admin-guide/LSM/LoadPin.rst +10 -0
@@ -19,3 +19,13 @@ block device backing the filesystem is not read-only, a sysctl is created to toggle pinning: ``/proc/sys/kernel/loadpin/enabled``. (Having a mutable filesystem means pinning is mutable too, but having the sysctl allows for easy testing on systems with a mutable filesystem.) + +It's also possible to exclude specific file types from LoadPin using kernel +command line option "``loadpin.exclude``". By default, all files are +included, but they can be excluded using kernel command line option such +as "``loadpin.exclude=kernel-module,kexec-image``". This allows to use +different mechanisms such as ``CONFIG_MODULE_SIG`` and +``CONFIG_KEXEC_VERIFY_SIG`` to verify kernel module and kernel image while +still use LoadPin to protect the integrity of other files kernel loads. The +full list of valid file types can be found in ``kernel_read_file_str`` +defined in ``include/linux/fs.h``.
security/loadpin/loadpin.c +42 -0
67 lines not on this page · raw message
Signature · 1 line
2.22.0.rc1.257.g3120a18244-goog
Quoted 8 lines · Ke Wu
Linux kernel already provide
MODULE_SIGandKEXEC_VERIFY_SIGto make sure loaded kernel module and kernel image are trusted. This patch adds a kernel command line option "loadpin.exclude" which allows to exclude specific file types from LoadPin. This is useful when people want to use different mechanisms to verify module and kernel image while still use LoadPin to protect the integrity of other files kernel loads.
Quoted 5 lines
Signed-off-by Ke Wu <[email protected]>---
Changelog since v2:
- Make size ofexclude_read_filesandignore_read_file_idto be equal to the size ofkernel_read_file_str.
Thanks! I've fixed this differently and it should be visible shortly.
-Kees
Quoted 107 lines
Changelog since v1:
- Markignore_read_file_idwith__ro_after_init.
- Markparse_exclude()with__init.
- UseARRAY_SIZE(ignore_read_file_id)instead ofREADING_MAX_ID.Documentation/admin-guide/LSM/LoadPin.rst | 10 ++++++ security/loadpin/loadpin.c | 42 +++++++++++++++++++++++ 2 files changed, 52 insertions(+)Documentation/admin-guide/LSM/LoadPin.rst +10
-0@@ -19,3 +19,13 @@ block device backing the filesystem is not read-only, a sysctl is created to toggle pinning: ``/proc/sys/kernel/loadpin/enabled``. (Having a mutable filesystem means pinning is mutable too, but having the sysctl allows for easy testing on systems with a mutable filesystem.) + +It's also possible to exclude specific file types from LoadPin using kernel +command line option "``loadpin.exclude``". By default, all files are +included, but they can be excluded using kernel command line option such +as "``loadpin.exclude=kernel-module,kexec-image``". This allows to use +different mechanisms such as ``CONFIG_MODULE_SIG`` and +``CONFIG_KEXEC_VERIFY_SIG`` to verify kernel module and kernel image while +still use LoadPin to protect the integrity of other files kernel loads. The +full list of valid file types can be found in ``kernel_read_file_str`` +defined in ``include/linux/fs.h``.security/loadpin/loadpin.c +42
-0@@ -45,6 +45,12 @@ static void report_load(const char *origin, struct file *file, char *operation) }static int enforce =IS_ENABLED (CONFIG_SECURITY_LOADPIN_ENFORCE ); +/* +* The size should be READING_MAX_ID + 1 to be equal to the size of +* kernel_read_file_str. +*/ +static char *exclude_read_files[READING_MAX_ID +1 ]; +static int ignore_read_file_id[READING_MAX_ID +1 ]__ro_after_init ;static struct super_block *pinned_root;static DEFINE_SPINLOCK (pinned_root_spinlock);@@ -129,6 +135,13 @@ static int loadpin_read_file(struct file *file, enum kernel_read_file_id id)struct super_block *load_root;const char *origin =kernel_read_file_id_str (id); +/* If the file id is excluded, ignore the pinning. */ +if ((unsigned int )id <ARRAY_SIZE (ignore_read_file_id) && + ignore_read_file_id[id]) { +report_load (origin, file,"pinning-excluded" ); +return 0 ; + } +/* This handles the older init_module API that has a NULL file. */ if (!file) {if (!enforce) {@@ -187,10 +200,37 @@ static struct security_hook_list loadpin_hooks[] __lsm_ro_after_init = { LSM_HOOK_INIT(kernel_load_data, loadpin_load_data), }; +static void __init parse_exclude (void ) +{ +int i, j; +char *cur; + +for (i =0 ; i <ARRAY_SIZE (exclude_read_files); i++) { + cur = exclude_read_files[i]; +if (!cur) +break ; +if (*cur =='\0' ) +continue ; + +for (j =0 ; j <ARRAY_SIZE (kernel_read_file_str); j++) { +if (strcmp (cur, kernel_read_file_str[j]) ==0 ) { +pr_info ("excluding: %s\n" , + kernel_read_file_str[j]); + ignore_read_file_id[j] =1 ; +/* +* Can not break, because one read_file_str +* may map to more than on read_file_id. +*/ + } + } + } +} +static int __init loadpin_init (void ) {pr_info ("ready to pin (currently %senforcing)\n" , enforce ?"" :"not " ); +parse_exclude ();security_add_hooks (loadpin_hooks,ARRAY_SIZE (loadpin_hooks),"loadpin" );return 0 ; }@@ -203,3 +243,5 @@ DEFINE_LSM(loadpin) = {/* Should not be mutable after boot, so not listed in sysfs (perm == 0). */ module_param (enforce, int,0 );MODULE_PARM_DESC (enforce,"Enforce module/firmware pinning" ); +module_param_array_named (exclude, exclude_read_files, charp,NULL ,0 ); +MODULE_PARM_DESC (exclude,"Exclude pinning specific read file types" );Signature · 1 line
2.22.0.rc1.257.g3120a18244-goog
Signature · 1 line
Kees Cook
PATCH v4 1/1 Allow to exclude specific file types in LoadPin
In reply to Ke WuLinux kernel already provide MODULE_SIG and KEXEC_VERIFY_SIG to make sure loaded kernel module and kernel image are trusted. This patch adds a kernel command line option "loadpin.exclude" which allows to exclude specific file types from LoadPin. This is useful when people want to use different mechanisms to verify module and kernel image while still use LoadPin to protect the integrity of other files kernel loads.
---
Changelog since v3:
- Undo patch v3 change.
- Use ignore_read_file_id rahther than kernel_read_file_str when iterating to prevent out-of-bounds write.
Changelog since v2:
- Make size of exclude_read_files and ignore_read_file_id to be equal to the size of kernel_read_file_str.
Changelog since v1:
- Mark ignore_read_file_id with __ro_after_init.
- Mark parse_exclude() with __init.
- Use ARRAY_SIZE(ignore_read_file_id) instead of READING_MAX_ID.
Documentation/admin-guide/LSM/LoadPin.rst | 10 ++++++ security/loadpin/loadpin.c | 44 +++++++++++++++++++++++ 2 files changed, 54 insertions(+)
Documentation/admin-guide/LSM/LoadPin.rst +10 -0
@@ -19,3 +19,13 @@ block device backing the filesystem is not read-only, a sysctl is created to toggle pinning: ``/proc/sys/kernel/loadpin/enabled``. (Having a mutable filesystem means pinning is mutable too, but having the sysctl allows for easy testing on systems with a mutable filesystem.) + +It's also possible to exclude specific file types from LoadPin using kernel +command line option "``loadpin.exclude``". By default, all files are +included, but they can be excluded using kernel command line option such +as "``loadpin.exclude=kernel-module,kexec-image``". This allows to use +different mechanisms such as ``CONFIG_MODULE_SIG`` and +``CONFIG_KEXEC_VERIFY_SIG`` to verify kernel module and kernel image while +still use LoadPin to protect the integrity of other files kernel loads. The +full list of valid file types can be found in ``kernel_read_file_str`` +defined in ``include/linux/fs.h``.
security/loadpin/loadpin.c +44 -0
69 lines not on this page · raw message
Signature · 1 line
2.22.0.rc1.311.g5d7573a151-goog