Files
craft-anything/crates/formats/tests/pyz_version_headers.rs
Afloat e957c1d8cb Use version-specific Python headers for extracted PYZ code (R3.12) (#1563)
Code taken out of a PyInstaller PYZ archive was always given a 16-byte .pyc header, although Python 2.5 to 3.2 use 8 bytes and 3.3 to 3.6 use 12, so older code had extra zeros between the header and the marshalled code and couldn't be read at its own header boundary. The output limit reserved 16 bytes too, refusing an exact limit for 2.7 or 3.6 code. Wrapping, header parsing and the PYZ output limit now share one header-size lookup from the release table, and unknown magic numbers keep the 16-byte form. Tests cover standalone and nested PYZ archives, modules and packages, and exact limits.
2026-11-11 02:22:26 +07:00

85 lines
4.2 KiB
Rust

use craft_anything_formats::FormatError;
use craft_anything_formats::packed::PackedFormat;
use craft_anything_formats::pyc;
use craft_anything_formats::pyinstaller::{PyInstaller, PyzArchive};
use craft_anything_testkit::packed::{code_311, pyinstaller, pyz};
// Marshal's None value is unchanged across these releases. These fixtures test byte preservation
// and header framing, not execution of a legacy Python code object.
const BODY: &[u8] = b"N";
#[test]
fn legacy_wrappers_put_the_original_marshal_body_after_the_versioned_header() {
for (magic, header_bytes) in [(62211, 8), (3379, 12)] {
let bytes = pyc::wrap_marshal(magic, BODY);
let header = pyc::parse_header(&bytes).unwrap();
assert_eq!(header.size, header_bytes);
assert_eq!(bytes.len(), header_bytes + BODY.len());
assert_eq!(&bytes[header.size..], BODY);
assert!(pyc::read_value(&bytes[header.size..], None).is_ok());
assert_eq!(header.source_mtime, Some(0));
assert_eq!(header.flags, None);
}
}
#[test]
fn standalone_code_and_packages_respect_the_exact_versioned_output_limit() {
for (magic, header_bytes) in [(62211, 8), (3379, 12), (3495, 16), (0x1234, 16)] {
let bytes = pyz(magic, &[("module", 0, BODY), ("package", 1, BODY)], magic == 62211, true);
let listing = PyzArchive.list(&bytes).unwrap();
assert!(!listing.truncated);
assert_eq!(listing.entries.len(), 2);
for entry in &listing.entries {
let exact_limit = (header_bytes + BODY.len()) as u64;
let extracted = PyzArchive.read(&bytes, entry, exact_limit).unwrap();
assert_eq!(extracted.len() as u64, exact_limit);
assert_eq!(&extracted[header_bytes..], BODY);
assert!(matches!(PyzArchive.read(&bytes, entry, exact_limit - 1), Err(FormatError::TooLarge(_))));
assert!(matches!(PyzArchive.read(&bytes, entry, header_bytes as u64 - 1), Err(FormatError::TooLarge(_))));
}
}
}
#[test]
fn nested_legacy_pyz_extraction_preserves_the_payload_and_raw_archive() {
for (magic, python, header_bytes) in [(62211, 27, 8), (3379, 36, 12)] {
let inner = pyz(magic, &[("demo", 0, BODY)], true, true);
let bytes = pyinstaller(&[("PYZ.pyz", b'z', &inner, false)], true, python);
let listing = PyInstaller.list(&bytes).unwrap();
assert!(!listing.truncated);
let module = listing.entries.iter().find(|entry| entry.path == "PYZ.pyz.modules/demo.pyc").unwrap();
let extracted = PyInstaller.read(&bytes, module, 1024).unwrap();
assert_eq!(&extracted[header_bytes..], BODY);
assert_eq!(PyInstaller.read(&bytes, module, (header_bytes + BODY.len()) as u64).unwrap(), extracted);
let raw = listing.entries.iter().find(|entry| entry.path == "PYZ.pyz").unwrap();
assert_eq!(PyInstaller.read(&bytes, raw, inner.len() as u64).unwrap(), inner);
}
}
#[test]
fn current_code_objects_and_unknown_magic_keep_the_modern_header() {
let body = code_311("<module>", "<module>", "demo.py", 1, &[], &["kept constant"], &[]);
let bytes = pyz(3495, &[("demo", 0, &body)], false, true);
let listing = PyzArchive.list(&bytes).unwrap();
let extracted = PyzArchive.read(&bytes, &listing.entries[0], (16 + body.len()) as u64).unwrap();
assert_eq!(&extracted[16..], body);
let parsed = pyc::read_pyc(&extracted).unwrap();
assert_eq!(parsed.header.version, Some("3.11"));
assert_eq!(parsed.header.size, 16);
assert!(parsed.code.is_some());
let unknown = pyc::wrap_marshal(0x1234, BODY);
assert_eq!(pyc::parse_header(&unknown).unwrap().size, 16);
assert_eq!(&unknown[16..], BODY);
}
#[test]
fn legacy_pyz_resources_never_spend_a_code_header_budget() {
let body = b"resource bytes";
let bytes = pyz(62211, &[("assets/data.txt", 2, body), ("namespace", 3, b"")], true, true);
let listing = PyzArchive.list(&bytes).unwrap();
assert_eq!(listing.entries.len(), 1);
assert_eq!(listing.facts["namespace_packages"][0], "namespace");
assert_eq!(PyzArchive.read(&bytes, &listing.entries[0], body.len() as u64).unwrap(), body);
assert!(matches!(PyzArchive.read(&bytes, &listing.entries[0], body.len() as u64 - 1), Err(FormatError::TooLarge(_))));
}