CVE-2023-53368
BaseFortify
Publication date: 2025-09-17
Last updated on: 2025-12-11
Assigner: kernel.org
Description
Description
CVSS Scores
EPSS Scores
| Probability: | |
| Percentile: |
Meta Information
Affected Vendors & Products
| Vendor | Product | Version / Range |
|---|---|---|
| linux | linux_kernel | From 3.10 (inc) to 5.4.257 (exc) |
| linux | linux_kernel | From 5.5 (inc) to 5.10.195 (exc) |
| linux | linux_kernel | From 5.11 (inc) to 5.15.132 (exc) |
| linux | linux_kernel | From 5.16 (inc) to 6.1.53 (exc) |
| linux | linux_kernel | From 6.2 (inc) to 6.4.16 (exc) |
| linux | linux_kernel | From 6.5 (inc) to 6.5.3 (exc) |
Helpful Resources
Exploitability
| CWE ID | Description |
|---|---|
| CWE-362 | The product contains a concurrent code sequence that requires temporary, exclusive access to a shared resource, but a timing window exists in which the shared resource can be modified by another code sequence operating concurrently. |
Attack-Flow Graph
AI Powered Q&A
Can you explain this vulnerability to me?
This vulnerability is a race condition in the Linux kernel's tracing subsystem. It occurs between writing an event into a CPU buffer and swapping that CPU buffer via the per_cpu/cpu0/snapshot interface. The race causes a warning in the kernel due to inconsistent state during buffer commit operations, specifically in the rb_end_commit() function. The issue arises because the buffer swap and event write happen concurrently on different CPUs, leading to incorrect buffer states and potential kernel warnings or panics. The fix involves performing the buffer swap on the target CPU using smp_call_function_single() to avoid the race.
How can this vulnerability impact me? :
This vulnerability can cause kernel warnings and potentially kernel panics due to the race condition in the tracing buffer management. This can lead to system instability or crashes when the tracing subsystem is heavily used, especially when multiple CPUs are writing and swapping buffers concurrently. It may disrupt normal system operation and debugging activities relying on kernel tracing.
How can this vulnerability be detected on my network or system? Can you suggest some commands?
This vulnerability can be detected by observing kernel warnings related to tracing buffer races in the system logs. A provided testcase script can reproduce the issue by repeatedly writing to /sys/kernel/tracing/per_cpu/cpu0/snapshot. The suggested commands include setting the kernel message log level to 7 with 'dmesg -n 7', enabling kernel panic on warnings with 'sysctl -w kernel.panic_on_warn=1', configuring tracing buffer size and events, and running a loop that writes to the snapshot file to trigger the race condition warning.
What immediate steps should I take to mitigate this vulnerability?
To mitigate this vulnerability, the fix involves performing the buffer swap on the target CPU where the buffer is located using smp_call_function_single(), which avoids the race condition. As an immediate step, you should update your Linux kernel to a version where this fix is applied. Until then, avoid running workloads or scripts that trigger frequent tracing snapshot writes concurrently on multiple CPUs.