A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
fix(sockets): require both send and receive for UDP connect (#15077)
Roman Volosatovs466daf157363
diff --git a/crates/test-programs/src/bin/p3_sockets_udp_send_race.rs b/crates/test-programs/src/bin/p3_sockets_udp_send_race.rsnew file mode 100644index 0000000000..6ec3e85267--- /dev/null+++ b/crates/test-programs/src/bin/p3_sockets_udp_send_race.rs@@ -0,0 +1,43 @@+use core::future::Future as _;+use core::pin::pin;+use core::task::{Context, Waker};++use test_programs::p3::wasi::sockets::types::{+ ErrorCode, IpAddress, IpAddressFamily, IpSocketAddress, UdpSocket,+};++struct Component;++test_programs::p3::export!(Component);++impl test_programs::p3::exports::wasi::cli::run::Guest for Component {+ async fn run() -> Result<(), ()> {+ let port = |name| std::env::var(name).unwrap().parse().unwrap();+ let loopback = IpAddress::new_loopback(IpAddressFamily::Ipv4);+ let allowed = IpSocketAddress::new(loopback, port("ALLOWED_PORT"));+ let forbidden = IpSocketAddress::new(loopback, port("FORBIDDEN_PORT"));++ let sock = UdpSocket::create(IpAddressFamily::Ipv4).unwrap();+ sock.connect(allowed).unwrap();++ let mut send = pin!(sock.send(b"x".to_vec(), None));+ let poll = send.as_mut().poll(&mut Context::from_waker(Waker::noop()));+ assert!(poll.is_pending());+ assert!(matches!(+ sock.connect(forbidden),+ Err(ErrorCode::AccessDenied)+ ));+ send.await.unwrap();++ sock.connect(allowed).unwrap();+ let mut send = pin!(sock.send(b"z".to_vec(), None));+ let poll = send.as_mut().poll(&mut Context::from_waker(Waker::noop()));+ assert!(poll.is_pending());+ sock.disconnect().unwrap();+ assert!(matches!(send.await, Err(ErrorCode::InvalidState)));++ Ok(())+ }+}++fn main() {}diff --git a/crates/wasi/src/sockets/udp.rs b/crates/wasi/src/sockets/udp.rsindex 9c236a3e66..db8ce32854 100644--- a/crates/wasi/src/sockets/udp.rs+++ b/crates/wasi/src/sockets/udp.rs@@ -127,17 +127,11 @@ impl UdpSocket {// On UDP sockets, "connecting" is just a local operation that sets the// default remote address for future sends and receives. It does not// actually do any I/O on its own. We'll allow the `connect` call- // if the address is permitted for sending or receiving.- if self- .permissions- .check(addr, SocketAddrUse::UdpSend)- .await- .is_err()- {- self.permissions- .check(addr, SocketAddrUse::UdpReceive)- .await?;- }+ // if the address is permitted for sending and receiving.+ self.permissions.check(addr, SocketAddrUse::UdpSend).await?;+ self.permissions+ .check(addr, SocketAddrUse::UdpReceive)+ .await?;}let result = connect(&self.socket, addr);diff --git a/crates/wasi/tests/all/p3/mod.rs b/crates/wasi/tests/all/p3/mod.rsindex 13b85ea516..97ba9510d0 100644--- a/crates/wasi/tests/all/p3/mod.rs+++ b/crates/wasi/tests/all/p3/mod.rs@@ -208,6 +208,44 @@ async fn p3_sockets_udp_send() -> wasmtime::Result<()> {run(P3_SOCKETS_UDP_SEND_COMPONENT).await}+#[test_log::test(tokio::test(flavor = "multi_thread"))]+async fn p3_sockets_udp_send_race() -> wasmtime::Result<()> {+ use std::io::ErrorKind;+ use std::net::{Ipv4Addr, UdpSocket};+ use tokio::task::yield_now;+ use wasmtime_wasi::sockets::SocketAddrUse;++ let allowed = UdpSocket::bind((Ipv4Addr::LOCALHOST, 0))?;+ let forbidden = UdpSocket::bind((Ipv4Addr::LOCALHOST, 0))?;+ let allowed_addr = allowed.local_addr()?;+ let forbidden_addr = forbidden.local_addr()?;++ run_with_builder(P3_SOCKETS_UDP_SEND_RACE_COMPONENT, false, |builder| {+ builder.socket_addr_check(move |addr, use_| {+ Box::pin(async move {+ yield_now().await;+ !matches!(use_, SocketAddrUse::UdpSend) || addr != forbidden_addr+ })+ });+ builder.env("ALLOWED_PORT", allowed_addr.port().to_string());+ builder.env("FORBIDDEN_PORT", forbidden_addr.port().to_string());+ })+ .await?;++ let mut buf = [0; 16];+ allowed.set_nonblocking(true)?;+ let n = allowed.recv(&mut buf)?;+ assert_eq!(&buf[..n], b"x");++ forbidden.set_nonblocking(true)?;+ assert!(+ matches!(forbidden.recv(&mut buf), Err(e) if e.kind() == ErrorKind::WouldBlock),+ "unexpected datagram delivered to the forbidden address"+ );++ Ok(())+}+#[test_log::test(tokio::test(flavor = "multi_thread"))]async fn p3_sockets_udp_sockopts() -> wasmtime::Result<()> {run(P3_SOCKETS_UDP_SOCKOPTS_COMPONENT).await