CVE-2026-53196: Linux io_ti USB Driver Heap Overflow – Physical Access RCE Risk
A vulnerability in the Linux kernel's USB serial driver for IO Technic devices allows a malicious USB device to overflow kernel memory when connected to a host system. The driver fails to properly validate the size of data it reads from a device's onboard memory, trusting an untrusted value from the device itself. When a crafted device is plugged in, it can write far more data into a small kernel buffer than it was designed to hold, potentially leading to code execution or system crash.
Source data · NVD / CISA · public domain
- CVSS
- 3.1 · 6.8 MEDIUM · CVSS:3.1/AV:P/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
- Weaknesses (CWE)
- CWE-787
- Affected products
- 13 configuration(s)
- Published / Modified
- 2026-06-25 / 2026-07-15
NVD description (verbatim)
In the Linux kernel, the following vulnerability has been resolved: USB: serial: io_ti: fix heap overflow in get_manuf_info() get_manuf_info() reads le16_to_cpu(rom_desc->Size) bytes from the device I2C EEPROM into a buffer allocated with kmalloc_obj(), which is sizeof(struct edge_ti_manuf_descriptor) = 10 bytes. The Size field comes from the device and is only validated (in check_i2c_image()) to make sure the descriptor fits within TI_MAX_I2C_SIZE (16384 bytes), not against the destination buffer size. A malicious USB device can therefore set Size to any value up to 16377, causing a heap overflow of up to 16367 bytes when plugged into a host running this driver. valid_csum() is called after read_rom() and also iterates buffer[0..Size-1], compounding the out-of-bounds access. Fix by rejecting descriptors with unexpected length before calling read_rom(). [ johan: amend commit message; also check for short descriptors ]
11 reference(s) · View on NVD →
SEC.co analysis · AI-assisted, reviewed against source
Technical summary
The io_ti USB serial driver's get_manuf_info() function allocates a 10-byte buffer (struct edge_ti_manuf_descriptor) but reads a byte count directly from device firmware without bounds-checking against the destination buffer. The Size field from the device's I2C EEPROM is validated only to ensure it fits within the global TI_MAX_I2C_SIZE limit (16384 bytes), not the 10-byte allocation. This allows a malicious device to trigger a heap overflow of up to 16367 bytes. The vulnerability is compounded by valid_csum() iterating over the same untrusted boundary post-read. The fix adds explicit validation of descriptor length before reading from the device.
Business impact
This vulnerability requires physical access (USB connection) to a host and affects systems running vulnerable Linux kernel versions with the io_ti serial driver enabled. Exploitation could lead to local privilege escalation, information disclosure, or denial of service. Organizations with industrial control systems, lab equipment, or other USB-connected hardware using this driver face a material risk if threat actors can control or intercept USB devices in their environment.
Affected systems
The Linux kernel io_ti USB serial driver is affected. This driver supports Edgeport USB-to-serial adapters manufactured by Inside Out Networks (now Digi). Any system with this driver compiled in and configured to handle such devices is vulnerable. Desktop and server systems accepting untrusted USB devices are at highest risk.
Exploitability
Exploitation requires physical access to plug in a malicious USB device. The attack surface is limited to environments where users connect unknown or untrusted USB hardware. The device firmware is fully controlled by the attacker, making the heap overflow trivial to trigger. Once triggered, an attacker with local access could potentially escalate privileges or crash the kernel, though the complexity of reliably achieving code execution varies by kernel configuration and ASLR implementation.
Remediation
Apply the kernel security patch that adds bounds validation to reject manufacturer descriptors with unexpected size values before attempting to read data from the device. Verify the patch is available in your Linux distribution's kernel update and deploy it to affected systems. As an interim measure, disable the io_ti driver module if USB Edgeport devices are not required.
Patch guidance
Contact your Linux distribution vendor (Red Hat, Canonical, SUSE, etc.) for a patched kernel version incorporating the io_ti heap overflow fix. The patch adds length validation in the io_ti driver to reject descriptors that do not match the expected struct size. Deployment should be prioritized for systems that accept external USB devices or operate in untrusted physical environments. Verify driver functionality after patching if Edgeport devices are in use.
Detection guidance
Monitor kernel logs for memory corruption warnings, heap allocator errors, or oops messages that correlate with USB device connection events. Systems running commodity Edgeport devices should log their insertion and removal; unexplained heap errors around these times warrant investigation. Tools like AddressSanitizer or KASAN (Kernel Address Sanitizer) in development/test builds will immediately detect the overflow; production systems should rely on kernel crash dumps and audit logs of USB device enumeration.
Why prioritize this
Although exploitation requires physical access (reducing exposed attack surface), the severity of the heap overflow—capable of overwriting arbitrary kernel memory with attacker-controlled data—justifies timely patching. Organizations in high-security environments or those accepting USB devices from less-trusted sources should prioritize this update. The CVSS score of 6.8 reflects the high impact on confidentiality, integrity, and availability, balanced against the physical access requirement.
Risk score, explained
The CVSS 3.1 score of 6.8 (MEDIUM) reflects: Attack Vector:Physical (requiring USB insertion), Access Complexity:Low (no special conditions after insertion), Privileges:None (no auth needed), User Interaction:None (automatic on plug), with high impact on Confidentiality, Integrity, and Availability. The physical requirement prevents remote exploitation but does not diminish the severity of the resulting memory corruption for vulnerable deployments.
Frequently asked questions
Do I need to physically connect a malicious device to be affected?
Yes. Exploitation requires an attacker to insert a crafted USB device (or modify firmware in a legitimate Edgeport device) and have a vulnerable Linux host accept the connection. Remote exploitation is not possible.
What happens if my Linux system doesn't use the io_ti driver?
Systems without the io_ti driver enabled or compiled in are not vulnerable. Check your kernel config or run `lsmod | grep io_ti` to confirm; if the module is not listed and not built-in, this CVE does not apply to your system.
Can the overflow be exploited to gain remote code execution?
Not directly remotely. However, if an attacker can control or physically access a USB device in your environment, they could escalate local privileges or crash the kernel. In supply-chain or physical-access scenarios, this is a material risk.
What is the difference between this vulnerability and a standard buffer overflow?
This overflow occurs in kernel heap memory from a USB device firmware field. The attacker does not need to craft a specific input format for a user process; they control the source (device firmware) and can trigger reading of extremely large amounts of data into a tiny buffer.
This analysis is provided for informational purposes and based on publicly disclosed vulnerability data as of the publication date. Actual risk and impact depend on your specific kernel version, driver configuration, and environment. Verify patch availability with your Linux distribution vendor before deployment. No proof-of-concept or exploit code is provided. Always test patches in a non-production environment first. This is not legal or liability advice. Source: NVD (public-domain), retrieved 2026-08-03. Analysis generated by SEC.co (claude-haiku-4-5).
Related vulnerabilities
- CVE-2026-11090MEDIUMChrome ANGLE Memory Leak Enables Cross-Origin Data Theft
- CVE-2026-10883HIGHType Confusion in Chrome ANGLE Graphics Library
- CVE-2026-10897HIGHCritical Chrome GPU Sandbox Escape Vulnerability
- CVE-2026-10907HIGHChrome ANGLE Out-of-Bounds Write – Remote Code Execution Risk
- CVE-2026-10941HIGHSkia Out-of-Bounds Memory Vulnerability in Chrome – Urgent Patch Required
- CVE-2026-11091HIGHCritical Chrome Memory Corruption Vulnerability in Dawn Graphics Engine
- CVE-2026-11173HIGHChrome V8 Out-of-Bounds Write Sandbox Escape – Patch Guidance
- CVE-2026-12019HIGHChrome Heap Overflow & Sandbox Escape (Linux, ChromeOS)