mirror of
https://github.com/storytold/craft-anything.git
synced 2026-11-19 14:00:52 +01:00
The input loaders trust an earlier file-size report before reading to EOF. A regular virtual file can report zero bytes and still return data beyond the configured limit, and files can grow between the size check and read. Some loaders accept devices or pipes, allowing a text or evidence-bundle request to wait indefinitely for a writer. Prefix reads also use metadata size to decide whether to assign a whole-file hash, so a truncated prefix of a zero-size-reporting file is misidentified as the whole input.
140 lines
6.2 KiB
Rust
140 lines
6.2 KiB
Rust
use craft_anything_engine::Target;
|
|
use craft_anything_engine::evidence::ErrorCode;
|
|
use craft_anything_engine::tools::static_input;
|
|
#[cfg(unix)]
|
|
use craft_anything_engine::{Caller, CancelToken, Ctx};
|
|
|
|
#[cfg(target_os = "linux")]
|
|
#[test]
|
|
fn text_tool_refuses_a_pipe_without_waiting_for_its_writer() {
|
|
use craft_anything_engine::{CallOptions, Engine};
|
|
use std::os::fd::AsRawFd;
|
|
use std::sync::mpsc;
|
|
use std::time::Duration;
|
|
|
|
let (reader, writer) = std::io::pipe().unwrap();
|
|
let path = format!("/proc/self/fd/{}", reader.as_raw_fd());
|
|
let (sender, receiver) = mpsc::channel();
|
|
let worker = std::thread::spawn(move || {
|
|
let engine = Engine::new(craft_anything_engine::testing::session());
|
|
let result = engine.call("core_text_read", serde_json::json!({"path": path}), CallOptions::new(Caller::Cli));
|
|
drop(reader);
|
|
sender.send(result).ok();
|
|
});
|
|
let immediate = receiver.recv_timeout(Duration::from_secs(1));
|
|
// Release a baseline read waiting for EOF before checking the bounded response.
|
|
drop(writer);
|
|
if immediate.is_err() {
|
|
let _ = receiver.recv_timeout(Duration::from_secs(1));
|
|
}
|
|
if worker.is_finished() {
|
|
worker.join().unwrap();
|
|
}
|
|
let result = immediate.expect("reading a pipe waited for its writer instead of rejecting it");
|
|
assert_eq!(result.unwrap_err().code, ErrorCode::BadInput);
|
|
}
|
|
|
|
#[cfg(target_os = "linux")]
|
|
#[test]
|
|
fn load_path_checks_actual_bytes_when_metadata_reports_zero() {
|
|
let path = "/proc/self/stat";
|
|
assert_eq!(std::fs::metadata(path).unwrap().len(), 0);
|
|
let result = static_input::load_path(path, 1);
|
|
assert!(result.is_err(), "a one-byte cap accepted {} bytes", result.as_ref().map_or(0, |input| input.bytes.len()));
|
|
assert_eq!(result.unwrap_err().code, ErrorCode::OverLimit);
|
|
}
|
|
|
|
#[cfg(target_os = "linux")]
|
|
#[test]
|
|
fn prefix_reader_checks_eof_before_hashing_zero_size_metadata() {
|
|
let mut session = craft_anything_engine::testing::session();
|
|
let ctx = Ctx { tool: "test", session: &mut session, cancel: CancelToken::default(), progress: &|_| {}, caller: Caller::Cli };
|
|
for cap in [1, 0] {
|
|
let prefix = static_input::load_prefix(&ctx, Some("/proc/self/stat"), cap).unwrap();
|
|
assert_eq!(prefix.bytes.len(), cap as usize);
|
|
assert_eq!(prefix.file_size, 0, "keep the metadata size rather than guessing a full length");
|
|
assert!(!prefix.whole, "a bounded prefix was reported as the whole virtual file");
|
|
assert!(prefix.subject.sha256.is_none(), "a prefix hash must not identify the whole file");
|
|
}
|
|
let whole = static_input::load_prefix(&ctx, Some("/proc/self/stat"), 16 * 1024).unwrap();
|
|
assert!(!whole.bytes.is_empty());
|
|
assert!(whole.whole);
|
|
assert_eq!(whole.subject.sha256, Some(craft_anything_engine::evidence::sha256_hex(&whole.bytes)));
|
|
}
|
|
|
|
#[cfg(target_os = "linux")]
|
|
#[test]
|
|
fn archive_input_checks_actual_bytes_when_metadata_reports_zero() {
|
|
use craft_anything_engine::{CallOptions, Engine};
|
|
let engine = Engine::new(craft_anything_engine::testing::session());
|
|
let result = engine.call("core_archive_show", serde_json::json!({"path": "/proc/self/stat", "max_total_bytes": 1}), CallOptions::new(Caller::Cli));
|
|
assert!(result.is_err(), "archive input read beyond its one-byte cap");
|
|
assert_eq!(result.unwrap_err().code, ErrorCode::OverLimit);
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
#[test]
|
|
fn load_path_refuses_a_non_regular_file() {
|
|
let result = static_input::load_path("/dev/null", 16);
|
|
assert!(result.is_err(), "a character device was accepted as a file");
|
|
assert_eq!(result.unwrap_err().code, ErrorCode::BadInput);
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
#[test]
|
|
fn prefix_reader_refuses_a_non_regular_file() {
|
|
let mut session = craft_anything_engine::testing::session();
|
|
let ctx = Ctx { tool: "test", session: &mut session, cancel: CancelToken::default(), progress: &|_| {}, caller: Caller::Cli };
|
|
let result = static_input::load_prefix(&ctx, Some("/dev/null"), 16);
|
|
assert!(result.is_err(), "a character device was accepted as a prefix input");
|
|
assert_eq!(result.unwrap_err().code, ErrorCode::BadInput);
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
#[test]
|
|
fn targets_refuse_a_non_regular_file() {
|
|
let result = Target::load(std::path::Path::new("/dev/null"));
|
|
assert!(result.is_err(), "a character device was accepted as a target");
|
|
assert_eq!(result.unwrap_err().code, ErrorCode::BadInput);
|
|
}
|
|
|
|
#[test]
|
|
fn ordinary_files_keep_exact_cap_and_empty_input_support() {
|
|
let directory = craft_anything_engine::testing::temp_dir();
|
|
let path = directory.join("input.bin");
|
|
std::fs::write(&path, b"four").unwrap();
|
|
let path = path.to_str().unwrap();
|
|
assert_eq!(&*static_input::load_path(path, 4).unwrap().bytes, b"four");
|
|
assert_eq!(&*static_input::load_path(path, u64::MAX).unwrap().bytes, b"four");
|
|
assert_eq!(static_input::load_path(path, 3).unwrap_err().code, ErrorCode::OverLimit);
|
|
std::fs::write(path, b"").unwrap();
|
|
assert!(static_input::load_path(path, 0).unwrap().bytes.is_empty());
|
|
assert!(Target::load(&directory).unwrap().bytes.is_empty());
|
|
std::fs::remove_dir_all(directory).unwrap();
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
#[test]
|
|
fn regular_file_symlinks_and_prefix_reads_keep_working() {
|
|
let directory = craft_anything_engine::testing::temp_dir();
|
|
let path = directory.join("file.bin");
|
|
let link = directory.join("link.bin");
|
|
std::fs::write(&path, b"hello").unwrap();
|
|
std::os::unix::fs::symlink(&path, &link).unwrap();
|
|
let link_name = link.to_str().unwrap();
|
|
assert_eq!(&*static_input::load_path(link_name, 5).unwrap().bytes, b"hello");
|
|
assert_eq!(&*Target::load(&link).unwrap().bytes, b"hello");
|
|
let mut session = craft_anything_engine::testing::session();
|
|
let ctx = Ctx { tool: "test", session: &mut session, cancel: CancelToken::default(), progress: &|_| {}, caller: Caller::Cli };
|
|
let prefix = static_input::load_prefix(&ctx, Some(link_name), 3).unwrap();
|
|
assert_eq!(prefix.bytes, b"hel");
|
|
assert_eq!(prefix.file_size, 5);
|
|
assert!(!prefix.whole);
|
|
assert!(prefix.subject.sha256.is_none());
|
|
let whole = static_input::load_prefix(&ctx, Some(link_name), 5).unwrap();
|
|
assert_eq!(whole.bytes, b"hello");
|
|
assert!(whole.whole);
|
|
assert!(whole.subject.sha256.is_some());
|
|
std::fs::remove_dir_all(directory).unwrap();
|
|
}
|