diff --git a/crates/console/prometeu-hal/src/cartridge.rs b/crates/console/prometeu-hal/src/cartridge.rs index 6ab7e04..02962a3 100644 --- a/crates/console/prometeu-hal/src/cartridge.rs +++ b/crates/console/prometeu-hal/src/cartridge.rs @@ -278,6 +278,7 @@ pub enum CartridgeError { MissingProgram, MissingAssets, IoError, + ProgramLoadFailed(prometeu_bytecode::load_limits::LoadFailure), } #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Deserialize, Serialize)] diff --git a/crates/console/prometeu-hal/src/cartridge_loader.rs b/crates/console/prometeu-hal/src/cartridge_loader.rs index 302da02..fd6f468 100644 --- a/crates/console/prometeu-hal/src/cartridge_loader.rs +++ b/crates/console/prometeu-hal/src/cartridge_loader.rs @@ -5,6 +5,9 @@ use crate::cartridge::{ CartridgeManifest, }; use crate::syscalls::{CapFlags, caps}; +use prometeu_bytecode::load_limits::{ + LoadBudget, LoadFailure, LoadLimits, LoadReason, LoadResource, +}; use std::collections::HashSet; use std::fs; use std::io::{Read, Seek, SeekFrom}; @@ -58,7 +61,9 @@ impl DirectoryCartridgeLoader { return Err(CartridgeError::MissingProgram); } - let program = fs::read(program_path).map_err(|_| CartridgeError::IoError)?; + let mut program_file = fs::File::open(program_path).map_err(|_| CartridgeError::IoError)?; + let program_len = program_file.metadata().map_err(|_| CartridgeError::IoError)?.len(); + let program = read_program(&mut program_file, program_len, LoadLimits::default())?; let assets_pa_path = path.join("assets.pa"); let (assets, asset_table, preload) = if assets_pa_path.exists() { @@ -98,6 +103,59 @@ impl DirectoryCartridgeLoader { pub struct PackedCartridgeLoader; +/// Admit the PBX input separately from parsing scratch. Metadata rejects an +/// oversized file before reservation; bounded reads also cover file growth. +fn read_program( + reader: &mut impl Read, + size_hint: u64, + limits: LoadLimits, +) -> Result, CartridgeError> { + let budget = LoadBudget::new(limits); + let limit = budget.limit(LoadResource::PbxBytes); + budget.check(LoadResource::PbxBytes, size_hint).map_err(CartridgeError::ProgramLoadFailed)?; + let resource_error = |reason, requested| { + let mut error = LoadFailure::resource(LoadResource::PbxBytes, requested, limit); + error.reason = reason; + CartridgeError::ProgramLoadFailed(error) + }; + let mut out = Vec::::new(); + let initial = + usize::try_from(size_hint).map_err(|_| resource_error(LoadReason::Overflow, size_hint))?; + out.try_reserve_exact(initial) + .map_err(|_| resource_error(LoadReason::Allocation, size_hint))?; + budget + .check(LoadResource::PbxBytes, out.capacity() as u64) + .map_err(CartridgeError::ProgramLoadFailed)?; + let mut chunk = [0u8; 8192]; + loop { + // At the ceiling inspect one extra byte without growing the input. + let remaining = limit - out.len() as u64; + let read_len = remaining.min(chunk.len() as u64).max(1) as usize; + let count = match reader.read(&mut chunk[..read_len]) { + Ok(count) => count, + Err(e) if e.kind() == std::io::ErrorKind::Interrupted => continue, + Err(_) => return Err(CartridgeError::IoError), + }; + if count == 0 { + return Ok(out); + } + let requested = (out.len() as u64) + .checked_add(count as u64) + .ok_or_else(|| resource_error(LoadReason::Overflow, u64::MAX))?; + budget + .check(LoadResource::PbxBytes, requested) + .map_err(CartridgeError::ProgramLoadFailed)?; + // Reserve exact growth rather than allowing Vec's geometric growth to + // exceed admission. Existing spare capacity is reused without billing twice. + out.try_reserve_exact(count) + .map_err(|_| resource_error(LoadReason::Allocation, requested))?; + budget + .check(LoadResource::PbxBytes, out.capacity() as u64) + .map_err(CartridgeError::ProgramLoadFailed)?; + out.extend_from_slice(&chunk[..count]); + } +} + impl PackedCartridgeLoader { pub fn load(_path: &Path) -> Result { Err(CartridgeError::InvalidFormat) @@ -204,6 +262,7 @@ mod tests { use crate::asset::{AssetCodec, AssetEntry, BankType, PreloadEntry}; use crate::cartridge::{ASSETS_PA_MAGIC, ASSETS_PA_SCHEMA_VERSION, AssetsPackPrelude}; use crate::glyph_bank::GLYPH_BANK_MAX_PALETTE_COUNT_V1; + use prometeu_bytecode::load_limits::LoadCode; use serde_json::json; use std::path::{Path, PathBuf}; use std::sync::atomic::{AtomicU64, Ordering}; @@ -289,6 +348,76 @@ mod tests { manifest } + #[test] + fn program_admission_accepts_exact_limit_and_rejects_growth_after_metadata() { + let limits = LoadLimits { pbx_bytes: 3, ..Default::default() }; + for hint in [0, 1, 3] { + assert_eq!(read_program(&mut &b"abc"[..], hint, limits).unwrap(), b"abc"); + let error = read_program(&mut &b"abcd"[..], hint, limits).unwrap_err(); + let CartridgeError::ProgramLoadFailed(error) = error else { + panic!("typed PBX admission failure expected") + }; + assert_eq!((error.code, error.reason), (LoadCode::ResourceLimit, LoadReason::Limit)); + assert_eq!( + (error.resource, error.requested, error.limit), + (Some(LoadResource::PbxBytes), Some(4), Some(3)) + ); + } + } + + #[test] + fn program_admission_rejects_oversized_metadata_before_reading() { + struct MustNotRead; + impl Read for MustNotRead { + fn read(&mut self, _: &mut [u8]) -> std::io::Result { + panic!("must reject before reading") + } + } + let limits = LoadLimits { pbx_bytes: 3, ..Default::default() }; + assert!(matches!( + read_program(&mut MustNotRead, 4, limits), + Err(CartridgeError::ProgramLoadFailed(_)) + )); + } + + #[test] + fn program_admission_handles_empty_short_and_interrupted_reads() { + assert!(read_program(&mut &[][..], 0, LoadLimits::default()).unwrap().is_empty()); + struct ShortReads { + interrupted: bool, + remaining: &'static [u8], + } + impl Read for ShortReads { + fn read(&mut self, bytes: &mut [u8]) -> std::io::Result { + if !self.interrupted { + self.interrupted = true; + return Err(std::io::ErrorKind::Interrupted.into()); + } + if self.remaining.is_empty() { + return Ok(0); + } + bytes[0] = self.remaining[0]; + self.remaining = &self.remaining[1..]; + Ok(1) + } + } + let mut reader = ShortReads { interrupted: false, remaining: b"abc" }; + assert_eq!(read_program(&mut reader, 2, LoadLimits::default()).unwrap(), b"abc"); + } + + #[test] + fn directory_loader_rejects_oversized_pbx_with_default_limit() { + let dir = TestCartridgeDir::new(manifest_with_capabilities(None)); + let file = fs::OpenOptions::new().write(true).open(dir.path().join("program.pbx")).unwrap(); + let limit = LoadLimits::default().pbx_bytes; + file.set_len(limit + 1).unwrap(); // Sparse file; no giant content allocation. + let error = DirectoryCartridgeLoader::load(dir.path()).unwrap_err(); + let CartridgeError::ProgramLoadFailed(error) = error else { + panic!("typed PBX admission failure expected") + }; + assert_eq!((error.requested, error.limit), (Some(limit + 1), Some(64 * 1_048_576))); + } + #[test] fn load_without_capabilities_defaults_to_none() { let dir = TestCartridgeDir::new(manifest_with_capabilities(None));