use crate::ascii85;
use crate::ascii_hex;
use crate::run_length;
use crate::security::standard::{decrypt_cipher_bytes, StringCipher};
use crate::{Dictionary, Error, Object, Result};
use flate2::read::ZlibDecoder;
use flate2::write::ZlibEncoder;
use flate2::Compression;
use std::io::{Read, Write};
const MAX_FILTER_CHAIN_LEN: usize = 16;
pub fn passthrough_codec_label(filter_name: &[u8]) -> Option<&'static str> {
match filter_name {
b"DCTDecode" => Some("DCTDecode"),
b"JBIG2Decode" => Some("JBIG2Decode"),
b"JPXDecode" => Some("JPXDecode"),
b"CCITTFaxDecode" => Some("CCITTFaxDecode"),
_ => None,
}
}
pub fn decode_stream_data(dict: &Dictionary, stream_data: &[u8]) -> Result<Vec<u8>> {
decode_stream_data_with_filters(
dict.get("Filter"),
dict.get("DecodeParms"),
stream_data,
DecodeLimits::default(),
)
}
#[derive(Clone, Copy, Debug, Default)]
pub struct DecodeLimits {
pub max_output: Option<usize>,
}
pub(crate) const DECODE_OUTPUT_LIMIT_PREFIX: &str = "decoded output exceeds configured limit of";
pub(crate) fn is_decode_output_limit_error(error: &Error) -> bool {
matches!(error, Error::Unsupported(message) if message.starts_with(DECODE_OUTPUT_LIMIT_PREFIX))
}
pub fn decode_stream_data_with_limits(
dict: &Dictionary,
stream_data: &[u8],
limits: DecodeLimits,
) -> Result<Vec<u8>> {
decode_stream_data_with_filters(
dict.get("Filter"),
dict.get("DecodeParms"),
stream_data,
limits,
)
}
#[allow(dead_code)]
pub(crate) fn decode_stream_data_with_decryption(
dict: &Dictionary,
stream_data: &[u8],
cipher: StringCipher<'_>,
) -> Result<Vec<u8>> {
let mut decrypted = stream_data.to_vec();
decrypt_cipher_bytes(&mut decrypted, cipher)?;
decode_stream_data(dict, &decrypted)
}
pub(crate) fn decode_stream_data_with_crypt_filter<F>(
dict: &Dictionary,
stream_data: &[u8],
mut decrypt_crypt: F,
) -> Result<Vec<u8>>
where
F: FnMut(Option<&Object>, &[u8]) -> Result<Vec<u8>>,
{
decode_stream_data_with_filters_and_crypt(
dict.get("Filter"),
dict.get("DecodeParms"),
stream_data,
DecodeLimits::default(),
&mut decrypt_crypt,
)
}
pub fn encode_stream_data(dict: &Dictionary, stream_data: &[u8]) -> Result<Vec<u8>> {
encode_stream_data_with_filters(dict.get("Filter"), dict.get("DecodeParms"), stream_data)
}
fn decode_stream_data_with_filters(
filter: Option<&Object>,
decode_params: Option<&Object>,
stream_data: &[u8],
limits: DecodeLimits,
) -> Result<Vec<u8>> {
decode_stream_data_with_filters_and_crypt(
filter,
decode_params,
stream_data,
limits,
&mut |_, _| {
Err(Error::Unsupported(
"unsupported stream filter: Crypt".to_string(),
))
},
)
}
fn decode_stream_data_with_filters_and_crypt<F>(
filter: Option<&Object>,
decode_params: Option<&Object>,
stream_data: &[u8],
limits: DecodeLimits,
decrypt_crypt: &mut F,
) -> Result<Vec<u8>>
where
F: FnMut(Option<&Object>, &[u8]) -> Result<Vec<u8>>,
{
match filter {
None => Ok(stream_data.to_vec()),
Some(filter) => {
if let Some(filter_name) = filter.as_name() {
if filter_name == b"Crypt" {
return decrypt_crypt(get_decode_params(decode_params, 0), stream_data);
}
let params = get_decode_params(decode_params, 0);
let decoded =
apply_single_filter_decode(filter_name, stream_data, params, limits.max_output)
.map_err(Error::Unsupported)?;
return apply_decode_params(params, &decoded);
}
if let Some(filters) = filter.as_array() {
if filters.len() > MAX_FILTER_CHAIN_LEN {
return Err(Error::Unsupported(format!(
"filter chain length {} exceeds maximum of {MAX_FILTER_CHAIN_LEN}",
filters.len()
)));
}
let mut decoded = stream_data.to_vec();
for (index, filter) in filters.iter().enumerate() {
let Some(filter_name) = filter.as_name() else {
return Err(Error::Unsupported(
"unsupported stream filter type: expected name".to_string(),
));
};
if filter_name == b"Crypt" {
decoded = decrypt_crypt(get_decode_params(decode_params, index), &decoded)?;
} else {
let params = get_decode_params(decode_params, index);
decoded = apply_single_filter_decode(
filter_name,
&decoded,
params,
limits.max_output,
)
.map_err(Error::Unsupported)?;
decoded = apply_decode_params(params, &decoded)?;
}
}
return Ok(decoded);
}
Err(Error::Unsupported(format!(
"unsupported stream filter syntax: {}",
object_debug_repr(filter)
)))
}
}
}
fn encode_stream_data_with_filters(
filter: Option<&Object>,
decode_params: Option<&Object>,
stream_data: &[u8],
) -> Result<Vec<u8>> {
match filter {
None => Ok(stream_data.to_vec()),
Some(filter) => {
if let Some(filter_name) = filter.as_name() {
let params = get_decode_params(decode_params, 0);
let after_predictor = apply_encode_params(params, stream_data)?;
return apply_single_filter_encode(filter_name, &after_predictor)
.map_err(Error::Unsupported);
}
if let Some(filters) = filter.as_array() {
let mut encoded = stream_data.to_vec();
for (index, filter) in filters.iter().enumerate().rev() {
let Some(filter_name) = filter.as_name() else {
return Err(Error::Unsupported(
"unsupported stream filter type: expected name".to_string(),
));
};
let params = get_decode_params(decode_params, index);
encoded = apply_encode_params(params, &encoded)?;
encoded = apply_single_filter_encode(filter_name, &encoded)
.map_err(Error::Unsupported)?;
}
return Ok(encoded);
}
Err(Error::Unsupported(format!(
"unsupported stream filter syntax: {}",
object_debug_repr(filter)
)))
}
}
}
fn get_decode_params(params: Option<&Object>, index: usize) -> Option<&Object> {
let param = params?;
if param.as_dict().is_some() {
Some(param)
} else {
param.as_array()?.get(index)
}
}
fn integer_decode_param(params: &Dictionary, key: &str) -> Result<Option<i64>> {
let Some(value) = params.get(key) else {
return Ok(None);
};
value
.as_integer()
.map(Some)
.ok_or_else(|| Error::Unsupported(format!("/DecodeParms /{key} must be integer")))
}
fn non_negative_usize_param(params: &Dictionary, key: &str) -> Result<Option<usize>> {
integer_decode_param(params, key)?
.map(|value| {
usize::try_from(value).map_err(|_| {
Error::Unsupported(format!("/DecodeParms /{key} must be non-negative"))
})
})
.transpose()
}
fn non_negative_u8_param(params: &Dictionary, key: &str) -> Result<Option<u8>> {
integer_decode_param(params, key)?
.map(|value| {
u8::try_from(value).map_err(|_| {
Error::Unsupported(format!("/DecodeParms /{key} must be non-negative"))
})
})
.transpose()
}
fn extract_predictor_params(decode_params: Option<&Object>) -> Result<Option<(u8, usize, usize)>> {
let Some(params) = decode_params.and_then(Object::as_dict) else {
return Ok(None);
};
let Some(predictor) = non_negative_u8_param(params, "Predictor")? else {
return Ok(None);
};
if predictor <= 1 {
return Ok(None);
}
if predictor == 2 {
return Err(Error::Unsupported(
"/DecodeParms /Predictor 2 is not supported for this stream type".to_string(),
));
}
if !(10..=15).contains(&predictor) {
return Err(Error::Unsupported(format!(
"unsupported /DecodeParms /Predictor {predictor}"
)));
}
let colors = non_negative_usize_param(params, "Colors")?.unwrap_or(1);
let bits_per_component = non_negative_usize_param(params, "BitsPerComponent")?.unwrap_or(8);
let columns = non_negative_usize_param(params, "Columns")?.ok_or_else(|| {
Error::Unsupported("/DecodeParms /Columns required for PNG predictor".to_string())
})?;
let row_bits = columns
.checked_mul(colors)
.and_then(|value| value.checked_mul(bits_per_component))
.ok_or_else(|| Error::Unsupported("/DecodeParms /Predictor overflow".to_string()))?;
let row_bytes = row_bits.div_ceil(8);
if row_bytes == 0 {
return Err(Error::Unsupported(
"/DecodeParms /Predictor produced zero row width".to_string(),
));
}
let bits_per_pixel = colors
.checked_mul(bits_per_component)
.ok_or_else(|| Error::Unsupported("/DecodeParms /Predictor overflow".to_string()))?;
let bytes_per_pixel = bits_per_pixel.div_ceil(8).max(1);
Ok(Some((predictor, row_bytes, bytes_per_pixel)))
}
fn apply_decode_params(decode_params: Option<&Object>, stream_data: &[u8]) -> Result<Vec<u8>> {
match extract_predictor_params(decode_params)? {
None => Ok(stream_data.to_vec()),
Some((_predictor, row_bytes, bytes_per_pixel)) => {
decode_png_predictor(stream_data, row_bytes, bytes_per_pixel)
}
}
}
fn apply_encode_params(decode_params: Option<&Object>, stream_data: &[u8]) -> Result<Vec<u8>> {
match extract_predictor_params(decode_params)? {
None => Ok(stream_data.to_vec()),
Some((predictor, row_bytes, bytes_per_pixel)) => {
encode_png_predictor(stream_data, row_bytes, bytes_per_pixel, predictor)
}
}
}
fn decode_png_predictor(bytes: &[u8], row_bytes: usize, bytes_per_pixel: usize) -> Result<Vec<u8>> {
let row_size = row_bytes
.checked_add(1)
.ok_or_else(|| Error::Unsupported("PNG predictor row size overflow".to_string()))?;
if !bytes.len().is_multiple_of(row_size) {
return Err(Error::Unsupported(
"corrupt PNG predictor stream".to_string(),
));
}
if bytes.is_empty() {
return Ok(Vec::new());
}
let row_count = bytes.len() / row_size;
let mut decoded = Vec::with_capacity(row_count * row_bytes);
let mut previous_row = vec![0u8; row_bytes];
for row in bytes.chunks_exact(row_size) {
let filter = row[0];
let raw = &row[1..];
let mut current = vec![0u8; row_bytes];
for i in 0..row_bytes {
let raw_byte = raw[i];
let left = if i >= bytes_per_pixel {
current[i - bytes_per_pixel]
} else {
0
};
let above = previous_row[i];
let upper_left = if i >= bytes_per_pixel {
previous_row[i - bytes_per_pixel]
} else {
0
};
current[i] = match filter {
0 => raw_byte,
1 => raw_byte.wrapping_add(left),
2 => raw_byte.wrapping_add(above),
3 => {
let average = (u16::from(left) + u16::from(above)) / 2;
raw_byte.wrapping_add(average as u8)
}
4 => {
let p = left as i16 + above as i16 - upper_left as i16;
let pa = (p - left as i16).abs();
let pb = (p - above as i16).abs();
let pc = (p - upper_left as i16).abs();
let predictor = if pa <= pb && pa <= pc {
left
} else if pb <= pc {
above
} else {
upper_left
};
raw_byte.wrapping_add(predictor)
}
_ => {
return Err(Error::Unsupported(
"unsupported PNG predictor filter".to_string(),
))
}
};
}
decoded.extend_from_slice(¤t);
previous_row = current;
}
Ok(decoded)
}
#[inline]
fn png_filter_byte(filter: u8, raw: u8, left: u8, above: u8, upper_left: u8) -> u8 {
match filter {
0 => raw,
1 => raw.wrapping_sub(left),
2 => raw.wrapping_sub(above),
3 => {
let avg = ((u16::from(left) + u16::from(above)) / 2) as u8;
raw.wrapping_sub(avg)
}
4 => {
let p = i16::from(left) + i16::from(above) - i16::from(upper_left);
let pa = (p - i16::from(left)).abs();
let pb = (p - i16::from(above)).abs();
let pc = (p - i16::from(upper_left)).abs();
let predictor_val = if pa <= pb && pa <= pc {
left
} else if pb <= pc {
above
} else {
upper_left
};
raw.wrapping_sub(predictor_val)
}
_ => unreachable!("png_filter_byte expects filter in 0..=4"),
}
}
fn encode_png_predictor(
bytes: &[u8],
row_bytes: usize,
bytes_per_pixel: usize,
predictor: u8,
) -> Result<Vec<u8>> {
if row_bytes == 0 || !bytes.len().is_multiple_of(row_bytes) {
return Err(Error::Unsupported(
"raw data not divisible by row_bytes".to_string(),
));
}
if bytes.is_empty() {
return Ok(Vec::new());
}
let row_count = bytes.len() / row_bytes;
let mut encoded = Vec::with_capacity(row_count * (row_bytes + 1));
let mut previous_row = vec![0u8; row_bytes];
for raw_row in bytes.chunks_exact(row_bytes) {
let filter_byte = if predictor == 15 {
let mut costs = [0u64; 5];
for i in 0..row_bytes {
let raw = raw_row[i];
let left = if i >= bytes_per_pixel {
raw_row[i - bytes_per_pixel]
} else {
0
};
let above = previous_row[i];
let upper_left = if i >= bytes_per_pixel {
previous_row[i - bytes_per_pixel]
} else {
0
};
for (f, cost) in costs.iter_mut().enumerate() {
let filtered = png_filter_byte(f as u8, raw, left, above, upper_left);
*cost += u64::from((filtered as i8).unsigned_abs());
}
}
costs
.iter()
.enumerate()
.min_by_key(|&(_, &c)| c)
.map(|(i, _)| i as u8)
.expect("costs has 5 entries")
} else {
predictor - 10
};
encoded.push(filter_byte);
for i in 0..row_bytes {
let raw = raw_row[i];
let left = if i >= bytes_per_pixel {
raw_row[i - bytes_per_pixel]
} else {
0
};
let above = previous_row[i];
let upper_left = if i >= bytes_per_pixel {
previous_row[i - bytes_per_pixel]
} else {
0
};
encoded.push(png_filter_byte(filter_byte, raw, left, above, upper_left));
}
previous_row.copy_from_slice(raw_row);
}
Ok(encoded)
}
fn apply_single_filter_decode(
filter_name: &[u8],
stream_data: &[u8],
decode_params: Option<&Object>,
max_output: Option<usize>,
) -> std::result::Result<Vec<u8>, String> {
if filter_name == b"FlateDecode" {
let mut decoded = Vec::new();
match max_output {
Some(limit) => {
ZlibDecoder::new(stream_data)
.take((limit as u64).saturating_add(1))
.read_to_end(&mut decoded)
.map_err(|error| error.to_string())?;
if decoded.len() > limit {
return Err(format!("{DECODE_OUTPUT_LIMIT_PREFIX} {limit} bytes"));
}
}
None => {
ZlibDecoder::new(stream_data)
.read_to_end(&mut decoded)
.map_err(|error| error.to_string())?;
}
}
return Ok(decoded);
}
if filter_name == b"LZWDecode" {
let early_change = match decode_params {
Some(Object::Dictionary(params)) => match params.get("EarlyChange") {
Some(Object::Integer(v)) => *v != 0,
_ => true, },
_ => true, };
return lzw_decode(stream_data, early_change, max_output);
}
if filter_name == b"ASCII85Decode" {
return ascii85::decode(stream_data);
}
if filter_name == b"ASCIIHexDecode" {
return ascii_hex::decode(stream_data);
}
if filter_name == b"RunLengthDecode" {
return run_length::decode(stream_data);
}
if let Some(label) = passthrough_codec_label(filter_name) {
return Err(format!(
"passthrough codec {label}: image/binary stream data is not decoded by flpdf (preserved verbatim)"
));
}
Err(format!(
"unsupported stream filter: {}",
std::str::from_utf8(filter_name).unwrap_or("<binary>")
))
}
fn lzw_decode(
data: &[u8],
early_change: bool,
max_output: Option<usize>,
) -> std::result::Result<Vec<u8>, String> {
const CLEAR_CODE: u16 = 256;
const EOD_CODE: u16 = 257;
const FIRST_CODE: u16 = 258;
const MAX_BITS: u32 = 12;
const MAX_TABLE_SIZE: usize = 1 << MAX_BITS;
let mut table: Vec<Vec<u8>> = (0u8..=255).map(|b| vec![b]).collect();
table.push(vec![]); table.push(vec![]);
let mut output = Vec::new();
let mut bit_buf: u64 = 0;
let mut bits_in_buf: u32 = 0;
let mut code_bits: u32 = 9;
let early_offset: usize = if early_change { 1 } else { 0 };
let mut prev_entry: Option<Vec<u8>> = None;
let mut byte_pos = 0usize;
loop {
while bits_in_buf < code_bits {
if byte_pos >= data.len() {
return Ok(output);
}
bit_buf = (bit_buf << 8) | u64::from(data[byte_pos]);
bits_in_buf += 8;
byte_pos += 1;
}
let shift = bits_in_buf - code_bits;
let code = ((bit_buf >> shift) & ((1u64 << code_bits) - 1)) as u16;
bits_in_buf -= code_bits;
bit_buf &= (1u64 << bits_in_buf) - 1;
if code == EOD_CODE {
break;
}
if code == CLEAR_CODE {
table.truncate(FIRST_CODE as usize);
code_bits = 9;
prev_entry = None;
continue;
}
let entry: Vec<u8> = if (code as usize) < table.len() {
table[code as usize].clone()
} else if code as usize == table.len() {
match &prev_entry {
Some(prev) => {
let mut s = prev.clone();
s.push(prev[0]);
s
}
None => {
return Err(format!(
"LZWDecode: code {code} is one past table end but no previous entry"
))
}
}
} else {
return Err(format!(
"LZWDecode: code {code} out of range (table size {})",
table.len()
));
};
output.extend_from_slice(&entry);
if let Some(limit) = max_output {
if output.len() > limit {
return Err(format!("{DECODE_OUTPUT_LIMIT_PREFIX} {limit} bytes"));
}
}
if let Some(ref prev) = prev_entry {
if table.len() < MAX_TABLE_SIZE {
let mut new_entry = prev.clone();
new_entry.push(entry[0]);
table.push(new_entry);
if code_bits < MAX_BITS && table.len() == (1usize << code_bits) - early_offset {
code_bits += 1;
}
}
}
prev_entry = Some(entry);
}
Ok(output)
}
fn apply_single_filter_encode(
filter_name: &[u8],
stream_data: &[u8],
) -> std::result::Result<Vec<u8>, String> {
if filter_name == b"FlateDecode" {
let mut encoder = ZlibEncoder::new(Vec::new(), Compression::default());
encoder
.write_all(stream_data)
.map_err(|error| error.to_string())?;
let encoded = encoder.finish().map_err(|error| error.to_string())?;
return Ok(encoded);
}
if filter_name == b"ASCII85Decode" {
return Ok(ascii85::encode(stream_data));
}
if filter_name == b"ASCIIHexDecode" {
return Ok(ascii_hex::encode(stream_data));
}
if filter_name == b"RunLengthDecode" {
return Ok(run_length::encode(stream_data));
}
if filter_name == b"LZWDecode" {
return Err(
"LZWEncode is not supported: flpdf writes stream compression as FlateDecode only \
(decision flpdf-9hc.7.2; qpdf has no LZW encoder either)"
.to_string(),
);
}
if let Some(label) = passthrough_codec_label(filter_name) {
return Err(format!(
"encode not supported for passthrough codec {label}: \
image/binary streams are preserved verbatim by flpdf"
));
}
Err(format!(
"unsupported stream filter: {}",
std::str::from_utf8(filter_name).unwrap_or("<binary>"),
))
}
fn object_debug_repr(object: &Object) -> &'static str {
match object {
Object::Name(name) if name == b"FlateDecode" => "FlateDecode",
Object::Name(name) if name == b"ASCII85Decode" => "ASCII85Decode",
Object::Name(name) if name == b"ASCIIHexDecode" => "ASCIIHexDecode",
Object::Name(name) if name == b"LZWDecode" => "LZWDecode",
Object::Name(name) if name == b"RunLengthDecode" => "RunLengthDecode",
_ => "unsupported",
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::security::primitives::rc4;
use crate::security::standard::StringCipher;
use aes::{Aes128, Aes256};
use cbc::cipher::{block_padding::Pkcs7, BlockEncryptMut, KeyIvInit};
use cbc::Encryptor;
fn flate_dict() -> Dictionary {
let mut dict = Dictionary::new();
dict.insert("Filter", Object::Name(b"FlateDecode".to_vec()));
dict
}
fn aes128_stream(key: &[u8; 16], iv: &[u8; 16], plaintext: &[u8]) -> Vec<u8> {
let enc = <Encryptor<Aes128> as KeyIvInit>::new(key.into(), iv.into());
let mut buf = plaintext.to_vec();
let msg_len = buf.len();
buf.resize(msg_len + 16, 0);
let ciphertext = enc.encrypt_padded_mut::<Pkcs7>(&mut buf, msg_len).unwrap();
let mut out = iv.to_vec();
out.extend_from_slice(ciphertext);
out
}
fn aes256_stream(key: &[u8; 32], iv: &[u8; 16], plaintext: &[u8]) -> Vec<u8> {
let enc = <Encryptor<Aes256> as KeyIvInit>::new(key.into(), iv.into());
let mut buf = plaintext.to_vec();
let msg_len = buf.len();
buf.resize(msg_len + 16, 0);
let ciphertext = enc.encrypt_padded_mut::<Pkcs7>(&mut buf, msg_len).unwrap();
let mut out = iv.to_vec();
out.extend_from_slice(ciphertext);
out
}
#[test]
fn decode_stream_data_with_decryption_decrypts_before_flate() {
let dict = flate_dict();
let plaintext = b"stream plaintext after flate";
let mut encrypted = encode_stream_data(&dict, plaintext).unwrap();
rc4(b"Key", &mut encrypted).unwrap();
let decoded = decode_stream_data_with_decryption(
&dict,
&encrypted,
StringCipher::Rc4 { key: b"Key" },
)
.unwrap();
assert_eq!(decoded, plaintext);
}
#[test]
fn decode_stream_data_with_decryption_handles_no_filter_rc4_streams() {
let dict = Dictionary::new();
let mut encrypted = b"raw encrypted stream".to_vec();
rc4(b"Key", &mut encrypted).unwrap();
let decoded = decode_stream_data_with_decryption(
&dict,
&encrypted,
StringCipher::Rc4 { key: b"Key" },
)
.unwrap();
assert_eq!(decoded, b"raw encrypted stream");
}
#[test]
fn decode_stream_data_with_decryption_handles_aes_streams() {
let dict = Dictionary::new();
let aes128_key = [0x11; 16];
let aes128_iv = [0x22; 16];
let aes128 = aes128_stream(&aes128_key, &aes128_iv, b"AES-128 stream");
let decoded = decode_stream_data_with_decryption(
&dict,
&aes128,
StringCipher::Aes128 { key: &aes128_key },
)
.unwrap();
assert_eq!(decoded, b"AES-128 stream");
let aes256_key = [0x33; 32];
let aes256_iv = [0x44; 16];
let aes256 = aes256_stream(&aes256_key, &aes256_iv, b"AES-256 stream");
let decoded = decode_stream_data_with_decryption(
&dict,
&aes256,
StringCipher::Aes256 { key: &aes256_key },
)
.unwrap();
assert_eq!(decoded, b"AES-256 stream");
}
#[test]
fn decode_stream_data_without_decryption_keeps_plaintext_behavior() {
let dict = flate_dict();
let plaintext = b"legacy plaintext flate";
let encoded = encode_stream_data(&dict, plaintext).unwrap();
let decoded = decode_stream_data(&dict, &encoded).unwrap();
assert_eq!(decoded, plaintext);
}
fn ascii_hex_dict() -> Dictionary {
let mut dict = Dictionary::new();
dict.insert("Filter", Object::Name(b"ASCIIHexDecode".to_vec()));
dict
}
#[test]
fn decode_stream_data_ascii_hex_round_trip() {
let dict = ascii_hex_dict();
let plaintext = b"Hello from ASCIIHexDecode filter!";
let encoded = encode_stream_data(&dict, plaintext).unwrap();
let decoded = decode_stream_data(&dict, &encoded).unwrap();
assert_eq!(decoded, plaintext.as_slice());
}
#[test]
fn decode_stream_data_ascii_hex_empty() {
let dict = ascii_hex_dict();
let plaintext = b"";
let encoded = encode_stream_data(&dict, plaintext).unwrap();
let decoded = decode_stream_data(&dict, &encoded).unwrap();
assert_eq!(decoded, plaintext.as_slice());
}
#[test]
fn decode_stream_data_ascii_hex_odd_length_data() {
let dict = ascii_hex_dict();
let plaintext = b"ABC";
let encoded = encode_stream_data(&dict, plaintext).unwrap();
let decoded = decode_stream_data(&dict, &encoded).unwrap();
assert_eq!(decoded, plaintext.as_slice());
}
fn ascii85_dict() -> Dictionary {
let mut dict = Dictionary::new();
dict.insert("Filter", Object::Name(b"ASCII85Decode".to_vec()));
dict
}
#[test]
fn decode_stream_data_ascii85_round_trip() {
let dict = ascii85_dict();
let plaintext = b"Hello from ASCII85Decode filter!";
let encoded = encode_stream_data(&dict, plaintext).unwrap();
let decoded = decode_stream_data(&dict, &encoded).unwrap();
assert_eq!(decoded, plaintext.as_slice());
}
#[test]
fn decode_stream_data_ascii85_empty() {
let dict = ascii85_dict();
let plaintext = b"";
let encoded = encode_stream_data(&dict, plaintext).unwrap();
let decoded = decode_stream_data(&dict, &encoded).unwrap();
assert_eq!(decoded, plaintext.as_slice());
}
#[test]
fn decode_stream_data_ascii85_zero_block() {
let dict = ascii85_dict();
let plaintext = [0u8; 8];
let encoded = encode_stream_data(&dict, &plaintext).unwrap();
assert!(
encoded.contains(&b'z'),
"encoder should emit 'z' for 4-byte zero block"
);
let decoded = decode_stream_data(&dict, &encoded).unwrap();
assert_eq!(decoded, plaintext.as_slice());
}
#[test]
fn decode_stream_data_ascii85_short_final_group() {
let dict = ascii85_dict();
for plaintext in [b"M".as_slice(), b"Ma", b"Man"] {
let encoded = encode_stream_data(&dict, plaintext).unwrap();
let decoded = decode_stream_data(&dict, &encoded).unwrap();
assert_eq!(
decoded,
plaintext,
"short final group round-trip failed for {} bytes",
plaintext.len()
);
}
}
#[test]
fn decode_stream_data_ascii85_rejects_invalid_byte() {
let dict = ascii85_dict();
let invalid_stream = b"9jqov~>";
let result = decode_stream_data(&dict, invalid_stream);
assert!(result.is_err(), "expected error for out-of-range byte");
let msg = result.unwrap_err().to_string();
assert!(
msg.contains("ASCII85Decode"),
"error message should contain 'ASCII85Decode', got: {msg}"
);
}
fn run_length_dict() -> Dictionary {
let mut dict = Dictionary::new();
dict.insert("Filter", Object::Name(b"RunLengthDecode".to_vec()));
dict
}
#[test]
fn decode_stream_data_run_length_round_trip() {
let dict = run_length_dict();
let plaintext = b"Hello from RunLengthDecode filter!";
let encoded = encode_stream_data(&dict, plaintext).unwrap();
let decoded = decode_stream_data(&dict, &encoded).unwrap();
assert_eq!(decoded, plaintext.as_slice());
}
#[test]
fn decode_stream_data_run_length_empty() {
let dict = run_length_dict();
let plaintext = b"";
let encoded = encode_stream_data(&dict, plaintext).unwrap();
let decoded = decode_stream_data(&dict, &encoded).unwrap();
assert_eq!(decoded, plaintext.as_slice());
}
#[test]
fn decode_stream_data_run_length_with_repeats() {
let dict = run_length_dict();
let mut plaintext = vec![0x42u8; 100]; plaintext.extend(b"literal");
plaintext.extend(vec![0xCCu8; 50]);
let encoded = encode_stream_data(&dict, &plaintext).unwrap();
let decoded = decode_stream_data(&dict, &encoded).unwrap();
assert_eq!(decoded, plaintext.as_slice());
}
#[test]
fn decode_stream_data_run_length_rejects_truncated_literal() {
let dict = run_length_dict();
let truncated_stream = vec![0x05u8, b'A', b'B', b'C'];
let result = decode_stream_data(&dict, &truncated_stream);
assert!(
result.is_err(),
"expected error for truncated literal stream"
);
let msg = result.unwrap_err().to_string();
assert!(
msg.contains("RunLengthDecode"),
"error message should contain 'RunLengthDecode', got: {msg}"
);
}
fn array_filter_dict(filters: &[&[u8]]) -> Dictionary {
let mut dict = Dictionary::new();
let names: Vec<Object> = filters.iter().map(|f| Object::Name(f.to_vec())).collect();
dict.insert("Filter", Object::Array(names));
dict
}
#[test]
fn encode_stream_data_array_chain_round_trips_ascii85_then_flate() {
let dict = array_filter_dict(&[b"ASCII85Decode", b"FlateDecode"]);
let plaintext = b"Round-trip me through ASCII85 over Flate, please!";
let encoded = encode_stream_data(&dict, plaintext).unwrap();
let decoded = decode_stream_data(&dict, &encoded).unwrap();
assert_eq!(decoded, plaintext.as_slice());
}
#[test]
fn encode_stream_data_array_chain_round_trips_ascii_hex_then_flate() {
let dict = array_filter_dict(&[b"ASCIIHexDecode", b"FlateDecode"]);
let plaintext: Vec<u8> = (0u8..=200u8).collect();
let encoded = encode_stream_data(&dict, &plaintext).unwrap();
let decoded = decode_stream_data(&dict, &encoded).unwrap();
assert_eq!(decoded, plaintext);
}
#[test]
fn encode_stream_data_array_chain_single_filter_matches_name_form() {
let array_dict = array_filter_dict(&[b"FlateDecode"]);
let name_dict = flate_dict();
let plaintext = b"single-filter array form";
let encoded_array = encode_stream_data(&array_dict, plaintext).unwrap();
let encoded_name = encode_stream_data(&name_dict, plaintext).unwrap();
assert_eq!(
encoded_array, encoded_name,
"Array form with one filter should produce the same bytes as the Name form"
);
}
fn png_predictor_dict(predictor: i64, columns: i64) -> Dictionary {
let mut dict = Dictionary::new();
dict.insert("Filter", Object::Name(b"FlateDecode".to_vec()));
let mut parms = Dictionary::new();
parms.insert("Predictor", Object::Integer(predictor));
parms.insert("Columns", Object::Integer(columns));
dict.insert("DecodeParms", Object::Dictionary(parms));
dict
}
fn png_predictor_dict_rgb(predictor: i64, columns: i64) -> Dictionary {
let mut dict = Dictionary::new();
dict.insert("Filter", Object::Name(b"FlateDecode".to_vec()));
let mut parms = Dictionary::new();
parms.insert("Predictor", Object::Integer(predictor));
parms.insert("Columns", Object::Integer(columns));
parms.insert("Colors", Object::Integer(3));
parms.insert("BitsPerComponent", Object::Integer(8));
dict.insert("DecodeParms", Object::Dictionary(parms));
dict
}
fn sample_raw_4x2() -> Vec<u8> {
vec![
10, 20, 30, 40, 50, 60, 70, 80, ]
}
#[test]
fn encode_stream_data_png_predictor_10_round_trip() {
let dict = png_predictor_dict(10, 4);
let raw = sample_raw_4x2();
let encoded = encode_stream_data(&dict, &raw).unwrap();
let decoded = decode_stream_data(&dict, &encoded).unwrap();
assert_eq!(decoded, raw);
}
#[test]
fn encode_stream_data_png_predictor_11_round_trip() {
let dict = png_predictor_dict(11, 4);
let raw = sample_raw_4x2();
let encoded = encode_stream_data(&dict, &raw).unwrap();
let decoded = decode_stream_data(&dict, &encoded).unwrap();
assert_eq!(decoded, raw);
}
#[test]
fn encode_stream_data_png_predictor_12_round_trip() {
let dict = png_predictor_dict(12, 4);
let raw = sample_raw_4x2();
let encoded = encode_stream_data(&dict, &raw).unwrap();
let decoded = decode_stream_data(&dict, &encoded).unwrap();
assert_eq!(decoded, raw);
}
#[test]
fn encode_stream_data_png_predictor_13_round_trip() {
let dict = png_predictor_dict(13, 4);
let raw = sample_raw_4x2();
let encoded = encode_stream_data(&dict, &raw).unwrap();
let decoded = decode_stream_data(&dict, &encoded).unwrap();
assert_eq!(decoded, raw);
}
#[test]
fn encode_stream_data_png_predictor_14_round_trip() {
let dict = png_predictor_dict(14, 4);
let raw = sample_raw_4x2();
let encoded = encode_stream_data(&dict, &raw).unwrap();
let decoded = decode_stream_data(&dict, &encoded).unwrap();
assert_eq!(decoded, raw);
}
#[test]
fn encode_stream_data_png_predictor_15_round_trip() {
let dict = png_predictor_dict(15, 4);
let raw = sample_raw_4x2();
let encoded = encode_stream_data(&dict, &raw).unwrap();
let decoded = decode_stream_data(&dict, &encoded).unwrap();
assert_eq!(decoded, raw);
}
#[test]
fn encode_stream_data_png_predictor_handles_multi_row() {
let dict = png_predictor_dict(12, 8);
let raw: Vec<u8> = (0u8..32).collect();
let encoded = encode_stream_data(&dict, &raw).unwrap();
let decoded = decode_stream_data(&dict, &encoded).unwrap();
assert_eq!(decoded, raw);
}
#[test]
fn encode_stream_data_png_predictor_rgb_fixture_round_trip() {
let dict = png_predictor_dict_rgb(15, 4);
let raw: Vec<u8> = (0u8..48).collect();
let encoded = encode_stream_data(&dict, &raw).unwrap();
let decoded = decode_stream_data(&dict, &encoded).unwrap();
assert_eq!(decoded, raw);
}
#[test]
fn encode_png_predictor_empty_input_skips_huge_row_allocation() {
let huge_row_bytes = usize::MAX / 2;
let encoded = encode_png_predictor(&[], huge_row_bytes, 1, 10).unwrap();
assert!(encoded.is_empty(), "empty input encodes to zero rows");
}
#[test]
fn decode_png_predictor_empty_input_skips_huge_row_allocation() {
let huge_row_bytes = usize::MAX / 2;
let decoded = decode_png_predictor(&[], huge_row_bytes, 1).unwrap();
assert!(decoded.is_empty(), "empty input decodes to zero rows");
}
#[test]
fn encode_stream_data_png_predictor_empty_input_round_trips_without_oom() {
let mut dict = Dictionary::new();
dict.insert("Filter", Object::Name(b"FlateDecode".to_vec()));
let mut parms = Dictionary::new();
parms.insert("Predictor", Object::Integer(10));
parms.insert("Columns", Object::Integer(i32::MAX as i64));
parms.insert("BitsPerComponent", Object::Integer(1));
dict.insert("DecodeParms", Object::Dictionary(parms));
let encoded = encode_stream_data(&dict, &[]).unwrap();
assert!(
!encoded.is_empty(),
"empty raw input is still Flate-wrapped, so the stream is non-empty"
);
let decoded = decode_stream_data(&dict, &encoded).unwrap();
assert!(decoded.is_empty(), "round-trips back to the empty input");
}
#[test]
fn passthrough_codec_label_recognizes_all_four_codecs() {
assert_eq!(
passthrough_codec_label(b"DCTDecode"),
Some("DCTDecode"),
"DCTDecode must be recognised"
);
assert_eq!(
passthrough_codec_label(b"JBIG2Decode"),
Some("JBIG2Decode"),
"JBIG2Decode must be recognised"
);
assert_eq!(
passthrough_codec_label(b"JPXDecode"),
Some("JPXDecode"),
"JPXDecode must be recognised"
);
assert_eq!(
passthrough_codec_label(b"CCITTFaxDecode"),
Some("CCITTFaxDecode"),
"CCITTFaxDecode must be recognised"
);
}
#[test]
fn passthrough_codec_label_is_case_sensitive() {
assert_eq!(
passthrough_codec_label(b"dctdecode"),
None,
"lowercase dctdecode must not match"
);
assert_eq!(
passthrough_codec_label(b"jbig2decode"),
None,
"lowercase jbig2decode must not match"
);
assert_eq!(
passthrough_codec_label(b"jpxdecode"),
None,
"lowercase jpxdecode must not match"
);
assert_eq!(
passthrough_codec_label(b"ccittfaxdecode"),
None,
"lowercase ccittfaxdecode must not match"
);
}
#[test]
fn passthrough_codec_label_returns_none_for_unknown_filters() {
assert_eq!(passthrough_codec_label(b"FlateDecode"), None);
assert_eq!(passthrough_codec_label(b"LZWDecode"), None);
assert_eq!(passthrough_codec_label(b"ASCII85Decode"), None);
assert_eq!(passthrough_codec_label(b"ASCIIHexDecode"), None);
assert_eq!(passthrough_codec_label(b"RunLengthDecode"), None);
assert_eq!(passthrough_codec_label(b"UnknownFilter"), None);
assert_eq!(passthrough_codec_label(b""), None);
}
#[test]
fn filter_chain_flate_ascii85_round_trip() {
let dict = array_filter_dict(&[b"ASCII85Decode", b"FlateDecode"]);
let payload = b"chain round-trip: Flate + ASCII85 (flpdf-9hc.7.5)";
let encoded = encode_stream_data(&dict, payload).unwrap();
let decoded = decode_stream_data(&dict, &encoded).unwrap();
assert_eq!(decoded, payload.as_slice());
}
#[test]
fn filter_dispatch_is_case_sensitive() {
let mut dict = Dictionary::new();
dict.insert("Filter", Object::Name(b"flatedecode".to_vec()));
let result = decode_stream_data(&dict, b"anything");
assert!(
result.is_err(),
"lowercase 'flatedecode' must not be accepted"
);
assert_eq!(
passthrough_codec_label(b"dctdecode"),
None,
"passthrough_codec_label must be case-sensitive"
);
assert_eq!(passthrough_codec_label(b"jpxdecode"), None);
let mut dict2 = Dictionary::new();
dict2.insert("Filter", Object::Name(b"dctdecode".to_vec()));
let result2 = decode_stream_data(&dict2, b"anything");
assert!(
result2.is_err(),
"lowercase 'dctdecode' must not be accepted"
);
let msg2 = result2.unwrap_err().to_string();
assert!(
!msg2.contains("passthrough codec"),
"lowercase filter should hit generic unsupported, not passthrough branch; got: {msg2}"
);
}
#[test]
fn passthrough_in_chain_returns_err_with_passthrough_message() {
let ascii85_encoded = ascii85::encode(b"some binary jpeg payload");
let dict = array_filter_dict(&[b"ASCII85Decode", b"DCTDecode"]);
let result = decode_stream_data(&dict, &ascii85_encoded);
assert!(
result.is_err(),
"chain containing DCTDecode must return Err"
);
let msg = result.unwrap_err().to_string();
assert!(
msg.contains("DCTDecode"),
"error must mention DCTDecode; got: {msg}"
);
assert!(
msg.contains("passthrough"),
"error must indicate passthrough intent; got: {msg}"
);
}
#[test]
fn lzw_encode_unsupported_returns_err() {
let mut dict = Dictionary::new();
dict.insert("Filter", Object::Name(b"LZWDecode".to_vec()));
let result = encode_stream_data(&dict, b"some data");
assert!(result.is_err(), "LZWEncode must not be supported");
let msg = result.unwrap_err().to_string();
assert!(
msg.contains("LZWEncode"),
"error must mention LZWEncode; got: {msg}"
);
assert!(
msg.contains("FlateDecode only"),
"error must mention FlateDecode only policy; got: {msg}"
);
}
#[test]
fn lzw_decode_malformed_one_past_end_without_prev_returns_err() {
let malformed: &[u8] = &[0x80, 0x40, 0x80];
let mut dict = Dictionary::new();
dict.insert("Filter", Object::Name(b"LZWDecode".to_vec()));
let result = decode_stream_data(&dict, malformed);
assert!(
result.is_err(),
"LZWDecode: code-258-after-clear-with-no-prev must return Err"
);
let msg = result.unwrap_err().to_string();
assert!(
msg.contains("LZWDecode"),
"error must mention LZWDecode; got: {msg}"
);
assert!(
msg.contains("no previous entry") || msg.contains("out of range"),
"error must describe the out-of-range / no-prev condition; got: {msg}"
);
}
#[test]
fn lzw_decode_malformed_genuinely_out_of_range_code_returns_err() {
let malformed: &[u8] = &[0x80, 0x40, 0xC0];
let mut dict = Dictionary::new();
dict.insert("Filter", Object::Name(b"LZWDecode".to_vec()));
let result = decode_stream_data(&dict, malformed);
assert!(
result.is_err(),
"LZWDecode: genuinely out-of-range code after ClearCode must return Err"
);
let msg = result.unwrap_err().to_string();
assert!(
msg.contains("LZWDecode"),
"error must mention LZWDecode; got: {msg}"
);
assert!(
msg.contains("out of range") || msg.contains("no previous entry"),
"error must describe the out-of-range condition; got: {msg}"
);
}
#[test]
fn decode_rejects_overlong_filter_chain() {
let mut dict = Dictionary::new();
dict.insert(
"Filter",
Object::Array(vec![Object::Name(b"FlateDecode".to_vec()); 17]),
);
let err = decode_stream_data(&dict, b"anything");
assert!(
matches!(err, Err(Error::Unsupported(ref m)) if m.contains("filter chain length")),
"got {err:?}"
);
}
#[test]
fn decode_stream_data_rejects_crypt_filter() {
let mut dict = Dictionary::new();
dict.insert("Filter", Object::Name(b"Crypt".to_vec()));
let err = decode_stream_data(&dict, b"data");
assert!(
matches!(err, Err(Error::Unsupported(ref m)) if m.contains("Crypt")),
"got {err:?}"
);
}
#[test]
fn decode_accepts_max_length_filter_chain() {
let original = b"hello";
let mut data = original.to_vec();
for _ in 0..16 {
data = encode_stream_data(
&{
let mut d = Dictionary::new();
d.insert("Filter", Object::Name(b"ASCIIHexDecode".to_vec()));
d
},
&data,
)
.unwrap();
}
let mut dict = Dictionary::new();
dict.insert(
"Filter",
Object::Array(vec![Object::Name(b"ASCIIHexDecode".to_vec()); 16]),
);
let decoded = decode_stream_data(&dict, &data).unwrap();
assert_eq!(decoded, original);
}
fn pack_lzw_9bit(codes: &[u16]) -> Vec<u8> {
let mut out = Vec::new();
let mut buf: u32 = 0;
let mut bits: u32 = 0;
for &code in codes {
buf = (buf << 9) | u32::from(code);
bits += 9;
while bits >= 8 {
bits -= 8;
out.push((buf >> bits) as u8);
}
}
if bits > 0 {
out.push((buf << (8 - bits)) as u8);
}
out
}
#[test]
fn flate_decode_honors_output_limit() {
let raw = vec![b'A'; 2000];
let mut dict = Dictionary::new();
dict.insert("Filter", Object::Name(b"FlateDecode".to_vec()));
let encoded = encode_stream_data(&dict, &raw).unwrap();
let err = decode_stream_data_with_limits(
&dict,
&encoded,
DecodeLimits {
max_output: Some(1999),
},
);
assert!(
matches!(err, Err(Error::Unsupported(ref m)) if m.contains("exceeds configured limit")),
"got {err:?}"
);
let ok = decode_stream_data_with_limits(
&dict,
&encoded,
DecodeLimits {
max_output: Some(2000),
},
)
.unwrap();
assert_eq!(ok.len(), 2000);
}
#[test]
fn lzw_decode_honors_output_limit() {
let mut codes = vec![65u16; 150];
codes.push(257); let lzw_bytes = pack_lzw_9bit(&codes);
let mut dict = Dictionary::new();
dict.insert("Filter", Object::Name(b"LZWDecode".to_vec()));
let err = decode_stream_data_with_limits(
&dict,
&lzw_bytes,
DecodeLimits {
max_output: Some(100),
},
);
assert!(
matches!(err, Err(Error::Unsupported(ref m)) if m.contains("exceeds configured limit")),
"got {err:?}"
);
let full = decode_stream_data(&dict, &lzw_bytes).unwrap();
assert_eq!(full, vec![b'A'; 150]);
assert!(full.len() > 100);
}
#[test]
fn decode_stream_data_is_unbounded_by_default() {
let raw = vec![b'Z'; 5000];
let mut dict = Dictionary::new();
dict.insert("Filter", Object::Name(b"FlateDecode".to_vec()));
let encoded = encode_stream_data(&dict, &raw).unwrap();
assert_eq!(decode_stream_data(&dict, &encoded).unwrap().len(), 5000);
assert_eq!(DecodeLimits::default().max_output, None);
}
#[test]
fn is_decode_output_limit_error_matches_only_the_limit_sentinel() {
let limit_err = Error::Unsupported(format!("{DECODE_OUTPUT_LIMIT_PREFIX} 1024 bytes"));
assert!(is_decode_output_limit_error(&limit_err));
let corrupt =
Error::Unsupported("corrupt deflate stream: invalid distance code".to_string());
assert!(!is_decode_output_limit_error(&corrupt));
let parse = Error::parse(0, "boom");
assert!(!is_decode_output_limit_error(&parse));
}
}