CVE-2026-53600: 
Rust vulnerability analysis and mitigation

CVE-2026-53600 is a PAX extension-header desynchronization vulnerability in the Rust crate async-tar that enables tar entry and content smuggling. The flaw exists in async-tar version 0.6.0 (and the current main HEAD at the time of disclosure), and was fixed in version 0.6.1. It was first published to the GitHub Advisory Database on July 8, 2026, with an initial private disclosure on June 1, 2026. The vulnerability carries a CVSS v4.0 base score of 6.3 (Medium) (Github Advisory, async-tar Advisory).

The root cause is improper input validation (CWE-20) combined with type confusion (CWE-843) in the poll_next_raw function within src/archive.rs. Per POSIX, a PAX extended-header record set must describe the next file entry, never an intermediary extension header such as a GNU longname (L), GNU longlink (K), or PAX x/g header. However, async-tar v0.6.0 lacks an is_extension_header guard, so when a buffered PAX size record is present, it is applied to whatever raw header is read next — including intermediary L headers. This causes the stream cursor (*next) to advance by the attacker-specified size rather than the L header's own declared size, desyncing the parser relative to POSIX-correct parsers like GNU tar. An attacker can craft an x → L → file sequence to exploit this: the malicious archive geometry places a PAX local-extension header declaring size=1024, followed by a GNU longname L header with its own declared size of 512, followed by a smuggled file header and payload. GNU tar correctly reads the L body as one block and surfaces a benign file, while async-tar reads two blocks as the longname, lands on the smuggled file header, and extracts the hidden payload. A full proof-of-concept with Rust source code is included in the advisory (Github Advisory).

The primary impact is differential extraction, also known as content/entry smuggling: files that a GNU-tar-based scanner or antivirus sees as benign opaque data are extracted by async-tar as different files with different content (e.g., an executable shell script), and vice versa. This breaks any security pipeline that scans an archive with one parser and extracts with async-tar, allowing an attacker to bypass malware scanners, secret detectors, and audit/inventory tooling. Affected consumers include server endpoints that unpack uploaded .tar/.tar.gz bodies, dependency and artifact fetchers, and archive-preview or scan pipelines — any context where Archive::new(reader).entries() is called on attacker-influenced input (async-tar Advisory).

A public proof-of-concept with full Rust source code (tar-builder and consumer binaries) is included in the GitHub Security Advisory, demonstrating end-to-end reproduction of the smuggling attack. No privileges or user interaction are required; the only precondition is the ability to influence the bytes of a tar stream consumed by an async-tar-based application. There is no evidence of in-the-wild exploitation at the time of disclosure, no threat actor attribution, and the CVE status remains "Reserved." The vulnerability is detected by Qualys (detection ID 5015224) and is not listed in the CISA KEV catalog (Github Advisory, async-tar Advisory).

1. Craft the malicious archive: Using the published PoC mktar.rs or equivalent tooling, construct a tar archive with the following block geometry (each block = 512 bytes):

   • B0: PAX local-extension header (x typeflag, ./PaxHeaders/0) with a size record set to an attacker-chosen value (e.g., 1024 = 2 blocks).
   • B1: PAX records body (" size=1024\n").
   • B2: GNU longname header (L typeflag, ././@LongLink) with its own declared size of 512 (1 block).
   • B3: Longname block containing the filename the reference parser will see (e.g., GNU_SEES_THIS.txt).
   • B4: A normal file header (placeholder_A, size 512) — this block is consumed as part of the longname by async-tar due to the desync.
   • B5: A valid tar header for the smuggled file (e.g., hidden_payload.sh, size 65) — async-tar lands here after the desync and parses it as a real entry.
   • B6: The smuggled payload body (e.g., #!/bin/sh\n# SMUGGLED ENTRY...\n).
   • B7–B8: Two zero blocks (EOF marker).

2. Deliver the archive: Submit the crafted .tar or .tar.gz to a target system that uses async-tar v0.6.0 to extract attacker-supplied archives — for example, upload it to a server endpoint that unpacks user-submitted tarballs, or inject it into a dependency/artifact fetch pipeline.

3. Bypass the scanner: If the pipeline scans the archive with GNU tar or a libarchive-based tool before extraction, the scanner sees only GNU_SEES_THIS.txt with 1024 bytes of opaque data and reports no threats.

4. Trigger extraction with async-tar: When async-tar processes the same archive via Archive::new(reader).entries(), the PAX size=1024 is mis-applied to the L header, advancing the cursor by 2 blocks instead of 1. The parser lands on B5, parses hidden_payload.sh as a real entry, and writes the smuggled #!/bin/sh script to disk.

5. Achieve objective: The smuggled executable (or other payload) is now on disk in the extraction directory, having bypassed any GNU-tar-based security scanner. The attacker can subsequently trigger execution of the script through application logic or other means (Github Advisory).

• File System: Unexpected files with executable content (e.g., shell scripts starting with #!/bin/sh) appearing in tar extraction output directories that do not correspond to entries listed by GNU tar or other reference parsers; file sizes inconsistent with what a reference parser reports for the same archive.
• Logs: Application logs showing async-tar extracting entries with paths or sizes that differ from those reported by a parallel scan using GNU tar or libarchive; entries named hidden_payload.sh or similar unexpected filenames in extraction logs.
• Network: Uploads of tar archives containing PAX local-extension headers (x typeflag) immediately followed by GNU longname headers (L typeflag) — detectable via deep packet inspection or archive content inspection at ingress points; unusually structured tar archives where the PAX size value is significantly larger than the L header's own declared size.
• Process: Unexpected script or binary execution originating from tar extraction directories shortly after archive unpacking operations (Github Advisory).

Upgrade async-tar to version 0.6.1 or later, which adds an is_extension_header guard in poll_next_raw (src/archive.rs) that prevents buffered PAX records from being applied to intermediary extension headers (L/K/x/g). In Cargo.toml, update the dependency to async-tar = ">=0.6.1" and run cargo update. No configuration-based workaround is available for v0.6.0; the only mitigation is upgrading. As an interim measure, operators can reject or quarantine tar archives containing PAX local-extension headers (x) immediately followed by GNU longname headers (L) at ingress, though this may break legitimate archives (Github Advisory, async-tar Advisory).

The vulnerability was reported by security researcher tonghuaroot and published by the maintainer (dignifiedquire) via a GitHub Security Advisory. The advisory notes that the defect class is consistent with a similar issue in the upstream tar-rs / tokio-tar lineage, suggesting awareness of this pattern in the Rust tar ecosystem. No significant broader media coverage or notable social media commentary has been identified at the time of this report (Github Advisory).