futex: don't leak robust_list pointer on exec race
PATCH v4 1/1 futex: don't leak robust_list pointer on exec race
sys_get_robust_list() and compat_get_robust_list() use ptrace_may_access() to check if the calling task is allowed to access another task's robust_list pointer. This check is racy against a concurrent exec() in the target process.
During exec(), a task may transition from a non-privileged binary to a privileged one (e.g., setuid binary) and its credentials/memory mappings may change. If get_robust_list() performs ptrace_may_access() before this transition, it may erroneously allow access to sensitive information after the target becomes privileged.
A racy access allows an attacker to exploit a window during which ptrace_may_access() passes before a target process transitions to a privileged state via exec().
For example, consider a non-privileged task T that is about to execute a setuid-root binary. An attacker task A calls get_robust_list(T) while T is still unprivileged. Since ptrace_may_access() checks permissions based on current credentials, it succeeds. However, if T begins exec immediately afterwards, it becomes privileged and may change its memory mappings. Because get_robust_list() proceeds to access T->robust_list without synchronizing with exec() it may read user-space pointers from a now-privileged process.
This violates the intended post-exec access restrictions and could expose sensitive memory addresses or be used as a primitive in a larger exploit chain. Consequently, the race can lead to unauthorized disclosure of information across privilege boundaries and poses a potential security risk.
Take a read lock on signal->exec_update_lock prior to invoking ptrace_may_access() and accessing the robust_list/compat_robust_list. This ensures that the target task's exec state remains stable during the check, allowing for consistent and synchronized validation of credentials.
---
changed in v4:
- added task_robust_list() function
changed in v3:
- replaced RCU with scoped_guard(rcu)
- corrected error return type cast
- added IS_ENABLED(CONFIG_COMPAT) for ensuring compatability
- removed stray newlines and unnecessary line breaks changed in v2:
- improved changelog
- helper function for common part of compat and native syscalls
kernel/futex/syscalls.c | 108 +++++++++++++++++++++------------------- 1 file changed, 58 insertions(+), 50 deletions(-)
kernel/futex/syscalls.c +58 -50
@@ -39,6 +39,58 @@ SYSCALL_DEFINE2(set_robust_list, struct robust_list_head __user *, head,return 0 ; } +static inline void __user *task_robust_list (struct task_struct *p,bool compat) +{ +#ifdef CONFIG_COMPAT +if (compat) +return p->compat_robust_list; +#endif +return p->robust_list; +} + +static void __user *get_robust_list_common (int pid,bool compat) +{ +struct task_struct *p; +void __user *head; +unsigned long ret; + + p = current; + +scoped_guard (rcu) { +if (pid) { + p =find_task_by_vpid (pid); +if (!p) +return (void __user *)ERR_PTR (-ESRCH ); + } +get_task_struct (p); + } + +/* +* Hold exec_update_lock to serialize with concurrent exec() +* so ptrace_may_access() is checked against stable credentials +*/ + ret =down_read_killable (&p->signal->exec_update_lock); +if (ret) + goto err_put; + + ret = -EPERM ; +if (!ptrace_may_access (p,PTRACE_MODE_READ_REALCREDS )) + goto err_unlock; + + head =task_robust_list (p, compat); + +up_read (&p->signal->exec_update_lock); +put_task_struct (p); + +return head; + +err_unlock: +up_read (&p->signal->exec_update_lock); +err_put: +put_task_struct (p); +return (void __user *)ERR_PTR (ret); +} +/** * sys_get_robust_list() - Get the robust-futex list head of a task * @pid: pid of the process [zero for current task]
@@ -49,36 +101,14 @@ SYSCALL_DEFINE3(get_robust_list, int, pid, struct robust_list_head __user * __user *, head_ptr, size_t __user *, len_ptr) { - struct robust_list_head __user *head; -unsigned long ret; -struct task_struct *p; - -rcu_read_lock (); - - ret = -ESRCH ; -if (!pid) - p = current; -else { - p =find_task_by_vpid (pid); -if (!p) - goto err_unlock; - } + struct robust_list_head __user *head = get_robust_list_common(pid, false); - ret = -EPERM ; -if (!ptrace_may_access (p,PTRACE_MODE_READ_REALCREDS )) - goto err_unlock; - - head = p->robust_list; -rcu_read_unlock (); +if (IS_ERR (head)) +return PTR_ERR (head);if (put_user (sizeof (*head), len_ptr))return -EFAULT ;return put_user (head, head_ptr); - -err_unlock: -rcu_read_unlock (); - -return ret; } long do_futex(u32 __user *uaddr, int op, u32 val, ktime_t *timeout,
@@ -455,36 +485,14 @@ COMPAT_SYSCALL_DEFINE3(get_robust_list, int, pid, compat_uptr_t __user *, head_ptr, compat_size_t __user *, len_ptr) { -struct compat_robust_list_head __user *head; -unsigned long ret; -struct task_struct *p; - -rcu_read_lock (); - - ret = -ESRCH ; -if (!pid) - p = current; -else { - p =find_task_by_vpid (pid); -if (!p) - goto err_unlock; - } - - ret = -EPERM ; -if (!ptrace_may_access (p,PTRACE_MODE_READ_REALCREDS )) - goto err_unlock; +struct compat_robust_list_head __user *head =get_robust_list_common (pid, true); - head = p->compat_robust_list; -rcu_read_unlock (); +if (IS_ERR (head)) +return PTR_ERR (head);if (put_user (sizeof (*head), len_ptr))return -EFAULT ;return put_user (ptr_to_compat (head), head_ptr); - -err_unlock: -rcu_read_unlock (); - -return ret; }#endif /* CONFIG_COMPAT */
Signature · 1 line
2.49.0
Quoted 200 lines · Pranav Tyagi
sys_get_robust_list()andcompat_get_robust_list()useptrace_may_access()to check if the calling task is allowed to access another task'srobust_listpointer. This check is racy against a concurrentexec()in the target process.During
exec(), a task may transition from a non-privileged binary to a privileged one (e.g., setuid binary) and its credentials/memory mappings may change. Ifget_robust_list()performsptrace_may_access()before this transition, it may erroneously allow access to sensitive information after the target becomes privileged.A racy access allows an attacker to exploit a window during which
ptrace_may_access()passes before a target process transitions to a privileged state viaexec().For example, consider a non-privileged task T that is about to execute a setuid-root binary. An attacker task A calls
get_robust_list(T)while T is still unprivileged. Sinceptrace_may_access()checks permissions based on current credentials, it succeeds. However, if T begins exec immediately afterwards, it becomes privileged and may change its memory mappings. Becauseget_robust_list()proceeds to accessT->robust_listwithout synchronizing withexec()it may read user-space pointers from a now-privileged process.This violates the intended post-exec access restrictions and could expose sensitive memory addresses or be used as a primitive in a larger exploit chain. Consequently, the race can lead to unauthorized disclosure of information across privilege boundaries and poses a potential security risk.
Take a read lock on
signal->exec_update_lockprior to invokingptrace_may_access()and accessing the robust_list/compat_robust_list. This ensures that the target task's exec state remains stable during the check, allowing for consistent and synchronized validation of credentials.Signed-off-by Pranav Tyagi <[email protected]>Suggested-by Jann Horn <[email protected]>---
changed in v4:
- addedtask_robust_list()function
changed in v3:
- replaced RCU withscoped_guard(rcu)
- corrected error return type cast
- addedIS_ENABLED(CONFIG_COMPAT)for ensuring compatability
- removed stray newlines and unnecessary line breaks changed in v2:
- improved changelog
- helper function for common part of compat and native syscallskernel/futex/syscalls.c | 108 +++++++++++++++++++++------------------- 1 file changed, 58 insertions(+), 50 deletions(-)kernel/futex/syscalls.c +58
-51@@ -39,6 +39,58 @@ SYSCALL_DEFINE2(set_robust_list, struct robust_list_head __user *, head,return 0 ; } +static inline void __user *task_robust_list (struct task_struct *p,bool compat) +{ +#ifdef CONFIG_COMPAT +if (compat) +return p->compat_robust_list; +#endif +return p->robust_list; +} + +static void __user *get_robust_list_common (int pid,bool compat) +{ +struct task_struct *p; +void __user *head; +unsigned long ret; + + p = current; + +scoped_guard (rcu) { +if (pid) { + p =find_task_by_vpid (pid); +if (!p) +return (void __user *)ERR_PTR (-ESRCH ); + } +get_task_struct (p); + } + +/* +* Hold exec_update_lock to serialize with concurrent exec() +* so ptrace_may_access() is checked against stable credentials +*/ + ret =down_read_killable (&p->signal->exec_update_lock); +if (ret) + goto err_put; + + ret = -EPERM ; +if (!ptrace_may_access (p,PTRACE_MODE_READ_REALCREDS )) + goto err_unlock; + + head =task_robust_list (p, compat); + +up_read (&p->signal->exec_update_lock); +put_task_struct (p); + +return head; + +err_unlock: +up_read (&p->signal->exec_update_lock); +err_put: +put_task_struct (p); +return (void __user *)ERR_PTR (ret); +} +/** * sys_get_robust_list() - Get the robust-futex list head of a task * @pid: pid of the process [zero for current task] @@ -49,36 +101,14 @@ SYSCALL_DEFINE3(get_robust_list, int, pid, struct robust_list_head __user * __user *, head_ptr, size_t __user *, len_ptr) { - struct robust_list_head __user *head; -unsigned long ret; -struct task_struct *p; - -rcu_read_lock (); - - ret = -ESRCH ; -if (!pid) - p = current; -else { - p =find_task_by_vpid (pid); -if (!p) - goto err_unlock; - } + struct robust_list_head __user *head = get_robust_list_common(pid, false); - ret = -EPERM ; -if (!ptrace_may_access (p,PTRACE_MODE_READ_REALCREDS )) - goto err_unlock; - - head = p->robust_list; -rcu_read_unlock (); +if (IS_ERR (head)) +return PTR_ERR (head);if (put_user (sizeof (*head), len_ptr))return -EFAULT ;return put_user (head, head_ptr); - -err_unlock: -rcu_read_unlock (); - -return ret; } long do_futex(u32 __user *uaddr, int op, u32 val, ktime_t *timeout,@@ -455,36 +485,14 @@ COMPAT_SYSCALL_DEFINE3(get_robust_list, int, pid, compat_uptr_t __user *, head_ptr, compat_size_t __user *, len_ptr) { -struct compat_robust_list_head __user *head; -unsigned long ret; -struct task_struct *p; - -rcu_read_lock (); - - ret = -ESRCH ; -if (!pid) - p = current; -else { - p =find_task_by_vpid (pid); -if (!p) - goto err_unlock; - } - - ret = -EPERM ; -if (!ptrace_may_access (p,PTRACE_MODE_READ_REALCREDS )) - goto err_unlock; +struct compat_robust_list_head __user *head =get_robust_list_common (pid, true); - head = p->compat_robust_list; -rcu_read_unlock (); +if (IS_ERR (head)) +return PTR_ERR (head);if (put_user (sizeof (*head), len_ptr))return -EFAULT ;return put_user (ptr_to_compat (head), head_ptr); - -err_unlock: -rcu_read_unlock (); - -return ret; }#endif /* CONFIG_COMPAT */ --
Quoted 2 lines
2.49.0
Hi,
This is a gentle follow-up on this patch. Please let me know if any further changes are required.
Regards
Pranav Tyagi
Quoted 200 lines · Pranav Tyagi
sys_get_robust_list()andcompat_get_robust_list()useptrace_may_access()to check if the calling task is allowed to access another task'srobust_listpointer. This check is racy against a concurrentexec()in the target process.During
exec(), a task may transition from a non-privileged binary to a privileged one (e.g., setuid binary) and its credentials/memory mappings may change. Ifget_robust_list()performsptrace_may_access()before this transition, it may erroneously allow access to sensitive information after the target becomes privileged.A racy access allows an attacker to exploit a window during which
ptrace_may_access()passes before a target process transitions to a privileged state viaexec().For example, consider a non-privileged task T that is about to execute a setuid-root binary. An attacker task A calls
get_robust_list(T)while T is still unprivileged. Sinceptrace_may_access()checks permissions based on current credentials, it succeeds. However, if T begins exec immediately afterwards, it becomes privileged and may change its memory mappings. Becauseget_robust_list()proceeds to accessT->robust_listwithout synchronizing withexec()it may read user-space pointers from a now-privileged process.This violates the intended post-exec access restrictions and could expose sensitive memory addresses or be used as a primitive in a larger exploit chain. Consequently, the race can lead to unauthorized disclosure of information across privilege boundaries and poses a potential security risk.
Take a read lock on
signal->exec_update_lockprior to invokingptrace_may_access()and accessing the robust_list/compat_robust_list. This ensures that the target task's exec state remains stable during the check, allowing for consistent and synchronized validation of credentials.Signed-off-by Pranav Tyagi <[email protected]>Suggested-by Jann Horn <[email protected]>---
changed in v4:
- addedtask_robust_list()function
changed in v3:
- replaced RCU withscoped_guard(rcu)
- corrected error return type cast
- addedIS_ENABLED(CONFIG_COMPAT)for ensuring compatability
- removed stray newlines and unnecessary line breaks changed in v2:
- improved changelog
- helper function for common part of compat and native syscallskernel/futex/syscalls.c | 108 +++++++++++++++++++++------------------- 1 file changed, 58 insertions(+), 50 deletions(-)kernel/futex/syscalls.c +58
-51@@ -39,6 +39,58 @@ SYSCALL_DEFINE2(set_robust_list, struct robust_list_head __user *, head,return 0 ; } +static inline void __user *task_robust_list (struct task_struct *p,bool compat) +{ +#ifdef CONFIG_COMPAT +if (compat) +return p->compat_robust_list; +#endif +return p->robust_list; +} + +static void __user *get_robust_list_common (int pid,bool compat) +{ +struct task_struct *p; +void __user *head; +unsigned long ret; + + p = current; + +scoped_guard (rcu) { +if (pid) { + p =find_task_by_vpid (pid); +if (!p) +return (void __user *)ERR_PTR (-ESRCH ); + } +get_task_struct (p); + } + +/* +* Hold exec_update_lock to serialize with concurrent exec() +* so ptrace_may_access() is checked against stable credentials +*/ + ret =down_read_killable (&p->signal->exec_update_lock); +if (ret) + goto err_put; + + ret = -EPERM ; +if (!ptrace_may_access (p,PTRACE_MODE_READ_REALCREDS )) + goto err_unlock; + + head =task_robust_list (p, compat); + +up_read (&p->signal->exec_update_lock); +put_task_struct (p); + +return head; + +err_unlock: +up_read (&p->signal->exec_update_lock); +err_put: +put_task_struct (p); +return (void __user *)ERR_PTR (ret); +} +/** * sys_get_robust_list() - Get the robust-futex list head of a task * @pid: pid of the process [zero for current task] @@ -49,36 +101,14 @@ SYSCALL_DEFINE3(get_robust_list, int, pid, struct robust_list_head __user * __user *, head_ptr, size_t __user *, len_ptr) { - struct robust_list_head __user *head; -unsigned long ret; -struct task_struct *p; - -rcu_read_lock (); - - ret = -ESRCH ; -if (!pid) - p = current; -else { - p =find_task_by_vpid (pid); -if (!p) - goto err_unlock; - } + struct robust_list_head __user *head = get_robust_list_common(pid, false); - ret = -EPERM ; -if (!ptrace_may_access (p,PTRACE_MODE_READ_REALCREDS )) - goto err_unlock; - - head = p->robust_list; -rcu_read_unlock (); +if (IS_ERR (head)) +return PTR_ERR (head);if (put_user (sizeof (*head), len_ptr))return -EFAULT ;return put_user (head, head_ptr); - -err_unlock: -rcu_read_unlock (); - -return ret; } long do_futex(u32 __user *uaddr, int op, u32 val, ktime_t *timeout,@@ -455,36 +485,14 @@ COMPAT_SYSCALL_DEFINE3(get_robust_list, int, pid, compat_uptr_t __user *, head_ptr, compat_size_t __user *, len_ptr) { -struct compat_robust_list_head __user *head; -unsigned long ret; -struct task_struct *p; - -rcu_read_lock (); - - ret = -ESRCH ; -if (!pid) - p = current; -else { - p =find_task_by_vpid (pid); -if (!p) - goto err_unlock; - } - - ret = -EPERM ; -if (!ptrace_may_access (p,PTRACE_MODE_READ_REALCREDS )) - goto err_unlock; +struct compat_robust_list_head __user *head =get_robust_list_common (pid, true); - head = p->compat_robust_list; -rcu_read_unlock (); +if (IS_ERR (head)) +return PTR_ERR (head);if (put_user (sizeof (*head), len_ptr))return -EFAULT ;return put_user (ptr_to_compat (head), head_ptr); - -err_unlock: -rcu_read_unlock (); - -return ret; }#endif /* CONFIG_COMPAT */ --
Quoted 2 lines
2.49.0
Hi,
Gentle ping. I am looking forward to any suggestions on this patch and would be more than happy to make any necessary changes.
Regards
Pranav Tyagi
André Almeida
reviewerHi Pranav,
Thanks for your patch! Some feedback bellow.
Em 13/08/2025 04:42, Pranav Tyagi escreveu:
Quoted 60 lines
sys_get_robust_list()andcompat_get_robust_list()useptrace_may_access()to check if the calling task is allowed to access another task'srobust_listpointer. This check is racy against a concurrentexec()in the target process.During
exec(), a task may transition from a non-privileged binary to a privileged one (e.g., setuid binary) and its credentials/memory mappings may change. Ifget_robust_list()performsptrace_may_access()before this transition, it may erroneously allow access to sensitive information after the target becomes privileged.A racy access allows an attacker to exploit a window during which
ptrace_may_access()passes before a target process transitions to a privileged state viaexec().For example, consider a non-privileged task T that is about to execute a setuid-root binary. An attacker task A calls
get_robust_list(T)while T is still unprivileged. Sinceptrace_may_access()checks permissions based on current credentials, it succeeds. However, if T begins exec immediately afterwards, it becomes privileged and may change its memory mappings. Becauseget_robust_list()proceeds to accessT->robust_listwithout synchronizing withexec()it may read user-space pointers from a now-privileged process.This violates the intended post-exec access restrictions and could expose sensitive memory addresses or be used as a primitive in a larger exploit chain. Consequently, the race can lead to unauthorized disclosure of information across privilege boundaries and poses a potential security risk.
Take a read lock on
signal->exec_update_lockprior to invokingptrace_may_access()and accessing the robust_list/compat_robust_list. This ensures that the target task's exec state remains stable during the check, allowing for consistent and synchronized validation of credentials.Signed-off-by Pranav Tyagi <[email protected]>Suggested-by Jann Horn <[email protected]>---
changed in v4:
- addedtask_robust_list()function
changed in v3:
- replaced RCU withscoped_guard(rcu)
- corrected error return type cast
- addedIS_ENABLED(CONFIG_COMPAT)for ensuring compatability
- removed stray newlines and unnecessary line breaks changed in v2:
- improved changelog
- helper function for common part of compat and native syscallskernel/futex/syscalls.c | 108 +++++++++++++++++++++------------------- 1 file changed, 58 insertions(+), 50 deletions(-)kernel/futex/syscalls.c +0
-0
kernel/futex/syscalls.c SYSCALL_DEFINE2(set_robust_list, struct robust_list_head __user *, head, · line 42
Quoted 4 lines
kernel/futex/syscalls.c +1
-0@@ -39,6 +39,58 @@ SYSCALL_DEFINE2(set_robust_list, struct robust_list_head __user *, head,return 0 ; } +static inline void __user *task_robust_list (struct task_struct *p,bool compat)
Function names inside of kernel/futex/ have the futex_ prefix
kernel/futex/syscalls.c SYSCALL_DEFINE2(set_robust_list, struct robust_list_head __user *, head, · line 51
Quoted 9 lines
kernel/futex/syscalls.c +9
-0+{ +#ifdef CONFIG_COMPAT +if (compat) +return p->compat_robust_list; +#endif +return p->robust_list; +} + +static void __user *get_robust_list_common (int pid,bool compat)
Same here
kernel/futex/syscalls.c SYSCALL_DEFINE2(set_robust_list, struct robust_list_head __user *, head, · line 55
Quoted 4 lines
kernel/futex/syscalls.c +4
-0+{ +struct task_struct *p; +void __user *head; +unsigned long ret;
down_read_killable() returns a int, but you are storing the return value in an unsigned long.
kernel/futex/syscalls.c SYSCALL_DEFINE2(set_robust_list, struct robust_list_head __user *, head, · line 57
Quoted 2 lines
kernel/futex/syscalls.c +2
-0+ + p = current;
Could this be initialized in the declaration?
Quoted 119 lines
kernel/futex/syscalls.c +42
-50+ +scoped_guard (rcu) { +if (pid) { + p =find_task_by_vpid (pid); +if (!p) +return (void __user *)ERR_PTR (-ESRCH ); + } +get_task_struct (p); + } + +/* +* Hold exec_update_lock to serialize with concurrent exec() +* so ptrace_may_access() is checked against stable credentials +*/ + ret =down_read_killable (&p->signal->exec_update_lock); +if (ret) + goto err_put; + + ret = -EPERM ; +if (!ptrace_may_access (p,PTRACE_MODE_READ_REALCREDS )) + goto err_unlock; + + head =task_robust_list (p, compat); + +up_read (&p->signal->exec_update_lock); +put_task_struct (p); + +return head; + +err_unlock: +up_read (&p->signal->exec_update_lock); +err_put: +put_task_struct (p); +return (void __user *)ERR_PTR (ret); +} +/** * sys_get_robust_list() - Get the robust-futex list head of a task * @pid: pid of the process [zero for current task] @@ -49,36 +101,14 @@ SYSCALL_DEFINE3(get_robust_list, int, pid, struct robust_list_head __user * __user *, head_ptr, size_t __user *, len_ptr) { - struct robust_list_head __user *head; -unsigned long ret; -struct task_struct *p; - -rcu_read_lock (); - - ret = -ESRCH ; -if (!pid) - p = current; -else { - p =find_task_by_vpid (pid); -if (!p) - goto err_unlock; - } + struct robust_list_head __user *head = get_robust_list_common(pid, false); - ret = -EPERM ; -if (!ptrace_may_access (p,PTRACE_MODE_READ_REALCREDS )) - goto err_unlock; - - head = p->robust_list; -rcu_read_unlock (); +if (IS_ERR (head)) +return PTR_ERR (head);if (put_user (sizeof (*head), len_ptr))return -EFAULT ;return put_user (head, head_ptr); - -err_unlock: -rcu_read_unlock (); - -return ret; } long do_futex(u32 __user *uaddr, int op, u32 val, ktime_t *timeout,@@ -455,36 +485,14 @@ COMPAT_SYSCALL_DEFINE3(get_robust_list, int, pid, compat_uptr_t __user *, head_ptr, compat_size_t __user *, len_ptr) { -struct compat_robust_list_head __user *head; -unsigned long ret; -struct task_struct *p; - -rcu_read_lock (); - - ret = -ESRCH ; -if (!pid) - p = current; -else { - p =find_task_by_vpid (pid); -if (!p) - goto err_unlock; - } - - ret = -EPERM ; -if (!ptrace_may_access (p,PTRACE_MODE_READ_REALCREDS )) - goto err_unlock; +struct compat_robust_list_head __user *head =get_robust_list_common (pid, true); - head = p->compat_robust_list; -rcu_read_unlock (); +if (IS_ERR (head)) +return PTR_ERR (head);if (put_user (sizeof (*head), len_ptr))return -EFAULT ;return put_user (ptr_to_compat (head), head_ptr); - -err_unlock: -rcu_read_unlock (); - -return ret; }#endif /* CONFIG_COMPAT */
Quoted 206 lines · André Almeida
Hi Pranav,
Thanks for your patch! Some feedback bellow.
Em 13/08/2025 04:42, Pranav Tyagi escreveu:
Quoted 60 lines
sys_get_robust_list()andcompat_get_robust_list()useptrace_may_access()to check if the calling task is allowed to access another task'srobust_listpointer. This check is racy against a concurrentexec()in the target process.During
exec(), a task may transition from a non-privileged binary to a privileged one (e.g., setuid binary) and its credentials/memory mappings may change. Ifget_robust_list()performsptrace_may_access()before this transition, it may erroneously allow access to sensitive information after the target becomes privileged.A racy access allows an attacker to exploit a window during which
ptrace_may_access()passes before a target process transitions to a privileged state viaexec().For example, consider a non-privileged task T that is about to execute a setuid-root binary. An attacker task A calls
get_robust_list(T)while T is still unprivileged. Sinceptrace_may_access()checks permissions based on current credentials, it succeeds. However, if T begins exec immediately afterwards, it becomes privileged and may change its memory mappings. Becauseget_robust_list()proceeds to accessT->robust_listwithout synchronizing withexec()it may read user-space pointers from a now-privileged process.This violates the intended post-exec access restrictions and could expose sensitive memory addresses or be used as a primitive in a larger exploit chain. Consequently, the race can lead to unauthorized disclosure of information across privilege boundaries and poses a potential security risk.
Take a read lock on
signal->exec_update_lockprior to invokingptrace_may_access()and accessing the robust_list/compat_robust_list. This ensures that the target task's exec state remains stable during the check, allowing for consistent and synchronized validation of credentials.Signed-off-by Pranav Tyagi <[email protected]>Suggested-by Jann Horn <[email protected]>---
changed in v4:
- addedtask_robust_list()function
changed in v3:
- replaced RCU withscoped_guard(rcu)
- corrected error return type cast
- addedIS_ENABLED(CONFIG_COMPAT)for ensuring compatability
- removed stray newlines and unnecessary line breaks changed in v2:
- improved changelog
- helper function for common part of compat and native syscallskernel/futex/syscalls.c | 108 +++++++++++++++++++++------------------- 1 file changed, 58 insertions(+), 50 deletions(-)kernel/futex/syscalls.c +0
-0kernel/futex/syscalls.c SYSCALL_DEFINE2(set_robust_list, struct robust_list_head __user *, head, · line 42
Quoted 4 lines
kernel/futex/syscalls.c +1
-0@@ -39,6 +39,58 @@ SYSCALL_DEFINE2(set_robust_list, struct robust_list_head __user *, head,return 0 ; } +static inline void __user *task_robust_list (struct task_struct *p,bool compat)Function names inside of
kernel/futex/have thefutex_prefixkernel/futex/syscalls.c SYSCALL_DEFINE2(set_robust_list, struct robust_list_head __user *, head, · line 51
Quoted 9 lines
kernel/futex/syscalls.c +9
-0+{ +#ifdef CONFIG_COMPAT +if (compat) +return p->compat_robust_list; +#endif +return p->robust_list; +} + +static void __user *get_robust_list_common (int pid,bool compat)Same here
kernel/futex/syscalls.c SYSCALL_DEFINE2(set_robust_list, struct robust_list_head __user *, head, · line 55
Quoted 4 lines
kernel/futex/syscalls.c +4
-0+{ +struct task_struct *p; +void __user *head; +unsigned long ret;
down_read_killable()returns a int, but you are storing the return value in an unsigned long.kernel/futex/syscalls.c SYSCALL_DEFINE2(set_robust_list, struct robust_list_head __user *, head, · line 57
Quoted 2 lines
kernel/futex/syscalls.c +2
-0+ + p = current;Could this be initialized in the declaration?
Quoted 108 lines
kernel/futex/syscalls.c +42
-45+ +scoped_guard (rcu) { +if (pid) { + p =find_task_by_vpid (pid); +if (!p) +return (void __user *)ERR_PTR (-ESRCH ); + } +get_task_struct (p); + } + +/* +* Hold exec_update_lock to serialize with concurrent exec() +* so ptrace_may_access() is checked against stable credentials +*/ + ret =down_read_killable (&p->signal->exec_update_lock); +if (ret) + goto err_put; + + ret = -EPERM ; +if (!ptrace_may_access (p,PTRACE_MODE_READ_REALCREDS )) + goto err_unlock; + + head =task_robust_list (p, compat); + +up_read (&p->signal->exec_update_lock); +put_task_struct (p); + +return head; + +err_unlock: +up_read (&p->signal->exec_update_lock); +err_put: +put_task_struct (p); +return (void __user *)ERR_PTR (ret); +} +/** * sys_get_robust_list() - Get the robust-futex list head of a task * @pid: pid of the process [zero for current task] @@ -49,36 +101,14 @@ SYSCALL_DEFINE3(get_robust_list, int, pid, struct robust_list_head __user * __user *, head_ptr, size_t __user *, len_ptr) { - struct robust_list_head __user *head; -unsigned long ret; -struct task_struct *p; - -rcu_read_lock (); - - ret = -ESRCH ; -if (!pid) - p = current; -else { - p =find_task_by_vpid (pid); -if (!p) - goto err_unlock; - } + struct robust_list_head __user *head = get_robust_list_common(pid, false); - ret = -EPERM ; -if (!ptrace_may_access (p,PTRACE_MODE_READ_REALCREDS )) - goto err_unlock; - - head = p->robust_list; -rcu_read_unlock (); +if (IS_ERR (head)) +return PTR_ERR (head);if (put_user (sizeof (*head), len_ptr))return -EFAULT ;return put_user (head, head_ptr); - -err_unlock: -rcu_read_unlock (); - -return ret; } long do_futex(u32 __user *uaddr, int op, u32 val, ktime_t *timeout,@@ -455,36 +485,14 @@ COMPAT_SYSCALL_DEFINE3(get_robust_list, int, pid, compat_uptr_t __user *, head_ptr, compat_size_t __user *, len_ptr) { -struct compat_robust_list_head __user *head; -unsigned long ret; -struct task_struct *p; - -rcu_read_lock (); - - ret = -ESRCH ; -if (!pid) - p = current; -else { - p =find_task_by_vpid (pid); -if (!p) - goto err_unlock; - } - - ret = -EPERM ; -if (!ptrace_may_access (p,PTRACE_MODE_READ_REALCREDS )) - goto err_unlock; +struct compat_robust_list_head __user *head =get_robust_list_common (pid, true); - head = p->compat_robust_list; -rcu_read_unlock (); +if (IS_ERR (head)) +return PTR_ERR (head);
Quoted 12 lines
kernel/futex/syscalls.c COMPAT_SYSCALL_DEFINE3(get_robust_list, int, pid, · line 498
Quoted 11 lines
kernel/futex/syscalls.c +0
-5if (put_user (sizeof (*head), len_ptr))return -EFAULT ; return put_user(ptr_to_compat(head), head_ptr); - -err_unlock: -rcu_read_unlock (); - - return ret; }#endif /* CONFIG_COMPAT */
Hi André,
Thanks for the feedback. I will make all the changes as per your observations and send a v5.
Regards
Pranav Tyagi