session_socket.rs (11381B)
1 //! One upstream protocol session over caller-selected byte I/O. 2 3 use crate::{RelayEndpoint, RelayUrl, RelayUrlPolicy, relay::policy_error}; 4 use async_wsocket::Message; 5 use futures::{Sink, future::BoxFuture, stream}; 6 use nostr_sdk::{ 7 error::Error as TransportError, 8 transport::websocket::{WebSocketSink, WebSocketStream, WebSocketTransport}, 9 }; 10 use radroots_transport::host::websocket::{ 11 Admission, Connector, Error as HostError, Frame, Socket, 12 }; 13 use std::{ 14 collections::BTreeMap, 15 fmt, 16 net::{IpAddr, SocketAddr}, 17 num::NonZeroUsize, 18 pin::Pin, 19 sync::Arc, 20 task::{Context, Poll}, 21 time::Duration, 22 }; 23 use url::Url; 24 25 pub(crate) const MAX_WIRE_MESSAGE_BYTES: usize = 512 * 1024; 26 27 #[derive(Clone, Debug)] 28 pub(crate) struct SessionWebsocketTransport { 29 host: Arc<dyn Connector>, 30 policies: Arc<BTreeMap<String, RelayUrlPolicy>>, 31 connect_timeout: Duration, 32 pub(crate) writers: crate::socket_write::WriterRegistry, 33 pub(crate) ingress: crate::source_ingress::IngressRegistry, 34 } 35 36 impl SessionWebsocketTransport { 37 pub(crate) fn new( 38 endpoints: &[RelayEndpoint], 39 connect_timeout: Duration, 40 host: Arc<dyn Connector>, 41 ) -> Self { 42 Self { 43 host, 44 connect_timeout, 45 ingress: crate::source_ingress::IngressRegistry::new( 46 endpoints 47 .iter() 48 .map(|endpoint| endpoint.url().as_str().to_owned()), 49 ), 50 writers: crate::socket_write::WriterRegistry::new( 51 endpoints 52 .iter() 53 .map(|endpoint| endpoint.url().as_str().to_owned()), 54 ), 55 policies: Arc::new( 56 endpoints 57 .iter() 58 .map(|endpoint| (endpoint.url().as_str().to_owned(), endpoint.policy())) 59 .collect(), 60 ), 61 } 62 } 63 } 64 65 impl WebSocketTransport for SessionWebsocketTransport { 66 fn support_ping(&self) -> bool { 67 self.host.supports_ping() 68 } 69 70 fn connect<'a>( 71 &'a self, 72 url: &'a Url, 73 proxy: Option<SocketAddr>, 74 ) -> BoxFuture<'a, Result<(WebSocketSink, WebSocketStream), TransportError>> { 75 Box::pin(async move { 76 if proxy.is_some() { 77 return Err(policy_error( 78 "proxy and Tor connection modes are not configured", 79 )); 80 } 81 let policy = self 82 .policies 83 .get(configured_policy_key(url)) 84 .copied() 85 .ok_or_else(|| policy_error("relay URL is not configured"))?; 86 let relay = RelayUrl::parse(url.as_str(), policy) 87 .map_err(|_| policy_error("relay URL is denied by network policy"))?; 88 let ingress = self 89 .ingress 90 .connection(relay.as_str()) 91 .ok_or_else(|| policy_error("relay ingress unavailable"))?; 92 let originals = ingress.clone(); 93 let admission = Arc::new(ConnectionAdmission { policy, ingress }); 94 let limit = NonZeroUsize::new(MAX_WIRE_MESSAGE_BYTES) 95 .expect("the fixed wire limit is positive"); 96 let socket = crate::host_time::timeout( 97 self.connect_timeout, 98 self.host 99 .connect(relay.as_str(), self.connect_timeout, limit, admission), 100 ) 101 .await 102 .map_err(|_| policy_error("relay connection deadline elapsed"))? 103 .map_err(host_error)?; 104 let writer = 105 crate::socket_write::SocketWriter::new(Box::pin(HostSink::new(socket.clone()))); 106 self.writers.install(relay.as_str(), &writer)?; 107 let sink: WebSocketSink = Box::pin(crate::socket_write::SharedSocketSink::new(writer)); 108 let receiver = 109 stream::try_unfold((socket, originals), |(socket, originals)| async move { 110 let frame = socket.receive().await.map_err(host_error)?; 111 let message = frame.map(from_host_frame).transpose()?.flatten(); 112 if let Some(Message::Text(text)) = &message 113 && !originals.capture(text) 114 { 115 return Err(policy_error("original relay ingress unavailable")); 116 } 117 Ok(message.map(|message| (message, (socket, originals)))) 118 }); 119 Ok((sink, Box::pin(receiver) as WebSocketStream)) 120 }) 121 } 122 } 123 124 struct ConnectionAdmission { 125 policy: RelayUrlPolicy, 126 ingress: crate::source_ingress::IngressConnection, 127 } 128 129 impl Admission for ConnectionAdmission { 130 fn permits_address(&self, address: IpAddr) -> bool { 131 self.policy.accepts_address(address) 132 } 133 fn admitted_read(&self, context: &Context<'_>) -> bool { 134 self.ingress.admitted(context) 135 } 136 fn admitted_write(&self, context: &Context<'_>) -> bool { 137 self.ingress.admitted_write(context) 138 } 139 fn charge(&self, bytes: usize, frames: usize, data: usize) -> bool { 140 self.ingress.charge(bytes, frames, data) 141 } 142 } 143 144 fn configured_policy_key(url: &Url) -> &str { 145 if url.path() == "/" && url.query().is_none() && url.fragment().is_none() { 146 url.as_str().strip_suffix('/').unwrap_or(url.as_str()) 147 } else { 148 url.as_str() 149 } 150 } 151 152 fn host_error(error: HostError) -> TransportError { 153 match error { 154 HostError::Policy => policy_error("relay socket policy rejected"), 155 HostError::Timeout => TransportError::with_static_message( 156 nostr_sdk::error::ErrorKind::Timeout, 157 "relay connection timed out", 158 ), 159 other => TransportError::transport(other), 160 } 161 } 162 163 fn from_host_frame(frame: Frame) -> Result<Option<Message>, TransportError> { 164 Ok(Some(match frame { 165 Frame::Text(text) => { 166 validate_wire_identifiers(&text)?; 167 Message::Text(text) 168 } 169 Frame::Binary(bytes) => { 170 if bytes.len() > MAX_WIRE_MESSAGE_BYTES { 171 return Err(policy_error("relay message exceeds the wire limit")); 172 } 173 // Preserve the original host bytes. The upstream Nostr session 174 // explicitly ignores binary messages; never promote them to text. 175 Message::Binary(bytes) 176 } 177 #[cfg(not(target_arch = "wasm32"))] 178 Frame::Ping(bytes) => Message::Ping(bytes), 179 #[cfg(not(target_arch = "wasm32"))] 180 Frame::Pong(bytes) => Message::Pong(bytes), 181 #[cfg(not(target_arch = "wasm32"))] 182 Frame::Close(frame) => { 183 Message::Close(frame.map(|frame| async_wsocket::message::CloseFrame { 184 code: frame.code, 185 reason: frame.reason, 186 })) 187 } 188 #[cfg(target_arch = "wasm32")] 189 Frame::Close(_) => return Ok(None), 190 _ => return Err(policy_error("unsupported host frame")), 191 })) 192 } 193 194 fn validate_wire_identifiers(text: &str) -> Result<(), TransportError> { 195 if text.len() > MAX_WIRE_MESSAGE_BYTES { 196 return Err(policy_error("relay message exceeds the wire limit")); 197 } 198 // Inspect original identifiers before the upstream fixed-array decoder. 199 // Never normalize or reserialize the accepted original message. 200 let Ok(serde_json::Value::Array(fields)) = serde_json::from_str(text) else { 201 return Ok(()); 202 }; 203 let canonical_hex = |value: Option<&serde_json::Value>, length| { 204 value 205 .and_then(serde_json::Value::as_str) 206 .is_some_and(|value| { 207 value.len() == length 208 && value 209 .bytes() 210 .all(|byte| byte.is_ascii_digit() || matches!(byte, b'a'..=b'f')) 211 }) 212 }; 213 let valid = match fields.first().and_then(serde_json::Value::as_str) { 214 Some("OK") => canonical_hex(fields.get(1), 64), 215 Some("EVENT") => fields.get(2).is_some_and(|event| { 216 canonical_hex(event.get("id"), 64) 217 && canonical_hex(event.get("pubkey"), 64) 218 && canonical_hex(event.get("sig"), 128) 219 }), 220 _ => true, 221 }; 222 if !valid { 223 return Err(policy_error("relay message has a noncanonical identifier")); 224 } 225 Ok(()) 226 } 227 228 fn to_host_frame(message: Message) -> Frame { 229 match message { 230 Message::Text(text) => Frame::Text(text), 231 Message::Binary(bytes) => Frame::Binary(bytes), 232 #[cfg(not(target_arch = "wasm32"))] 233 Message::Ping(bytes) => Frame::Ping(bytes), 234 #[cfg(not(target_arch = "wasm32"))] 235 Message::Pong(bytes) => Frame::Pong(bytes), 236 #[cfg(not(target_arch = "wasm32"))] 237 Message::Close(frame) => { 238 Frame::Close( 239 frame.map(|frame| radroots_transport::host::websocket::CloseFrame { 240 code: frame.code, 241 reason: frame.reason, 242 }), 243 ) 244 } 245 } 246 } 247 248 struct HostSink { 249 socket: Arc<dyn Socket>, 250 pending: Option<BoxFuture<'static, Result<(), TransportError>>>, 251 closing: bool, 252 } 253 254 impl HostSink { 255 fn new(socket: Arc<dyn Socket>) -> Self { 256 Self { 257 socket, 258 pending: None, 259 closing: false, 260 } 261 } 262 fn poll_pending(&mut self, context: &mut Context<'_>) -> Poll<Result<(), TransportError>> { 263 if let Some(pending) = &mut self.pending { 264 let result = futures::ready!(pending.as_mut().poll(context)); 265 self.pending = None; 266 return Poll::Ready(result); 267 } 268 Poll::Ready(Ok(())) 269 } 270 } 271 272 impl Sink<Message> for HostSink { 273 type Error = TransportError; 274 fn poll_ready( 275 mut self: Pin<&mut Self>, 276 context: &mut Context<'_>, 277 ) -> Poll<Result<(), TransportError>> { 278 if self.closing { 279 return Poll::Ready(Err(policy_error("host socket is closing"))); 280 } 281 self.poll_pending(context) 282 } 283 fn start_send(mut self: Pin<&mut Self>, message: Message) -> Result<(), TransportError> { 284 if self.closing || self.pending.is_some() { 285 return Err(policy_error("host socket is not ready")); 286 } 287 let socket = self.socket.clone(); 288 let frame = to_host_frame(message); 289 self.pending = Some(Box::pin(async move { 290 socket.send(frame).await.map_err(host_error) 291 })); 292 Ok(()) 293 } 294 fn poll_flush( 295 mut self: Pin<&mut Self>, 296 context: &mut Context<'_>, 297 ) -> Poll<Result<(), TransportError>> { 298 self.poll_pending(context) 299 } 300 fn poll_close( 301 mut self: Pin<&mut Self>, 302 context: &mut Context<'_>, 303 ) -> Poll<Result<(), TransportError>> { 304 futures::ready!(self.poll_pending(context))?; 305 if !self.closing { 306 self.closing = true; 307 let socket = self.socket.clone(); 308 self.pending = Some(Box::pin( 309 async move { socket.close().await.map_err(host_error) }, 310 )); 311 } 312 self.poll_pending(context) 313 } 314 } 315 316 impl fmt::Debug for ConnectionAdmission { 317 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { 318 formatter.write_str("ConnectionAdmission([redacted])") 319 } 320 } 321 322 #[cfg(test)] 323 #[path = "session_socket_tests.rs"] 324 mod tests;