rxi microtar
CVE-2026-54417
HIGH
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
ReconCraft tar header with size field 0xFFFFFE00
-
DeliveryDeliver archive to application ingestion endpoint
-
ExploitApplication calls mtar_find() or mtar_next() loop
-
Install32-bit addition overflows, offset wraps to zero
-
C2mtar_next() seeks to current record position repeatedly
-
ExecuteProcess consumes 100% CPU indefinitely
-
ImpactService becomes unresponsive
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Integer overflow checks
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 | The target application must use rxi microtar to parse a tar archive supplied by or derived from attacker-controlled input - for example, a user-uploaded file, a downloaded package, or a network-received archive. The attacker must be able to craft a tar header whose size field is a multiple of 512 in the range 0xFFFFFC01-0xFFFFFE00 (e.g., 0xFFFFFE00 = 4,294,966,784 bytes), which is a precise but mechanically straightforward requirement. No authentication is required per CVSS PR:N, and no user interaction is required per CVSS UI:N, assuming archive processing is performed server-side or programmatically. Exploitation is limited to environments where: (1) the rxi microtar library is linked into the application, (2) archive parsing runs synchronously on a thread without a CPU-time or iteration-count watchdog, and (3) the application does not perform pre-validation of tar header size fields before passing archives to the library. Environments that process archives in isolated subprocesses with CPU limits or that validate header fields before parsing are not vulnerable to process hang. |
| Impact | The CVSS 4.0 score of 8.7 (AV:N/AC:L/AT:N/PR:N/UI:N/VA:H) reflects a remotely triggerable, low-complexity availability-only flaw, which is accurate given the unauthenticated network delivery path and deterministic infinite-loop outcome. However, the EPSS score of 0.42% (33rd percentile) and SSVC Automatable:none together indicate that automated, at-scale exploitation is not currently occurring or expected imminently - likely because the attack is contingent on delivering a crafted archive through an application-specific ingestion channel rather than a universally open socket. The SSVC Technical Impact:total reflects the complete loss of availability when triggered, consistent with an unrecoverable process hang. The absence of a CISA KEV listing and low EPSS corroborate that this is a credible but not presently widespread threat. The primary real-world risk lies in applications that accept tar archives from untrusted parties (e.g., user-uploaded files, network-retrieved packages) and process them synchronously without timeout controls. Note: SSVC Automatable:none appears conservative given the straightforward crafted-input vector; defenders should not rely solely on that signal. |
| Exploit ScenarioDerived | An attacker uploads or delivers a specially crafted tar archive containing a header with the size field set to 0xFFFFFE00 (or another qualifying multiple of 512) to any service that uses microtar to iterate archive entries - such as a file upload endpoint, a package manager, or a build tool. When the target application calls mtar_find() or manually loops with mtar_next(), the function seeks to offset zero relative to the current record on every iteration, repeating indefinitely. The process consumes 100% of one CPU core and becomes unresponsive until killed externally, achieving denial of service with a single malformed archive submission. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv2 – Aug 10, 2026
Denial of service through infinite CPU consumption affects rxi microtar 0.1.0, a lightweight C library for tar archive parsing. The mtar_next() function performs 32-bit arithmetic to compute the offset to the next record; when a tar header encodes a size value in the range 0xFFFFFC01-0xFFFFFE00 (multiples of 512), the addition of round_up(h.size, 512) and sizeof(mtar_raw_header_t) wraps to zero, causing the function to seek back to the current record position rather than advancing. Any application that uses microtar to iterate archive entries - via mtar_find() or a manual loop - will loop indefinitely over the same record, pegging the process at 100% CPU with no recovery path. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in the CISA Known Exploited Vulnerabilities catalog.
Earlier versions of this analysis (1)
Denial of service in rxi microtar 0.1.0 allows remote attackers to hang any consumer of the library at 100% CPU by supplying a crafted tar archive whose header size field triggers a 32-bit integer overflow in mtar_next(). The flaw affects every application that parses untrusted tar streams with this lightweight C library, and no public exploit is identified at time of analysis, though the trigger is trivial to construct from the description alone.
RemediationAI
No vendor-released patch has been identified at time of analysis; the CVE references point exclusively to the existing source code with no fix commit, tagged release, or upstream pull request visible. Downstream maintainers embedding microtar should apply a local patch to mtar_next() that performs the offset arithmetic in a wider integer type (e.g., uint64_t) before assigning back to the 32-bit seek position, rejecting records where the computed next offset would overflow. As a compensating control, applications processing untrusted archives should enforce a maximum record count or total bytes-consumed limit to terminate pathological loops - a practical ceiling of, say, 65,536 records would stop the infinite loop with minimal impact on legitimate archives. Sandboxing or process-isolating the archive parsing component (e.g., running it in a child process with CPU time limits via setrlimit(RLIMIT_CPU)) provides defense in depth regardless of the library version. Restricting archive ingestion to authenticated, trusted sources reduces the network attack surface without requiring code changes.
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
rxi microtar (cpe:2.3:a:rxi:microtar:*:*:*:*:*:*:*:*) is a single-file, dependency-free C library for reading and writing POSIX tar archives, commonly embedded in game engines, embedded firmware, and minimalist C projects. The root cause is CWE-190 (Integer Overflow or Wraparound): the offset computation in mtar_next() at src/microtar.c:239 uses native 32-bit unsigned integer arithmetic. For header size values such as 0xFFFFFE00 (a multiple of 512), round_up(0xFFFFFE00, 512) yields 0xFFFFFE00, and adding sizeof(mtar_raw_header_t) (512 bytes) overflows to 0x00000000. The resulting seek lands on the current record's start position, creating a permanent loop. The CPE wildcard version field indicates that the vulnerability may extend beyond the documented 0.1.0 release to any version sharing this code path.
Know when Microtar 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:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
Network-delivered crafted archive, no privileges or interaction needed; pure availability impact with no confidentiality or integrity consequence.
Primary rating from Vendor (TuranSec).
CVSS VectorVendor: TuranSec
Lifecycle Timeline
2DescriptionCVE.org
An integer overflow in the mtar_next() function in src/microtar.c in rxi microtar 0.1.0 allows a remote attacker to cause a denial of service (uncontrolled CPU consumption / infinite loop) via a crafted tar archive. mtar_next() computes the offset to the next record as round_up(h.size, 512) + sizeof(mtar_raw_header_t) using 32-bit arithmetic. When the header size field is a multiple of 512 in the range 0xFFFFFC01-0xFFFFFE00 (e.g. 0xFFFFFE00), the addition wraps to 0, so mtar_next() seeks to the current record position instead of advancing. As a result, mtar_find() and any loop that iterates entries with mtar_next() repeat indefinitely over the same record, hanging the process at 100% CPU with no recovery.
Executive ViewAI
Applications using rxi microtar 0.1.0 are vulnerable to denial of service attacks that render systems unresponsive through CPU exhaustion when processing specially crafted tar archives. While no public exploit has been identified at time of analysis, the vulnerability is trivial to exploit and poses significant risk for organizations processing untrusted archives. No vendor patch is currently available, requiring immediate implementation of compensating controls.
Implement strict file size limits and processing timeouts for tar archive operations. Apply CPU resource quotas and monitoring to detect anomalous consumption patterns during archive processing. Restrict tar archive processing to verified trusted sources only and implement input validation to reject malformed headers.
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
Integer overflow occurs when an arithmetic operation produces a result that exceeds the maximum value a given integer type can store.
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
Affected Products (CPE)CVE.org
Stack-based buffer overflow in microtar through 0.1.0 allows remote attackers to corrupt stack memory and potentially ac
Stack buffer overflow in rxi's microtar C library allows memory corruption when an application archives files with attac
Stack-based buffer overflow in rxi microtar 0.1.0's raw_to_header() function allows a remote attacker to cause denial of
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB