Reject invalid record sizes and return malformed-input errors

Validate payload sizes before record/header writes and make header packing
return io::Result when the total size overflows the format limit.

Return located parse errors for invalid UTF-8 and timestamp year overflow.
Validate cell timestamps consistently in full reads, selected reads, and
hierarchy scans while retaining scan behavior for skipped text geometry.

Add regression coverage for preserved writer outputs, padded metadata sizes,
malformed strings, timestamp boundaries, bounded errors, and Python bindings.
Document the fallible header packing API.

Validation: all 97 Rust tests pass in debug and release; all 16 Python tests
pass against the rebuilt native library.
This commit is contained in:
Jan Petykiewicz 2026-11-16 21:28:54 -08:00
commit 31afef0529

View file

@ -7,7 +7,7 @@ use std::io::Write;
use crate::record::{RecordHeader, Record};
use crate::records;
use crate::elements::{read_elements, scan_elements, DListBuilder, FListBuilder, ScanRefRecord};
use crate::basic::{IResult, OResult, take_bytes, fail};
use crate::basic::{ErrType, IResult, OResult, decode_utf8, take_bytes, fail};
use std::string::String;
use std::collections::HashMap;
@ -324,13 +324,14 @@ fn make_scan_builder() -> StructBuilder {
fn append_file_header(
lib_builder: &mut StructBuilder,
header: &FileHeader,
) {
) -> Result<(), ErrType> {
let name = decode_utf8(header.name.clone())?;
let dbu_builder = lib_builder.field_builder::<Float64Builder>(0).unwrap();
dbu_builder.append_value(header.meters_per_db_unit);
let uu_builder = lib_builder.field_builder::<Float64Builder>(1).unwrap();
uu_builder.append_value(header.user_units_per_db_unit);
let libname_builder = lib_builder.field_builder::<StringBuilder>(2).unwrap();
libname_builder.append_value(String::from_utf8(header.name.clone()).unwrap());
libname_builder.append_value(name);
let mtl_builder = lib_builder.field_builder::<FListBuilder>(3).unwrap();
let mt_builder = mtl_builder.values().as_any_mut().downcast_mut::<Int16Builder>().unwrap();
mt_builder.append_values(&header.mod_time, &[true; 6]);
@ -339,6 +340,7 @@ fn append_file_header(
let at_builder = atl_builder.values().as_any_mut().downcast_mut::<Int16Builder>().unwrap();
at_builder.append_values(&header.acc_time, &[true; 6]);
atl_builder.append(true);
Ok(())
}
@ -441,14 +443,16 @@ where
let (mut input, mut header) = RecordHeader::read(input)?;
while header.tag != records::RTAG_ENDLIB {
let record_start = base_offset + input_size - input.len() - 4;
(input, _) = take_bytes(input, header.data_size)?;
if header.tag == records::RTAG_BGNSTR {
(input, _) = records::BGNSTR::read_data(input, header.data_size)?;
let name_bytes;
(input, name_bytes) = records::STRNAME::read(input)?;
let name = String::from_utf8(name_bytes).unwrap();
let name = decode_utf8(name_bytes).map_err(|error| (input, error))?;
let id = intern_name(names, name);
let (next_input, ()) = on_struct(input, record_start, id, names)?;
input = next_input;
} else {
(input, _) = take_bytes(input, header.data_size)?;
}
(input, header) = RecordHeader::read(input)?;
}
@ -461,7 +465,7 @@ pub fn read_library(input: &[u8]) -> IResult<'_, StructArray> {
let mut lib_builder = make_library_builder();
let (input, header) = FileHeader::read(input)?;
append_file_header(&mut lib_builder, &header);
append_file_header(&mut lib_builder, &header).map_err(|error| (input, error))?;
let base_offset = full_input_size - input.len();
let mut names = HashMap::<String, u32>::new();
@ -497,7 +501,7 @@ pub fn scan_library(input: &[u8]) -> IResult<'_, StructArray> {
let mut lib_builder = make_scan_builder();
let (input, header) = FileHeader::read(input)?;
append_file_header(&mut lib_builder, &header);
append_file_header(&mut lib_builder, &header).map_err(|error| (input, error))?;
let base_offset = full_input_size - input.len();
let mut names = HashMap::<String, u32>::new();
@ -541,8 +545,8 @@ pub fn scan_library(input: &[u8]) -> IResult<'_, StructArray> {
/// as its remainder; it does not advance a sequential parsing cursor.
pub fn read_selected_library<'a>(input: &'a [u8], ranges: &[(u64, u64)]) -> IResult<'a, StructArray> {
let mut lib_builder = make_library_builder();
let (_, header) = FileHeader::read(input)?;
append_file_header(&mut lib_builder, &header);
let (header_end, header) = FileHeader::read(input)?;
append_file_header(&mut lib_builder, &header).map_err(|error| (header_end, error))?;
let mut names = HashMap::<String, u32>::new();
let mut layers = HashMap::<u32, u32>::new();
@ -558,7 +562,7 @@ pub fn read_selected_library<'a>(input: &'a [u8], ranges: &[(u64, u64)]) -> IRes
let struct_input = &input[start..end];
let (struct_input, _) = records::BGNSTR::read(struct_input)?;
let (struct_input, name_bytes) = records::STRNAME::read(struct_input)?;
let name = String::from_utf8(name_bytes).unwrap();
let name = decode_utf8(name_bytes).map_err(|error| (struct_input, error))?;
let file_offset = end - struct_input.len();
let id = intern_name(&mut names, name);