sysctl: prepare sysctl core for const struct ctl_table
Subsystems (6)
v2 cover sysctl: prepare sysctl core for const struct ctl_table
Adapt the internal and external APIs of the sysctl core to handle read-only instances of "struct ctl_table".
Patch 1: Bugfix for the sysctl core, the bug can be reliably triggered
with the series applied
Patch 2: Trivial preparation commit for the sysctl BPF hook Patch 3: Adapts the internal sysctl APIs
Patch 4: Adapts the external sysctl APIs
Patch 5: Constifies the sysctl internal tables as proof that it works Patch 6: Updates scripts/const_structs.checkpatch for "struct ctl_table"
Motivation
==========
Moving structures containing function pointers into unmodifiable .rodata prevents attackers or bugs from corrupting and diverting those pointers.
Also the "struct ctl_table" exposed by the sysctl core were never meant to be mutated by users.
For this goal changes to both the sysctl core and "const" qualifiers for various sysctl APIs are necessary.
Full Process
============
* Drop ctl_table modifications from the sysctl core ([0], in mainline)
* Constify arguments to ctl_table_root::{set_ownership,permissions}
([1], in mainline)
* Migrate users of "ctl_table_header::ctl_table_arg" to "const".
(in mainline)
* Afterwards convert "ctl_table_header::ctl_table_arg" itself to const.
(in mainline)
* Prepare helpers used to implement proc_handlers throughout the tree to use "const struct ctl_table *". ([2], in mainline)
* Afterwards switch over all proc_handlers callbacks to use
"const struct ctl_table *" in one commit. (in mainline)
* Switch over the internals of the sysctl core to "const struct ctl_table *" (this series)
* Switch include/linux/sysctl.h to "const struct ctl_table *" (this series)
* Transition instances of "struct ctl_table" through the tree to const (to be done)
This series is meant to be applied through the sysctl tree.
---
Changes in v2:
- Avoid spurious permanent empty tables (patch 1)
- Link to v1: https://lore.kernel.org/r/[email protected]
---
Thomas Weißschuh (6):
sysctl: avoid spurious permanent empty tables
bpf: Constify ctl_table argument of filter function
sysctl: move internal interfaces to const struct ctl_table
sysctl: allow registration of const struct ctl_table
sysctl: make internal ctl_tables const const_structs.checkpatch: add ctl_table
fs/proc/internal.h | 2 +- fs/proc/proc_sysctl.c | 100 +++++++++++++++++++++------------------ include/linux/bpf-cgroup.h | 2 +- include/linux/sysctl.h | 12 ++--- kernel/bpf/cgroup.c | 2 +- scripts/const_structs.checkpatch | 1 + 6 files changed, 63 insertions(+), 56 deletions(-)
---
base-commit: 8400291e289ee6b2bf9779ff1c83a291501f017b
change-id: 20240729-sysctl-const-api-73954f3d62c1
Best regards,
Signature · 1 line
Thomas Weißschuh <[email protected]>
PATCH v2 1/6 sysctl: avoid spurious permanent empty tables
The test if a table is a permanently empty one, inspects the address of the registered ctl_table argument.
However as sysctl_mount_point is an empty array and does not occupy and space it can end up sharing an address with another object in memory. If that other object itself is a "struct ctl_table" then registering that table will fail as it's incorrectly recognized as permanently empty.
Avoid this issue by adding a dummy element to the array so that is not empty anymore.
Explicitly register the table with zero elements as otherwise the dummy element would be recognized as a sentinel element which would lead to a runtime warning from the sysctl core.
While the issue seems not being encountered at this time, this seems mostly to be due to luck.
Also a future change, constifying sysctl_mount_point and root_table, can reliably trigger this issue on clang 18.
Given that empty arrays are non-standard in the first place it seems prudent to avoid them if possible.
--- fs/proc/proc_sysctl.c | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-)
fs/proc/proc_sysctl.c +8 -3
@@ -29,8 +29,13 @@ static const struct inode_operations proc_sys_inode_operations;static const struct file_operations proc_sys_dir_file_operations;static const struct inode_operations proc_sys_dir_operations; -/* Support for permanently empty directories */ -static struct ctl_table sysctl_mount_point[] = { }; +/* +* Support for permanently empty directories. +* Must be non-empty to avoid sharing an address with other tables. +*/ +static struct ctl_table sysctl_mount_point[] = { + { } +};/** * register_sysctl_mount_point() - registers a sysctl mount point
@@ -42,7 +47,7 @@ static struct ctl_table sysctl_mount_point[] = { };*/ struct ctl_table_header *register_sysctl_mount_point (const char *path) { -return register_sysctl (path, sysctl_mount_point); +return register_sysctl_sz (path, sysctl_mount_point,0 ); }EXPORT_SYMBOL (register_sysctl_mount_point);
Signature · 1 line
2.46.0
Re: [PATCH v2 1/6] sysctl: avoid spurious permanent empty tables
(trimmed recipients to only sysctl maintainers)
Hi Joel,
Quoted 13 lines · Thomas Weißschuh
The test if a table is a permanently empty one, inspects the address of the registered
ctl_tableargument.
However assysctl_mount_pointis an empty array and does not occupy and space it can end up sharing an address with another object in memory. If that other object itself is a "structctl_table" then registering that table will fail as it's incorrectly recognized as permanently empty.Avoid this issue by adding a dummy element to the array so that is not empty anymore.
Explicitly register the table with zero elements as otherwise the dummy element would be recognized as a sentinel element which would lead to a runtime warning from the sysctl core.
Quoted 7 lines
While the issue seems not being encountered at this time, this seems mostly to be due to luck.
Also a future change, constifyingsysctl_mount_pointandroot_table, can reliably trigger this issue on clang 18.Given that empty arrays are non-standard in the first place it seems prudent to avoid them if possible.
Unfortunately I forgot to include the following trailers in this patch:
They will be part of v3 if it comes to that, but if you end up applying v2, please do also add those trailers.
Quoted 29 lines
Fixes 4a7b29f65094 ("sysctl: move sysctl type to ctl_table_header")Fixes a35dd3a786f5 ("sysctl: drop now unnecessary out-of-bounds check")Signed-off-by Thomas Weißschuh <[email protected]>--- fs/proc/proc_sysctl.c | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-)fs/proc/proc_sysctl.c +7
-2@@ -29,8 +29,13 @@ static const struct inode_operations proc_sys_inode_operations;static const struct file_operations proc_sys_dir_file_operations;static const struct inode_operations proc_sys_dir_operations; -/* Support for permanently empty directories */ -static struct ctl_table sysctl_mount_point[] = { }; +/* +* Support for permanently empty directories. +* Must be non-empty to avoid sharing an address with other tables. +*/ +static struct ctl_table sysctl_mount_point[] = { + { } +};/** * register_sysctl_mount_point() - registers a sysctl mount point
fs/proc/proc_sysctl.c static struct ctl_table sysctl_mount_point[] = { }; · line 52
Quoted 7 lines
fs/proc/proc_sysctl.c +1
-1@@ -42,7 +47,7 @@ static struct ctl_table sysctl_mount_point[] = { };*/ struct ctl_table_header *register_sysctl_mount_point (const char *path) { -return register_sysctl (path, sysctl_mount_point); +return register_sysctl_sz (path, sysctl_mount_point,0 ); }EXPORT_SYMBOL (register_sysctl_mount_point);
Thanks,
Thomas
Re: [PATCH v2 1/6] sysctl: avoid spurious permanent empty tables
Quoted 26 lines · Thomas Weißschuh
(trimmed recipients to only sysctl maintainers)
Hi Joel,
Quoted 13 lines · Thomas Weißschuh
The test if a table is a permanently empty one, inspects the address of the registered
ctl_tableargument.
However assysctl_mount_pointis an empty array and does not occupy and space it can end up sharing an address with another object in memory. If that other object itself is a "structctl_table" then registering that table will fail as it's incorrectly recognized as permanently empty.Avoid this issue by adding a dummy element to the array so that is not empty anymore.
Explicitly register the table with zero elements as otherwise the dummy element would be recognized as a sentinel element which would lead to a runtime warning from the sysctl core.Quoted 7 lines
While the issue seems not being encountered at this time, this seems mostly to be due to luck.
Also a future change, constifyingsysctl_mount_pointandroot_table, can reliably trigger this issue on clang 18.Given that empty arrays are non-standard in the first place it seems prudent to avoid them if possible.
Quoted 8 lines
Unfortunately I forgot to include the following trailers in this patch:
Reported-by kernel test robot <[email protected]>They will be part of v3 if it comes to that, but if you end up applying v2, please do also add those trailers.
This is a bugfix and it should be included in the next release. Please send this commit separately with the Reported-by tag, I'll make sure that this gets pushed up for 6.11.
I'll add reviewing the rest of the patchset to my "coming back from PTO" todolist. But since we are so late in the cycle, it might get bumped to the next release.
Thx
Signature · 1 line
Joel Granados
Re: [PATCH v2 1/6] sysctl: avoid spurious permanent empty tables
In reply to Thomas WeißschuhHi Joel,
Quoted 18 lines · Thomas Weißschuh
The test if a table is a permanently empty one, inspects the address of the registered
ctl_tableargument.
However assysctl_mount_pointis an empty array and does not occupy and space it can end up sharing an address with another object in memory. If that other object itself is a "structctl_table" then registering that table will fail as it's incorrectly recognized as permanently empty.Avoid this issue by adding a dummy element to the array so that is not empty anymore.
Explicitly register the table with zero elements as otherwise the dummy element would be recognized as a sentinel element which would lead to a runtime warning from the sysctl core.While the issue seems not being encountered at this time, this seems mostly to be due to luck.
Also a future change, constifyingsysctl_mount_pointandroot_table, can reliably trigger this issue on clang 18.
Quoted 7 lines
Given that empty arrays are non-standard in the first place it seems prudent to avoid them if possible.
Fixes 4a7b29f65094 ("sysctl: move sysctl type to ctl_table_header")Fixes a35dd3a786f5 ("sysctl: drop now unnecessary out-of-bounds check")Signed-off-by Thomas Weißschuh <[email protected]>
Any updates on this?
I fear it can theoretically also happen on v6.11.
Quoted 37 lines
--- fs/proc/proc_sysctl.c | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-)fs/proc/proc_sysctl.c +8
-3@@ -29,8 +29,13 @@ static const struct inode_operations proc_sys_inode_operations;static const struct file_operations proc_sys_dir_file_operations;static const struct inode_operations proc_sys_dir_operations; -/* Support for permanently empty directories */ -static struct ctl_table sysctl_mount_point[] = { }; +/* +* Support for permanently empty directories. +* Must be non-empty to avoid sharing an address with other tables. +*/ +static struct ctl_table sysctl_mount_point[] = { + { } +};/** * register_sysctl_mount_point() - registers a sysctl mount point @@ -42,7 +47,7 @@ static struct ctl_table sysctl_mount_point[] = { };*/ struct ctl_table_header *register_sysctl_mount_point (const char *path) { -return register_sysctl (path, sysctl_mount_point); +return register_sysctl_sz (path, sysctl_mount_point,0 ); }EXPORT_SYMBOL (register_sysctl_mount_point);Signature · 2 lines
-- 2.46.0
Re: [PATCH v2 1/6] sysctl: avoid spurious permanent empty tables
Quoted 24 lines · Thomas Weißschuh
Hi Joel,
Quoted 21 lines · Thomas Weißschuh
The test if a table is a permanently empty one, inspects the address of the registered
ctl_tableargument.
However assysctl_mount_pointis an empty array and does not occupy and space it can end up sharing an address with another object in memory. If that other object itself is a "structctl_table" then registering that table will fail as it's incorrectly recognized as permanently empty.Avoid this issue by adding a dummy element to the array so that is not empty anymore.
Explicitly register the table with zero elements as otherwise the dummy element would be recognized as a sentinel element which would lead to a runtime warning from the sysctl core.While the issue seems not being encountered at this time, this seems mostly to be due to luck.
Also a future change, constifyingsysctl_mount_pointandroot_table, can reliably trigger this issue on clang 18.Given that empty arrays are non-standard in the first place it seems prudent to avoid them if possible.
Quoted 8 lines
Quoted 4 lines
Fixes 4a7b29f65094 ("sysctl: move sysctl type to ctl_table_header")Fixes a35dd3a786f5 ("sysctl: drop now unnecessary out-of-bounds check")Signed-off-by Thomas Weißschuh <[email protected]>Any updates on this?
I fear it can theoretically also happen on v6.11.
This is already in next and will probably make it for v6.11. The "fixed" tag will make is so it is ported to 6.10.
Best
Signature · 1 line
Joel Granados
PATCH v2 2/6 bpf: Constify ctl_table argument of filter function
In reply to Thomas WeißschuhThe sysctl core is moving to allow "struct ctl_table" in read-only memory. As a preparation for that all functions handling "struct ctl_table" need to be able to work with "const struct ctl_table".
As __cgroup_bpf_run_filter_sysctl() does not modify its table, it can be adapted trivially.
--- include/linux/bpf-cgroup.h | 2 +- kernel/bpf/cgroup.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-)
include/linux/bpf-cgroup.h +1 -1
@@ -138,7 +138,7 @@ int __cgroup_bpf_check_dev_permission(short dev_type, u32 major, u32 minor, short access, enum cgroup_bpf_attach_type atype);int __cgroup_bpf_run_filter_sysctl (struct ctl_table_header *head, -struct ctl_table *table,int write, +const struct ctl_table *table,int write,char **buf,size_t *pcount,loff_t *ppos,enum cgroup_bpf_attach_type atype);
kernel/bpf/cgroup.c +1 -1
@@ -1691,7 +1691,7 @@ const struct bpf_verifier_ops cg_dev_verifier_ops = {* returned value != 1 during execution. In all other cases 0 is returned. */ int __cgroup_bpf_run_filter_sysctl (struct ctl_table_header *head, -struct ctl_table *table,int write, +const struct ctl_table *table,int write,char **buf,size_t *pcount,loff_t *ppos,enum cgroup_bpf_attach_type atype) {
Signature · 1 line
2.46.0
PATCH v2 3/6 sysctl: move internal interfaces to const struct ctl_table
In reply to Thomas WeißschuhAs a preparation to make all the core sysctl code work with const struct ctl_table switch over the internal function to use the const variant.
Some pointers to "struct ctl_table" need to stay non-const as they are newly allocated and modified before registration.
--- fs/proc/internal.h | 2 +- fs/proc/proc_sysctl.c | 81 +++++++++++++++++++++++++------------------------- include/linux/sysctl.h | 2 +- 3 files changed, 43 insertions(+), 42 deletions(-)
fs/proc/internal.h +1 -1
@@ -102,7 +102,7 @@ struct proc_inode {union proc_op op;struct proc_dir_entry *pde;struct ctl_table_header *sysctl; -struct ctl_table *sysctl_entry; +const struct ctl_table *sysctl_entry;struct hlist_node sibling_inodes;const struct proc_ns_operations *ns_ops;struct inode vfs_inode;
fs/proc/proc_sysctl.c +41 -40
293 lines not on this page · raw message
include/linux/sysctl.h +1 -1
@@ -162,7 +162,7 @@ struct ctl_node { struct ctl_table_header { union { struct { - struct ctl_table *ctl_table; + const struct ctl_table *ctl_table; int ctl_table_size; int used; int count;
Signature · 1 line
2.46.0
PATCH v2 4/6 sysctl: allow registration of const struct ctl_table
In reply to Thomas WeißschuhPutting structure, especially those containing function pointers, into read-only memory makes the safer and easier to reason about. Change the sysctl registration APIs to allow registration of "const struct ctl_table".
--- fs/proc/proc_sysctl.c | 6 +++--- include/linux/sysctl.h | 10 +++++----- 2 files changed, 8 insertions(+), 8 deletions(-)
fs/proc/proc_sysctl.c +3 -3
@@ -1359,7 +1359,7 @@ static struct ctl_dir *sysctl_mkdir_p(struct ctl_dir *dir, const char *path)*/ struct ctl_table_header *__register_sysctl_table (struct ctl_table_set *set, -const char *path,struct ctl_table *table,size_t table_size) +const char *path,const struct ctl_table *table,size_t table_size) {struct ctl_table_root *root = set->dir.header.root;struct ctl_table_header *header;
@@ -1420,7 +1420,7 @@ struct ctl_table_header *__register_sysctl_table(* * See __register_sysctl_table for more details. */ -struct ctl_table_header *register_sysctl_sz (const char *path,struct ctl_table *table, +struct ctl_table_header *register_sysctl_sz (const char *path,const struct ctl_table *table,size_t table_size) { return __register_sysctl_table(&sysctl_table_root.default_set,
@@ -1449,7 +1449,7 @@ EXPORT_SYMBOL(register_sysctl_sz);* * Context: if your base directory does not exist it will be created for you. */ -void __init __register_sysctl_init (const char *path,struct ctl_table *table, +void __init __register_sysctl_init (const char *path,const struct ctl_table *table,const char *table_name,size_t table_size) {struct ctl_table_header *hdr =register_sysctl_sz (path, table, table_size);
include/linux/sysctl.h +5 -5
@@ -223,13 +223,13 @@ extern void retire_sysctl_set(struct ctl_table_set *set);struct ctl_table_header *__register_sysctl_table (struct ctl_table_set *set, -const char *path,struct ctl_table *table,size_t table_size); -struct ctl_table_header *register_sysctl_sz (const char *path,struct ctl_table *table, +const char *path,const struct ctl_table *table,size_t table_size); +struct ctl_table_header *register_sysctl_sz (const char *path,const struct ctl_table *table,size_t table_size);void unregister_sysctl_table (struct ctl_table_header * table);extern int sysctl_init_bases (void ); -extern void __register_sysctl_init (const char *path,struct ctl_table *table, +extern void __register_sysctl_init (const char *path,const struct ctl_table *table,const char *table_name,size_t table_size);#define register_sysctl_init (path, table) \ __register_sysctl_init(path, table, #table, ARRAY_SIZE(table))
@@ -251,7 +251,7 @@ extern int no_unaligned_warning;#else /* CONFIG_SYSCTL */ -static inline void register_sysctl_init (const char *path,struct ctl_table *table) +static inline void register_sysctl_init (const char *path,const struct ctl_table *table) { }
@@ -261,7 +261,7 @@ static inline struct ctl_table_header *register_sysctl_mount_point(const char *p }static inline struct ctl_table_header *register_sysctl_sz (const char *path, -struct ctl_table *table, +const struct ctl_table *table,size_t table_size) {return NULL ;
Signature · 1 line
2.46.0
PATCH v2 5/6 sysctl: make internal ctl_tables const
In reply to Thomas WeißschuhNow that the sysctl core can handle registration of "const struct ctl_table" constify the sysctl internal tables.
--- fs/proc/proc_sysctl.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
fs/proc/proc_sysctl.c +2 -2
@@ -33,7 +33,7 @@ static const struct inode_operations proc_sys_dir_operations;* Support for permanently empty directories. * Must be non-empty to avoid sharing an address with other tables. */ -static struct ctl_table sysctl_mount_point[] = { +static const struct ctl_table sysctl_mount_point[] = { { } };
@@ -67,7 +67,7 @@ void proc_sys_poll_notify(struct ctl_table_poll *poll)wake_up_interruptible (&poll->wait); } -static struct ctl_table root_table[] = { +static const struct ctl_table root_table[] = { { .procname ="" , .mode =S_IFDIR |S_IRUGO |S_IXUGO ,
Signature · 1 line
2.46.0
PATCH v2 6/6 const_structs.checkpatch: add ctl_table
In reply to Thomas WeißschuhNow that the sysctl core can handle "const struct ctl_table", make sure that new usages of the struct already enter the tree as const.
--- scripts/const_structs.checkpatch | 1 + 1 file changed, 1 insertion(+)
scripts/const_structs.checkpatch +1 -0
@@ -6,6 +6,7 @@ bus_type clk_ops comedi_lrange component_ops +ctl_table dentry_operations dev_pm_ops device_type
Signature · 1 line
2.46.0
Joel Granados
maintainerQuoted 2 lines · Thomas Weißschuh
Adapt the internal and external APIs of the sysctl core to handle read-only instances of "struct
ctl_table".
Finally getting around to this. Testing for this has been done on sysctl-testing base:v6.11-rc6 and now on base:v6.12-rc2. Putting this in sysctl-next so it will get further testing on its way to v6.13. First patch (bugfix) will be ignored as it is already upstream.
Best
Quoted 71 lines
Patch 1: Bugfix for the sysctl core, the bug can be reliably triggered
with the series applied
Patch 2: Trivial preparation commit for the sysctl BPF hook Patch 3: Adapts the internal sysctl APIs
Patch 4: Adapts the external sysctl APIs
Patch 5: Constifies the sysctl internal tables as proof that it works Patch 6: Updatesscripts/const_structs.checkpatchfor "structctl_table"Motivation
==========Moving structures containing function pointers into unmodifiable .rodata prevents attackers or bugs from corrupting and diverting those pointers.
Also the "struct
ctl_table" exposed by the sysctl core were never meant to be mutated by users.For this goal changes to both the sysctl core and "const" qualifiers for various sysctl APIs are necessary.
Full Process
============* Drop
ctl_tablemodifications from the sysctl core ([0], in mainline)
* Constify arguments to ctl_table_root::{set_ownership,permissions}
([1], in mainline)
* Migrate users of "ctl_table_header::ctl_table_arg" to "const".
(in mainline)
* Afterwards convert "ctl_table_header::ctl_table_arg" itself to const.
(in mainline)
* Prepare helpers used to implementproc_handlersthroughout the tree to use "const structctl_table*". ([2], in mainline)
* Afterwards switch over allproc_handlerscallbacks to use
"const structctl_table*" in one commit. (in mainline)
* Switch over the internals of the sysctl core to "const structctl_table*" (this series)
* Switchinclude/linux/sysctl.hto "const structctl_table*" (this series)
* Transition instances of "structctl_table" through the tree to const (to be done)This series is meant to be applied through the sysctl tree.
Signed-off-by Thomas Weißschuh <[email protected]>---
Changes in v2:
- Avoid spurious permanent empty tables (patch 1)
- Link to v1: https://lore.kernel.org/r/[email protected]---
Thomas Weißschuh (6):
sysctl: avoid spurious permanent empty tables
bpf: Constifyctl_tableargument of filter function
sysctl: move internal interfaces to const structctl_table
sysctl: allow registration of const structctl_table
sysctl: make internalctl_tablesconst const_structs.checkpatch: addctl_tablefs/proc/internal.h | 2 +- fs/proc/proc_sysctl.c | 100 +++++++++++++++++++++------------------ include/linux/bpf-cgroup.h | 2 +- include/linux/sysctl.h | 12 ++--- kernel/bpf/cgroup.c | 2 +- scripts/const_structs.checkpatch | 1 + 6 files changed, 63 insertions(+), 56 deletions(-)---
base-commit:8400291e289ee6b2bf9779ff1c83a291501f017b
change-id: 20240729-sysctl-const-api-73954f3d62c1Best regards,
Signature · 1 line
Thomas Weißschuh <[email protected]>
Signature · 1 line
Joel Granados