642d5a256791
squashfs_lz4.rs
use craft_anything_formats::fsread::{Limits, squashfs};
fn put16(data: &mut [u8], at: usize, value: u16) {
data[at..at + 2].copy_from_slice(&value.to_le_bytes());
}
fn put32(data: &mut [u8], at: usize, value: u32) {
data[at..at + 4].copy_from_slice(&value.to_le_bytes());
}
fn put64(data: &mut [u8], at: usize, value: u64) {
data[at..at + 8].copy_from_slice(&value.to_le_bytes());
}
fn literals(bytes: &[u8]) -> Vec<u8> {
let mut out = vec![(bytes.len().min(15) as u8) << 4];
if bytes.len() >= 15 {
let mut remainder = bytes.len() - 15;
while remainder >= 255 {
out.push(255);
remainder -= 255;
}
out.push(remainder as u8);
}
out.extend_from_slice(bytes);
out
}
fn meta(out: &mut Vec<u8>, bytes: &[u8], compressed: bool) -> u64 {
let start = out.len() as u64;
let block = if compressed { literals(bytes) } else { bytes.to_vec() };
out.extend_from_slice(&((block.len() as u16) | if compressed { 0 } else { 0x8000 }).to_le_bytes());
out.extend_from_slice(&block);
start
}
fn image(block: &[u8], size: usize, compressed: bool, compressed_meta: bool, fragment: Option<(&[u8], u32)>) -> Vec<u8> {
let mut data = vec![0; 96];
data.extend_from_slice(block);
let frag_start = data.len() as u64;
let frag_block = fragment.map(|(bytes, _)| literals(bytes));
if let Some(bytes) = &frag_block {
data.extend_from_slice(bytes);
}
let nblocks = usize::from(fragment.is_none());
let root = 32 + nblocks * 4;
let mut inodes = vec![0; root + 32];
put16(&mut inodes, 0, 2);
put32(&mut inodes, 12, 2);
put32(&mut inodes, 16, 96);
put32(&mut inodes, 20, if fragment.is_some() { 0 } else { u32::MAX });
put32(&mut inodes, 24, fragment.map_or(0, |(_, offset)| offset));
put32(&mut inodes, 28, size as u32);
if nblocks != 0 {
put32(&mut inodes, 32, block.len() as u32 | if compressed { 0 } else { 0x0100_0000 });
}
put16(&mut inodes, root, 1);
put32(&mut inodes, root + 12, 1);
put32(&mut inodes, root + 20, 2);
put16(&mut inodes, root + 24, 27);
put32(&mut inodes, root + 28, 1);
let inode_table = meta(&mut data, &inodes, compressed_meta);
let mut dirs = vec![0; 24];
put32(&mut dirs, 8, 1);
put16(&mut dirs, 14, 1);
put16(&mut dirs, 16, 2);
put16(&mut dirs, 18, 3);
dirs[20..24].copy_from_slice(b"file");
let dir_table = meta(&mut data, &dirs, compressed_meta);
let frag_table = if let Some(bytes) = frag_block {
let mut entry = vec![0; 16];
put64(&mut entry, 0, frag_start);
put32(&mut entry, 8, bytes.len() as u32);
let table = meta(&mut data, &entry, compressed_meta);
let index = data.len() as u64;
data.extend_from_slice(&table.to_le_bytes());
index
} else {
u64::MAX
};
let id_table = data.len() as u64;
data.extend_from_slice(&(id_table + 8).to_le_bytes());
meta(&mut data, &[0; 4], false);
data[..4].copy_from_slice(b"hsqs");
put32(&mut data, 4, 2);
put32(&mut data, 12, 4096);
put32(&mut data, 16, u32::from(fragment.is_some()));
put16(&mut data, 20, 5);
put16(&mut data, 22, 12);
put16(&mut data, 26, 1);
put16(&mut data, 28, 4);
put64(&mut data, 32, root as u64);
let used = data.len() as u64;
put64(&mut data, 40, used);
put64(&mut data, 48, id_table);
put64(&mut data, 56, u64::MAX);
put64(&mut data, 64, inode_table);
put64(&mut data, 72, dir_table);
put64(&mut data, 80, frag_table);
put64(&mut data, 88, u64::MAX);
data
}
fn recovered(data: &[u8]) -> Vec<u8> {
let result = squashfs::read(data, &Limits::default());
assert!(result.complete, "{:?}", result.warnings);
result.entries.iter().find(|e| e.path == "file").unwrap().data.clone().unwrap()
}
#[test]
fn compressed_metadata_and_regular_file_blocks_are_recovered() {
let payload = b"compressed metadata can be shorter than 8192 bytes";
assert_eq!(recovered(&image(&literals(payload), payload.len(), true, true, None)), payload);
assert_eq!(recovered(&image(payload, payload.len(), false, false, None)), payload);
}
#[test]
fn repeated_matches_and_compressed_fragments_are_recovered() {
let block = [0x3b, b'a', b'b', b'c', 3, 0, 0x50, b't', b'a', b'i', b'l', b'!'];
assert_eq!(recovered(&image(&block, 23, true, true, None)), b"abcabcabcabcabcabctail!");
assert_eq!(recovered(&image(&[], 4, true, true, Some((b"xxxtailzzz", 3)))), b"tail");
}
#[test]
fn corrupt_and_oversized_lz4_data_is_not_returned() {
for block in [vec![0xf0], vec![0x00, 0, 0], literals(&vec![b'x'; 4097])] {
let result = squashfs::read(&image(&block, 4096, true, false, None), &Limits::default());
assert!(!result.complete);
assert!(result.entries.iter().find(|e| e.path == "file").unwrap().data.is_none());
}
let bytes = image(&literals(b"hello"), 5, true, true, None);
let result = squashfs::read(&bytes, &Limits { max_file_bytes: 4, ..Limits::default() });
assert!(!result.complete);
assert!(result.entries.iter().find(|e| e.path == "file").unwrap().data.is_none());
}
#[test]
fn metadata_output_keeps_the_eight_kibibyte_limit() {
let mut data = image(&literals(b"hello"), 5, true, true, None);
let inode = u64::from_le_bytes(data[64..72].try_into().unwrap()) as usize;
let directory = u64::from_le_bytes(data[72..80].try_into().unwrap()) as usize;
let id = u64::from_le_bytes(data[48..56].try_into().unwrap()) as usize;
let oversized = literals(&vec![0; 8193]);
let mut replacement = (oversized.len() as u16).to_le_bytes().to_vec();
replacement.extend_from_slice(&oversized);
let shift = replacement.len() - (directory - inode);
data.splice(inode..directory, replacement);
put64(&mut data, 72, (directory + shift) as u64);
put64(&mut data, 48, (id + shift) as u64);
let used = data.len() as u64;
put64(&mut data, 40, used);
let result = squashfs::read(&data, &Limits::default());
assert!(!result.complete);
assert!(result.entries.is_empty());
assert!(result.warnings.iter().any(|w| w.contains("metadata block did not decompress")));
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.