1use 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 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 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 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 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
237fn 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 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 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(¤t)) == 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 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}