bpf: reject BPF_MAP_TYPE_INODE_STORAGE creation if BPF LSM is uninitialized
Subsystems (4)
PATCH 1/1 bpf: reject BPF_MAP_TYPE_INODE_STORAGE creation if BPF LSM is uninitialized
When CONFIG_BPF_LSM=y is set, BPF inode storage maps (BPF_MAP_TYPE_INODE_STORAGE) are compiled into the kernel. However, if the BPF LSM is not explicitly enabled at boot time (e.g. omitted from the "lsm=" boot parameter), lsm_prepare() is never executed for the BPF LSM.
Consequently, the BPF inode security blob offset (bpf_lsm_blob_sizes.lbs_inode) is never initialized and remains at its default compiled size of 8 bytes instead of being updated to a valid offset past the reserved struct rcu_head (typically 16 bytes or more).
When a privileged user creates and updates a BPF_MAP_TYPE_INODE_STORAGE map, bpf_inode() evaluates inode->i_security + 8. This erroneously aliases the struct rcu_head.func callback pointer at the beginning of the inode->i_security blob. During subsequent map element cleanup or inode destruction, writing NULL to owner_storage clears the queued RCU callback pointer. When rcu_do_batch() later executes the queued callback, it attempts an instruction fetch at address 0x0, triggering an immediate kernel panic.
Fix this by introducing a global bpf_lsm_initialized boolean flag marked with __ro_after_init. Set this flag to true inside bpf_lsm_init() when the LSM framework successfully registers the BPF LSM. Gate map allocation in inode_storage_map_alloc() on this flag, returning -EOPNOTSUPP if the BPF LSM is in turn uninitialized.
This fail-fast approach prevents userspace from allocating inode storage maps when the supporting BPF LSM infrastructure is absent, avoiding zombie map states.
--- include/linux/bpf_lsm.h | 4 ++++ kernel/bpf/bpf_inode_storage.c | 9 +++++++++ security/bpf/hooks.c | 3 +++ 3 files changed, 16 insertions(+)
include/linux/bpf_lsm.h +4 -0
@@ -14,6 +14,8 @@#ifdef CONFIG_BPF_LSM +extern bool bpf_lsm_initialized__ro_after_init ; +#define LSM_HOOK (RET ,DEFAULT ,NAME , ...) \ RET bpf_lsm_##NAME(__VA_ARGS__);#include <linux/lsm_hook_defs.h>
@@ -56,6 +58,8 @@ bool bpf_lsm_hook_returns_errno(u32 btf_id);#else /* !CONFIG_BPF_LSM */ +#define bpf_lsm_initialized false +static inline bool bpf_lsm_is_sleepable_hook (u32 btf_id) {return false;
kernel/bpf/bpf_inode_storage.c +9 -0
@@ -178,6 +178,15 @@ static int notsupp_get_next_key(struct bpf_map *map, void *key,static struct bpf_map *inode_storage_map_alloc (union bpf_attr *attr) { +/* +* Do not allow allocation of BPF_MAP_TYPE_INODE_STORAGE if the BPF LSM +* was not initialized by the LSM framework at boot. Without proper +* initialization, the BPF inode security blob offset remains unprepared, +* causing bpf_inode() to calculate an invalid memory offset and corrupt +* inode->i_security. +*/ +if (!bpf_lsm_initialized) +return ERR_PTR (-EOPNOTSUPP );return bpf_local_storage_map_alloc (attr, &inode_cache); }
security/bpf/hooks.c +3 -0
@@ -7,6 +7,8 @@#include <linux/bpf_lsm.h> #include <uapi/linux/lsm.h> +bool bpf_lsm_initialized__ro_after_init ; +static struct security_hook_list bpf_lsm_hooks[]__ro_after_init = { #define LSM_HOOK(RET, DEFAULT, NAME, ...) \ LSM_HOOK_INIT(NAME, bpf_lsm_##NAME),
@@ -24,6 +26,7 @@ static int __init bpf_lsm_init(void) {security_add_hooks (bpf_lsm_hooks,ARRAY_SIZE (bpf_lsm_hooks), &bpf_lsmid); + bpf_lsm_initialized = true;pr_info ("LSM support for eBPF active\n" );return 0 ; }
Signature · 1 line
2.55.0.rc0.799.gd6f94ed593-goog
Quoted 27 lines · Matt Bobrowski
When
CONFIG_BPF_LSM=yis set, BPF inode storage maps (BPF_MAP_TYPE_INODE_STORAGE) are compiled into the kernel. However, if the BPF LSM is not explicitly enabled at boot time (e.g. omitted from the "lsm=" boot parameter),lsm_prepare()is never executed for the BPF LSM.Consequently, the BPF inode security blob offset (bpf_lsm_blob_sizes.lbs_inode) is never initialized and remains at its default compiled size of 8 bytes instead of being updated to a valid offset past the reserved struct
rcu_head(typically 16 bytes or more).When a privileged user creates and updates a
BPF_MAP_TYPE_INODE_STORAGEmap,bpf_inode()evaluatesinode->i_security+ 8. This erroneously aliases the struct rcu_head.func callback pointer at the beginning of theinode->i_securityblob. During subsequent map element cleanup or inode destruction, writing NULL toowner_storageclears the queued RCU callback pointer. Whenrcu_do_batch()later executes the queued callback, it attempts an instruction fetch at address0x0, triggering an immediate kernel panic.Fix this by introducing a global
bpf_lsm_initializedboolean flag marked with__ro_after_init. Set this flag to true insidebpf_lsm_init()when the LSM framework successfully registers the BPF LSM. Gate map allocation ininode_storage_map_alloc()on this flag, returning-EOPNOTSUPPif the BPF LSM is in turn uninitialized.
Quoted 7 lines
This fail-fast approach prevents userspace from allocating inode storage maps when the supporting BPF LSM infrastructure is absent, avoiding zombie map states.
Fixes 8ea636848aca ("bpf: Implement bpf_local_storage for inodes")Reported-by oxsignal <[email protected]>Signed-off-by Matt Bobrowski <[email protected]>
It makes sense for since the only users of inode-local storage are related to LSM (case in point, this whole bug is due to storing the storage map in the inode's ->security in the first place).
Quoted 69 lines
--- include/linux/bpf_lsm.h | 4 ++++ kernel/bpf/bpf_inode_storage.c | 9 +++++++++ security/bpf/hooks.c | 3 +++ 3 files changed, 16 insertions(+)include/linux/bpf_lsm.h +4
-0@@ -14,6 +14,8 @@#ifdef CONFIG_BPF_LSM +extern bool bpf_lsm_initialized__ro_after_init ; +#define LSM_HOOK (RET ,DEFAULT ,NAME , ...) \ RET bpf_lsm_##NAME(__VA_ARGS__);#include <linux/lsm_hook_defs.h> @@ -56,6 +58,8 @@ bool bpf_lsm_hook_returns_errno(u32 btf_id);#else /* !CONFIG_BPF_LSM */ +#define bpf_lsm_initialized false +static inline bool bpf_lsm_is_sleepable_hook (u32 btf_id) {return false;kernel/bpf/bpf_inode_storage.c +9
-0@@ -178,6 +178,15 @@ static int notsupp_get_next_key(struct bpf_map *map, void *key,static struct bpf_map *inode_storage_map_alloc (union bpf_attr *attr) { +/* +* Do not allow allocation of BPF_MAP_TYPE_INODE_STORAGE if the BPF LSM +* was not initialized by the LSM framework at boot. Without proper +* initialization, the BPF inode security blob offset remains unprepared, +* causing bpf_inode() to calculate an invalid memory offset and corrupt +* inode->i_security. +*/ +if (!bpf_lsm_initialized) +return ERR_PTR (-EOPNOTSUPP );return bpf_local_storage_map_alloc (attr, &inode_cache); }security/bpf/hooks.c +3
-0@@ -7,6 +7,8 @@#include <linux/bpf_lsm.h> #include <uapi/linux/lsm.h> +bool bpf_lsm_initialized__ro_after_init ; +static struct security_hook_list bpf_lsm_hooks[]__ro_after_init = { #define LSM_HOOK(RET, DEFAULT, NAME, ...) \ LSM_HOOK_INIT(NAME, bpf_lsm_##NAME),@@ -24,6 +26,7 @@ static int __init bpf_lsm_init(void) {security_add_hooks (bpf_lsm_hooks,ARRAY_SIZE (bpf_lsm_hooks), &bpf_lsmid); + bpf_lsm_initialized = true;pr_info ("LSM support for eBPF active\n" );return 0 ; }
Quoted 28 lines · Matt Bobrowski
When
CONFIG_BPF_LSM=yis set, BPF inode storage maps (BPF_MAP_TYPE_INODE_STORAGE) are compiled into the kernel. However, if the BPF LSM is not explicitly enabled at boot time (e.g. omitted from the "lsm=" boot parameter),lsm_prepare()is never executed for the BPF LSM.Consequently, the BPF inode security blob offset (bpf_lsm_blob_sizes.lbs_inode) is never initialized and remains at its default compiled size of 8 bytes instead of being updated to a valid offset past the reserved struct
rcu_head(typically 16 bytes or more).When a privileged user creates and updates a
BPF_MAP_TYPE_INODE_STORAGEmap,bpf_inode()evaluatesinode->i_security+ 8. This erroneously aliases the struct rcu_head.func callback pointer at the beginning of theinode->i_securityblob. During subsequent map element cleanup or inode destruction, writing NULL toowner_storageclears the queued RCU callback pointer. Whenrcu_do_batch()later executes the queued callback, it attempts an instruction fetch at address0x0, triggering an immediate kernel panic.Fix this by introducing a global
bpf_lsm_initializedboolean flag marked with__ro_after_init. Set this flag to true insidebpf_lsm_init()when the LSM framework successfully registers the BPF LSM. Gate map allocation ininode_storage_map_alloc()on this flag, returning-EOPNOTSUPPif the BPF LSM is in turn uninitialized.
Quoted 7 lines
This fail-fast approach prevents userspace from allocating inode storage maps when the supporting BPF LSM infrastructure is absent, avoiding zombie map states.
Fixes 8ea636848aca ("bpf: Implement bpf_local_storage for inodes")Reported-by oxsignal <[email protected]>Signed-off-by Matt Bobrowski <[email protected]>
Quoted 73 lines
--- include/linux/bpf_lsm.h | 4 ++++ kernel/bpf/bpf_inode_storage.c | 9 +++++++++ security/bpf/hooks.c | 3 +++ 3 files changed, 16 insertions(+)include/linux/bpf_lsm.h +4
-0@@ -14,6 +14,8 @@#ifdef CONFIG_BPF_LSM +extern bool bpf_lsm_initialized__ro_after_init ; +#define LSM_HOOK (RET ,DEFAULT ,NAME , ...) \ RET bpf_lsm_##NAME(__VA_ARGS__);#include <linux/lsm_hook_defs.h> @@ -56,6 +58,8 @@ bool bpf_lsm_hook_returns_errno(u32 btf_id);#else /* !CONFIG_BPF_LSM */ +#define bpf_lsm_initialized false +static inline bool bpf_lsm_is_sleepable_hook (u32 btf_id) {return false;kernel/bpf/bpf_inode_storage.c +9
-0@@ -178,6 +178,15 @@ static int notsupp_get_next_key(struct bpf_map *map, void *key,static struct bpf_map *inode_storage_map_alloc (union bpf_attr *attr) { +/* +* Do not allow allocation of BPF_MAP_TYPE_INODE_STORAGE if the BPF LSM +* was not initialized by the LSM framework at boot. Without proper +* initialization, the BPF inode security blob offset remains unprepared, +* causing bpf_inode() to calculate an invalid memory offset and corrupt +* inode->i_security. +*/ +if (!bpf_lsm_initialized) +return ERR_PTR (-EOPNOTSUPP );return bpf_local_storage_map_alloc (attr, &inode_cache); }security/bpf/hooks.c +3
-1@@ -7,6 +7,8 @@#include <linux/bpf_lsm.h> #include <uapi/linux/lsm.h> +bool bpf_lsm_initialized__ro_after_init ; +static struct security_hook_list bpf_lsm_hooks[]__ro_after_init = { #define LSM_HOOK(RET, DEFAULT, NAME, ...) \ LSM_HOOK_INIT(NAME, bpf_lsm_##NAME),@@ -24,6 +26,7 @@ static int __init bpf_lsm_init(void) {security_add_hooks (bpf_lsm_hooks,ARRAY_SIZE (bpf_lsm_hooks), &bpf_lsmid); + bpf_lsm_initialized = true;pr_info ("LSM support for eBPF active\n" );return 0 ; } --2.55.0.rc0.799.gd6f94ed593-goog
Daniel Borkmann
maintainerQuoted 27 lines · Matt Bobrowski
When
CONFIG_BPF_LSM=yis set, BPF inode storage maps (BPF_MAP_TYPE_INODE_STORAGE) are compiled into the kernel. However, if the BPF LSM is not explicitly enabled at boot time (e.g. omitted from the "lsm=" boot parameter),lsm_prepare()is never executed for the BPF LSM.Consequently, the BPF inode security blob offset (bpf_lsm_blob_sizes.lbs_inode) is never initialized and remains at its default compiled size of 8 bytes instead of being updated to a valid offset past the reserved struct
rcu_head(typically 16 bytes or more).When a privileged user creates and updates a
BPF_MAP_TYPE_INODE_STORAGEmap,bpf_inode()evaluatesinode->i_security+ 8. This erroneously aliases the struct rcu_head.func callback pointer at the beginning of theinode->i_securityblob. During subsequent map element cleanup or inode destruction, writing NULL toowner_storageclears the queued RCU callback pointer. Whenrcu_do_batch()later executes the queued callback, it attempts an instruction fetch at address0x0, triggering an immediate kernel panic.Fix this by introducing a global
bpf_lsm_initializedboolean flag marked with__ro_after_init. Set this flag to true insidebpf_lsm_init()when the LSM framework successfully registers the BPF LSM. Gate map allocation ininode_storage_map_alloc()on this flag, returning-EOPNOTSUPPif the BPF LSM is in turn uninitialized.
Quoted 7 lines
This fail-fast approach prevents userspace from allocating inode storage maps when the supporting BPF LSM infrastructure is absent, avoiding zombie map states.
Fixes 8ea636848aca ("bpf: Implement bpf_local_storage for inodes")Reported-by oxsignal <[email protected]>Signed-off-by Matt Bobrowski <[email protected]>
(Looks like pwbot is asleep; applied to bpf.)
Quoted 32 lines · Daniel Borkmann
Quoted 31 lines · Matt Bobrowski
When
CONFIG_BPF_LSM=yis set, BPF inode storage maps (BPF_MAP_TYPE_INODE_STORAGE) are compiled into the kernel. However, if the BPF LSM is not explicitly enabled at boot time (e.g. omitted from the "lsm=" boot parameter),lsm_prepare()is never executed for the BPF LSM.Consequently, the BPF inode security blob offset (bpf_lsm_blob_sizes.lbs_inode) is never initialized and remains at its default compiled size of 8 bytes instead of being updated to a valid offset past the reserved struct
rcu_head(typically 16 bytes or more).When a privileged user creates and updates a
BPF_MAP_TYPE_INODE_STORAGEmap,bpf_inode()evaluatesinode->i_security+ 8. This erroneously aliases the struct rcu_head.func callback pointer at the beginning of theinode->i_securityblob. During subsequent map element cleanup or inode destruction, writing NULL toowner_storageclears the queued RCU callback pointer. Whenrcu_do_batch()later executes the queued callback, it attempts an instruction fetch at address0x0, triggering an immediate kernel panic.Fix this by introducing a global
bpf_lsm_initializedboolean flag marked with__ro_after_init. Set this flag to true insidebpf_lsm_init()when the LSM framework successfully registers the BPF LSM. Gate map allocation ininode_storage_map_alloc()on this flag, returning-EOPNOTSUPPif the BPF LSM is in turn uninitialized.This fail-fast approach prevents userspace from allocating inode storage maps when the supporting BPF LSM infrastructure is absent, avoiding zombie map states.
Quoted 5 lines
Quoted 3 lines
Fixes 8ea636848aca ("bpf: Implement bpf_local_storage for inodes")Reported-by oxsignal <[email protected]>Signed-off-by Matt Bobrowski <[email protected]>(Looks like pwbot is asleep; applied to bpf.)
Thank you Daniel!