7.4 CVE-2025-38352

CISA Kev Catalog Patch

In the Linux kernel, the following vulnerability has been resolved: posix-cpu-timers: fix race between handle_posix_cpu_timers() and posix_cpu_timer_del() If an exiting non-autoreaping task has already passed exit_notify() and calls handle_posix_cpu_timers() from IRQ, it can be reaped by its parent or debugger right after unlock_task_sighand(). If a concurrent posix_cpu_timer_del() runs at that moment, it won't be able to detect timer->it.cpu.firing != 0: cpu_timer_task_rcu() and/or lock_task_sighand() will fail. Add the tsk->exit_state check into run_posix_cpu_timers() to fix this. This fix is not needed if CONFIG_POSIX_CPU_TIMERS_TASK_WORK=y, because exit_task_work() is called before exit_notify(). But the check still makes sense, task_work_add(&tsk->posix_cputimers_work.work) will fail anyway in this case.
https://nvd.nist.gov/vuln/detail/CVE-2025-38352

Categories

CWE-367 : Time-of-check Time-of-use (TOCTOU) Race Condition
The product checks the state of a resource before using that resource, but the resource's state can change between the check and the use in a way that invalidates the results of the check. The TOCTTOU acronym expands to "Time Of Check To Time Of Use". The TOCCTOU acronym is most likely a typo of TOCTTOU, but it has been used in some influential documents, so the typo is repeated fairly frequently. Automated static analysis, commonly referred to as Static Application Security Testing (SAST), can find some instances of this weakness by analyzing source code (or binary/compiled code) without having to execute it. Typically, this is done by building a model of data flow and control flow, then searching for potentially-vulnerable patterns that connect "sources" (origins of input) with "sinks" (destinations where the data interacts with external components, a lower layer such as the OS, etc.) The most basic advice for TOCTOU vulnerabilities is to not perform a check before the use. This does not resolve the underlying issue of the execution of a function on a resource whose state and identity cannot be assured, but it does help to limit the false sense of security given by the check. When the file being altered is owned by the current user and group, set the effective gid and uid to that of the current user and group when executing this statement. Limit the interleaving of operations on files from multiple processes. If you cannot perform operations atomically and you must share access to the resource between multiple processes or threads, then try to limit the amount of time (CPU cycles) between the check and use of the resource. This will not fix the problem, but it could make it more difficult for an attack to succeed. Recheck the resource after the use call to verify that the action was taken appropriately. Ensure that some environmental locking mechanism can be used to protect resources effectively. Ensure that locking occurs before the check, as opposed to afterwards, such that the resource, as checked, is the same as it is when in use. TOCTOU in sandbox process allows installation of untrusted browser add-ons by replacing a file after it has been verified, but before it is executed Chain: A multi-threaded race condition (CWE-367) allows attackers to cause two threads to process the same RPC request, which causes a use-after-free (CWE-416) in one thread PHP flaw allows remote attackers to execute arbitrary code by aborting execution before the initialization of key data structures is complete. chain: time-of-check time-of-use (TOCTOU) race condition in program allows bypass of protection mechanism that was designed to prevent symlink attacks. chain: time-of-check time-of-use (TOCTOU) race condition in program allows bypass of protection mechanism that was designed to prevent symlink attacks.

References

134c704f-9b21-4f2e-91b3-4a467353bcc0

https://www.cisa.gov/known-exploited-vulnerabilities-catalog?field_cve=CVE-20... US Government Resource

416baaa9-dc9f-4396-8d5f-8c081fb06d67 Patch

https://git.kernel.org/stable/c/2c72fe18cc5f9f1750f5bc148cf1c94c29e106ff Patch
https://git.kernel.org/stable/c/2f3daa04a9328220de46f0d5c919a6c0073a9f0b Patch
https://git.kernel.org/stable/c/460188bc042a3f40f72d34b9f7fc6ee66b0b757b Patch
https://git.kernel.org/stable/c/764a7a5dfda23f69919441f2eac2a83e7db6e5bb Patch
https://git.kernel.org/stable/c/78a4b8e3795b31dae58762bc091bb0f4f74a2200 Patch
https://git.kernel.org/stable/c/c076635b3a42771ace7d276de8dc3bc76ee2ba1b Patch
https://git.kernel.org/stable/c/c29d5318708e67ac13c1b6fc1007d179fb65b4d7 Patch
https://git.kernel.org/stable/c/f90fff1e152dedf52b932240ebbd670d83330eca Patch

af854a3a-2127-422b-91ae-364da2661108 Patch

https://lists.debian.org/debian-lts-announce/2025/10/msg00007.html Mailing List Third Party Advisory
https://lists.debian.org/debian-lts-announce/2025/10/msg00008.html Mailing List Third Party Advisory

CPE

cpe	start	end
Configuration 1
cpe:2.3:o:linux:linux_kernel::::::::	>= 2.6.36	< 5.4.295
cpe:2.3:o:linux:linux_kernel::::::::	>= 5.5	< 5.10.239
cpe:2.3:o:linux:linux_kernel::::::::	>= 5.11	< 5.15.186
cpe:2.3:o:linux:linux_kernel::::::::	>= 5.16	< 6.1.142
cpe:2.3:o:linux:linux_kernel::::::::	>= 6.2	< 6.6.94
cpe:2.3:o:linux:linux_kernel::::::::	>= 6.7	< 6.12.34
cpe:2.3:o:linux:linux_kernel::::::::	>= 6.13	< 6.15.3
cpe:2.3:o:linux:linux_kernel:6.16:rc1::::::
Configuration 2
cpe:2.3:o:debian:debian_linux:11.0:::::::*

REMEDIATION

Patch

Url
https://git.kernel.org/stable/c/2c72fe18cc5f9f1750f5bc148cf1c94c29e106ff
https://git.kernel.org/stable/c/2f3daa04a9328220de46f0d5c919a6c0073a9f0b
https://git.kernel.org/stable/c/460188bc042a3f40f72d34b9f7fc6ee66b0b757b
https://git.kernel.org/stable/c/764a7a5dfda23f69919441f2eac2a83e7db6e5bb
https://git.kernel.org/stable/c/78a4b8e3795b31dae58762bc091bb0f4f74a2200
https://git.kernel.org/stable/c/c076635b3a42771ace7d276de8dc3bc76ee2ba1b
https://git.kernel.org/stable/c/c29d5318708e67ac13c1b6fc1007d179fb65b4d7
https://git.kernel.org/stable/c/f90fff1e152dedf52b932240ebbd670d83330eca

EXPLOITS

Exploit-db.com

id	description	date
No known exploits

POC Github

Url
No known exploits

Other Nist (github, ...)

Url
No known exploits

CAPEC

Common Attack Pattern Enumerations and Classifications

id	description	severity
27	Leveraging Race Conditions via Symbolic Links This attack leverages the use of symbolic links (Symlinks) in order to write to sensitive files. An attacker can create a Symlink link to a target file not otherwise accessible to them. When the privileged program tries to create a temporary file with the same name as the Symlink link, it will actually write to the target file pointed to by the attackers' Symlink link. If the attacker can insert malicious content in the temporary file they will be writing to the sensitive file by using the Symlink. The race occurs because the system checks if the temporary file exists, then creates the file. The attacker would typically create the Symlink during the interval between the check and the creation of the temporary file. [Verify that target host's platform supports symbolic links.] This attack pattern is only applicable on platforms that support symbolic links. [Examine application's file I/O behavior] Analyze the application's file I/O behavior to determine where it stores files, as well as the operations it performs to read/write files. [Verify ability to write to filesystem] The attacker verifies ability to write to the target host's file system. [Replace file with a symlink to a sensitive system file.] Between the time that the application checks to see if a file exists (or if the user has access to it) and the time the application actually opens the file, the attacker replaces the file with a symlink to a sensitive system file.	High
29	Leveraging Time-of-Check and Time-of-Use (TOCTOU) Race Conditions This attack targets a race condition occurring between the time of check (state) for a resource and the time of use of a resource. A typical example is file access. The adversary can leverage a file access race condition by "running the race", meaning that they would modify the resource between the first time the target program accesses the file and the time the target program uses the file. During that period of time, the adversary could replace or modify the file, causing the application to behave unexpectedly. The adversary explores to gauge what level of access they have. The adversary confirms access to a resource on the target host. The adversary confirms ability to modify the targeted resource. The adversary decides to leverage the race condition by "running the race", meaning that they would modify the resource between the first time the target program accesses the file and the time the target program uses the file. During that period of time, the adversary can replace the resource and cause an escalation of privilege.	High

Cybersecurity needs ?

Strengthen software security from the outset with our DevSecOps expertise

Integrate security right from the start of the software development cycle for more robust applications and greater customer confidence.
Our team of DevSecOps experts can help you secure your APIs, data pipelines, CI/CD chains, Docker containers and Kubernetes deployments.

Discover this offer

Soutenez No Hack Me sur Tipeee