8384f3a347
* Bring back `Module::deserialize` I thought I was being clever suggesting that `Module::deserialize` was removed from #2791 by funneling all module constructors into `Module::new`. As our studious fuzzers have found, though, this means that `Module::new` is not safe currently to pass arbitrary user-defined input into. Now one might pretty reasonable expect to be able to do that, however, being a WebAssembly engine and all. This PR as a result separates the `deserialize` part of `Module::new` back into `Module::deserialize`. This means that binary blobs created with `Module::serialize` and `Engine::precompile_module` will need to be passed to `Module::deserialize` to "rehydrate" them back into a `Module`. This restores the property that it should be safe to pass arbitrary input to `Module::new` since it's always expected to be a wasm module. This also means that fuzzing will no longer attempt to fuzz `Module::deserialize` which isn't something we want to do anyway. * Fix an example * Mark `Module::deserialize` as `unsafe`
62 lines
1.8 KiB
Rust
62 lines
1.8 KiB
Rust
use anyhow::{bail, Result};
|
|
use wasmtime::*;
|
|
|
|
fn serialize(engine: &Engine, wat: &'static str) -> Result<Vec<u8>> {
|
|
let module = Module::new(&engine, wat)?;
|
|
Ok(module.serialize()?)
|
|
}
|
|
|
|
unsafe fn deserialize_and_instantiate(store: &Store, buffer: &[u8]) -> Result<Instance> {
|
|
let module = Module::deserialize(store.engine(), buffer)?;
|
|
Ok(Instance::new(&store, &module, &[])?)
|
|
}
|
|
|
|
#[test]
|
|
fn test_version_mismatch() -> Result<()> {
|
|
let engine = Engine::default();
|
|
let mut buffer = serialize(&engine, "(module)")?;
|
|
buffer[13 /* header length */ + 1 /* version length */] = 'x' as u8;
|
|
|
|
match unsafe { Module::deserialize(&engine, &buffer) } {
|
|
Ok(_) => bail!("expected deserialization to fail"),
|
|
Err(e) => assert!(e
|
|
.to_string()
|
|
.starts_with("Module was compiled with incompatible Wasmtime version")),
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn test_module_serialize_simple() -> Result<()> {
|
|
let buffer = serialize(
|
|
&Engine::default(),
|
|
"(module (func (export \"run\") (result i32) i32.const 42))",
|
|
)?;
|
|
|
|
let store = Store::default();
|
|
let instance = unsafe { deserialize_and_instantiate(&store, &buffer)? };
|
|
let run = instance.get_typed_func::<(), i32>("run")?;
|
|
let result = run.call(())?;
|
|
|
|
assert_eq!(42, result);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn test_module_serialize_fail() -> Result<()> {
|
|
let buffer = serialize(
|
|
&Engine::default(),
|
|
"(module (func (export \"run\") (result i32) i32.const 42))",
|
|
)?;
|
|
|
|
let mut config = Config::new();
|
|
config.cranelift_opt_level(OptLevel::None);
|
|
let store = Store::new(&Engine::new(&config)?);
|
|
match unsafe { deserialize_and_instantiate(&store, &buffer) } {
|
|
Ok(_) => bail!("expected failure at deserialization"),
|
|
Err(_) => (),
|
|
}
|
|
Ok(())
|
|
}
|