Skip to content

A lightweight WebAssembly runtime that is fast, secure, and standards-compliant

More eagerly validate future/stream pointer alignment (#14639)

Alex Crichton9ad225144fc9
diff --git a/crates/wasmtime/src/runtime/component/concurrent/futures_and_streams.rs b/crates/wasmtime/src/runtime/component/concurrent/futures_and_streams.rs
index faed6fea09..7ced6850e0 100644
--- a/crates/wasmtime/src/runtime/component/concurrent/futures_and_streams.rs
+++ b/crates/wasmtime/src/runtime/component/concurrent/futures_and_streams.rs
@@ -3515,27 +3515,29 @@ impl Instance {
count: usize,
) -> Result<()> {
let types = self.id().get(store).component().types();
- let size = usize::try_from(
- match ty {
- TransmitIndex::Future(ty) => types[types[ty].ty]
- .payload
- .map(|ty| types.canonical_abi(&ty).size32),
- TransmitIndex::Stream(ty) => types[types[ty].ty]
- .payload
- .map(|ty| types.canonical_abi(&ty).size32),
- }
- .unwrap_or(0),
- )?;
-
- if count > 0 && size > 0 {
- self.options_memory(store, options)
- .get(address..)
- .and_then(|b| b.get(..size.checked_mul(count)?))
- .map(drop)
- .ok_or_else(|| crate::format_err!("read pointer out of bounds of memory"))
- } else {
- Ok(())
+ let payload = match ty {
+ TransmitIndex::Future(ty) => types[types[ty].ty].payload,
+ TransmitIndex::Stream(ty) => types[types[ty].ty].payload,
+ };
+ let Some(payload) = payload else {
+ return Ok(());
+ };
+ // As-written the spec currently exempts zero-length reads/writes from
+ // bounds/alignment checks.
+ if count == 0 {
+ return Ok(());
+ }
+ let abi = types.canonical_abi(&payload);
+ let size = usize::try_from(abi.size32)?;
+ let align = usize::try_from(abi.align32)?;
+ if address % align != 0 {
+ bail!("buffer pointer not aligned");
}
+ self.options_memory(store, options)
+ .get(address..)
+ .and_then(|b| b.get(..size.checked_mul(count)?))
+ .map(drop)
+ .ok_or_else(|| crate::format_err!("buffer pointer out of bounds of memory"))
}
/// Write to the specified stream or future from the guest.
diff --git a/tests/misc_testsuite/component-model/async/misaligned-buffer.wast b/tests/misc_testsuite/component-model/async/misaligned-buffer.wast
new file mode 100644
index 0000000000..c6268217ea
--- /dev/null
+++ b/tests/misc_testsuite/component-model/async/misaligned-buffer.wast
@@ -0,0 +1,102 @@
+;;! component_model_async = true
+
+;; Buffer pointers are validated at the time a `{stream,future}.{read,write}`
+;; is issued regardless of the state of the other end of the stream or future.
+(component definition $C
+ (core module $libc (memory (export "mem") 1))
+ (core instance $libc (instantiate $libc))
+ (type $ST (stream u32))
+ (type $FT (future u32))
+ (core func $stream.new (canon stream.new $ST))
+ (core func $stream.read
+ (canon stream.read $ST async (memory (core memory $libc "mem"))))
+ (core func $stream.write
+ (canon stream.write $ST async (memory (core memory $libc "mem"))))
+ (core func $stream.drop-readable (canon stream.drop-readable $ST))
+ (core func $future.new (canon future.new $FT))
+ (core func $future.read
+ (canon future.read $FT async (memory (core memory $libc "mem"))))
+ (core func $future.write
+ (canon future.write $FT async (memory (core memory $libc "mem"))))
+ (core module $M
+ (import "" "stream.new" (func $stream.new (result i64)))
+ (import "" "stream.read" (func $stream.read (param i32 i32 i32) (result i32)))
+ (import "" "stream.write" (func $stream.write (param i32 i32 i32) (result i32)))
+ (import "" "stream.drop-readable" (func $stream.drop-readable (param i32)))
+ (import "" "future.new" (func $future.new (result i64)))
+ (import "" "future.read" (func $future.read (param i32 i32) (result i32)))
+ (import "" "future.write" (func $future.write (param i32 i32) (result i32)))
+
+ ;; Reads `n` items to `p` from a new stream with no writer.
+ (func (export "stream-read") (param $p i32) (param $n i32) (result i32)
+ (call $stream.read (i32.wrap_i64 (call $stream.new))
+ (local.get $p) (local.get $n)))
+
+ ;; Writes `n` items from `p` to a new stream with no reader.
+ (func (export "stream-write") (param $p i32) (param $n i32) (result i32)
+ (call $stream.write
+ (i32.wrap_i64 (i64.shr_u (call $stream.new) (i64.const 32)))
+ (local.get $p) (local.get $n)))
+
+ ;; Writes `n` items from `p` to a new stream whose readable end has been
+ ;; dropped.
+ (func (export "stream-write-dropped") (param $p i32) (param $n i32)
+ (result i32)
+ (local $rw i64)
+ (local.set $rw (call $stream.new))
+ (call $stream.drop-readable (i32.wrap_i64 (local.get $rw)))
+ (call $stream.write
+ (i32.wrap_i64 (i64.shr_u (local.get $rw) (i64.const 32)))
+ (local.get $p) (local.get $n)))
+
+ ;; Reads to `p` from a new future with no writer.
+ (func (export "future-read") (param $p i32) (result i32)
+ (call $future.read (i32.wrap_i64 (call $future.new)) (local.get $p)))
+
+ ;; Writes from `p` to a new future with no reader.
+ (func (export "future-write") (param $p i32) (result i32)
+ (call $future.write
+ (i32.wrap_i64 (i64.shr_u (call $future.new) (i64.const 32)))
+ (local.get $p)))
+ )
+ (core instance $m (instantiate $M (with "" (instance
+ (export "stream.new" (func $stream.new))
+ (export "stream.read" (func $stream.read))
+ (export "stream.write" (func $stream.write))
+ (export "stream.drop-readable" (func $stream.drop-readable))
+ (export "future.new" (func $future.new))
+ (export "future.read" (func $future.read))
+ (export "future.write" (func $future.write))))))
+ (func (export "stream-read") (param "p" u32) (param "n" u32) (result u32)
+ (canon lift (core func $m "stream-read")))
+ (func (export "stream-write") (param "p" u32) (param "n" u32) (result u32)
+ (canon lift (core func $m "stream-write")))
+ (func (export "stream-write-dropped") (param "p" u32) (param "n" u32)
+ (result u32)
+ (canon lift (core func $m "stream-write-dropped")))
+ (func (export "future-read") (param "p" u32) (result u32)
+ (canon lift (core func $m "future-read")))
+ (func (export "future-write") (param "p" u32) (result u32)
+ (canon lift (core func $m "future-write")))
+)
+
+;; Misaligned: trap immediately, whether the operation would otherwise block or
+;; report that the other end was dropped.
+(component instance $i1 $C)
+(assert_trap (invoke "stream-read" (u32.const 1) (u32.const 1)) "pointer not aligned")
+(component instance $i2 $C)
+(assert_trap (invoke "stream-write" (u32.const 1) (u32.const 1)) "pointer not aligned")
+(component instance $i3 $C)
+(assert_trap (invoke "stream-write-dropped" (u32.const 1) (u32.const 1)) "pointer not aligned")
+(component instance $i4 $C)
+(assert_trap (invoke "future-read" (u32.const 1)) "pointer not aligned")
+(component instance $i5 $C)
+(assert_trap (invoke "future-write" (u32.const 1)) "pointer not aligned")
+
+;; Aligned: the operation blocks, or reports DROPPED.
+(component instance $i6 $C)
+(assert_return (invoke "stream-read" (u32.const 4) (u32.const 1)) (u32.const 0xffffffff))
+(assert_return (invoke "stream-write" (u32.const 4) (u32.const 1)) (u32.const 0xffffffff))
+(assert_return (invoke "stream-write-dropped" (u32.const 4) (u32.const 1)) (u32.const 1))
+(assert_return (invoke "future-read" (u32.const 4)) (u32.const 0xffffffff))
+(assert_return (invoke "future-write" (u32.const 4)) (u32.const 0xffffffff))