From 7bce4752117c90f025f6645643c177bb4019e0e4 Mon Sep 17 00:00:00 2001 From: Vincent <1729065730@qq.com> Date: Tue, 27 Oct 2026 19:15:41 +0800 Subject: [PATCH] Return Serde errors for corrupt RLE and RunEnd metadata RLE deserialize called dtype.as_ptype(), which panics for a non-primitive file dtype. RunEnd deserialize used vortex_expect on usize::try_from for num_runs and offset, which panics on 32-bit for values above usize::MAX. Both now return errors so a corrupt file read fails instead of panicking. Partially addresses #10756 (ALP-RD covered by #10760). Signed-off-by: Vincent <1729065730@qq.com> --- encodings/fastlanes/src/rle/vtable/mod.rs | 30 +++++++++- vortex-array/src/arrays/runend/array.rs | 68 ++++++++++++++++++++++- 2 files changed, 95 insertions(+), 3 deletions(-) diff --git a/encodings/fastlanes/src/rle/vtable/mod.rs b/encodings/fastlanes/src/rle/vtable/mod.rs index a06c615807e..a2eaa35fca1 100644 --- a/encodings/fastlanes/src/rle/vtable/mod.rs +++ b/encodings/fastlanes/src/rle/vtable/mod.rs @@ -190,9 +190,10 @@ impl VTable for RLE { "RLEArray expects 0 buffers, got {}", buffers.len() ); + let values_ptype = PType::try_from(dtype)?; let values = children.get( 0, - &DType::Primitive(dtype.as_ptype(), Nullability::NonNullable), + &DType::Primitive(values_ptype, Nullability::NonNullable), usize::try_from(metadata.values_len)?, )?; @@ -410,4 +411,31 @@ mod tests { Ok(()) } + + #[test] + fn test_deserialize_rejects_non_primitive_dtype() -> VortexResult<()> { + let metadata = RLEMetadata { + values_len: 0, + indices_len: 0, + indices_ptype: PType::U16 as i32, + values_idx_offsets_len: 0, + values_idx_offsets_ptype: PType::U64 as i32, + offset: 0, + } + .encode_to_vec(); + let children: Vec = Vec::new(); + let result = RLE.deserialize( + &DType::Utf8(Nullability::NonNullable), + 0, + &metadata, + &[], + &children, + &SESSION, + ); + assert!(result.is_err_and(|err| { + err.to_string() + .contains("Cannot convert DType utf8 into PType") + })); + Ok(()) + } } diff --git a/vortex-array/src/arrays/runend/array.rs b/vortex-array/src/arrays/runend/array.rs index 3a4e5493387..6de7fc03299 100644 --- a/vortex-array/src/arrays/runend/array.rs +++ b/vortex-array/src/arrays/runend/array.rs @@ -166,11 +166,21 @@ impl VTable for RunEnd { let metadata = RunEndMetadata::decode(metadata)?; let ends_ptype = metadata.get_ends_ptype()?; let ends_dtype = DType::Primitive(ends_ptype, Nullability::NonNullable); - let runs = usize::try_from(metadata.num_runs).vortex_expect("Must be a valid usize"); + let runs = usize::try_from(metadata.num_runs).map_err(|_| { + vortex_err!( + "RunEndMetadata num_runs {} exceeds usize range", + metadata.num_runs + ) + })?; let ends = children.get(0, &ends_dtype, runs)?; let values = children.get(1, dtype, runs)?; - let offset = usize::try_from(metadata.offset).vortex_expect("Offset must be a valid usize"); + let offset = usize::try_from(metadata.offset).map_err(|_| { + vortex_err!( + "RunEndMetadata offset {} exceeds usize range", + metadata.offset + ) + })?; RunEndData::validate_parts( &ends, &values, @@ -976,4 +986,58 @@ mod tests { Ok(()) } + + // On 32-bit targets, a crafted num_runs / offset above usize::MAX used to panic via + // vortex_expect. Keep a regression that only builds where the conversion can fail. + #[cfg(target_pointer_width = "32")] + #[test] + fn test_deserialize_rejects_num_runs_overflow() -> VortexResult<()> { + let metadata = RunEndMetadata { + ends_ptype: PType::U32 as i32, + num_runs: u64::from(u32::MAX) + 1, + offset: 0, + } + .encode_to_vec(); + let children: Vec = Vec::new(); + let result = RunEnd.deserialize( + &DType::Primitive(PType::I32, Nullability::NonNullable), + 0, + &metadata, + &[], + &children, + &SESSION, + ); + assert!(result.is_err_and(|err| { + err.to_string() + .contains("RunEndMetadata num_runs") + && err.to_string().contains("exceeds usize range") + })); + Ok(()) + } + + #[cfg(target_pointer_width = "32")] + #[test] + fn test_deserialize_rejects_offset_overflow() -> VortexResult<()> { + let metadata = RunEndMetadata { + ends_ptype: PType::U32 as i32, + num_runs: 0, + offset: u64::from(u32::MAX) + 1, + } + .encode_to_vec(); + let children: Vec = Vec::new(); + let result = RunEnd.deserialize( + &DType::Primitive(PType::I32, Nullability::NonNullable), + 0, + &metadata, + &[], + &children, + &SESSION, + ); + assert!(result.is_err_and(|err| { + err.to_string() + .contains("RunEndMetadata offset") + && err.to_string().contains("exceeds usize range") + })); + Ok(()) + } }