Skip to main content

USB Test EUVDEUVD-2026-112149

| CVE-2026-116776 HIGH
Heap-based Buffer Overflow (CWE-122)
2026-10-28 GitHub_M
7.0
CVSS 4.0 · Vendor: GitHub_M
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Connect malicious-firmware USB device
  2. Delivery
    User launches elevated USB Test and starts a drive test
  3. Exploit
    Device reports sub-8-byte (or zero) BytesPerSector via IOCTL_DISK_GET_DRIVE_GEOMETRY
  4. Execution
    Undersized heap buffer overflowed by fixed 8-byte memcpy
  5. Impact
    Heap corruption crashes elevated process, may permit code execution

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Heap buffer bounds checking
MITRE ATT&CK

1 technique across 1 tactic: Execution

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Requires a physically connected USB storage device with malicious or altered firmware that returns a crafted DISK_GEOMETRY.BytesPerSector - specifically a value below 8 (e.g., 1) to trigger the 7-byte heap out-of-bounds write at drivetest.cpp:86, or 0 to trigger the divide-by-zero at drivetest.cpp:61, or an enormous value (e.g., 2000000000) to cause std::bad_alloc. The victim must run the elevated USB Test application (<= 1.1.4), select the rogue drive, and start a drive test; getSectorSize() in driveinfo.cpp must not have the v1.1.5 success/bounds validation. Limiting factors: no network or remote vector, physical device access and active user initiation of a test are both required, and the issue is absent once updated to 1.1.5 (the vendor states updating is the fix; the only workaround is to avoid testing untrusted devices and secure the system against unauthorized driver modification).

Impact

The signals point to a genuine but tightly-scoped memory-safety flaw rather than a widespread emergency. The CVSS 4.0 vector (AV:P/AC:L/AT:N/PR:H/UI:P) is the dominant limiter: exploitation requires a physically connected malicious USB storage device (AV:P), an elevated/privileged context (PR:H), and user interaction to start a drive test (UI:P), which together make opportunistic or automated mass exploitation implausible. No EPSS score is provided and the CVE is NOT in CISA KEV, so there is no evidence of active exploitation. The advisory supplies a proof-of-concept, but it is an in-source simulation (hard-coding BytesPerSector) rather than a verified working device-firmware exploit, so RCE remains 'a credible threat' per the vendor, with only DoS and predictable heap corruption actually proven. The vuln.today decision label is 'this_week', consistent with a patch-promptly-but-not-emergency posture. Net: this is a real, well-documented RCE/DoS primitive for the handful of people who run this niche tool, but the physical attack vector, required privileged context, and tiny deployment footprint keep real-world risk low for the general population despite the 7.0 base score.

Exploit ScenarioDerived

An attacker hands or plants a USB flash drive with malicious/altered firmware that reports a sector size below eight bytes (e.g., 1) or zero. A victim connects it and runs the elevated USB Test utility, selects the rogue drive, and starts any test; the undersized buffer is overflowed by the fixed 8-byte memcpy (or a divide-by-zero fires), crashing the elevated process and potentially allowing code execution. A public proof-of-concept exists as an in-source simulation; it is not verified as working, device-delivered exploit code.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Oct 28, 2026

Heap-based out-of-bounds write in USB Test 1.1.4 and earlier lets a rogue USB flash drive with crafted firmware corrupt the heap of the elevated Windows CLI process, crashing it and, per the vendor advisory, credibly opening a path to arbitrary code execution when a user starts a drive test. The utility trusts the DISK_GEOMETRY.BytesPerSector value returned by IOCTL_DISK_GET_DRIVE_GEOMETRY without checking the call result or bounding the value, so a device reporting fewer than 8 bytes per sector under-sizes a heap buffer that then receives an 8-byte memcpy on every loop iteration; a reported value of 0 triggers a divide-by-zero and an enormous value causes std::bad_alloc. Exploitation requires a physically attached malicious device and a user who launches the tool, selects that drive and starts a test, which keeps the exposure narrow despite the vendor rating of 7.0; the vendor fix is version 1.1.5, and a public PoC reference exists (an in-source simulation of the untrusted value) but it is not verified as working exploit code.

RemediationAI

Upgrade to USB Test 1.1.5 (release-v1.1.5, https://github.com/n-romanovich/usb-test/releases/tag/release-v1.1.5), which is the vendor-released patch; commit 5b6caac844461024520b02337d3a541fbe128f89 enforces that the geometry query succeeds and that BytesPerSector falls between 512 and 4096, exiting with code 3 otherwise, which closes both the out-of-bounds memcpy and the divide-by-zero paths. Full details are in advisory GHSA-cfrv-c9q2-7cr3. Because the vendor treats updating as the complete fix, the only documented compensating measure for systems that cannot patch immediately is procedural: do not run USB Test 1.1.4 or earlier against untrusted, unknown or potentially reflashed removable drives, and keep the host secured against unauthorized driver modification, since a tampered storage driver can return the same hostile geometry values regardless of the physical device; the trade-off is that this removes the tool's core function for any untested media rather than fixing the defect. Rebooting or re-imaging after a crash on such a drive is advisable, since heap corruption occurred inside an elevated process.

Affected VersionsENISA

usb-test < 1.1.5

Affected Packages

euvd usb_test fix: 1.1.5

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

USB Test is a small Windows console utility that validates sector integrity and detects overreported capacity on USB flash drives through the Win32 device I/O interface. In driveinfo.cpp, getSectorSize() issues IOCTL_DISK_GET_DRIVE_GEOMETRY and returns the DISK_GEOMETRY.BytesPerSector field supplied by the device firmware/driver; the pre-fix code ignored the bytesReturned out-parameter of DeviceIoControl and imposed no sanity range on the value. That untrusted number flows into drivetest.cpp, where it is used as a divisor (line 61), as the sizing argument for a heap vector<char> buffer (line 72), and as the implicit bound for a fixed 8-byte memcpy(buffer.data(), &sector, 8) (line 86). The root cause is CWE-122 heap-based buffer overflow: the copy size is not derived from the allocated size, so any BytesPerSector below 8 produces a repeatable out-of-bounds write of up to 7 bytes that is performed across millions of loop iterations, while a zero value raises a divide-by-zero exception and a multi-gigabyte value raises std::bad_alloc. The upstream fix in commit 5b6caac extends the DeviceIoControl condition to require dg.BytesPerSector >= 512 && dg.BytesPerSector <= 4096 and to terminate with exit(3) when the geometry query fails or the value is out of range. Because the utility is typically run with elevated privileges to access raw drive handles, any corruption in its heap occurs in a high-integrity process, which is why the advisory escalates the proven denial-of-service primitive to a credible RCE concern; the trigger itself is a single unvalidated firmware-reported value, not a heap-grooming or timing race.

Know when Usb Test gets its next vulnerability

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (GitHub_M) PRIMARY 7.0 HIGH
CVSS:4.0/AV:P/AC:L/AT:N/PR:H/UI:P/VC:N/VI:H/VA:H/SC:N/SI:H/SA:H
vuln.today AI 5.4 MEDIUM

Physical malicious USB (AV:P) and the elevated-only vulnerable path (PR:H) with a user-started test (UI:R); no info disclosure (C:N), while heap corruption yields code execution and crashes (I:H/A:H).

3.1 AV:P/AC:L/PR:H/UI:R/S:U/C:N/I:H/A:H
4.0 AV:P/AC:L/AT:N/PR:H/UI:A/VC:N/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Physical
Attack Complexity
Low
Attack Requirements
None
Privileges Required
High
User Interaction
Passive
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
High
Subsequent system: Availability
High

Lifecycle Timeline

2
Patch available
Oct 28, 2026 - 16:03 EUVD
CVE Published
Oct 28, 2026 - 15:42 cve.org
HIGH 7.0

DescriptionCVE.org

USB Test is a lightweight Windows CLI utility for verifying sector integrity and detecting overreported capacity on USB flash drives. Prior to version 1.1.5, getSectorSize() in USB Test/src/driveinfo.cpp trusts DISK_GEOMETRY.BytesPerSector returned by IOCTL_DISK_GET_DRIVE_GEOMETRY without checking whether the call succeeded or enforcing size bounds. USB Test/src/drivetest.cpp uses the value for division and to size a heap buffer before memcpy(buffer.data(), &sector, 8), so a physically connected malicious USB storage device can report a value below eight bytes and cause repeated out-of-bounds writes, or report zero and cause a divide-by-zero denial of service when a user starts a drive test. The heap corruption can crash the elevated application and may permit arbitrary code execution. This issue is fixed in version 1.1.5.

Technical POC Analysis

CWE-122, heap-based buffer overflow, in getSectorSize() at src/driveinfo.cpp:178 of the USB Test Windows CLI.

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

USB Test 1.1.4 and earlier contain a heap-based out-of-bounds write vulnerability that could allow a malicious USB flash drive to corrupt memory in an elevated Windows CLI process, potentially leading to arbitrary code execution. This affects organizations where users run USB drive tests on untrusted devices, exposing them to targeted attacks via physical media. While exploitation requires user interaction and physical device access, the elevated privileges of the tool make it a significant risk for insider threats or supply chain attacks.

Business Impact: Medium
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

Prevalence
Rare
obscure single-developer GitHub CLI utility, negligible enterprise footprint
Data Quality
4 sources
Confidence: Medium

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS N/A
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Defer
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact
Medium

Priority Score

35
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +35
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.

A heap overflow occurs when a program writes data beyond the bounds of a buffer allocated in the heap memory region.

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy