642d5a256791
decompress.rs
//! Bounded, pure-Rust decompressors for the stream formats a firmware image commonly carries:
//! xz, standalone LZMA (`.lzma`), bzip2 and Zstandard. Each decoder caps its output at `max_out`
//! bytes (returning `TooLarge` rather than allocating without limit) and never panics on a corrupt
//! or truncated stream. gzip/zlib/zip live in `firmware`; these complete the set.
//!
//! All three backing crates (`lzma-rs`, `bzip2-rs`, `ruzstd`) are pure Rust and build for
//! `wasm32-unknown-unknown`.
use std::io::{self, Read, Write};
/// Why a decode stopped.
#[derive(Debug, Clone, Copy, PartialEq, Eq, thiserror::Error)]
pub enum DecompressError {
#[error("the compressed stream is damaged")]
Corrupt,
#[error("the compressed stream ends early")]
Truncated,
#[error("the output would exceed the size limit")]
TooLarge,
}
/// A `Write` sink that collects at most `cap` bytes, then refuses the rest. The `exceeded` flag lets
/// the caller tell a size-limit stop from a genuine decode error.
struct CapWrite {
buf: Vec<u8>,
cap: usize,
exceeded: bool,
}
impl CapWrite {
fn new(cap: usize) -> Self {
CapWrite { buf: Vec::new(), cap, exceeded: false }
}
}
impl Write for CapWrite {
fn write(&mut self, data: &[u8]) -> io::Result<usize> {
if self.buf.len().saturating_add(data.len()) > self.cap {
self.exceeded = true;
return Err(io::Error::other("output size limit reached"));
}
self.buf.extend_from_slice(data);
Ok(data.len())
}
fn flush(&mut self) -> io::Result<()> {
Ok(())
}
}
fn cap_of(max_out: u64) -> usize {
usize::try_from(max_out).unwrap_or(usize::MAX)
}
/// Read a `Read` source into a `Vec`, capped at `cap` bytes.
fn read_capped(mut src: impl Read, cap: usize) -> Result<Vec<u8>, DecompressError> {
let mut out = Vec::new();
let mut chunk = [0u8; 64 * 1024];
loop {
match src.read(&mut chunk) {
Ok(0) => return Ok(out),
Ok(n) => {
let slice = chunk.get(..n).unwrap_or(&[]);
if out.len().saturating_add(slice.len()) > cap {
return Err(DecompressError::TooLarge);
}
out.extend_from_slice(slice);
}
Err(e) if e.kind() == io::ErrorKind::Interrupted => continue,
Err(_) => return Err(DecompressError::Corrupt),
}
}
}
/// Decompress every xz stream, including standard stream padding, within one output budget.
pub fn xz(input: &[u8], max_out: u64) -> Result<Vec<u8>, DecompressError> {
let ranges = xz_stream_ranges(input, max_out)?;
let mut out = CapWrite::new(cap_of(max_out));
for range in ranges.into_iter().rev() {
let stream = input.get(range).ok_or(DecompressError::Truncated)?;
let mut cursor = io::Cursor::new(stream);
match lzma_rs::xz_decompress(&mut cursor, &mut out) {
Ok(()) => {}
Err(_) if out.exceeded => return Err(DecompressError::TooLarge),
Err(lzma_rs::error::Error::HeaderTooShort(_)) => return Err(DecompressError::Truncated),
Err(_) => return Err(DecompressError::Corrupt),
}
}
Ok(out.buf)
}
/// Decode only the first stream in a SquashFS block; bytes after its footer are not another block.
pub(crate) fn xz_single(input: &[u8], max_out: u64) -> Result<Vec<u8>, DecompressError> {
let mut out = CapWrite::new(cap_of(max_out));
let mut cursor = io::Cursor::new(input);
match lzma_rs::xz_decompress(&mut cursor, &mut out) {
Ok(()) => Ok(out.buf),
Err(_) if out.exceeded => Err(DecompressError::TooLarge),
Err(lzma_rs::error::Error::HeaderTooShort(_)) => Err(DecompressError::Truncated),
Err(_) => {
// The decoder requires EOF after the first footer. Recheck its consumed prefix as
// a complete stream, rather than accepting partial output from a failed decode.
let end = usize::try_from(cursor.position()).map_err(|_| DecompressError::Corrupt)?;
if end == 0 || end >= input.len() {
return Err(DecompressError::Corrupt);
}
let prefix = input.get(..end).ok_or(DecompressError::Truncated)?;
drop(out);
xz(prefix, max_out)
}
}
}
/// Find stream boundaries backwards through their checked footer/index sizes, without
/// repeatedly trying the decoder at candidate magic bytes inside compressed data.
fn xz_stream_ranges(input: &[u8], max_out: u64) -> Result<Vec<std::ops::Range<usize>>, DecompressError> {
let mut ranges = Vec::new();
let mut end = input.len();
let mut declared = 0u64;
while end > 0 {
let padded_end = end;
while end > 0 && input.get(end - 1) == Some(&0) {
end -= 1;
}
if end == 0 || !(padded_end - end).is_multiple_of(4) {
return Err(DecompressError::Corrupt);
}
let footer_at = end.checked_sub(12).ok_or(DecompressError::Truncated)?;
let footer = input.get(footer_at..end).ok_or(DecompressError::Truncated)?;
let read = crate::bytes::Reader::new(footer);
let footer_fields = footer.get(4..10).ok_or(DecompressError::Truncated)?;
if footer.get(10..) != Some(b"YZ") || read.u32_le(0) != Some(crate::firmware::crc32(footer_fields)) {
return Err(DecompressError::Corrupt);
}
let backward = u64::from(read.u32_le(4).ok_or(DecompressError::Truncated)?);
let index_len = usize::try_from((backward + 1) * 4).map_err(|_| DecompressError::Corrupt)?;
let index_at = footer_at.checked_sub(index_len).ok_or(DecompressError::Truncated)?;
let index = input.get(index_at..footer_at).ok_or(DecompressError::Truncated)?;
let crc_at = index.len().checked_sub(4).ok_or(DecompressError::Truncated)?;
let index_read = crate::bytes::Reader::new(index);
let index_fields = index.get(..crc_at).ok_or(DecompressError::Truncated)?;
if index.first() != Some(&0) || index_read.u32_le(crc_at) != Some(crate::firmware::crc32(index_fields)) {
return Err(DecompressError::Corrupt);
}
let mut records = index.get(1..crc_at).ok_or(DecompressError::Corrupt)?;
let count = xz_vli(&mut records)?;
if count > (records.len() / 2) as u64 {
return Err(DecompressError::Corrupt);
}
let mut block_bytes = 0usize;
for _ in 0..count {
let unpadded = xz_vli(&mut records)?;
if unpadded == 0 {
return Err(DecompressError::Corrupt);
}
let padded = usize::try_from(unpadded.checked_add(3).ok_or(DecompressError::Corrupt)? & !3).map_err(|_| DecompressError::Corrupt)?;
block_bytes = block_bytes.checked_add(padded).filter(|bytes| *bytes <= index_at).ok_or(DecompressError::Corrupt)?;
declared = declared.checked_add(xz_vli(&mut records)?).filter(|size| *size <= max_out).ok_or(DecompressError::TooLarge)?;
}
if records.len() > 3 || records.iter().any(|&byte| byte != 0) {
return Err(DecompressError::Corrupt);
}
let start = index_at.checked_sub(block_bytes).and_then(|at| at.checked_sub(12)).ok_or(DecompressError::Corrupt)?;
let magic_end = start.checked_add(6).ok_or(DecompressError::Corrupt)?;
if input.get(start..magic_end) != Some(b"\xfd7zXZ\0") {
return Err(DecompressError::Corrupt);
}
ranges.push(start..end);
end = start;
}
if ranges.is_empty() {
return Err(DecompressError::Corrupt);
}
Ok(ranges)
}
/// XZ variable-length integers have at most nine bytes and no redundant final zero.
fn xz_vli(input: &mut &[u8]) -> Result<u64, DecompressError> {
let mut value = 0u64;
for shift in (0..63).step_by(7) {
let (&byte, rest) = input.split_first().ok_or(DecompressError::Truncated)?;
*input = rest;
value |= u64::from(byte & 0x7f) << shift;
if byte & 0x80 == 0 {
return if shift != 0 && byte == 0 { Err(DecompressError::Corrupt) } else { Ok(value) };
}
}
Err(DecompressError::Corrupt)
}
/// Decompress a standalone LZMA (`.lzma`, `0x5d` props) stream, producing at most `max_out` bytes.
pub fn lzma(input: &[u8], max_out: u64) -> Result<Vec<u8>, DecompressError> {
let cap = cap_of(max_out).min(isize::MAX as usize);
let (header, stream) = input.split_at_checked(13).ok_or(DecompressError::Truncated)?;
let mut header = <[u8; 13]>::try_from(header).map_err(|_| DecompressError::Truncated)?;
let declared = u64::from_le_bytes(header[5..13].try_into().map_err(|_| DecompressError::Truncated)?);
if declared != u64::MAX && declared > cap as u64 {
return Err(DecompressError::TooLarge);
}
// The decoder retains a window before flushing to CapWrite. Bound that window too,
// so a tiny output budget cannot first grow an arbitrarily large dictionary.
let dictionary = u32::from_le_bytes(header[1..5].try_into().map_err(|_| DecompressError::Truncated)?);
let window_limit = u32::try_from(cap).unwrap_or(u32::MAX).max(4096);
let dictionary = dictionary.max(4096).min(window_limit);
header[1..5].copy_from_slice(&dictionary.to_le_bytes());
let options = lzma_rs::decompress::Options { memlimit: Some(dictionary as usize), ..Default::default() };
let mut out = CapWrite::new(cap);
let mut cursor = io::Cursor::new(header).chain(io::Cursor::new(stream));
match lzma_rs::lzma_decompress_with_options(&mut cursor, &mut out, &options) {
Ok(()) => Ok(out.buf),
Err(_) if out.exceeded => Err(DecompressError::TooLarge),
Err(lzma_rs::error::Error::HeaderTooShort(_)) => Err(DecompressError::Truncated),
Err(_) => Err(DecompressError::Corrupt),
}
}
/// Decode a complete LZMA piece with properties but no size header, bounding its dictionary and output.
pub(crate) fn lzma_raw_complete(input: &[u8], out_len: u32) -> Result<Vec<u8>, DecompressError> {
let cap = usize::try_from(out_len).map_err(|_| DecompressError::TooLarge)?;
if cap > isize::MAX as usize {
return Err(DecompressError::TooLarge);
}
let (properties, stream) = input.split_at_checked(5).ok_or(DecompressError::Truncated)?;
let [property, d0, d1, d2, d3] = <[u8; 5]>::try_from(properties).map_err(|_| DecompressError::Truncated)?;
// No match can reach farther back than the entire output. Keep the decoder's minimum window,
// but avoid oversized dictionary arithmetic on 32-bit targets before its memory limit is checked.
let dictionary = u32::from_le_bytes([d0, d1, d2, d3]).max(4096).min(out_len.max(4096));
let [d0, d1, d2, d3] = dictionary.to_le_bytes();
let properties = [property, d0, d1, d2, d3];
let decode = |size: Option<u64>| {
let options =
lzma_rs::decompress::Options { unpacked_size: lzma_rs::decompress::UnpackedSize::UseProvided(size), memlimit: Some(cap), ..Default::default() };
let mut out = CapWrite::new(cap);
let mut cursor = io::Cursor::new(properties).chain(io::Cursor::new(stream));
match lzma_rs::lzma_decompress_with_options(&mut cursor, &mut out, &options) {
Ok(()) if cursor.get_ref().1.position() == stream.len() as u64 => Ok(out.buf),
Ok(()) => Err(DecompressError::Corrupt),
Err(_) if out.exceeded => Err(DecompressError::TooLarge),
Err(lzma_rs::error::Error::HeaderTooShort(_)) => Err(DecompressError::Truncated),
Err(_) => Err(DecompressError::Corrupt),
}
};
let output = decode(None)?;
if output.len() == cap {
return Ok(output);
}
// A zero range code at EOF can precede the last zero literals in a stream without an end marker.
// Retry a short result with its known size only after completion succeeded; never recover a failed probe.
drop(output);
decode(Some(u64::from(out_len)))
}
/// Decode the property bytes and raw stream of a ZIP method-14 member.
#[cfg(test)]
pub(crate) fn lzma_zip(input: &[u8], expected_size: u64, has_end_marker: bool, max_out: u64) -> Result<Vec<u8>, DecompressError> {
let cap = cap_of(max_out).min(isize::MAX as usize);
if expected_size > cap as u64 {
return Err(DecompressError::TooLarge);
}
let (properties, stream) = input.split_at_checked(5).ok_or(DecompressError::Truncated)?;
let [property, d0, d1, d2, d3] = <[u8; 5]>::try_from(properties).map_err(|_| DecompressError::Truncated)?;
let window_limit = u32::try_from(cap).unwrap_or(u32::MAX).max(4096);
let dictionary = u32::from_le_bytes([d0, d1, d2, d3]).max(4096).min(window_limit);
let [d0, d1, d2, d3] = dictionary.to_le_bytes();
let properties = [property, d0, d1, d2, d3];
let size = if has_end_marker { None } else { Some(expected_size) };
let options = lzma_rs::decompress::Options {
unpacked_size: lzma_rs::decompress::UnpackedSize::UseProvided(size),
memlimit: Some(dictionary as usize),
..Default::default()
};
let mut out = CapWrite::new(cap);
let mut cursor = io::Cursor::new(properties).chain(io::Cursor::new(stream));
match lzma_rs::lzma_decompress_with_options(&mut cursor, &mut out, &options) {
Ok(()) if cursor.get_ref().1.position() == stream.len() as u64 => Ok(out.buf),
Ok(()) => Err(DecompressError::Corrupt),
Err(_) if out.exceeded => Err(DecompressError::TooLarge),
Err(lzma_rs::error::Error::HeaderTooShort(_)) => Err(DecompressError::Truncated),
Err(_) => Err(DecompressError::Corrupt),
}
}
/// Decompress a bzip2 stream, producing at most `max_out` bytes.
pub fn bzip2(input: &[u8], max_out: u64) -> Result<Vec<u8>, DecompressError> {
read_capped(bzip2_rs::DecoderReader::new(input), cap_of(max_out))
}
/// Decompress a Zstandard stream, producing at most `max_out` bytes.
pub fn zstd(mut input: &[u8], max_out: u64) -> Result<Vec<u8>, DecompressError> {
if input.is_empty() {
return Err(DecompressError::Corrupt);
}
let mut out = CapWrite::new(cap_of(max_out));
while !input.is_empty() {
if matches!(input.get(..4), Some([0x50..=0x5f, 0x2a, 0x4d, 0x18])) {
let header = input.get(4..8).and_then(|s| s.try_into().ok()).ok_or(DecompressError::Truncated)?;
let len = u32::from_le_bytes(header) as usize;
input = input.get(8..).and_then(|body| body.get(len..)).ok_or(DecompressError::Truncated)?;
continue;
}
let mut decoder = ruzstd::decoding::StreamingDecoder::new(&mut input).map_err(|_| DecompressError::Corrupt)?;
if io::copy(&mut decoder, &mut out).is_err() {
return Err(if out.exceeded { DecompressError::TooLarge } else { DecompressError::Corrupt });
}
}
Ok(out.buf)
}
/// Decompress one raw LZ4 block (no frame) that inflates to exactly `out_len` bytes, as Unity
/// bundles store them.
pub fn lz4_block(input: &[u8], out_len: usize) -> Result<Vec<u8>, DecompressError> {
let out = lz4_block_capped(input, out_len)?;
if out.len() != out_len {
return Err(DecompressError::Truncated);
}
Ok(out)
}
/// Decode one raw LZ4 block when its output size is an upper bound, as in SquashFS metadata.
pub(crate) fn lz4_block_capped(input: &[u8], out_len: usize) -> Result<Vec<u8>, DecompressError> {
let mut out = Vec::with_capacity(out_len.min(64 << 20));
let mut i = 0usize;
let byte = |i: &mut usize| -> Result<u8, DecompressError> {
let b = *input.get(*i).ok_or(DecompressError::Truncated)?;
*i += 1;
Ok(b)
};
// A 4-bit length of 15 continues in the following bytes, 255 at a time.
let length = |i: &mut usize, base: u8| -> Result<usize, DecompressError> {
let mut n = usize::from(base);
if base == 15 {
loop {
let b = byte(i)?;
n = n.checked_add(usize::from(b)).ok_or(DecompressError::Corrupt)?;
if b != 255 {
break;
}
}
}
Ok(n)
};
while i < input.len() {
let token = byte(&mut i)?;
let literals = length(&mut i, token >> 4)?;
let end = i.checked_add(literals).ok_or(DecompressError::Corrupt)?;
let run = input.get(i..end).ok_or(DecompressError::Truncated)?;
if out.len() + literals > out_len {
return Err(DecompressError::TooLarge);
}
out.extend_from_slice(run);
i = end;
// The last sequence has literals only.
if i >= input.len() {
break;
}
let offset = usize::from(u16::from_le_bytes([byte(&mut i)?, byte(&mut i)?]));
if offset == 0 || offset > out.len() {
return Err(DecompressError::Corrupt);
}
let len = length(&mut i, token & 15)?.checked_add(4).ok_or(DecompressError::Corrupt)?;
if out.len() + len > out_len {
return Err(DecompressError::TooLarge);
}
// Each copied run extends the same repeating pattern, so it can
// supply the next run even when the match overlaps its destination.
let start = out.len() - offset;
let mut remaining = len;
while remaining > 0 {
let count = remaining.min(out.len() - start);
out.extend_from_within(start..start + count);
remaining -= count;
}
}
Ok(out)
}
#[cfg(test)]
mod tests {
use super::*;
use craft_anything_testkit::firmware as fx;
#[test]
fn lz4_blocks_with_literals_and_overlapping_matches() {
// "abcabcabcabc!": 3 literals, a 9-byte match 3 back (overlapping), then "!".
let block = [0x35, b'a', b'b', b'c', 3, 0, 0x10, b'!'];
assert_eq!(lz4_block(&block, 13).unwrap(), b"abcabcabcabc!");
// A long literal run uses the extra length bytes.
let mut long = vec![0xf0, 5]; // 15 + 5 = 20 literals
long.extend_from_slice(&[b'x'; 20]);
assert_eq!(lz4_block(&long, 20).unwrap(), [b'x'; 20]);
assert_eq!(lz4_block(&block, 12), Err(DecompressError::TooLarge));
assert_eq!(lz4_block(&block, 14), Err(DecompressError::Truncated));
assert_eq!(lz4_block(&[0x10, b'a', 9, 0], 10), Err(DecompressError::Corrupt), "a match before the start");
for n in 0..64u8 {
let junk: Vec<u8> = (0..n).map(|k| k.wrapping_mul(37).wrapping_add(n)).collect();
let _ = lz4_block(&junk, 100);
}
}
#[test]
fn long_lz4_matches_repeat_the_entire_offset_pattern() {
for pattern in [&b"x"[..], &b"abc"[..], &b"01234567"[..]] {
let mut block = vec![((pattern.len() as u8) << 4) | 15];
block.extend_from_slice(pattern);
block.extend_from_slice(&(pattern.len() as u16).to_le_bytes());
block.extend_from_slice(&[255, 255, 7, 0x50]);
block.extend_from_slice(b"final");
let mut expected = pattern.to_vec();
expected.extend(pattern.iter().copied().cycle().take(19 + 255 + 255 + 7));
expected.extend_from_slice(b"final");
assert_eq!(lz4_block(&block, expected.len()).unwrap(), expected);
}
}
#[test]
fn xz_round_trip() {
let c = fx::XZ_FIXTURE;
assert_eq!(xz(c, 1 << 20).unwrap(), fx::XZ_PLAIN);
// A tiny cap reports TooLarge, never a partial lie.
assert_eq!(xz(c, 4), Err(DecompressError::TooLarge));
// Truncation never panics.
for len in 0..c.len() {
let _ = xz(&c[..len], 1 << 20);
}
}
#[test]
fn xz_concatenated_streams_and_padding_share_one_budget() {
let input = [fx::XZ_FIXTURE, &[0; 4], fx::XZ_FIXTURE, &[0; 8]].concat();
let expected = [fx::XZ_PLAIN, fx::XZ_PLAIN].concat();
assert_eq!(xz(&input, expected.len() as u64).unwrap(), expected);
assert_eq!(xz(&input, expected.len() as u64 - 1), Err(DecompressError::TooLarge));
let mut empty = Vec::new();
lzma_rs::xz_compress(&mut io::Cursor::new(b""), &mut empty).unwrap();
let with_empty = [&empty[..], fx::XZ_FIXTURE, &empty[..]].concat();
assert_eq!(xz(&with_empty, fx::XZ_PLAIN.len() as u64).unwrap(), fx::XZ_PLAIN);
assert!(xz(&empty, 0).unwrap().is_empty());
}
#[test]
fn xz_first_stream_ignores_the_tail_and_keeps_its_own_budget() {
let cap = fx::XZ_PLAIN.len() as u64;
assert_eq!(xz_single(fx::XZ_FIXTURE, cap).unwrap(), fx::XZ_PLAIN);
for tail in [fx::XZ_FIXTURE, &fx::XZ_FIXTURE[..13], b"junk", &[0; 4]] {
let input = [fx::XZ_FIXTURE, tail].concat();
assert_eq!(xz_single(&input, cap).unwrap(), fx::XZ_PLAIN);
assert_eq!(xz_single(&input, cap - 1), Err(DecompressError::TooLarge));
}
let mut empty = Vec::new();
lzma_rs::xz_compress(&mut io::Cursor::new(b""), &mut empty).unwrap();
let input = [&empty[..], fx::XZ_FIXTURE].concat();
assert!(xz_single(&input, 0).unwrap().is_empty());
}
#[test]
fn xz_first_stream_never_returns_failed_decode_output() {
for len in 0..fx::XZ_FIXTURE.len() {
assert!(xz_single(&fx::XZ_FIXTURE[..len], 1024).is_err(), "truncated at {len}");
}
for at in [0, 8, fx::XZ_FIXTURE.len() - 13, fx::XZ_FIXTURE.len() - 12, fx::XZ_FIXTURE.len() - 1] {
let mut input = fx::XZ_FIXTURE.to_vec();
input[at] ^= 1;
input.extend_from_slice(fx::XZ_FIXTURE);
assert!(xz_single(&input, 1024).is_err(), "damaged at {at}");
}
}
#[test]
fn xz_rejects_incomplete_members_and_nonstandard_padding() {
for padding in [1, 2, 3, 5] {
let input = [fx::XZ_FIXTURE, &vec![0; padding]].concat();
assert!(xz(&input, 1000).is_err());
}
assert!(xz(&[&[0; 4][..], fx::XZ_FIXTURE].concat(), 1000).is_err());
assert!(xz(&[fx::XZ_FIXTURE, b"junk"].concat(), 1000).is_err());
for missing in 1..fx::XZ_FIXTURE.len() {
let input = [fx::XZ_FIXTURE, &fx::XZ_FIXTURE[..fx::XZ_FIXTURE.len() - missing]].concat();
assert!(xz(&input, 1000).is_err(), "missing {missing} bytes");
}
for at in [fx::XZ_FIXTURE.len() - 13, fx::XZ_FIXTURE.len() - 12] {
let mut damaged = fx::XZ_FIXTURE.to_vec();
damaged[at] ^= 1;
assert!(xz(&damaged, 1000).is_err());
}
}
#[test]
fn xz_index_sizes_and_integer_encodings_are_checked() {
assert_eq!(xz_vli(&mut &[0x80, 0][..]), Err(DecompressError::Corrupt));
assert_eq!(xz_vli(&mut &[0xff; 10][..]), Err(DecompressError::Corrupt));
assert_eq!(xz_vli(&mut &[0x81, 1][..]), Ok(129));
let mut damaged = fx::XZ_FIXTURE.to_vec();
let footer = damaged.len() - 12;
let backward = u32::from_le_bytes(damaged[footer + 4..footer + 8].try_into().unwrap());
let index = footer - (backward as usize + 1) * 4;
damaged[index + 2] = 0;
let checksum = crate::firmware::crc32(&damaged[index..footer - 4]);
damaged[footer - 4..footer].copy_from_slice(&checksum.to_le_bytes());
assert!(xz(&damaged, 1000).is_err());
}
#[test]
fn lzma_round_trip() {
let c = fx::LZMA_FIXTURE;
assert_eq!(lzma(c, 1 << 20).unwrap(), fx::LZMA_PLAIN);
assert_eq!(lzma(c, 4), Err(DecompressError::TooLarge));
for len in 0..c.len() {
let _ = lzma(&c[..len], 1 << 20);
}
}
#[test]
fn standalone_lzma_checks_declared_sizes_before_decoding() {
let mut header = [0u8; 13];
header[0] = 0x5d;
header[1..5].copy_from_slice(&u32::MAX.to_le_bytes());
header[5..13].copy_from_slice(&1_000_000_000u64.to_le_bytes());
assert_eq!(lzma(&header, 64), Err(DecompressError::TooLarge));
assert_eq!(lzma(&header[..12], 64), Err(DecompressError::Truncated));
let mut valid = fx::LZMA_FIXTURE.to_vec();
valid[1..5].copy_from_slice(&u32::MAX.to_le_bytes());
assert_eq!(lzma(&valid, fx::LZMA_PLAIN.len() as u64).unwrap(), fx::LZMA_PLAIN);
assert_eq!(lzma(&valid, 0), Err(DecompressError::TooLarge));
}
#[test]
fn standalone_lzma_stops_before_a_large_window_reaches_a_damaged_tail() {
let plain = vec![b'a'; 16 * 1024];
let mut compressed = Vec::new();
lzma_rs::lzma_compress(&mut io::Cursor::new(&plain), &mut compressed).unwrap();
compressed.truncate(compressed.len() - 5);
assert_eq!(lzma(&compressed, 64), Err(DecompressError::TooLarge));
assert_eq!(lzma(&compressed, plain.len() as u64), Err(DecompressError::Corrupt));
}
#[test]
fn bzip2_round_trip() {
let c = fx::BZIP2_FIXTURE;
assert_eq!(bzip2(c, 1 << 20).unwrap(), fx::BZIP2_PLAIN);
assert_eq!(bzip2(c, 2), Err(DecompressError::TooLarge));
for len in 0..c.len() {
let _ = bzip2(&c[..len], 1 << 20);
}
}
#[test]
fn zstd_round_trip() {
let c = fx::ZSTD_FIXTURE;
assert_eq!(zstd(c, 1 << 20).unwrap(), fx::ZSTD_PLAIN);
assert_eq!(zstd(c, 2), Err(DecompressError::TooLarge));
for len in 0..c.len() {
let _ = zstd(&c[..len], 1 << 20);
}
}
#[test]
fn zstandard_members_can_contain_multiple_frames() {
let frame = fx::ZSTD_FIXTURE;
let plain = fx::ZSTD_PLAIN;
let skip = [0x50, 0x2a, 0x4d, 0x18, 3, 0, 0, 0, 1, 2, 3];
let input = [frame, &skip, frame].concat();
let expected = [plain, plain].concat();
assert_eq!(zstd(&input, expected.len() as u64).unwrap(), expected);
assert_eq!(zstd(&input, plain.len() as u64), Err(DecompressError::TooLarge));
assert!(zstd(&[frame, &skip[..9]].concat(), u64::MAX).is_err());
assert!(zstd(&[frame, &frame[..5]].concat(), u64::MAX).is_err());
}
#[test]
fn garbage_never_panics() {
for seed in 0..64u64 {
let n = craft_anything_testkit::noise(seed, 400);
let _ = xz(&n, 1 << 20);
let _ = lzma(&n, 1 << 20);
let _ = bzip2(&n, 1 << 20);
let _ = zstd(&n, 1 << 20);
}
}
}
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.