Share asset decoding validation and reject truncated payloads
This commit is contained in:
@@ -1,4 +1,5 @@
|
||||
#![allow(clippy::collapsible_if)]
|
||||
mod decode;
|
||||
mod resumable;
|
||||
use crate::memory_banks::{GlyphBankPoolInstaller, SceneBankPoolInstaller, SoundBankPoolInstaller};
|
||||
use prometeu_hal::AssetBridge;
|
||||
@@ -634,62 +635,13 @@ impl AssetManager {
|
||||
fn decode_glyph_bank_layout(
|
||||
entry: &AssetEntry,
|
||||
) -> Result<(TileSize, usize, usize, usize, usize, usize), String> {
|
||||
let meta = entry.metadata_as_glyph_bank()?;
|
||||
|
||||
let tile_size = match meta.tile_size {
|
||||
8 => TileSize::Size8,
|
||||
16 => TileSize::Size16,
|
||||
32 => TileSize::Size32,
|
||||
_ => return Err(format!("Invalid tile_size: {}", meta.tile_size)),
|
||||
};
|
||||
|
||||
let palette_count = meta.palette_count as usize;
|
||||
if !(1..=GLYPH_BANK_MAX_PALETTE_COUNT_V1).contains(&palette_count) {
|
||||
return Err(format!("Invalid palette_count: {}", meta.palette_count));
|
||||
}
|
||||
|
||||
let width = meta.width as usize;
|
||||
let height = meta.height as usize;
|
||||
|
||||
let logical_pixels = width.checked_mul(height).ok_or("GlyphBank dimensions overflow")?;
|
||||
let serialized_pixel_bytes = logical_pixels.div_ceil(2);
|
||||
let palette_bytes = palette_count
|
||||
.checked_mul(GLYPH_BANK_PALETTE_BYTES_PER_PALETTE)
|
||||
.ok_or("GlyphBank palette size overflow")?;
|
||||
let serialized_size = serialized_pixel_bytes
|
||||
.checked_add(palette_bytes)
|
||||
.ok_or("GlyphBank serialized size overflow")?;
|
||||
let decoded_size =
|
||||
logical_pixels.checked_add(palette_bytes).ok_or("GlyphBank decoded size overflow")?;
|
||||
|
||||
if entry.size != serialized_size as u64 {
|
||||
return Err(format!(
|
||||
"Invalid GLYPHBANK serialized size: expected {}, got {}",
|
||||
serialized_size, entry.size
|
||||
));
|
||||
}
|
||||
|
||||
if entry.decoded_size != decoded_size as u64 {
|
||||
return Err(format!(
|
||||
"Invalid GLYPHBANK decoded_size: expected {}, got {}",
|
||||
decoded_size, entry.decoded_size
|
||||
));
|
||||
}
|
||||
|
||||
Ok((tile_size, width, height, serialized_pixel_bytes, palette_count, palette_bytes))
|
||||
decode::glyph_layout(entry)
|
||||
}
|
||||
|
||||
fn unpack_glyph_bank_pixels(packed_pixels: &[u8], logical_pixels: usize) -> Vec<u8> {
|
||||
let mut pixel_indices = Vec::with_capacity(logical_pixels);
|
||||
for &packed in packed_pixels {
|
||||
if pixel_indices.len() < logical_pixels {
|
||||
pixel_indices.push(packed >> 4);
|
||||
}
|
||||
if pixel_indices.len() < logical_pixels {
|
||||
pixel_indices.push(packed & 0x0f);
|
||||
}
|
||||
}
|
||||
pixel_indices
|
||||
let mut pixels = Vec::with_capacity(logical_pixels);
|
||||
decode::append_pixels(&mut pixels, packed_pixels, logical_pixels);
|
||||
pixels
|
||||
}
|
||||
|
||||
fn op_mode_for(entry: &AssetEntry) -> Result<AssetOpMode, String> {
|
||||
@@ -1260,17 +1212,7 @@ impl AssetManager {
|
||||
let palette_data = &buffer[packed_pixel_bytes..packed_pixel_bytes + palette_bytes];
|
||||
|
||||
let mut palettes = vec![[Color::BLACK; GLYPH_BANK_COLORS_PER_PALETTE]; palette_count];
|
||||
for (p, pal) in palettes.iter_mut().enumerate() {
|
||||
for (c, slot) in pal.iter_mut().enumerate() {
|
||||
let offset = (p * 16 + c) * 4;
|
||||
*slot = Color::rgba(
|
||||
palette_data[offset],
|
||||
palette_data[offset + 1],
|
||||
palette_data[offset + 2],
|
||||
palette_data[offset + 3],
|
||||
);
|
||||
}
|
||||
}
|
||||
decode::write_palettes(&mut palettes, 0, palette_data);
|
||||
|
||||
Ok(GlyphBank { tile_size, width, height, pixel_indices, palettes })
|
||||
}
|
||||
@@ -1295,17 +1237,7 @@ impl AssetManager {
|
||||
.map_err(|_| "Buffer too small for GLYPHBANK".to_string())?;
|
||||
|
||||
let mut palettes = vec![[Color::BLACK; GLYPH_BANK_COLORS_PER_PALETTE]; palette_count];
|
||||
for (p, pal) in palettes.iter_mut().enumerate() {
|
||||
for (c, slot) in pal.iter_mut().enumerate() {
|
||||
let offset = (p * 16 + c) * 4;
|
||||
*slot = Color::rgba(
|
||||
palette_data[offset],
|
||||
palette_data[offset + 1],
|
||||
palette_data[offset + 2],
|
||||
palette_data[offset + 3],
|
||||
);
|
||||
}
|
||||
}
|
||||
decode::write_palettes(&mut palettes, 0, &palette_data);
|
||||
|
||||
Ok(GlyphBank { tile_size, width, height, pixel_indices, palettes })
|
||||
}
|
||||
@@ -1340,7 +1272,7 @@ impl AssetManager {
|
||||
entry: &AssetEntry,
|
||||
assets_data: Arc<RwLock<AssetsPayloadSource>>,
|
||||
) -> Result<SceneBank, String> {
|
||||
let _ = entry.metadata_as_scene_bank()?;
|
||||
decode::scene_metadata(entry)?;
|
||||
let op_mode = Self::op_mode_for(entry)?;
|
||||
let slice = {
|
||||
let assets_data = assets_data.read().unwrap();
|
||||
@@ -1367,152 +1299,25 @@ impl AssetManager {
|
||||
entry: &AssetEntry,
|
||||
buffer: &[u8],
|
||||
) -> Result<SceneBank, String> {
|
||||
let _ = entry.metadata_as_scene_bank()?;
|
||||
|
||||
if buffer.len() < SCENE_HEADER_BYTES_V1 {
|
||||
return Err("Buffer too small for SCENE".to_string());
|
||||
}
|
||||
|
||||
if buffer[0..4] != SCENE_PAYLOAD_MAGIC_V1 {
|
||||
return Err("Invalid SCENE magic".to_string());
|
||||
}
|
||||
|
||||
let version = u16::from_le_bytes([buffer[4], buffer[5]]);
|
||||
if version != SCENE_PAYLOAD_VERSION_V1 {
|
||||
return Err(format!("Unsupported SCENE version: {}", version));
|
||||
}
|
||||
|
||||
let layer_count = u16::from_le_bytes([buffer[6], buffer[7]]) as usize;
|
||||
if layer_count != SCENE_LAYER_COUNT_V1 {
|
||||
return Err(format!("Invalid SCENE layer count: {}", layer_count));
|
||||
}
|
||||
|
||||
decode::scene_metadata(entry)?;
|
||||
decode::payload_size(entry, buffer.len())?;
|
||||
decode::scene_header(buffer)?;
|
||||
let mut offset = SCENE_HEADER_BYTES_V1;
|
||||
let mut decoded_size = 0_usize;
|
||||
let layers = std::array::from_fn(|_| SceneLayer {
|
||||
active: false,
|
||||
glyph_asset_id: 0,
|
||||
tile_size: TileSize::Size8,
|
||||
parallax_factor: ParallaxFactor { x: 1.0, y: 1.0 },
|
||||
tilemap: TileMap { width: 0, height: 0, tiles: Vec::new() },
|
||||
});
|
||||
let mut layers = layers;
|
||||
|
||||
let mut decoded = 0;
|
||||
let mut layers = decode::empty_layers();
|
||||
for layer in &mut layers {
|
||||
let header_end = offset
|
||||
let end = offset
|
||||
.checked_add(SCENE_LAYER_HEADER_BYTES_V1)
|
||||
.ok_or("SCENE layer header offset overflow")?;
|
||||
if header_end > buffer.len() {
|
||||
return Err("Buffer too small for SCENE layer header".to_string());
|
||||
}
|
||||
|
||||
let flags = buffer[offset];
|
||||
let glyph_asset_id = i32::from_le_bytes([
|
||||
buffer[offset + 1],
|
||||
buffer[offset + 2],
|
||||
buffer[offset + 3],
|
||||
buffer[offset + 4],
|
||||
]);
|
||||
let tile_size_raw = buffer[offset + 5];
|
||||
let tile_size = match tile_size_raw {
|
||||
8 => TileSize::Size8,
|
||||
16 => TileSize::Size16,
|
||||
32 => TileSize::Size32,
|
||||
other => return Err(format!("Invalid SCENE tile size: {}", other)),
|
||||
};
|
||||
let parallax_factor_x = f32::from_le_bytes([
|
||||
buffer[offset + 8],
|
||||
buffer[offset + 9],
|
||||
buffer[offset + 10],
|
||||
buffer[offset + 11],
|
||||
]);
|
||||
let parallax_factor_y = f32::from_le_bytes([
|
||||
buffer[offset + 12],
|
||||
buffer[offset + 13],
|
||||
buffer[offset + 14],
|
||||
buffer[offset + 15],
|
||||
]);
|
||||
if !parallax_factor_x.is_finite() || !parallax_factor_y.is_finite() {
|
||||
return Err("Invalid SCENE parallax_factor".to_string());
|
||||
}
|
||||
|
||||
let width = u32::from_le_bytes([
|
||||
buffer[offset + 16],
|
||||
buffer[offset + 17],
|
||||
buffer[offset + 18],
|
||||
buffer[offset + 19],
|
||||
]) as usize;
|
||||
let height = u32::from_le_bytes([
|
||||
buffer[offset + 20],
|
||||
buffer[offset + 21],
|
||||
buffer[offset + 22],
|
||||
buffer[offset + 23],
|
||||
]) as usize;
|
||||
let tile_count = u32::from_le_bytes([
|
||||
buffer[offset + 24],
|
||||
buffer[offset + 25],
|
||||
buffer[offset + 26],
|
||||
buffer[offset + 27],
|
||||
]) as usize;
|
||||
|
||||
let expected_tile_count =
|
||||
width.checked_mul(height).ok_or("SCENE tile count overflow")?;
|
||||
if tile_count != expected_tile_count {
|
||||
return Err(format!(
|
||||
"Invalid SCENE tile count for layer: expected {}, got {}",
|
||||
expected_tile_count, tile_count
|
||||
));
|
||||
}
|
||||
|
||||
offset = header_end;
|
||||
|
||||
let tile_bytes = tile_count
|
||||
.checked_mul(SCENE_TILE_RECORD_BYTES_V1)
|
||||
.ok_or("SCENE tile payload overflow")?;
|
||||
let tiles_end = offset.checked_add(tile_bytes).ok_or("SCENE payload overflow")?;
|
||||
if tiles_end > buffer.len() {
|
||||
return Err("Buffer too small for SCENE tile data".to_string());
|
||||
}
|
||||
|
||||
let mut tiles = Vec::with_capacity(tile_count);
|
||||
for _ in 0..tile_count {
|
||||
let tile_flags = buffer[offset];
|
||||
let palette_id = buffer[offset + 1];
|
||||
let glyph_id = u16::from_le_bytes([buffer[offset + 2], buffer[offset + 3]]);
|
||||
tiles.push(Tile {
|
||||
active: (tile_flags & 0b0000_0001) != 0,
|
||||
glyph: Glyph { glyph_id, palette_id },
|
||||
flip_x: (tile_flags & 0b0000_0010) != 0,
|
||||
flip_y: (tile_flags & 0b0000_0100) != 0,
|
||||
});
|
||||
offset += SCENE_TILE_RECORD_BYTES_V1;
|
||||
}
|
||||
|
||||
decoded_size = decoded_size
|
||||
.checked_add(SCENE_DECODED_LAYER_OVERHEAD_BYTES_V1)
|
||||
.and_then(|size| size.checked_add(tile_count * size_of::<Tile>()))
|
||||
.ok_or("SCENE decoded_size overflow")?;
|
||||
|
||||
*layer = SceneLayer {
|
||||
active: (flags & 0b0000_0001) != 0,
|
||||
glyph_asset_id,
|
||||
tile_size,
|
||||
parallax_factor: ParallaxFactor { x: parallax_factor_x, y: parallax_factor_y },
|
||||
tilemap: TileMap { width, height, tiles },
|
||||
};
|
||||
.ok_or("SCENE header offset overflow")?;
|
||||
let header =
|
||||
buffer.get(offset..end).ok_or("Buffer too small for SCENE layer header")?;
|
||||
*layer = decode::scene_layer(header, end, entry.size, &mut decoded)?;
|
||||
let tile_bytes =
|
||||
layer.tilemap.width * layer.tilemap.height * SCENE_TILE_RECORD_BYTES_V1;
|
||||
offset = end + tile_bytes; // checked by scene_layer before allocation
|
||||
decode::append_tiles(&mut layer.tilemap.tiles, &buffer[end..offset]);
|
||||
}
|
||||
|
||||
if offset != buffer.len() {
|
||||
return Err("Trailing bytes in SCENE payload".to_string());
|
||||
}
|
||||
|
||||
if entry.decoded_size != decoded_size as u64 {
|
||||
return Err(format!(
|
||||
"Invalid SCENE decoded_size: expected {}, got {}",
|
||||
decoded_size, entry.decoded_size
|
||||
));
|
||||
}
|
||||
|
||||
decode::scene_finish(entry, offset, decoded)?;
|
||||
Ok(SceneBank { layers })
|
||||
}
|
||||
|
||||
@@ -1529,15 +1334,10 @@ impl AssetManager {
|
||||
entry: &AssetEntry,
|
||||
buffer: &[u8],
|
||||
) -> Result<SoundBank, String> {
|
||||
let meta = entry.metadata_as_sound_bank()?;
|
||||
let sample_rate = meta.sample_rate;
|
||||
|
||||
let sample_rate = decode::sound_rate(entry)?;
|
||||
decode::payload_size(entry, buffer.len())?;
|
||||
let mut data = Vec::with_capacity(buffer.len() / 2);
|
||||
for i in (0..buffer.len()).step_by(2) {
|
||||
if i + 1 < buffer.len() {
|
||||
data.push(i16::from_le_bytes([buffer[i], buffer[i + 1]]));
|
||||
}
|
||||
}
|
||||
decode::append_pcm(&mut data, buffer);
|
||||
|
||||
let sample = Arc::new(Sample::new(sample_rate, data));
|
||||
Ok(SoundBank::new(vec![sample]))
|
||||
|
||||
Reference in New Issue
Block a user