CVE-2026-80876
Received Received - Intake

Buffer Overflow in Linux Kernel Ring Buffer

Vulnerability report for CVE-2026-80876, including description, CVSS score, EPSS score, affected products, exploitability, helpful resources, and attack-flow context.

Publication date: 2026-09-04

Last updated on: 2026-09-04

Assigner: kernel.org

Description

In the Linux kernel, the following vulnerability has been resolved: ring-buffer: Fix event length with forced 8-byte alignment When RB_FORCE_8BYTE_ALIGNMENT is true, rb_calculate_event_length() reserves the space of event->array[0] for placing the data length and rb_update_event() stores the data length in event->array[0] accordingly. As a result the whole event length will add extra 4 bytes for sizeof(event.array[0]) unconditionally. But ring_buffer_event_length() only subtracts the sizeof(event->array[0]) for events larger than RB_MAX_SMALL_DATA + sizeof(event->array[0]). As a result, small events on architectures with RB_FORCE_8BYTE_ALIGNMENT=true report a data length that is 4 bytes larger than expected. To fix it, add the RB_FORCE_8BYTE_ALIGNMENT as a condition to subtract the size of that length field whenever RB_FORCE_8BYTE_ALIGNMENT is true. This issue is observed in a riscv64 kernel with CONFIG_HAVE_64BIT_ALIGNED_ACCESS set to y, when we run ftrace selftest trace_marker_raw.tc, we get the weird log: for cases where the id is 1..100, the number of data field is 8*N, but once id exceeds 100, the number of data field becomes 8*N+4: # 1 buf: 58 00 00 00 80 5e d1 63 (number of data field is 8*1) ... # a buf: 58 ... (number of data field is 8*2) ... # 64 buf: 58 ... (number of data field is 8*13) # 65 buf: 58 ... (number of data field is 8*13+4) After applying this change, the number of data field keeps being 8*N+4 consistently.

CVSS Scores

EPSS Scores

Probability:
Percentile:

Meta Information

Published
2026-09-04
Last Modified
2026-09-04
Generated
2026-09-05
AI Q&A
2026-09-05
EPSS Evaluated
N/A
NVD
EUVD

Affected Vendors & Products

Showing 1 associated CPE
Vendor Product Version / Range
linux linux_kernel *

Helpful Resources

Exploitability

CWE
CWE Icon
KEV
KEV Icon
CWE ID Description
CWE-UNKNOWN

Attack-Flow Graph

AI Quick Actions

Instant insights powered by AI
Executive Summary

This vulnerability in the Linux kernel involves incorrect calculation of event lengths in the ring buffer when forced 8-byte alignment is enabled. The function rb_calculate_event_length() reserves extra space for the data length, causing small events to report a data length 4 bytes larger than expected. This affects architectures like riscv64 with specific configuration settings.

Detection Guidance

This vulnerability is specific to the Linux kernel's ring-buffer implementation and requires kernel-level inspection. Detection involves checking kernel configuration and running ftrace selftests. Use commands like 'grep RB_FORCE_8BYTE_ALIGNMENT /boot/config-$(uname -r)' to verify if the vulnerable configuration is enabled. Run 'trace_marker_raw.tc' from ftrace selftests to observe inconsistent data field lengths.

Impact Analysis

This vulnerability may cause incorrect data length reporting in ring buffer events, potentially leading to buffer overflows or underflows. It could affect systems using ftrace or similar tracing tools, especially on riscv64 architectures with CONFIG_HAVE_64BIT_ALIGNED_ACCESS enabled.

Mitigation Strategies

Apply the kernel patch that fixes the ring-buffer event length calculation. Update your Linux kernel to a version containing the fix. If using a custom kernel, ensure RB_FORCE_8BYTE_ALIGNMENT is handled correctly in the ring-buffer code. Monitor for unusual ftrace output indicating misaligned data fields.

Chat Assistant

Ask questions about this CVE
Hi! I’m here to help you understand CVE-2026-80876. Ask me anything about the vulnerability, its impact, or mitigation strategies.
0/70

EPSS Chart