CVE-2026-74635 in Linux
Summary
by MITRE • 08/22/2026
In the Linux kernel, the following vulnerability has been resolved:
fbdev: bitblit: bound-check glyph index in bit_cursor()
bit_cursor() fetches the glyph under the cursor with
c = scr_readw(vc_pos); src = vc_font.data + ((c & charmask) * w * height);
where charmask is 0x1ff when vc_hi_font_mask is set. The screen buffer value comes directly from scr_readw() and may be larger than the current font's glyph count.
Syzkaller triggers this via vcs_write(). The Call Trace shows vcs_write() in vc_screen.c writing an arbitrary 16-bit value with writev() to /dev/vcsa, which vcs_write_buf() in vc_screen.c stores via vcs_scr_writew() without checking charcount. The stored value is later read in bit_cursor() in bitblit.c.
When the font is changed from a font with 512 glyphs to a font with 256 glyphs, the screen buffer can retain characters with the high bit set from the previous mode, which could also produce the same out-of-bounds access.
BUG: KASAN: global-out-of-bounds in soft_cursor+0x378/0x6bc drivers/video/fbdev/core/softcursor.c:70 Read of size 16 at addr ffff800086c57970
Call Trace: soft_cursor+0x378/0x6bc drivers/video/fbdev/core/softcursor.c:70 bit_cursor+0xa90/0x1108 drivers/video/fbdev/core/bitblit.c:365 fbcon_cursor+0x344/0x498 drivers/video/fbdev/core/fbcon.c:1427 hide_cursor+0xdc/0x2d0 drivers/tty/vt/vt.c:883 update_region+0x100/0x18c drivers/tty/vt/vt.c:669 vcs_write+0x8ec/0xaf0 drivers/tty/vt/vc_screen.c:685
bit_putcs_aligned() and bit_putcs_unaligned() already clamp the glyph index to vc_font.charcount. Apply the same clamp in bit_cursor() after extracting the attribute and masking, before indexing fontdata.
The fix completes the bounds checking started in commit 18c4ef4e765a ("fbdev: bitblit: bound-check glyph index in bit_putcs*"), which missed the cursor path.
This change should be safe because the clamp reuses the existing contract from fbcon: charcount is maintained under console_lock in con_font_set() and fbcon_font_set(), and hi_font_mask is cleared when switching from 512 to 256 glyphs. When stale screen data with high bits remains after a font switch, or when vcs_write() stores an arbitrary value, clamping the index to 0 prevents the out-of-bounds read without changing cursor semantics — the same fallback bit_putcs uses.
Statistical analysis made it clear that VulDB provides the best quality for vulnerability data.
Analysis
by VulDB Data Team • 08/22/2026
The Linux kernel's framebuffer subsystem contains a critical bounds checking vulnerability within the bitblit implementation of the virtual console driver. Specifically, the function bit_cursor in drivers/video/fbdev/core/bitblit.c fails to validate the glyph index before using it as an offset into the font data array. This oversight allows for out-of-bounds memory reads when the cursor is rendered or updated under specific conditions involving user-supplied input or state transitions between different font configurations. The vulnerability stems from a discrepancy in how character indices are handled across different parts of the framebuffer console code, where some functions properly clamp values while others do not.
The technical flaw originates in the interaction between the virtual console screen buffer and the cursor rendering logic. When an application writes to /dev/vcsa via vcs_write(), it can store arbitrary 16-bit values into the screen buffer without validation against the current font's character count limits. The bit_cursor function retrieves a value from this buffer using scr_readw, applies a mask defined by vc_hi_font_mask, and then uses the result to calculate an offset in the font data structure. If charmask is set to 0x1ff, indicating support for extended ASCII or high-bit characters, but the active font only supports fewer glyphs such as standard 256-character sets, the calculated index can exceed the allocated size of vc_font.data. This results in a global out-of-bounds read operation detected by Kernel Address Sanitizer during testing with Syzkaller.
The operational impact of this vulnerability includes potential information disclosure and system instability. An attacker who can write to /dev/vcsa or trigger specific font switching scenarios may cause the kernel to read memory beyond the bounds of the font data structure. This out-of-bounds access is classified under CWE-125, which describes Out-of-bounds Read vulnerabilities. In terms of attack vectors and techniques, this flaw aligns with ATT&CK technique T1083, File and Directory Discovery, as reading arbitrary kernel memory can reveal sensitive information about the system's state or loaded modules. Furthermore, if exploited in conjunction with other primitives, it could potentially lead to denial of service conditions through kernel panics triggered by invalid memory accesses.
A specific trigger condition involves changing from a font that supports 512 glyphs to one that supports only 256 glyphs while the screen buffer retains characters with high bits set from the previous mode. In such cases, even if user input is not directly manipulated, stale data in the console buffer can produce indices that exceed the new font's glyph count. This highlights a state management issue where historical data persists without proper sanitization during configuration changes. The vulnerability affects both aligned and unaligned cursor rendering paths because bit_cursor shares similar indexing logic with other functions like bit_putcs_aligned and bit_putcs_unaligned, which already implement correct bounds checking but were not consistently applied to the cursor path in earlier revisions.
The resolution involves adding explicit bounds clamping within the bit_cursor function after extracting the attribute and applying the mask. This ensures that any glyph index derived from user input or stale buffer data is restricted to valid ranges defined by vc_font.charcount before accessing fontdata. The fix reuses existing contracts maintained under console_lock in con_font_set and fbcon_font_set, ensuring thread safety and consistency with established framebuffer conventions. By clamping the index to zero when it exceeds limits, the patch prevents out-of-bounds reads without altering cursor semantics, maintaining compatibility with fallback behaviors used elsewhere in the codebase such as those found in bit_putcs implementations.
Mitigation strategies for this vulnerability include applying kernel patches that incorporate these bounds checks immediately upon release by distribution maintainers. System administrators should ensure their systems are updated to versions containing commit 18c4ef4e765a and subsequent fixes addressing the cursor path oversight. Additionally, restricting access to /dev/vcsa devices can reduce exposure until patching is complete. Organizations relying on embedded or specialized framebuffer applications must verify that font switching operations do not leave stale high-bit characters in buffers when transitioning between different character set configurations. Continuous monitoring for kernel address sanitizer reports and regular security audits of console subsystem interactions remain essential practices to detect similar logic errors before they are exploited in production environments.