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.rsindex 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.wastnew file mode 100644index 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))