Skip to content

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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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