Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessConnect malicious-firmware USB device
-
DeliveryUser launches elevated USB Test and starts a drive test
-
ExploitDevice reports sub-8-byte (or zero) BytesPerSector via IOCTL_DISK_GET_DRIVE_GEOMETRY
-
ExecutionUndersized heap buffer overflowed by fixed 8-byte memcpy
-
ImpactHeap 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
Affected Packages
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(), §or, 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
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
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).
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.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(), §or, 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
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.
Apply vendor patch.
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
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.
EUVD-2026-112149
NVD
CVE.org
GitHub
Exploit-DB