642d5a256791
wasm_reference_bytes.rs
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));
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.