An unnamed factory ship game: getrandom in WASM based scripts

[alec-deason]

I've been experimenting with using Rust based WASM modules as scripts in my game. One of the frustrations with that is the lack of getrandom and thus rand in the WASM guest environment. In WASM on the web or as a WASI executable there are existing tools to solve that problem but hosting directly in rust is a bit more raw. Turns out it's not that hard to do.

I'm just talking about the getrandom issue here. If my WASM scripting continues to work out well I'll likely write more about how I'm setting the over all system up.

I'm using wasmer as my runtime. On the host side you'll need to write a shim that calls the host's version of getrandom and then pass that into the WASM module when it's initialized. Then on the guest side you have to configure getrandom to call the external shim.

Host setup

First you need to setup some context objects that will be used by the shim function:

let store = Store::default();
#[derive(WasmerEnv, Clone, Default)]
pub struct Env {
    #[wasmer(export)]
    memory: LazyInit<Memory>,
}

The interesting bit here is Env.memory which will be initialized by the runtime with a reference to the guest's main memory. We need that because we're going to need to resolve pointers into that memory inside the shim:

// ptr and len represent a slice object on the guest side into which need to write the random bits
fn __get_random(env: &Env, ptr: i32, len: i32) {
    if let Some(memory) = env.memory_ref() {
        // retrieve a MemoryView (basically a Vec<Cell<u8>>) of the guest's memory
        let view: MemoryView<u8> = memory.view();

        let mut buff: Vec<u8> = vec![0; len as usize];
        // Actually get the randomness from the host's getrandom
        getrandom::getrandom(&mut buff).unwrap();

        // and write it into guest memory
        for (dst, src) in view[ptr as usize..ptr as usize + len as usize].iter().zip(buff) {
            dst.set(src);
        }
    }
}

Once we have that shim we setup the import object that will inject it into the guest and then initialize the guest module itself:

let import_object = imports! {
    "env" => { "__get_random" => Function::new_native_with_env(&store, Env::default(), __get_random), },
};
let module = Module::new(&store, wasm_src).unwrap();

let mut instance =
    Instance::new(&module, &import_object).unwrap();

And that's it on the host side. Now the guest has access to the host's getrandom.

Guest setup

Switching to the crate that will be our WASM guest. First off it needs to have it's getrandom dependency declared with the "custom" feature which allows us to delegate to the shim function injected by the host. Then we just wire up the shim:

use getrandom::register_custom_getrandom;

use getrandom::Error;

extern {
    // the function injected by the host
    fn __get_random(ptr: i32, len: i32);
}

fn external_getrandom(buf: &mut [u8]) -> Result<(), Error> {
    let len = buf.len();
    let ptr = buf.as_ptr();
    unsafe { __get_random(ptr as i32, len as i32); }
    Ok(())
}
register_custom_getrandom!(external_getrandom);

There's not much going on there except that we convert the slice which getrandom gives us into a ptr and a length which we can pass across the guest->host boundary.

And hopefully that saves someone an afternoon of fussing with this stuff.