fix(audio): validate FLAC stream precision and complete consumption

This commit is contained in:
Dylan M. Taylor committed 2026-11-15 11:05:37 -05:00
1 parent 2d5f2e4a73
commit ad9850f18f
2 files changed
+84 -2

No files matched your search

+47 -2
View File
@@ -225,6 +225,11 @@ impl Decoder {
/// Decode the frame at the start of `data`.
pub fn decode_frame(&self, data: &[u8]) -> Result<Frame> {
// StreamInfo has public fields: container callers can construct it without
// parse(), so validate before it can control shifts and sample reads.
if self.info.is_some_and(|i| !(4..=32).contains(&i.bits_per_sample) || !(1..=8).contains(&i.channels) || i.sample_rate == 0) {
return Err(DecodeError::Invalid("invalid decoder STREAMINFO"));
}
let mut r = Bits::new(data);
if r.bits(15)? != 0x7FFC {
return Err(DecodeError::Invalid("missing frame sync code"));
@@ -315,8 +320,7 @@ impl Decoder {
}
let mut chans = Vec::with_capacity(channels);
for c in out {
let v: Result<Vec<i32>> =
c.into_iter().map(|s| i32::try_from(s).map_err(|_| DecodeError::Invalid("sample outside the bit depth"))).collect();
let v: Result<Vec<i32>> = c.into_iter().map(|s| checked_sample(s, bits)).collect();
chans.push(v?);
}
Ok(Frame { sample_rate, bits_per_sample: bits as u8, variable_block_size: variable, number, block_size, channels: chans, size })
@@ -542,6 +546,11 @@ pub fn decode_with_limit(bytes: &[u8], max_values: u64) -> Result<Decoded> {
if frame.channels.len() != channels.len() {
return Err(DecodeError::Invalid("the channel count changes inside the stream"));
}
// One file has one sample rate and depth. Otherwise callers would play
// samples under incompatible STREAMINFO metadata.
if frame.sample_rate != info.sample_rate || frame.bits_per_sample != info.bits_per_sample {
return Err(DecodeError::Invalid("frame format differs from STREAMINFO"));
}
total += frame.block_size as u64;
if total.saturating_mul(channels.len() as u64) > max_values {
return Err(DecodeError::TooLarge);
@@ -551,8 +560,44 @@ pub fn decode_with_limit(bytes: &[u8], max_values: u64) -> Result<Decoded> {
}
pos += frame.size;
}
// Unknown total_samples must not turn a corrupt/truncated next frame into
// a successfully decoded shorter recording.
if pos != bytes.len() {
return Err(DecodeError::Invalid("trailing data or missing frame sync"));
}
if info.total_samples != 0 && total != info.total_samples {
return Err(DecodeError::Truncated);
}
Ok(Decoded { info, channels })
}
// Validate the advertised precision, not just the storage type. Malformed
// predictors may produce an i32 that is still invalid for 4–24-bit audio.
fn checked_sample(sample: i64, bits: u32) -> Result<i32> {
if !(4..=32).contains(&bits) {
return Err(DecodeError::Invalid("invalid sample bit depth"));
}
let bound = 1i64 << (bits - 1);
if !(-bound..bound).contains(&sample) {
return Err(DecodeError::Invalid("sample outside the bit depth"));
}
i32::try_from(sample).map_err(|_| DecodeError::Invalid("sample outside the bit depth"))
}
#[cfg(test)]
mod sample_bounds_tests {
use super::checked_sample;
#[test]
fn samples_must_fit_declared_precision() {
for bits in 4..=32 {
let bound = 1i64 << (bits - 1);
assert_eq!(checked_sample(-bound, bits).map(i64::from), Ok(-bound));
assert_eq!(checked_sample(bound - 1, bits).map(i64::from), Ok(bound - 1));
assert!(checked_sample(-bound - 1, bits).is_err());
assert!(checked_sample(bound, bits).is_err());
}
assert!(checked_sample(0, 0).is_err());
assert!(checked_sample(0, 255).is_err());
}
}
+37
View File
@@ -172,3 +172,40 @@ fn ffmpeg_decodes_our_files_to_our_samples() {
assert!(interleave(&got.channels) == want, "{channels}ch {bits}-bit: samples differ from ffmpeg's decode");
}
}
#[test]
fn rejects_unknown_length_corruption_and_streaminfo_format_mismatch() {
let src = signal(1, 100, 16, 7);
let original = encode(&src, 44_100, 16, 4096, 5);
let at = STREAMINFO_OFFSET as usize;
// STREAMINFO is not CRC-covered. Clear only the 36-bit total sample count.
let mut unknown = original.clone();
unknown[at + 13] &= 0xf0;
unknown[at + 14..at + 18].fill(0);
assert_eq!(decode(&unknown).unwrap().channels, src);
for tail in [vec![0xff], vec![0x00, 0x00]] {
let mut broken = unknown.clone();
broken.extend(tail);
assert!(decode(&broken).is_err());
}
// The encoder spells these in frame headers, independent of STREAMINFO.
let mut wrong_rate = original.clone();
let mut packed = u64::from_be_bytes(wrong_rate[at + 10..at + 18].try_into().unwrap());
packed = (packed & ((1u64 << 44) - 1)) | (48_000u64 << 44);
wrong_rate[at + 10..at + 18].copy_from_slice(&packed.to_be_bytes());
assert!(decode(&wrong_rate).is_err());
let mut wrong_depth = original;
wrong_depth[at + 12] = (wrong_depth[at + 12] & !1) | 1;
wrong_depth[at + 13] = (wrong_depth[at + 13] & 0x0f) | 0x70;
assert!(decode(&wrong_depth).is_err());
}
#[test]
fn caller_constructed_streaminfo_is_validated_before_decoding() {
let file = encode(&signal(1, 100, 16, 9), 44_100, 16, 4096, 5);
let info = StreamInfo::parse(&file[STREAMINFO_OFFSET as usize..]).unwrap();
for bits in [0, 1, 3, 33, 64, 255] {
let invalid = StreamInfo { bits_per_sample: bits, ..info };
assert!(matches!(Decoder::new(invalid).decode_frame(&[]), Err(DecodeError::Invalid(_))));
}
}