在Rust中通过Wasmer向WASM模块传递字节数组时触发HeapAccessOutOfBounds错误，如何解决？

嘿，这个问题我之前也碰到过！核心原因是你搞错了WASM的内存模型——WASM运行在沙箱环境里，有自己独立的线性内存空间，根本访问不到宿主进程里的内存指针，直接传宿主的指针当然会触发越界错误啦。

问题本质拆解 #

你原代码里直接把宿主byte_array.as_ptr()传给WASM函数，这个指针是宿主进程的虚拟内存地址，WASM实例的沙箱完全看不到这块内存，当WASM尝试通过这个指针读取数据时，自然会触发HeapAccessOutOfBounds错误。

正确的做法是：宿主和WASM之间的数据必须通过WASM实例导出的线性内存来传递，步骤如下：

解决方案步骤 #

1. 从WASM实例中获取导出的内存对象

WASM模块默认会导出名为memory的线性内存（除非你手动配置不导出），我们需要先拿到这个内存对象，才能在宿主侧操作WASM的内存空间。

2. 确保WASM内存有足够空间存放数据

WASM内存以“页”为单位（每页64KB），我们需要检查当前内存是否能容纳要传递的字节数组，如果不够就扩容。

3. 将宿主的字节数组复制到WASM内存中

通过Wasmer提供的MemoryView，我们可以把宿主的数据写入到WASM内存的指定偏移位置。

4. 调用WASM函数时传递WASM内存内的偏移量（而非宿主指针）

现在WASM函数读取的是自己内存里的数据，就能正常访问了。

修改后的完整宿主代码 #

pub mod get_tx_data;

use wasmer::{imports, Cranelift, Instance, Module, Store, Value, Memory};
use std::mem;

fn main() {
    // 读取WASM文件
    let wasm_bytes = include_bytes!("banana_swap.wasm");

    // 创建带Cranelift编译器的Store
    let compiler = Cranelift::default();
    let mut store = Store::new(compiler);

    // 编译WASM模块
    let module = Module::new(&store, wasm_bytes).unwrap();

    // 创建空的导入对象（这里不需要宿主函数导入）
    let import_object = imports! {};

    let instance = Instance::new(&mut store, &module, &import_object).unwrap();
    
    // 获取WASM导出的内存和函数
    let memory = instance.exports.get_memory("memory").unwrap();
    let process_bytes = instance.exports.get_function("process_bytes").unwrap();

    // 示例字节数组
    let byte_array: Vec<u8> = vec![0x48, 0x65, 0x6C, 0x6C, 0x6F];
    let len = byte_array.len();

    // 计算需要的内存页数，确保WASM内存足够
    let required_pages = (len + 65535) / 65536; // 每页64KB
    let current_pages = memory.size(&store);
    if current_pages < required_pages {
        memory.grow(&mut store, required_pages - current_pages).unwrap();
    }

    // 获取WASM内存的视图，方便读写
    let mut view = memory.view(&mut store);

    // 选择WASM内存中的起始偏移量（示例用0，实际场景建议用WASM内部分配的内存）
    let offset = 0u32;

    // 将宿主的字节数组复制到WASM内存中
    view.write(offset, &byte_array).unwrap();

    // 调用WASM函数：传递WASM内存内的偏移量和数组长度
    let result = process_bytes.call(&mut store, &[
        Value::I32(offset as i32),
        Value::I32(len as i32)
    ]).unwrap();

    // 打印结果
    println!("Result: {:?}", result);
}

进阶优化：使用WASM内部的内存分配器 #

上面的示例用了偏移量0，在简单场景下没问题，但如果WASM模块还有其他内存操作，容易出现冲突。更规范的做法是在WASM模块里实现内存分配器，导出alloc和free函数，让宿主调用这些函数来申请/释放内存：

首先给WASM模块添加依赖和代码

在WASM项目的Cargo.toml里添加：

[dependencies]
wee_alloc = "0.4.5"

然后修改WASM的代码：

use wee_alloc::WeeAlloc;

// 设置WASM的全局内存分配器
#[global_allocator]
static ALLOC: WeeAlloc = WeeAlloc::INIT;

#[no_mangle]
pub extern "C" fn alloc(size: usize) -> *mut u8 {
    let mut buf = Vec::with_capacity(size);
    let ptr = buf.as_mut_ptr();
    mem::forget(buf); // 让内存不被自动释放
    ptr
}

#[no_mangle]
pub extern "C" fn free(ptr: *mut u8, size: usize) {
    unsafe {
        // 重新构造Vec并自动释放内存
        Vec::from_raw_parts(ptr, 0, size);
    }
}

#[no_mangle]
pub extern "C" fn process_bytes(ptr: *const u8, len: usize) -> u8 {
    if len > 0 {
        let bytes = unsafe { std::slice::from_raw_parts(ptr, len) };
        bytes[0]
    } else {
        0
    }
}

然后修改宿主代码，调用WASM的alloc和free

// ... 前面的代码不变 ...

// 获取WASM导出的alloc和free函数
let alloc = instance.exports.get_function("alloc").unwrap();
let free = instance.exports.get_function("free").unwrap();

// 调用alloc申请内存，得到WASM内存内的偏移量
let alloc_result = alloc.call(&mut store, &[Value::I32(len as i32)]).unwrap();
let offset = match alloc_result {
    Value::I32(val) => val as u32,
    _ => panic!("alloc returned unexpected value"),
};

// 复制数据到WASM内存
view.write(offset, &byte_array).unwrap();

// 调用process_bytes函数
let result = process_bytes.call(&mut store, &[
    Value::I32(offset as i32),
    Value::I32(len as i32)
]).unwrap();

// 调用free释放内存
free.call(&mut store, &[Value::I32(offset as i32), Value::I32(len as i32)]).unwrap();

// ... 后面的代码不变 ...

这样就实现了安全的内存管理，避免内存泄漏和地址冲突。

备注：内容来源于stack exchange，提问作者user23844397