mirror of
https://github.com/storytold/craft-anything.git
synced 2026-11-19 05:50:53 +01:00
The metadata entry limit didn't bound the text that references produce: a valid 401 KB module with one 1,000-parameter type and 100,000 functions kept 500 MB of repeated signatures, and re-exporting one long function name copied it into every export. Each referenced type signature is now formatted once and cached, and the cache and every kept copy of a signature or name draw on one budget (64 MiB, or three times the input if larger) that is checked before copying. Metadata left out marks the report truncated with a warning. Function and tag index counting carries on past the display limit, so leaving rows out can't shift later indices or report a false declaration-body mismatch.
152 lines
5.9 KiB
Rust
152 lines
5.9 KiB
Rust
use craft_anything_formats::wasm::{WasmReport, inspect};
|
|
|
|
fn leb(mut value: usize) -> Vec<u8> {
|
|
let mut out = Vec::new();
|
|
while value >= 128 {
|
|
out.push((value as u8 & 0x7f) | 0x80);
|
|
value >>= 7;
|
|
}
|
|
out.push(value as u8);
|
|
out
|
|
}
|
|
|
|
fn string(out: &mut Vec<u8>, value: &str) {
|
|
out.extend(leb(value.len()));
|
|
out.extend(value.as_bytes());
|
|
}
|
|
|
|
fn section(module: &mut Vec<u8>, id: u8, body: &[u8]) {
|
|
module.push(id);
|
|
module.extend(leb(body.len()));
|
|
module.extend(body);
|
|
}
|
|
|
|
fn shared_type(functions: usize, imports: usize, imported_tags: usize, defined_tags: usize, params: usize) -> Vec<u8> {
|
|
let mut module = b"\0asm\x01\0\0\0".to_vec();
|
|
let mut ty = vec![1, 0x60];
|
|
ty.extend(leb(params));
|
|
ty.extend(std::iter::repeat_n(0x7f, params));
|
|
ty.push(0);
|
|
section(&mut module, 1, &ty);
|
|
if imports + imported_tags > 0 {
|
|
let mut body = leb(imports + imported_tags);
|
|
for i in 0..imports + imported_tags {
|
|
string(&mut body, "env");
|
|
string(&mut body, "item");
|
|
if i < imports {
|
|
body.extend([0, 0]);
|
|
} else {
|
|
body.extend([4, 0, 0]);
|
|
}
|
|
}
|
|
section(&mut module, 2, &body);
|
|
}
|
|
if functions > 0 {
|
|
let mut body = leb(functions);
|
|
body.extend(std::iter::repeat_n(0, functions));
|
|
section(&mut module, 3, &body);
|
|
}
|
|
if defined_tags > 0 {
|
|
let mut body = leb(defined_tags);
|
|
for _ in 0..defined_tags {
|
|
body.extend([0, 0]);
|
|
}
|
|
section(&mut module, 13, &body);
|
|
}
|
|
if functions > 0 {
|
|
let mut body = leb(functions);
|
|
for _ in 0..functions {
|
|
body.extend([2, 0, 0x0b]);
|
|
}
|
|
section(&mut module, 10, &body);
|
|
}
|
|
module
|
|
}
|
|
|
|
fn derived_bytes(report: &WasmReport) -> usize {
|
|
report.imports.iter().map(|item| item.signature.len()).sum::<usize>()
|
|
+ report.tags.iter().map(|item| item.signature.len()).sum::<usize>()
|
|
+ report.functions.iter().map(|item| item.signature.len() + item.name.as_ref().map_or(0, String::len)).sum::<usize>()
|
|
+ report.exports.iter().map(|item| item.target_name.as_ref().map_or(0, String::len)).sum::<usize>()
|
|
}
|
|
|
|
fn bounded(module: &[u8]) -> WasmReport {
|
|
assert!(module.len() < 1 << 20);
|
|
let report = inspect(module).unwrap();
|
|
assert!(report.parse_error.is_none());
|
|
assert!(derived_bytes(&report) <= 64 << 20, "{} input bytes retain {} derived string bytes", module.len(), derived_bytes(&report));
|
|
assert!(report.truncated);
|
|
assert!(report.warnings.iter().any(|warning| warning.contains("byte budget")), "{:?}", report.warnings);
|
|
report
|
|
}
|
|
|
|
#[test]
|
|
fn repeated_function_signatures_have_a_byte_budget() {
|
|
let report = bounded(&shared_type(16_384, 0, 0, 0, 1000));
|
|
assert!(report.validation.valid, "{:?}", report.validation);
|
|
assert!(!report.functions.is_empty());
|
|
assert!(report.functions.len() < 16_384);
|
|
assert!(report.functions.iter().enumerate().all(|(index, function)| function.index as usize == index && function.signature.starts_with("(i32, i32")));
|
|
assert!(!report.warnings.iter().any(|warning| warning.contains("function declarations")));
|
|
}
|
|
|
|
#[test]
|
|
fn repeated_import_signatures_stay_bounded_even_when_validation_fails() {
|
|
let report = bounded(&shared_type(0, 16_384, 0, 0, 1000));
|
|
assert!(!report.validation.valid);
|
|
assert!(report.validation.error.as_deref().unwrap().contains("effective type size"));
|
|
assert_eq!(report.imported_functions, 16_384);
|
|
assert!(!report.imports.is_empty());
|
|
assert!(report.imports.len() < 16_384);
|
|
}
|
|
|
|
#[test]
|
|
fn imported_and_defined_tags_share_the_same_budget_as_functions() {
|
|
for (functions, imports, imported_tags, defined_tags) in [(0, 0, 8192, 0), (0, 0, 0, 16_384), (4096, 4096, 4096, 4096)] {
|
|
let report = bounded(&shared_type(functions, imports, imported_tags, defined_tags, 1000));
|
|
assert_eq!(report.imported_functions as usize, imports);
|
|
assert!(report.tags.len() < imported_tags + defined_tags);
|
|
assert!(report.tags.iter().all(|tag| tag.signature.starts_with("(i32, i32")));
|
|
assert!(report.tags.iter().filter(|tag| !tag.imported).all(|tag| tag.index as usize >= imported_tags));
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn exported_function_names_cannot_multiply_a_small_name_section() {
|
|
let mut module = shared_type(0, 1, 0, 0, 0);
|
|
let name = "λ".repeat(32_768);
|
|
let mut exports = leb(1280);
|
|
for index in 0..1280 {
|
|
string(&mut exports, &format!("export_{index}"));
|
|
exports.extend([0, 0]);
|
|
}
|
|
section(&mut module, 7, &exports);
|
|
let mut map = vec![1, 0];
|
|
string(&mut map, &name);
|
|
let mut names = vec![4, b'n', b'a', b'm', b'e', 1];
|
|
names.extend(leb(map.len()));
|
|
names.extend(map);
|
|
section(&mut module, 0, &names);
|
|
let report = bounded(&module);
|
|
assert!(report.validation.valid, "{:?}", report.validation);
|
|
assert_eq!(report.exports.len(), 1280);
|
|
assert!(report.exports.iter().any(|export| export.target_name.is_none()));
|
|
assert!(report.exports.iter().filter_map(|export| export.target_name.as_deref()).all(|value| value == name));
|
|
}
|
|
|
|
#[test]
|
|
fn ordinary_shared_signatures_and_names_remain_complete() {
|
|
let report = inspect(&shared_type(2, 2, 2, 2, 3)).unwrap();
|
|
assert!(report.validation.valid, "{:?}", report.validation);
|
|
assert!(!report.truncated, "{:?}", report.warnings);
|
|
assert_eq!(report.imported_functions, 2);
|
|
assert_eq!(report.functions.len(), 2);
|
|
assert_eq!(report.tags.len(), 4);
|
|
assert!(report.imports.iter().all(|item| item.signature == "(i32, i32, i32) -> ()"));
|
|
assert!(report.tags.iter().all(|tag| tag.signature == "(i32, i32, i32) -> ()"));
|
|
assert_eq!(report.functions.iter().map(|function| function.index).collect::<Vec<_>>(), [2, 3]);
|
|
assert_eq!(report.tags.iter().map(|tag| tag.index).collect::<Vec<_>>(), [0, 1, 2, 3]);
|
|
assert!(report.tags[..2].iter().all(|tag| tag.imported));
|
|
assert!(report.tags[2..].iter().all(|tag| !tag.imported));
|
|
}
|