bpf: fix crash in bpf_[set|remove]_dentry_xattr for negative dentries
PATCH 1/1 bpf: fix crash in bpf_[set|remove]_dentry_xattr for negative dentries
bpf_set_dentry_xattr and bpf_remove_dentry_xattr BPF kfuncs attempt to lock the inode of the supplied dentry without checking if it is NULL. If a negative dentry is passed (e.g. from security_inode_create), d_inode(dentry) returns NULL, and inode_lock(inode) will cause a NULL pointer dereference.
Trivially fix this by adding a NULL check for inode before attempting to lock it, returning -EINVAL if it is NULL.
--- fs/bpf_fs_kfuncs.c | 6 ++++++ 1 file changed, 6 insertions(+)
fs/bpf_fs_kfuncs.c +6 -0
@@ -289,6 +289,9 @@ __bpf_kfunc int bpf_set_dentry_xattr(struct dentry *dentry, const char *name__ststruct inode *inode =d_inode (dentry);int ret; +if (!inode) +return -EINVAL ; +inode_lock (inode); ret =bpf_set_dentry_xattr_locked (dentry, name__str, value_p, flags);inode_unlock (inode);
@@ -314,6 +317,9 @@ __bpf_kfunc int bpf_remove_dentry_xattr(struct dentry *dentry, const char *name_struct inode *inode =d_inode (dentry);int ret; +if (!inode) +return -EINVAL ; +inode_lock (inode); ret =bpf_remove_dentry_xattr_locked (dentry, name__str);inode_unlock (inode);
Signature · 1 line
2.54.0.545.g6539524ca2-goog
[email protected]
AI reviewThank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider: - [High] Incomplete Fix: Negative dentries still trigger WARN_ON splats in bpf_get_dentry_xattr and _locked…
Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider:
- [High] Incomplete Fix: Negative dentries still trigger WARN_ON splats in bpf_get_dentry_xattr and _locked variants
- [High] BPF verifier blindly substitutes locked kfuncs, allowing arbitrary VFS lock bypass
- [High] Missing VFS parameter sanitization allows out-of-bounds xattr sizes and arbitrary flags --
commit 07ec989f2fe3141fcb87e29833232a3f0591690d
Author: Matt Bobrowski <[email protected]>
bpf: fix crash in bpf_[set|remove]_dentry_xattr for negative dentries
This commit adds a NULL check for the inode in bpf_set_dentry_xattr() and bpf_remove_dentry_xattr() to prevent a NULL pointer dereference when a negative dentry is passed. If the inode is NULL, the functions now return -EINVAL instead of attempting to lock it.
fs/bpf_fs_kfuncs.c __bpf_kfunc int bpf_set_dentry_xattr(struct dentry *dentry, const char *name__st · line 293
Quoted 10 lines
fs/bpf_fs_kfuncs.c +2
-0@@ -289,6 +289,9 @@ __bpf_kfunc int bpf_set_dentry_xattr(struct dentry *dentry, const char *name__ststruct inode *inode =d_inode (dentry);int ret; +if (!inode) +return -EINVAL ;
Are similar checks needed for bpf_get_dentry_xattr() and the _locked variants (bpf_set_dentry_xattr_locked() and bpf_remove_dentry_xattr_locked())?
If a negative dentry is passed to those functions, they will extract a NULL inode and pass it to bpf_xattr_write_permission() or bpf_xattr_read_permission(), which will trigger a WARN_ON(!inode) splat:
fs/bpf_fs_kfuncs.c:bpf_set_dentry_xattr_locked() {
...
struct inode *inode = d_inode(dentry);
...
ret = bpf_xattr_write_permission(name__str, inode);
...
}Could a user-controlled BPF program intentionally pass a negative dentry to trigger this warning, causing a denial of service on systems with panic_on_warn enabled?
fs/bpf_fs_kfuncs.c __bpf_kfunc int bpf_set_dentry_xattr(struct dentry *dentry, const char *name__st · line 296
Quoted 3 lines
fs/bpf_fs_kfuncs.c +1
-0+inode_lock (inode); ret =bpf_set_dentry_xattr_locked (dentry, name__str, value_p, flags);
This isn't a regression from this patch, but does the BPF verifier safely handle the substitution of these locked kfuncs?
If a program is attached to an LSM hook that holds an inode lock, the verifier unconditionally rewrites calls to bpf_set_dentry_xattr() to bpf_set_dentry_xattr_locked(). The verifier doesn't check if the dentry argument provided to the kfunc is the specific context argument that the VFS already locked.
Can a BPF program obtain a trusted pointer to an unrelated, unlocked dentry and pass it to the kfunc, causing the substituted _locked variant to execute __vfs_setxattr() without acquiring the proper VFS locks?
Additionally, do these kfuncs bypass necessary VFS parameter sanitization?
The standard setxattr system call sanitizes inputs in setxattr_copy(), rejecting sizes larger than XATTR_SIZE_MAX and masking flags. Since bpf_set_dentry_xattr() and its _locked variant directly invoke __vfs_setxattr(), a BPF program can supply arbitrary unvalidated flags and massive values up to 4GB.
Could this bypass lead to huge allocations, integer overflows, or out-of-bounds accesses in drivers that assume VFS-enforced bounds?
Quoted 2 lines
fs/bpf_fs_kfuncs.c +0
-0inode_unlock (inode);return ret;
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
Quoted 44 lines · On Wed, Apr 29, 2026 at 10:10:00PM +0000, [email protected] wrote:
Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider:
- [High] Incomplete Fix: Negative dentries still triggerWARN_ONsplats inbpf_get_dentry_xattrand_lockedvariants
- [High] BPF verifier blindly substitutes locked kfuncs, allowing arbitrary VFS lock bypass
- [High] Missing VFS parameter sanitization allows out-of-bounds xattr sizes and arbitrary flags --commit
07ec989f2fe3141fcb87e29833232a3f0591690d
Author: Matt Bobrowski <[email protected]>bpf: fix crash in bpf_[set|remove]_dentry_xattr for negative dentries
This commit adds a NULL check for the inode in
bpf_set_dentry_xattr()andbpf_remove_dentry_xattr()to prevent a NULL pointer dereference when a negative dentry is passed. If the inode is NULL, the functions now return-EINVALinstead of attempting to lock it.fs/bpf_fs_kfuncs.c __bpf_kfunc int bpf_set_dentry_xattr(struct dentry *dentry, const char *name__st · line 293
Quoted 10 lines
fs/bpf_fs_kfuncs.c +2
-0@@ -289,6 +289,9 @@ __bpf_kfunc int bpf_set_dentry_xattr(struct dentry *dentry, const char *name__ststruct inode *inode =d_inode (dentry);int ret; +if (!inode) +return -EINVAL ;Are similar checks needed for
bpf_get_dentry_xattr()and the_lockedvariants (bpf_set_dentry_xattr_locked()andbpf_remove_dentry_xattr_locked())?If a negative dentry is passed to those functions, they will extract a NULL inode and pass it to
bpf_xattr_write_permission()orbpf_xattr_read_permission(), which will trigger aWARN_ON(!inode)splat:fs/bpf_fs_kfuncs.c:bpf_set_dentry_xattr_locked() { ... struct inode *inode = d_inode(dentry); ... ret = bpf_xattr_write_permission(name__str, inode); ... }
Quoted 3 lines
Could a user-controlled BPF program intentionally pass a negative dentry to trigger this warning, causing a denial of service on systems with
panic_on_warnenabled?
Yes, dropping the WARN_ON(!inode) makes sense to me. By definition, attempting to set an extended attribute on a negative dentry is considered as an invalid operation, so it should be handled gracefully.
Quoted 13 lines
fs/bpf_fs_kfuncs.c __bpf_kfunc int bpf_set_dentry_xattr(struct dentry *dentry, const char *name__st · line 296
Quoted 3 lines
fs/bpf_fs_kfuncs.c +1
-0+inode_lock (inode); ret =bpf_set_dentry_xattr_locked (dentry, name__str, value_p, flags);This isn't a regression from this patch, but does the BPF verifier safely handle the substitution of these locked kfuncs?
If a program is attached to an LSM hook that holds an inode lock, the verifier unconditionally rewrites calls to
bpf_set_dentry_xattr()tobpf_set_dentry_xattr_locked(). The verifier doesn't check if the dentry argument provided to the kfunc is the specific context argument that the VFS already locked.
Quoted 3 lines
Can a BPF program obtain a trusted pointer to an unrelated, unlocked dentry and pass it to the kfunc, causing the substituted
_lockedvariant to execute__vfs_setxattr()without acquiring the proper VFS locks?
Probably a valid concern and the current approach does seem a little fragile. This too should be reviewed in further depth separately though.
Quoted 10 lines
Additionally, do these kfuncs bypass necessary VFS parameter sanitization?
The standard setxattr system call sanitizes inputs in
setxattr_copy(), rejecting sizes larger thanXATTR_SIZE_MAXand masking flags. Sincebpf_set_dentry_xattr()and its_lockedvariant directly invoke__vfs_setxattr(), a BPF program can supply arbitrary unvalidated flags and massive values up to 4GB.Could this bypass lead to huge allocations, integer overflows, or out-of-bounds accesses in drivers that assume VFS-enforced bounds?
I believe this is a valid concern and should be addressed separately in a follow up patch. Thank you for bringing this to our attention.
Quoted 5 lines
Quoted 2 lines
fs/bpf_fs_kfuncs.c +0
-0inode_unlock (inode);return ret;
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1