const MAX_EXPANDED: usize = 256 * 1024 * 1024;
pub(crate) struct File {
pub name: String,
pub file_type: [u8; 4],
pub creator: [u8; 4],
pub finder_flags: u16,
pub data: Vec<u8>,
pub rsrc: Vec<u8>,
}
struct Entry {
name: String,
metadata: [u8; 45],
}
fn take<'a>(bytes: &'a [u8], position: &mut usize, count: usize) -> Result<&'a [u8], String> {
let end = position
.checked_add(count)
.ok_or("installer offset overflow")?;
let value = bytes
.get(*position..end)
.ok_or("truncated Smaller Installer")?;
*position = end;
Ok(value)
}
fn word(bytes: &[u8]) -> usize {
u16::from_be_bytes([bytes[0], bytes[1]]) as usize
}
fn long(bytes: &[u8]) -> usize {
u32::from_be_bytes(bytes[..4].try_into().unwrap()) as usize
}
fn directory(
bytes: &[u8],
position: &mut usize,
count: usize,
prefix: &str,
depth: usize,
entries: &mut Vec<Entry>,
) -> Result<(), String> {
if depth > 32 {
return Err("Smaller Installer folder nesting exceeds limit".into());
}
let mut remaining = count;
while remaining > 0 {
let size = take(bytes, position, 1)?[0];
let name =
crate::trap::types::decode_mac_roman(take(bytes, position, (size & 127) as usize)?);
if name.is_empty() || matches!(name.as_str(), "." | "..") || name.contains([':', '\0']) {
return Err("invalid Smaller Installer path component".into());
}
let name = crate::trap::TrapDispatcher::encode_hfs_component_for_vfs(&name);
let path = if prefix.is_empty() {
name
} else {
format!("{prefix}/{name}")
};
remaining -= 1;
if size & 128 != 0 {
let children = word(take(bytes, position, 2)?);
if children > remaining {
return Err("invalid Smaller Installer folder count".into());
}
directory(bytes, position, children, &path, depth + 1, entries)?;
remaining -= children;
} else {
entries.push(Entry {
name: path,
metadata: take(bytes, position, 45)?.try_into().unwrap(),
});
}
}
Ok(())
}
pub(crate) fn expand(bytes: &[u8], resources: &[u8]) -> Result<Option<Vec<File>>, String> {
if !resources
.windows(b"Smaller Installer".len())
.any(|window| window == b"Smaller Installer")
{
return Ok(None);
}
if let Some((count, records_start, end)) = compact_directory(bytes, 0) {
if count == 0 {
return Err("empty Smaller Installer directory".into());
}
let mut entries = Vec::new();
let mut position = records_start;
directory(bytes, &mut position, count, "", 0, &mut entries)?;
return expand_entries(bytes, entries, end, 0..end).map(Some);
}
let mut position = 4;
let count = word(take(bytes, &mut position, 2)?);
take(bytes, &mut position, 4)?;
if count == 0 {
return Err("empty Smaller Installer directory".into());
}
let mut entries = Vec::new();
directory(bytes, &mut position, count, "", 0, &mut entries)?;
expand_entries(bytes, entries, position, 0..position).map(Some)
}
fn compact_directory(bytes: &[u8], index: usize) -> Option<(usize, usize, usize)> {
if index.checked_add(7).is_none_or(|end| end > bytes.len()) {
return None;
}
let count = word(&bytes[index + 4..index + 6]);
let mut end = index + 7;
take(bytes, &mut end, bytes[index + 6] as usize).ok()?;
let records_start = end;
for _ in 0..count {
let size = take(bytes, &mut end, 1).ok()?[0];
take(bytes, &mut end, (size & 127) as usize).ok()?;
take(bytes, &mut end, if size & 128 != 0 { 2 } else { 45 }).ok()?;
}
let checksum = crc(bytes[index + 4..end].iter().copied());
(checksum == long(&bytes[index..]) as u32).then_some((count, records_start, end))
}
pub(crate) fn expand_compact_pro(bytes: &[u8]) -> Result<Option<Vec<File>>, String> {
if bytes.len() < 15 || bytes[0] != 1 || bytes[1] != 1 {
return Ok(None);
}
let index = long(&bytes[4..8]);
if index < 8 {
return Ok(None);
}
let Some((count, records_start, end)) = compact_directory(bytes, index) else {
return Ok(None);
};
if count == 0 {
return Err("empty Compact Pro directory".into());
}
let mut entries = Vec::new();
let mut position = records_start;
directory(bytes, &mut position, count, "", 0, &mut entries)?;
expand_entries(bytes, entries, 8, index..end).map(Some)
}
fn expand_entries(
bytes: &[u8],
entries: Vec<Entry>,
minimum_fork_offset: usize,
directory_range: std::ops::Range<usize>,
) -> Result<Vec<File>, String> {
let mut expanded = 0usize;
let mut files = Vec::new();
let mut names = std::collections::BTreeSet::new();
for entry in entries {
let m = entry.metadata;
let flags = word(&m[27..]);
if m[0] != 1 || flags & !6 != 0 {
return Err("unsupported Smaller Installer volume or flags".into());
}
if !names.insert(entry.name.to_lowercase()) {
return Err("duplicate Smaller Installer path".into());
}
let resource_len = long(&m[29..]);
let data_len = long(&m[33..]);
expanded = expanded
.checked_add(resource_len)
.and_then(|size| size.checked_add(data_len))
.ok_or("installer expansion overflow")?;
if expanded > MAX_EXPANDED {
return Err("Smaller Installer expanded size exceeds limit".into());
}
let mut offset = long(&m[1..]);
let fork_end = offset
.checked_add(long(&m[37..]))
.and_then(|end| end.checked_add(long(&m[41..])))
.ok_or("Compact Pro fork offset overflow")?;
if offset < minimum_fork_offset
|| (offset < directory_range.end && fork_end > directory_range.start)
{
return Err("Compact Pro fork overlaps header or directory".into());
}
let rp = take(bytes, &mut offset, long(&m[37..]))?;
let dp = take(bytes, &mut offset, long(&m[41..]))?;
let rsrc = decode(rp, resource_len, flags & 2 != 0)?;
let data = decode(dp, data_len, flags & 4 != 0)?;
if crc(rsrc.iter().chain(data.iter()).copied()) != long(&m[23..]) as u32 {
return Err(format!(
"Smaller Installer checksum mismatch: {}",
entry.name
));
}
files.push(File {
name: entry.name,
file_type: m[5..9].try_into().unwrap(),
creator: m[9..13].try_into().unwrap(),
finder_flags: word(&m[21..]) as u16,
data,
rsrc,
});
}
Ok(files)
}
fn crc(bytes: impl Iterator<Item = u8>) -> u32 {
let mut value = u32::MAX;
for byte in bytes {
value ^= byte as u32;
for _ in 0..8 {
value = (value >> 1) ^ (0xedb88320 & 0u32.wrapping_sub(value & 1));
}
}
value
}
struct Bits<'a> {
bytes: &'a [u8],
position: usize,
}
impl Bits<'_> {
fn read(&mut self, count: usize) -> Result<usize, String> {
let mut value = 0;
for _ in 0..count {
let byte = self
.bytes
.get(self.position / 8)
.ok_or("truncated Compact Pro bitstream")?;
value = (value << 1) | ((byte >> (7 - self.position % 8)) & 1) as usize;
self.position += 1;
}
Ok(value)
}
}
#[derive(Default)]
struct Code {
symbols: Vec<u8>,
counts: [usize; 16],
first_codes: [usize; 16],
first_symbols: [usize; 16],
}
impl Code {
fn read(bits: &mut Bits<'_>, count: usize) -> Result<Self, String> {
let packed_count = bits.read(8)?;
if packed_count * 2 > count {
return Err("oversized Compact Pro prefix table".into());
}
let mut lengths = Vec::new();
for pair in 0..packed_count {
let byte = bits.read(8)?;
for (symbol, length) in [(pair * 2, byte >> 4), (pair * 2 + 1, byte & 15)] {
if length != 0 {
lengths.push((length, symbol));
}
}
}
lengths.sort_unstable();
let mut code = 0;
let mut previous = 0;
let mut table = Self::default();
for (length, symbol) in lengths {
code <<= length - previous;
if code >= 1 << length {
return Err("oversubscribed Compact Pro prefix table".into());
}
if table.counts[length] == 0 {
table.first_codes[length] = code;
table.first_symbols[length] = table.symbols.len();
}
table.counts[length] += 1;
table.symbols.push(symbol as u8);
code += 1;
previous = length;
}
Ok(table)
}
fn symbol(&self, bits: &mut Bits<'_>) -> Result<u8, String> {
let mut code = 0;
for length in 1..=15 {
code = (code << 1) | bits.read(1)?;
if let Some(index) = code.checked_sub(self.first_codes[length]) {
if index < self.counts[length] {
return Ok(self.symbols[self.first_symbols[length] + index]);
}
}
}
Err("invalid Compact Pro prefix code".into())
}
}
struct Lzh<'a> {
bits: Bits<'a>,
codes: [Code; 3],
block_start: usize,
charge: usize,
initialized: bool,
window: [u8; 8192],
cursor: usize,
distance: usize,
remaining: usize,
}
impl<'a> Lzh<'a> {
fn new(bytes: &'a [u8]) -> Self {
Self {
bits: Bits { bytes, position: 0 },
codes: Default::default(),
block_start: 0,
charge: 0,
initialized: false,
window: [0; 8192],
cursor: 0,
distance: 0,
remaining: 0,
}
}
fn next(&mut self) -> Result<u8, String> {
if self.remaining == 0 {
if !self.initialized || self.charge >= 0x1fff0 {
if self.initialized {
self.bits.position = self.bits.position.div_ceil(8) * 8;
let padding = if (self.bits.position / 8 - self.block_start) & 1 == 0 {
2
} else {
3
};
self.bits.read(padding * 8)?;
}
self.codes = [
Code::read(&mut self.bits, 256)?,
Code::read(&mut self.bits, 64)?,
Code::read(&mut self.bits, 128)?,
];
self.block_start = self.bits.position / 8;
self.charge = 0;
self.initialized = true;
}
if self.bits.read(1)? != 0 {
self.charge += 2;
let byte = self.codes[0].symbol(&mut self.bits)?;
return Ok(self.record(byte));
}
self.charge += 3;
self.remaining = self.codes[1].symbol(&mut self.bits)? as usize;
if self.remaining == 0 {
return Err("zero-length Compact Pro match".into());
}
self.distance =
((self.codes[2].symbol(&mut self.bits)? as usize) << 6) | self.bits.read(6)?;
}
self.remaining -= 1;
let byte = self.window[self.cursor.wrapping_sub(self.distance) & 8191];
Ok(self.record(byte))
}
fn record(&mut self, byte: u8) -> u8 {
self.window[self.cursor & 8191] = byte;
self.cursor = self.cursor.wrapping_add(1);
byte
}
}
fn decode(bytes: &[u8], size: usize, compressed: bool) -> Result<Vec<u8>, String> {
if size > MAX_EXPANDED {
return Err("Compact Pro fork exceeds limit".into());
}
if size == 0 {
return if bytes.is_empty() {
Ok(Vec::new())
} else {
Err("nonempty packed zero-length fork".into())
};
}
let mut lzh = compressed.then(|| Lzh::new(bytes));
let mut position = 0;
let mut next = || -> Result<u8, String> {
if let Some(stream) = &mut lzh {
stream.next()
} else {
Ok(take(bytes, &mut position, 1)?[0])
}
};
let mut output = Vec::with_capacity(size);
let mut previous = 0;
let mut escaped = false;
while output.len() < size {
let byte = if escaped { 0x81 } else { next()? };
escaped = false;
if byte != 0x81 {
output.push(byte);
previous = byte;
continue;
}
let following = match next() {
Ok(byte) => byte,
Err(_) if !compressed && output.len() + 1 == size => {
output.push(0x81);
break;
}
Err(error) => return Err(error),
};
match following {
0x82 => match next()? {
0 => {
output.extend_from_slice(&[0x81, 0x82]);
previous = 0x82;
}
count @ 2..=255 => {
let run = count as usize - 1;
if run > size - output.len() {
return Err("Compact Pro run exceeds fork length".into());
}
output.resize(output.len() + run, previous);
}
_ => return Err("invalid Compact Pro repeat count".into()),
},
0x81 => {
output.push(0x81);
previous = 0x81;
escaped = true;
}
byte => {
output.extend_from_slice(&[0x81, byte]);
previous = byte;
}
}
if output.len() > size {
return Err("Compact Pro escape exceeds fork length".into());
}
}
Ok(output)
}
#[cfg(test)]
mod tests {
use super::*;
fn simple_tables() -> Vec<u8> {
let mut bytes = vec![33];
bytes.extend_from_slice(&[0; 32]);
bytes.extend_from_slice(&[1, 2, 0, 1, 1, 0x10]);
bytes
}
#[test]
fn lzh_copies_overlapping_window_matches() {
let mut bytes = simple_tables();
bytes.extend_from_slice(&[0x80, 0x20]);
assert_eq!(decode(&bytes, 4, true).unwrap(), b"AAAA");
assert!(decode(&bytes[..bytes.len() - 1], 4, true).is_err());
assert!(decode(&[2, 0x11, 0x10], 1, true).is_err());
}
#[test]
fn lzh_refreshes_tables_at_block_boundary() {
let mut bytes = simple_tables();
bytes.extend_from_slice(&[0xaa; 16_382]);
bytes.extend_from_slice(&[0; 2]);
bytes.extend_from_slice(&simple_tables());
bytes.push(0x80);
assert_eq!(decode(&bytes, 65_529, true).unwrap(), vec![b'A'; 65_529]);
}
#[test]
fn rle_handles_runs_and_escape_pairs() {
assert_eq!(decode(&[b'A', 0x81, 0x82, 4], 4, false).unwrap(), b"AAAA");
assert_eq!(decode(&[0x81, 0x82, 0], 2, false).unwrap(), [0x81, 0x82]);
assert_eq!(decode(&[0x81, b'B'], 2, false).unwrap(), [0x81, b'B']);
assert_eq!(
decode(&[0x81, 0x81, b'B'], 3, false).unwrap(),
[0x81, 0x81, b'B']
);
}
#[test]
fn malformed_streams_fail_without_partial_forks() {
for stream in [
&[0x81][..],
&[0x81, 0x82][..],
&[0x81, 0x82, 1][..],
&[b'A', 0x81, 0x82, 255][..],
] {
assert!(decode(stream, 4, false).is_err());
}
assert!(decode(&[0x81, b'B'], 1, false).is_err());
assert!(decode(&[129], 10, true).is_err());
assert!(decode(&[1], 0, false).is_err());
}
#[test]
fn final_raw_rle_literal_is_bounded_and_fork_checksum_checked() {
assert_eq!(decode(&[0x81], 1, false).unwrap(), [0x81]);
assert_eq!(decode(&[b'A', 0x81], 2, false).unwrap(), [b'A', 0x81]);
assert_eq!(decode(&[0x81, 0x81], 2, false).unwrap(), [0x81, 0x81]);
for resource_only in [false, true] {
let mut bytes = fixture();
bytes[60] = 0x81;
bytes[38..42].copy_from_slice(&crc([0x81].into_iter()).to_be_bytes());
if resource_only {
bytes[44..48].copy_from_slice(&1u32.to_be_bytes());
bytes[48..52].copy_from_slice(&0u32.to_be_bytes());
bytes[52..56].copy_from_slice(&1u32.to_be_bytes());
bytes[56..60].copy_from_slice(&0u32.to_be_bytes());
}
let files = expand(&bytes, b"Smaller Installer").unwrap().unwrap();
assert_eq!(files.len(), 1);
assert_eq!(files[0].data, if resource_only { vec![] } else { vec![0x81] });
assert_eq!(files[0].rsrc, if resource_only { vec![0x81] } else { vec![] });
bytes[38] ^= 1;
assert!(expand(&bytes, b"Smaller Installer").is_err());
}
assert!(decode(&[0x81], 2, false).is_err());
assert!(decode(&[0x81, 0x82], 1, false).is_err());
assert!(decode(&[0x81, b'B'], 1, false).is_err());
}
fn fixture() -> Vec<u8> {
let mut bytes = vec![0; 10];
bytes[4..6].copy_from_slice(&1u16.to_be_bytes());
bytes.extend_from_slice(&[4, b'T', b'e', b's', b't']);
let mut m = [0; 45];
m[0] = 1;
m[1..5].copy_from_slice(&60u32.to_be_bytes());
m[5..9].copy_from_slice(b"TEXT");
m[9..13].copy_from_slice(b"ttxt");
m[23..27].copy_from_slice(&crc([b'A'].into_iter()).to_be_bytes());
m[33..37].copy_from_slice(&1u32.to_be_bytes());
m[41..45].copy_from_slice(&1u32.to_be_bytes());
bytes.extend_from_slice(&m);
bytes.push(b'A');
bytes
}
fn compact_fixture() -> Vec<u8> {
let installer = fixture();
let mut bytes = vec![1, 1, 0, 0, 0, 0, 0, 9, b'A'];
bytes.extend_from_slice(&[0, 0, 0, 0, 0, 1, 0]);
bytes.extend_from_slice(&installer[10..60]);
bytes[22..26].copy_from_slice(&8u32.to_be_bytes());
seal_directory(&mut bytes);
bytes
}
fn seal_directory(bytes: &mut [u8]) {
let index = long(&bytes[4..8]);
let checksum = crc(bytes[index + 4..].iter().copied());
bytes[index..index + 4].copy_from_slice(&checksum.to_be_bytes());
}
#[test]
fn compact_pro_recognizes_checked_container_and_preserves_metadata() {
let bytes = compact_fixture();
let files = expand_compact_pro(&bytes).unwrap().unwrap();
assert_eq!(files.len(), 1);
assert_eq!(files[0].name, "Test");
assert_eq!(files[0].data, b"A");
assert!(files[0].rsrc.is_empty());
assert_eq!(files[0].file_type, *b"TEXT");
assert_eq!(files[0].creator, *b"ttxt");
for length in 0..bytes.len() {
assert!(expand_compact_pro(&bytes[..length]).unwrap().is_none());
}
let mut corrupt = bytes.clone();
corrupt[17] ^= 1;
assert!(expand_compact_pro(&corrupt).unwrap().is_none());
let mut corrupt = bytes;
corrupt[8] = b'B';
assert!(expand_compact_pro(&corrupt).is_err());
}
#[test]
fn compact_pro_keeps_folder_paths_and_resource_only_applications() {
let mut bytes = compact_fixture();
bytes[26..30].copy_from_slice(b"APPL");
bytes[42..44].copy_from_slice(&0x4000u16.to_be_bytes());
bytes[50..54].copy_from_slice(&1u32.to_be_bytes());
bytes[54..58].copy_from_slice(&0u32.to_be_bytes());
bytes[58..62].copy_from_slice(&1u32.to_be_bytes());
bytes[62..66].copy_from_slice(&0u32.to_be_bytes());
bytes[13..15].copy_from_slice(&2u16.to_be_bytes());
bytes.splice(16..16, [0x84, b'D', b'o', b'c', b's', 0, 1]);
seal_directory(&mut bytes);
let files = expand_compact_pro(&bytes).unwrap().unwrap();
assert_eq!(files[0].name, "Docs/Test");
assert!(files[0].data.is_empty());
assert_eq!(files[0].rsrc, b"A");
assert_eq!(files[0].file_type, *b"APPL");
assert_eq!(files[0].finder_flags, 0x4000);
}
#[test]
fn compact_pro_preserves_literal_hfs_slashes_within_components() {
let mut bytes = compact_fixture();
bytes[18] = b'/';
seal_directory(&mut bytes);
let files = expand_compact_pro(&bytes).unwrap().unwrap();
let expected = crate::trap::TrapDispatcher::encode_hfs_component_for_vfs("T/st");
assert_eq!(files[0].name, expected);
assert!(!files[0].name.contains('/'));
assert_eq!(files[0].data, b"A");
assert_eq!(files[0].file_type, *b"TEXT");
assert_eq!(files[0].creator, *b"ttxt");
bytes[13..15].copy_from_slice(&2u16.to_be_bytes());
bytes.splice(16..16, [0x84, b'D', b'/', b'c', b's', 0, 1]);
seal_directory(&mut bytes);
let files = expand_compact_pro(&bytes).unwrap().unwrap();
let folder = crate::trap::TrapDispatcher::encode_hfs_component_for_vfs("D/cs");
assert_eq!(files[0].name, format!("{folder}/{expected}"));
assert_eq!(files[0].name.matches('/').count(), 1);
assert_eq!(files[0].data, b"A");
}
#[test]
fn compact_pro_still_rejects_invalid_hfs_components() {
for name in ["", ".", "..", ":", "a:b", "a\0b"] {
let mut bytes = compact_fixture();
bytes.splice(
16..21,
std::iter::once(name.len() as u8).chain(name.bytes()),
);
seal_directory(&mut bytes);
assert!(expand_compact_pro(&bytes).is_err(), "name {name:?}");
}
}
#[test]
fn compact_pro_rejects_authenticated_invalid_paths_flags_and_ranges() {
for (offset, replacement) in [
(17, b':'), (21, 2), (49, 1), ] {
let mut bytes = compact_fixture();
bytes[offset] = replacement;
seal_directory(&mut bytes);
assert!(expand_compact_pro(&bytes).is_err(), "offset {offset}");
}
for offset in [0u32, 7, 9, 16, u32::MAX] {
let mut bytes = compact_fixture();
bytes[22..26].copy_from_slice(&offset.to_be_bytes());
seal_directory(&mut bytes);
assert!(expand_compact_pro(&bytes).is_err(), "fork offset {offset}");
}
}
fn compact_header_installer() -> Vec<u8> {
let mut bytes = vec![0, 0, 0, 0, 0, 2, 2, b'h', b'i'];
bytes.extend_from_slice(&[0x81, b'D', 0, 1]);
bytes.extend_from_slice(&fixture()[10..60]);
let fork = bytes.len() as u32;
bytes[19..23].copy_from_slice(&fork.to_be_bytes());
let checksum = crc(bytes[4..].iter().copied());
bytes[..4].copy_from_slice(&checksum.to_be_bytes());
bytes.push(b'A');
bytes
}
#[test]
fn installer_reads_crc_checked_compact_directory_header() {
let bytes = compact_header_installer();
let files = expand(&bytes, b"Smaller Installer").unwrap().unwrap();
assert_eq!(files.len(), 1);
assert_eq!(files[0].name, "D/Test");
assert_eq!(files[0].data, b"A");
assert_eq!(files[0].file_type, *b"TEXT");
let mut corrupt = bytes.clone();
corrupt[0] ^= 1;
assert!(expand(&corrupt, b"Smaller Installer").is_err());
let mut overlapping = bytes;
overlapping[19..23].copy_from_slice(&4u32.to_be_bytes());
let checksum = crc(overlapping[4..63].iter().copied());
overlapping[..4].copy_from_slice(&checksum.to_be_bytes());
assert!(expand(&overlapping, b"Smaller Installer").is_err());
}
#[test]
fn installer_checks_metadata_and_crc() {
let mut bytes = fixture();
assert!(expand(&bytes, b"unrelated application").unwrap().is_none());
let files = expand(&bytes, b"Smaller Installer").unwrap().unwrap();
assert_eq!(files[0].data, b"A");
assert_eq!(files[0].file_type, *b"TEXT");
bytes[60] = b'B';
assert!(expand(&bytes, b"Smaller Installer").is_err());
bytes = fixture();
bytes[42] = 1;
assert!(expand(&bytes, b"Smaller Installer").is_err());
bytes = fixture();
bytes[16..20].copy_from_slice(&0u32.to_be_bytes());
assert!(expand(&bytes, b"Smaller Installer").is_err());
bytes = fixture();
bytes[48..52].copy_from_slice(&u32::MAX.to_be_bytes());
assert!(expand(&bytes, b"Smaller Installer").is_err());
}
}