Skip to main content

resopt/
archive.rs

1//! Bounded ZIP inspection. Archive names are data, never filesystem destinations.
2use crate::{Resource, ResourceAnalysis, analyze_image::Context, filesystem::write_artifact};
3use anyhow::{Context as _, Result, ensure};
4use serde::{Deserialize, Serialize};
5use std::{
6    collections::BTreeSet,
7    io::{Cursor, Read},
8    path::{Path, PathBuf},
9};
10use zip::ZipArchive;
11
12const MAX_ARCHIVE_BYTES: usize = 64 * 1024 * 1024;
13const MAX_ENTRIES: usize = 10_000;
14const MAX_ENTRY_BYTES: u64 = 64 * 1024 * 1024;
15const MAX_EXPANDED_BYTES: u64 = 256 * 1024 * 1024;
16const MAX_PREVIEWS: usize = 32;
17
18#[derive(Debug, Clone, Serialize, Deserialize)]
19pub struct ArchiveEntry {
20    pub path: String,
21    pub bytes: u64,
22    pub compressed_bytes: u64,
23    pub format: String,
24    pub kind: String,
25    pub directory: bool,
26    pub metadata: bool,
27    pub preview: Option<PathBuf>,
28    pub issues: Vec<String>,
29}
30
31#[derive(Debug, Clone, Serialize, Deserialize)]
32pub struct ArchiveInfo {
33    pub entries: Vec<ArchiveEntry>,
34    pub expanded_bytes: u64,
35    pub compressed_bytes: u64,
36    pub preview_limit: usize,
37    #[serde(default)]
38    pub optimized_images: usize,
39    /// Rewriting must not invalidate external package integrity contracts.
40    pub rewrite_blockers: Vec<String>,
41}
42
43fn safe_name(name: &str) -> bool {
44    let path = name.strip_suffix('/').unwrap_or(name);
45    !path.is_empty()
46        && path.len() <= 1024
47        && !path.contains(['\\', ':', '\0'])
48        && !path.chars().any(char::is_control)
49        && path
50            .split('/')
51            .all(|p| !p.is_empty() && p != "." && p != "..")
52}
53
54fn metadata(name: &str) -> bool {
55    name.split('/')
56        .any(|part| part == "__MACOSX" || part == ".DS_Store" || part.starts_with("._"))
57}
58
59fn open(bytes: &[u8]) -> Result<(ZipArchive<Cursor<&[u8]>>, ArchiveInfo)> {
60    ensure!(bytes.len() <= MAX_ARCHIVE_BYTES, "archive_input_limit");
61    // Bound the central-directory allocation before the ZIP library parses it.
62    ensure!(bytes.len() >= 22, "invalid_zip");
63    let end = (bytes.len().saturating_sub(65_557)..=bytes.len() - 22)
64        .rev()
65        .find(|&i| {
66            bytes.get(i..i + 4) == Some(b"PK\x05\x06")
67                && i + 22 + u16::from_le_bytes([bytes[i + 20], bytes[i + 21]]) as usize
68                    == bytes.len()
69        })
70        .context("archive_end_record_missing")?;
71    let u16_at = |i| u16::from_le_bytes([bytes[end + i], bytes[end + i + 1]]);
72    let count = u16_at(10) as usize;
73    ensure!(
74        u16_at(4) == 0 && u16_at(6) == 0 && u16_at(8) as usize == count,
75        "archive_multidisk_not_supported"
76    );
77    ensure!(count <= MAX_ENTRIES, "archive_entry_count_limit");
78    let mut zip = ZipArchive::new(Cursor::new(bytes)).context("invalid_zip")?;
79    ensure!(zip.len() == count, "archive_duplicate_or_zip64_directory");
80    ensure!(zip.len() <= MAX_ENTRIES, "archive_entry_count_limit");
81    let mut info = ArchiveInfo {
82        entries: vec![],
83        expanded_bytes: 0,
84        compressed_bytes: 0,
85        preview_limit: MAX_PREVIEWS,
86        optimized_images: 0,
87        rewrite_blockers: vec![],
88    };
89    let mut names = BTreeSet::new();
90    for i in 0..zip.len() {
91        let file = zip.by_index(i).context("archive_entry_unreadable")?;
92        let name = std::str::from_utf8(file.name_raw()).context("archive_non_utf8_path")?;
93        ensure!(safe_name(name), "archive_unsafe_path");
94        ensure!(
95            names.insert(name.trim_end_matches('/').to_lowercase()),
96            "archive_duplicate_path"
97        );
98        ensure!(!file.is_symlink(), "archive_symlink");
99        ensure!(!file.encrypted(), "archive_encrypted");
100        ensure!(file.size() <= MAX_ENTRY_BYTES, "archive_entry_size_limit");
101        info.expanded_bytes = info
102            .expanded_bytes
103            .checked_add(file.size())
104            .context("archive_size_overflow")?;
105        ensure!(
106            info.expanded_bytes <= MAX_EXPANDED_BYTES,
107            "archive_expansion_limit"
108        );
109        info.compressed_bytes += file.compressed_size();
110        let lower = name.to_ascii_lowercase();
111        let base = lower.rsplit('/').next().unwrap_or("");
112        // These require a package publisher, not an in-place byte optimizer.
113        if matches!(base, "manifest.json" | "pack-info.json" | "sniff.json")
114            || lower.starts_with("meta-inf/")
115            || lower.contains("_codesignature/")
116            || lower.ends_with(".sig")
117            || lower.ends_with(".signature")
118        {
119            info.rewrite_blockers
120                .push(format!("package_integrity_metadata: {name}"));
121        }
122        let extension = Path::new(name)
123            .extension()
124            .and_then(|e| e.to_str())
125            .unwrap_or("")
126            .to_ascii_lowercase();
127        let format = match extension.as_str() {
128            "jpg" | "jpe" => "jpeg".into(),
129            "tif" => "tiff".into(),
130            _ => extension,
131        };
132        info.entries.push(ArchiveEntry {
133            path: name.into(),
134            bytes: file.size(),
135            compressed_bytes: file.compressed_size(),
136            kind: crate::resources::kind(&format).into(),
137            format,
138            directory: file.is_dir(),
139            metadata: metadata(name),
140            preview: None,
141            issues: vec![],
142        });
143    }
144    // Even though nothing is extracted, reject file/directory aliasing as ambiguous.
145    for entry in &info.entries {
146        if !entry.directory {
147            let prefix = format!("{}/", entry.path.to_lowercase());
148            ensure!(
149                !names.iter().any(|name| name.starts_with(&prefix)),
150                "archive_path_conflict"
151            );
152        }
153    }
154    Ok((zip, info))
155}
156
157fn read_entry(zip: &mut ZipArchive<Cursor<&[u8]>>, index: usize) -> Result<Vec<u8>> {
158    let file = zip.by_index(index)?;
159    let size = file.size();
160    ensure!(size <= MAX_ENTRY_BYTES, "archive_entry_size_limit");
161    let mut bytes = Vec::new();
162    file.take(size + 1)
163        .read_to_end(&mut bytes)
164        .context("archive_entry_crc_or_data_error")?;
165    ensure!(bytes.len() as u64 == size, "archive_entry_size_mismatch");
166    Ok(bytes)
167}
168
169pub(crate) fn analyze(
170    context: &Context<'_>,
171    resource: &Resource,
172    index: usize,
173    bytes: &[u8],
174    digest: &str,
175) -> ResourceAnalysis {
176    let mut row = ResourceAnalysis::new(resource, "inspected");
177    row.sha256 = Some(digest.into());
178    match inspect(context, index, bytes) {
179        Ok(info) => {
180            row.archive = Some(info);
181            if !context.options.probe_only
182                && !context.control.is_cancelled()
183                && resource.conversion_exclusion.is_none()
184                && bytes.len() as u64 >= context.options.min_input_bytes
185                && let Err(error) = add_candidate(context, resource, index, bytes, &mut row)
186            {
187                row.status = "failed".into();
188                row.candidates.clear();
189                row.smallest_candidate = None;
190                row.issues.push(format!("{error:#}"));
191            }
192        }
193        Err(error) => {
194            row.status = "failed".into();
195            row.issues.push(format!("{error:#}"));
196        }
197    }
198    if context.control.is_cancelled() {
199        row.status = "not_analyzed".into();
200    }
201    row
202}
203
204fn inspect(context: &Context<'_>, index: usize, bytes: &[u8]) -> Result<ArchiveInfo> {
205    let (mut zip, mut info) = open(bytes)?;
206    let mut images: Vec<_> = info
207        .entries
208        .iter()
209        .enumerate()
210        .filter(|(_, e)| !e.directory && !e.metadata && crate::capabilities::decodable(&e.format))
211        .map(|(i, e)| (i, e.bytes))
212        .collect();
213    images.sort_by_key(|(_, size)| std::cmp::Reverse(*size));
214    for (i, _) in images.into_iter().take(MAX_PREVIEWS) {
215        if context.control.is_cancelled() {
216            break;
217        }
218        let attempt = (|| -> Result<PathBuf> {
219            let bytes = read_entry(&mut zip, i)?;
220            let _lease = context.budget.acquire(context.options.max_pixels);
221            let decoded = crate::image_backend::decode(&bytes, context.options.max_pixels)?;
222            let png = crate::image_backend::preview(&decoded)?;
223            let preview = PathBuf::from(format!("previews/{index}-zip-{i}.png"));
224            write_artifact(&context.out.join(&preview), &png)?;
225            Ok(preview)
226        })();
227        match attempt {
228            Ok(path) => info.entries[i].preview = Some(path),
229            Err(error) => info.entries[i]
230                .issues
231                .push(format!("preview_unavailable: {error:#}")),
232        }
233    }
234    Ok(info)
235}
236
237// Keep unmodified entries as their original compressed streams. Only static PNG
238// IDAT bytes may change; paths, dimensions, atlas/config payloads and permissions
239// are independently verified again at apply time.
240fn optimize(bytes: &[u8], context: &Context<'_>, info: &mut ArchiveInfo) -> Result<Vec<u8>> {
241    use std::io::Write;
242    let (mut zip, _) = open(bytes)?;
243    if !info.rewrite_blockers.is_empty() {
244        return Ok(bytes.to_vec());
245    }
246    // Cocos and custom resource manifests may carry digests outside manifest.json.
247    for i in 0..zip.len() {
248        if info.entries[i].format == "json"
249            && !info.entries[i].metadata
250            && !info.entries[i].directory
251        {
252            let data = read_entry(&mut zip, i)?;
253            if has_integrity_fields(&data) {
254                info.rewrite_blockers.push(format!(
255                    "package_integrity_metadata: {}",
256                    info.entries[i].path
257                ));
258            }
259        }
260    }
261    if !info.rewrite_blockers.is_empty() {
262        return Ok(bytes.to_vec());
263    }
264    let mut output = zip::ZipWriter::new(Cursor::new(Vec::new()));
265    output.set_raw_comment(zip.comment().into())?;
266    let policy = crate::optimizer::Policy {
267        reductions: false,
268        ..context.options.png_policy()
269    };
270    for i in 0..zip.len() {
271        ensure!(
272            !context.control.is_cancelled(),
273            "archive_analysis_cancelled"
274        );
275        let entry = &mut info.entries[i];
276        let original = if entry.directory {
277            vec![]
278        } else {
279            read_entry(&mut zip, i)?
280        };
281        let file = zip.by_index(i)?;
282        // Preserve extended timestamps/extra fields and per-entry comments verbatim.
283        let plain = file.extra_data().is_none_or(|extra| extra.is_empty())
284            && file.comment().is_empty()
285            && file.unix_mode().is_some();
286        let pixels = original.get(16..24).and_then(|data| {
287            let width = u32::from_be_bytes(data[..4].try_into().ok()?) as usize;
288            let height = u32::from_be_bytes(data[4..].try_into().ok()?) as usize;
289            width.checked_mul(height)
290        });
291        let candidate = if !entry.metadata
292            && plain
293            && original.starts_with(b"\x89PNG\r\n\x1a\n")
294            && pixels.is_some_and(|p| p > 0 && p <= context.options.max_pixels)
295        {
296            let _lease = context.budget.acquire(pixels.unwrap());
297            match crate::optimizer::optimize(&original, &policy) {
298                Ok(smaller) if smaller.len() < original.len() => Some(smaller),
299                Ok(_) => None,
300                Err(error) => {
301                    entry
302                        .issues
303                        .push(format!("archive_image_unchanged: {error:#}"));
304                    None
305                }
306            }
307        } else {
308            None
309        };
310        if let Some(smaller) = candidate {
311            output.start_file(file.name(), file.options())?;
312            output.write_all(&smaller)?;
313            info.optimized_images += 1;
314        } else {
315            output.raw_copy_file(file)?;
316        }
317    }
318    let candidate = output.finish()?.into_inner();
319    ensure!(candidate.len() <= MAX_ARCHIVE_BYTES, "archive_output_limit");
320    if info.optimized_images == 0 || candidate.len() >= bytes.len() {
321        info.optimized_images = 0;
322        return Ok(bytes.to_vec());
323    }
324    verify(bytes, &candidate)?;
325    Ok(candidate)
326}
327
328fn has_integrity_fields(bytes: &[u8]) -> bool {
329    fn inspect(value: &serde_json::Value) -> bool {
330        match value {
331            serde_json::Value::Object(fields) => fields.iter().any(|(key, value)| {
332                let nonempty = !value.is_null()
333                    && value.as_str() != Some("")
334                    && !value.as_array().is_some_and(Vec::is_empty)
335                    && !value.as_object().is_some_and(serde_json::Map::is_empty);
336                (matches!(
337                    key.to_ascii_lowercase().as_str(),
338                    "md5" | "sha1" | "sha256" | "integrity" | "md5assetsmap"
339                ) && nonempty)
340                    || (key.eq_ignore_ascii_case("hash")
341                        && nonempty
342                        && fields
343                            .keys()
344                            .any(|k| matches!(k.as_str(), "path" | "file" | "filename" | "url")))
345                    || inspect(value)
346            }),
347            serde_json::Value::Array(values) => values.iter().any(inspect),
348            _ => false,
349        }
350    }
351    serde_json::from_slice(bytes)
352        .map(|v| inspect(&v))
353        .unwrap_or(true)
354}
355
356pub(crate) fn verify(original: &[u8], candidate: &[u8]) -> Result<()> {
357    let (mut before, old) = open(original)?;
358    let (mut after, new) = open(candidate)?;
359    ensure!(
360        old.rewrite_blockers.is_empty(),
361        "archive_integrity_contract_requires_publisher"
362    );
363    ensure!(
364        old.entries.len() == new.entries.len() && before.comment() == after.comment(),
365        "archive_structure_changed"
366    );
367    for i in 0..before.len() {
368        let a = before.by_index(i)?;
369        let b = after.by_index(i)?;
370        ensure!(
371            a.name_raw() == b.name_raw()
372                && a.is_dir() == b.is_dir()
373                && a.unix_mode() == b.unix_mode()
374                && a.last_modified() == b.last_modified()
375                && a.comment() == b.comment()
376                && a.extra_data().unwrap_or(&[]) == b.extra_data().unwrap_or(&[]),
377            "archive_entry_metadata_changed"
378        );
379        drop((a, b));
380        let a = read_entry(&mut before, i)?;
381        let b = read_entry(&mut after, i)?;
382        if old.entries[i].format == "json" && !old.entries[i].metadata {
383            ensure!(
384                !has_integrity_fields(&a),
385                "archive_integrity_contract_requires_publisher"
386            );
387        }
388        if a != b {
389            ensure!(
390                !old.entries[i].metadata && a.starts_with(b"\x89PNG\r\n\x1a\n"),
391                "archive_non_image_payload_changed"
392            );
393            crate::optimizer::verify(&a, &b, false)?;
394        }
395    }
396    Ok(())
397}
398
399fn add_candidate(
400    context: &Context<'_>,
401    resource: &Resource,
402    index: usize,
403    original: &[u8],
404    row: &mut ResourceAnalysis,
405) -> Result<()> {
406    use crate::filesystem::{hash, write_new};
407    let info = row.archive.as_mut().context("missing_archive_info")?;
408    let candidate = optimize(original, context, info)?;
409    let savings = original.len().saturating_sub(candidate.len()) as u64;
410    if savings < context.options.min_savings_bytes.max(1) {
411        return Ok(());
412    }
413    let artifact = PathBuf::from(format!("candidates/{index}-zip-0.zip"));
414    let source = PathBuf::from(format!("originals/{index}.zip"));
415    let current = crate::filesystem::contained_file(context.root, &resource.path)
416        .and_then(|path| crate::resources::bounded_read(&path))?;
417    ensure!(
418        Some(hash(&current)) == row.sha256,
419        "source_changed_during_analysis"
420    );
421    write_new(&context.out.join(&artifact), &candidate)?;
422    write_new(&context.out.join(&source), original)?;
423    row.candidates.push(crate::ImageCandidate {
424        format: "zip".into(),
425        quality: None,
426        lossy: false,
427        bytes: candidate.len() as u64,
428        savings_bytes: savings,
429        valid: true,
430        rejection: None,
431        difference: None,
432        artifact: Some(artifact),
433        preview: None,
434        sha256: Some(hash(&candidate)),
435        warnings: vec![],
436        notes: vec![format!("archive_pngs_optimized: {}", info.optimized_images)],
437    });
438    row.original_artifact = Some(source);
439    row.smallest_candidate = Some(0);
440    row.status = "candidates_available".into();
441    Ok(())
442}
443
444#[cfg(test)]
445mod tests {
446    use super::*;
447    use std::io::Write;
448    use zip::{ZipWriter, write::SimpleFileOptions};
449
450    fn fixture(entries: &[(&str, &[u8])]) -> Vec<u8> {
451        let mut zip = ZipWriter::new(Cursor::new(Vec::new()));
452        for (name, bytes) in entries {
453            zip.start_file(*name, SimpleFileOptions::default()).unwrap();
454            zip.write_all(bytes).unwrap();
455        }
456        zip.finish().unwrap().into_inner()
457    }
458
459    #[test]
460    fn inspects_contents_without_extracting_and_flags_manifest_contracts() {
461        let bytes = fixture(&[
462            ("assets/texture.png", b"png"),
463            ("manifest.json", b"{}"),
464            ("__MACOSX/._texture.png", b"metadata"),
465        ]);
466        let (mut zip, info) = open(&bytes).unwrap();
467        assert_eq!(info.entries.len(), 3);
468        assert_eq!(info.expanded_bytes, 13);
469        assert_eq!(read_entry(&mut zip, 0).unwrap(), b"png");
470        assert!(info.entries[2].metadata);
471        assert_eq!(info.rewrite_blockers.len(), 1);
472    }
473
474    #[test]
475    fn verification_rejects_changed_atlas_and_injected_digest_contracts() {
476        let original = fixture(&[("a.atlas", b"size: 32,32"), ("settings.json", b"{}")]);
477        let changed = fixture(&[("a.atlas", b"size: 31,32"), ("settings.json", b"{}")]);
478        assert!(verify(&original, &changed).is_err());
479        let protected = fixture(&[("settings.json", br#"{"sha256":"abc"}"#)]);
480        assert!(verify(&protected, &protected).is_err());
481        assert!(!has_integrity_fields(br#"{"md5AssetsMap":{}}"#));
482        // Spine's skeleton hash describes the unchanged skeleton, not texture bytes.
483        assert!(!has_integrity_fields(br#"{"skeleton":{"hash":"abc"}}"#));
484        assert!(has_integrity_fields(br#"{"path":"a.png","hash":"abc"}"#));
485    }
486
487    #[test]
488    fn rejects_unsafe_ambiguous_and_oversized_archives() {
489        for name in ["../escape.png", "/absolute.png", "a/../b", "C:/x", "a\\b"] {
490            assert!(open(&fixture(&[(name, b"x")])).is_err(), "{name}");
491        }
492        assert!(open(&fixture(&[("A.png", b"x"), ("a.png", b"y")])).is_err());
493        assert!(open(&fixture(&[("a", b"x"), ("a/b", b"y")])).is_err());
494        let mut bytes = fixture(&[("a.png", b"x")]);
495        let central = bytes.windows(4).position(|b| b == b"PK\x01\x02").unwrap();
496        bytes[central + 24..central + 28]
497            .copy_from_slice(&((MAX_ENTRY_BYTES + 1) as u32).to_le_bytes());
498        assert!(open(&bytes).is_err());
499    }
500}