rwebtransport 0.1.0 → 0.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (113) hide show
  1. package/Cargo.lock +666 -666
  2. package/Cargo.toml +31 -31
  3. package/LICENSE +202 -202
  4. package/NOTICE +41 -41
  5. package/README.md +550 -550
  6. package/crates/echo-server/Cargo.toml +20 -20
  7. package/crates/echo-server/src/main.rs +666 -666
  8. package/crates/native/Cargo.toml +23 -23
  9. package/crates/native/src/config.rs +129 -129
  10. package/crates/native/src/driver.rs +463 -463
  11. package/crates/native/src/lib.rs +821 -821
  12. package/crates/native/src/server.rs +718 -718
  13. package/crates/native/src/session.rs +1191 -1191
  14. package/crates/native/src/tls.rs +96 -96
  15. package/crates/wtcore/Cargo.toml +15 -15
  16. package/crates/wtcore/src/h3.rs +226 -226
  17. package/crates/wtcore/src/lib.rs +9 -9
  18. package/dist/index.js.map +1 -1
  19. package/dist/index.mjs.map +1 -1
  20. package/package.json +80 -79
  21. package/prebuilds/darwin-arm64/rwebtransport.node +0 -0
  22. package/prebuilds/linux-arm64/rwebtransport.node +0 -0
  23. package/prebuilds/linux-x64/rwebtransport.node +0 -0
  24. package/prebuilds/win32-x64/rwebtransport.node +0 -0
  25. package/scripts/bench.mjs +180 -180
  26. package/scripts/build.js +67 -67
  27. package/scripts/postinstall.js +67 -67
  28. package/scripts/setup-unix.sh +129 -129
  29. package/scripts/setup-windows.ps1 +229 -229
  30. package/vendor/quiche/AGENTS.md +75 -75
  31. package/vendor/quiche/COPYING +23 -23
  32. package/vendor/quiche/Cargo.lock +1212 -1212
  33. package/vendor/quiche/Cargo.toml +215 -215
  34. package/vendor/quiche/README.md +466 -466
  35. package/vendor/quiche/examples/Makefile +46 -46
  36. package/vendor/quiche/examples/README.md +20 -20
  37. package/vendor/quiche/examples/cert-big.crt +90 -90
  38. package/vendor/quiche/examples/cert.crt +18 -18
  39. package/vendor/quiche/examples/cert.key +28 -28
  40. package/vendor/quiche/examples/client.c +343 -343
  41. package/vendor/quiche/examples/client.rs +281 -281
  42. package/vendor/quiche/examples/gen-certs.sh +15 -15
  43. package/vendor/quiche/examples/http3-client.c +473 -473
  44. package/vendor/quiche/examples/http3-client.rs +349 -349
  45. package/vendor/quiche/examples/http3-server.c +614 -614
  46. package/vendor/quiche/examples/http3-server.rs +680 -680
  47. package/vendor/quiche/examples/qpack-decode.rs +87 -87
  48. package/vendor/quiche/examples/qpack-encode.rs +88 -88
  49. package/vendor/quiche/examples/rootca.crt +21 -21
  50. package/vendor/quiche/examples/server.c +529 -529
  51. package/vendor/quiche/examples/server.rs +529 -529
  52. package/vendor/quiche/include/quiche.h +1282 -1282
  53. package/vendor/quiche/src/buffers.rs +105 -105
  54. package/vendor/quiche/src/build.rs +66 -66
  55. package/vendor/quiche/src/cid.rs +1079 -1079
  56. package/vendor/quiche/src/crypto/boringssl.rs +373 -373
  57. package/vendor/quiche/src/crypto/mod.rs +671 -671
  58. package/vendor/quiche/src/dgram.rs +118 -118
  59. package/vendor/quiche/src/error.rs +263 -263
  60. package/vendor/quiche/src/ffi.rs +2290 -2290
  61. package/vendor/quiche/src/flowcontrol.rs +246 -246
  62. package/vendor/quiche/src/frame.rs +2172 -2172
  63. package/vendor/quiche/src/h3/AGENTS.md +54 -54
  64. package/vendor/quiche/src/h3/ffi.rs +442 -442
  65. package/vendor/quiche/src/h3/frame.rs +1404 -1404
  66. package/vendor/quiche/src/h3/mod.rs +8223 -8223
  67. package/vendor/quiche/src/h3/qpack/decoder.rs +288 -288
  68. package/vendor/quiche/src/h3/qpack/encoder.rs +235 -235
  69. package/vendor/quiche/src/h3/qpack/mod.rs +202 -202
  70. package/vendor/quiche/src/h3/qpack/static_table.rs +323 -323
  71. package/vendor/quiche/src/h3/stream.rs +1595 -1595
  72. package/vendor/quiche/src/lib.rs +9556 -9556
  73. package/vendor/quiche/src/minmax.rs +446 -446
  74. package/vendor/quiche/src/packet.rs +2334 -2334
  75. package/vendor/quiche/src/path.rs +1374 -1374
  76. package/vendor/quiche/src/pmtud.rs +652 -652
  77. package/vendor/quiche/src/rand.rs +64 -64
  78. package/vendor/quiche/src/range_buf.rs +186 -186
  79. package/vendor/quiche/src/ranges.rs +755 -755
  80. package/vendor/quiche/src/recovery/AGENTS.md +80 -80
  81. package/vendor/quiche/src/recovery/bandwidth.rs +565 -565
  82. package/vendor/quiche/src/recovery/bytes_in_flight.rs +179 -179
  83. package/vendor/quiche/src/recovery/congestion/cubic.rs +1038 -1038
  84. package/vendor/quiche/src/recovery/congestion/delivery_rate.rs +514 -514
  85. package/vendor/quiche/src/recovery/congestion/hystart.rs +241 -241
  86. package/vendor/quiche/src/recovery/congestion/mod.rs +361 -361
  87. package/vendor/quiche/src/recovery/congestion/prr.rs +238 -238
  88. package/vendor/quiche/src/recovery/congestion/recovery.rs +1170 -1170
  89. package/vendor/quiche/src/recovery/congestion/reno.rs +291 -291
  90. package/vendor/quiche/src/recovery/congestion/test_sender.rs +201 -201
  91. package/vendor/quiche/src/recovery/gcongestion/bbr/bandwidth_sampler.rs +1947 -1947
  92. package/vendor/quiche/src/recovery/gcongestion/bbr/windowed_filter.rs +158 -158
  93. package/vendor/quiche/src/recovery/gcongestion/bbr.rs +37 -37
  94. package/vendor/quiche/src/recovery/gcongestion/bbr2/drain.rs +120 -120
  95. package/vendor/quiche/src/recovery/gcongestion/bbr2/mode.rs +318 -318
  96. package/vendor/quiche/src/recovery/gcongestion/bbr2/network_model.rs +784 -784
  97. package/vendor/quiche/src/recovery/gcongestion/bbr2/probe_bw.rs +729 -729
  98. package/vendor/quiche/src/recovery/gcongestion/bbr2/probe_rtt.rs +175 -175
  99. package/vendor/quiche/src/recovery/gcongestion/bbr2/startup.rs +190 -190
  100. package/vendor/quiche/src/recovery/gcongestion/bbr2.rs +855 -855
  101. package/vendor/quiche/src/recovery/gcongestion/mod.rs +275 -275
  102. package/vendor/quiche/src/recovery/gcongestion/pacer.rs +294 -294
  103. package/vendor/quiche/src/recovery/gcongestion/recovery.rs +1384 -1384
  104. package/vendor/quiche/src/recovery/mod.rs +3086 -3086
  105. package/vendor/quiche/src/recovery/rtt.rs +152 -152
  106. package/vendor/quiche/src/stream/mod.rs +2210 -2210
  107. package/vendor/quiche/src/stream/recv_buf.rs +1236 -1236
  108. package/vendor/quiche/src/stream/send_buf.rs +849 -849
  109. package/vendor/quiche/src/test_utils.rs +681 -681
  110. package/vendor/quiche/src/tests.rs +12922 -12922
  111. package/vendor/quiche/src/tls/boringssl.rs +375 -375
  112. package/vendor/quiche/src/tls/mod.rs +1245 -1245
  113. package/vendor/quiche/src/transport_params.rs +628 -628
@@ -1,718 +1,718 @@
1
- // SPDX-License-Identifier: Apache-2.0
2
- //! The WebTransport **server** driver: one thread owning a UDP socket and a
3
- //! table of QUIC connections, each running a server-role [`WtSession`]. It
4
- //! accepts Extended CONNECTs, surfaces each established session (and its stream
5
- //! / datagram events) to JS tagged with a session id, and routes per-session
6
- //! commands back down.
7
- //!
8
- //! Like the client driver, the whole thing runs inside a `catch_unwind` panic
9
- //! boundary and honours the shared in-flight backpressure counter so a hostile
10
- //! peer cannot balloon the neon event queue.
11
-
12
- use std::collections::HashMap;
13
- use std::net::SocketAddr;
14
- use std::sync::atomic::Ordering;
15
- use std::sync::mpsc::Receiver;
16
- use std::sync::Arc;
17
-
18
- use mio::net::UdpSocket;
19
- use mio::{Events, Interest, Poll};
20
-
21
- use crate::config::build_server_config;
22
- use crate::driver::{DriverShared, SOCKET_TOKEN};
23
- use crate::session::{Ev, WtSession};
24
-
25
- const LOCAL_CONN_ID_LEN: usize = 16;
26
- const MAX_INFLIGHT_BATCHES: i64 = 128;
27
-
28
- /// Hard cap on concurrent QUIC connections so a hostile client (or spoofed
29
- /// source addresses) cannot grow the connection table without bound.
30
- const MAX_CONNECTIONS: usize = 16_384;
31
-
32
- /// Maximum UDP packets read per event-loop wake before yielding to the rest of
33
- /// the loop (timeouts, commands, reaping). Bounds per-wake work so a sustained
34
- /// inbound flood cannot starve `Shutdown` handling or idle-connection reaping.
35
- const MAX_RECV_PER_WAKE: usize = 1024;
36
-
37
- /// Everything the server thread needs to start listening.
38
- pub struct ServerSetup {
39
- pub host: String,
40
- pub port: u16,
41
- pub cert_path: String,
42
- pub key_path: String,
43
- /// Bind with `SO_REUSEPORT` (Unix) so several processes (e.g. Node `cluster`
44
- /// workers) can share one listening port and have the kernel load-balance
45
- /// connections across them.
46
- pub reuse_port: bool,
47
- }
48
-
49
- /// Bind a non-blocking UDP socket, optionally with `SO_REUSEPORT` for clustering.
50
- fn bind_udp(addr: SocketAddr, reuse_port: bool) -> std::io::Result<UdpSocket> {
51
- use socket2::{Domain, Protocol, Socket, Type};
52
- let domain = if addr.is_ipv4() {
53
- Domain::IPV4
54
- } else {
55
- Domain::IPV6
56
- };
57
- let sock = Socket::new(domain, Type::DGRAM, Some(Protocol::UDP))?;
58
- sock.set_nonblocking(true)?;
59
- #[cfg(unix)]
60
- if reuse_port {
61
- sock.set_reuse_port(true)?;
62
- }
63
- let _ = reuse_port; // SO_REUSEPORT is Unix-only
64
- sock.bind(&addr.into())?;
65
- Ok(UdpSocket::from_std(sock.into()))
66
- }
67
-
68
- /// Commands from JS into the server thread. All session-scoped commands carry the
69
- /// session id assigned when the session was established.
70
- pub enum ServerCommand {
71
- OpenStream {
72
- session: u64,
73
- request_id: u64,
74
- bidi: bool,
75
- },
76
- Write {
77
- session: u64,
78
- id: u64,
79
- data: Vec<u8>,
80
- request_id: u64,
81
- },
82
- Fin {
83
- session: u64,
84
- id: u64,
85
- },
86
- ResetStream {
87
- session: u64,
88
- id: u64,
89
- code: u64,
90
- },
91
- StopSending {
92
- session: u64,
93
- id: u64,
94
- code: u64,
95
- },
96
- SetPaused {
97
- session: u64,
98
- id: u64,
99
- paused: bool,
100
- },
101
- SendDatagram {
102
- session: u64,
103
- data: Vec<u8>,
104
- request_id: u64,
105
- },
106
- CloseSession {
107
- session: u64,
108
- code: u32,
109
- reason: Vec<u8>,
110
- },
111
- /// Tear the whole server down.
112
- Shutdown,
113
- }
114
-
115
- /// Messages from the server thread out to JS.
116
- pub enum ServerMsg {
117
- /// The server is bound and listening on this UDP port.
118
- Listening(u16),
119
- /// A fatal server-level error (setup failure).
120
- ServerError(String),
121
- /// The server stopped.
122
- ServerClosed,
123
- /// A session-scoped event (`ev`) for session `session`.
124
- Session(u64, Ev),
125
- }
126
-
127
- /// Sink implemented by the neon layer to deliver [`ServerMsg`]s to JS.
128
- pub trait ServerEventSink: Send {
129
- fn emit(&self, messages: Vec<ServerMsg>);
130
- }
131
-
132
- struct ServerConn {
133
- conn: quiche::Connection,
134
- session: WtSession,
135
- session_id: u64,
136
- closed_emitted: bool,
137
- }
138
-
139
- /// Server thread entry point, wrapped in a panic boundary.
140
- pub fn run(
141
- setup: ServerSetup,
142
- mut poll: Poll,
143
- rx: Receiver<ServerCommand>,
144
- sink: Box<dyn ServerEventSink>,
145
- shared: Arc<DriverShared>,
146
- ) {
147
- let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
148
- run_inner(setup, &mut poll, rx, sink.as_ref(), &shared);
149
- }));
150
- shared.closed.store(true, Ordering::Relaxed);
151
- if let Err(payload) = result {
152
- let msg = payload
153
- .downcast_ref::<&str>()
154
- .map(|s| (*s).to_string())
155
- .or_else(|| payload.downcast_ref::<String>().cloned())
156
- .unwrap_or_else(|| "unknown panic".to_string());
157
- sink.emit(vec![
158
- ServerMsg::ServerError(format!("rwebtransport server panic: {msg}")),
159
- ServerMsg::ServerClosed,
160
- ]);
161
- } else {
162
- sink.emit(vec![ServerMsg::ServerClosed]);
163
- }
164
- }
165
-
166
- /// Length of the authentication tag appended to a Retry token.
167
- const TOKEN_TAG_LEN: usize = 16;
168
-
169
- /// A serialized source-address identity (IP + port) used as the address the
170
- /// token is bound to. A spoofed source can never receive the Retry, and the tag
171
- /// is keyed by a per-process secret it does not know, so it cannot forge one.
172
- fn addr_identity(src: &SocketAddr) -> Vec<u8> {
173
- let mut id = match src.ip() {
174
- std::net::IpAddr::V4(a) => a.octets().to_vec(),
175
- std::net::IpAddr::V6(a) => a.octets().to_vec(),
176
- };
177
- id.extend_from_slice(&src.port().to_be_bytes());
178
- id
179
- }
180
-
181
- /// HMAC-SHA256 (RFC 2104) over `data` keyed by `secret`, built on BoringSSL's
182
- /// SHA-256. Infallible: `boring::sha::sha256` cannot fail.
183
- fn hmac_sha256(secret: &[u8], data: &[u8]) -> [u8; 32] {
184
- const BLOCK: usize = 64;
185
- let mut key = [0u8; BLOCK];
186
- if secret.len() > BLOCK {
187
- key[..32].copy_from_slice(&boring::sha::sha256(secret));
188
- } else {
189
- key[..secret.len()].copy_from_slice(secret);
190
- }
191
- let mut ipad = [0x36u8; BLOCK];
192
- let mut opad = [0x5cu8; BLOCK];
193
- for i in 0..BLOCK {
194
- ipad[i] ^= key[i];
195
- opad[i] ^= key[i];
196
- }
197
- let mut inner = Vec::with_capacity(BLOCK + data.len());
198
- inner.extend_from_slice(&ipad);
199
- inner.extend_from_slice(data);
200
- let inner_hash = boring::sha::sha256(&inner);
201
- let mut outer = Vec::with_capacity(BLOCK + 32);
202
- outer.extend_from_slice(&opad);
203
- outer.extend_from_slice(&inner_hash);
204
- boring::sha::sha256(&outer)
205
- }
206
-
207
- /// Constant-time byte comparison so token validation does not leak the tag via
208
- /// timing.
209
- fn constant_time_eq(a: &[u8], b: &[u8]) -> bool {
210
- if a.len() != b.len() {
211
- return false;
212
- }
213
- let mut diff = 0u8;
214
- for (x, y) in a.iter().zip(b.iter()) {
215
- diff |= x ^ y;
216
- }
217
- diff == 0
218
- }
219
-
220
- /// Mint a stateless Retry token that authenticates the client's source address
221
- /// and carries the original destination connection id. The token is
222
- /// `b"rwt1" || orig_dcid || HMAC(secret, addr || orig_dcid)[..16]`. Because the
223
- /// tag is keyed by a secret known only to this process, a spoofed source cannot
224
- /// forge a token it never received, which is what makes the Retry actually
225
- /// prevent source-address spoofing (reflection) and state exhaustion rather than
226
- /// just being a formality.
227
- fn mint_token(secret: &[u8], orig_dcid: &[u8], src: &SocketAddr) -> Vec<u8> {
228
- let mut mac_input = addr_identity(src);
229
- mac_input.extend_from_slice(orig_dcid);
230
- let tag = hmac_sha256(secret, &mac_input);
231
- let mut token = Vec::with_capacity(4 + orig_dcid.len() + TOKEN_TAG_LEN);
232
- token.extend_from_slice(b"rwt1");
233
- token.extend_from_slice(orig_dcid);
234
- token.extend_from_slice(&tag[..TOKEN_TAG_LEN]);
235
- token
236
- }
237
-
238
- /// Validate a Retry token against `src` and recover the original destination
239
- /// connection id. Fails closed on any mismatch (forged/replayed/truncated).
240
- fn validate_token<'a>(
241
- secret: &[u8],
242
- src: &SocketAddr,
243
- token: &'a [u8],
244
- ) -> Option<quiche::ConnectionId<'a>> {
245
- let rest = token.strip_prefix(b"rwt1")?;
246
- if rest.len() < TOKEN_TAG_LEN {
247
- return None;
248
- }
249
- let (orig_dcid, tag) = rest.split_at(rest.len() - TOKEN_TAG_LEN);
250
- let mut mac_input = addr_identity(src);
251
- mac_input.extend_from_slice(orig_dcid);
252
- let expected = hmac_sha256(secret, &mac_input);
253
- if !constant_time_eq(&expected[..TOKEN_TAG_LEN], tag) {
254
- return None;
255
- }
256
- Some(quiche::ConnectionId::from_ref(orig_dcid))
257
- }
258
-
259
- /// A per-process random secret keying the Retry-token HMAC. Regenerated on every
260
- /// start, so tokens are unforgeable and do not survive a restart.
261
- fn random_secret() -> [u8; 32] {
262
- let mut b = [0u8; 32];
263
- if getrandom::getrandom(&mut b).is_err() {
264
- let seed: u128 = std::time::SystemTime::now()
265
- .duration_since(std::time::UNIX_EPOCH)
266
- .map(|d| d.as_nanos())
267
- .unwrap_or(0);
268
- let s = seed.to_le_bytes();
269
- for (i, slot) in b.iter_mut().enumerate() {
270
- *slot = s[i % s.len()];
271
- }
272
- }
273
- b
274
- }
275
-
276
- fn random_scid() -> [u8; LOCAL_CONN_ID_LEN] {
277
- let mut b = [0u8; LOCAL_CONN_ID_LEN];
278
- if getrandom::getrandom(&mut b).is_err() {
279
- let seed: u128 = std::time::SystemTime::now()
280
- .duration_since(std::time::UNIX_EPOCH)
281
- .map(|d| d.as_nanos())
282
- .unwrap_or(0);
283
- b.copy_from_slice(&seed.to_le_bytes());
284
- }
285
- b
286
- }
287
-
288
- fn run_inner(
289
- setup: ServerSetup,
290
- poll: &mut Poll,
291
- rx: Receiver<ServerCommand>,
292
- sink: &dyn ServerEventSink,
293
- shared: &Arc<DriverShared>,
294
- ) {
295
- let bind: SocketAddr = match format!("{}:{}", setup.host, setup.port).parse() {
296
- Ok(a) => a,
297
- Err(e) => {
298
- sink.emit(vec![ServerMsg::ServerError(format!(
299
- "invalid bind addr: {e}"
300
- ))]);
301
- return;
302
- }
303
- };
304
- let mut socket = match bind_udp(bind, setup.reuse_port) {
305
- Ok(s) => s,
306
- Err(e) => {
307
- sink.emit(vec![ServerMsg::ServerError(format!("bind failed: {e}"))]);
308
- return;
309
- }
310
- };
311
- let local_addr = match socket.local_addr() {
312
- Ok(a) => a,
313
- Err(e) => {
314
- sink.emit(vec![ServerMsg::ServerError(format!("local addr: {e}"))]);
315
- return;
316
- }
317
- };
318
- let mut config = match build_server_config(&setup.cert_path, &setup.key_path) {
319
- Ok(c) => c,
320
- Err(e) => {
321
- sink.emit(vec![ServerMsg::ServerError(e)]);
322
- return;
323
- }
324
- };
325
- if let Err(e) = poll
326
- .registry()
327
- .register(&mut socket, SOCKET_TOKEN, Interest::READABLE)
328
- {
329
- sink.emit(vec![ServerMsg::ServerError(format!("register: {e}"))]);
330
- return;
331
- }
332
-
333
- sink.emit(vec![ServerMsg::Listening(local_addr.port())]);
334
-
335
- let mut events = Events::with_capacity(1024);
336
- let mut recv_buf = vec![0u8; 65_535];
337
- let mut send_buf = vec![0u8; 1350];
338
-
339
- let mut clients: HashMap<Vec<u8>, ServerConn> = HashMap::new();
340
- let mut routing: HashMap<Vec<u8>, Vec<u8>> = HashMap::new();
341
- let mut sessions: HashMap<u64, Vec<u8>> = HashMap::new();
342
- let mut next_session_id: u64 = 1;
343
-
344
- // Per-process secret keying the stateless Retry token (see mint_token).
345
- let token_secret = random_secret();
346
-
347
- loop {
348
- let timeout = clients.values().filter_map(|c| c.conn.timeout()).min();
349
- if poll.poll(&mut events, timeout).is_err() {
350
- continue;
351
- }
352
-
353
- let mut out: Vec<ServerMsg> = Vec::new();
354
-
355
- // 1. Read datagrams and route them, up to a per-wake budget so a flood
356
- // cannot starve the rest of the loop (commands, timeouts, reaping).
357
- let mut got_packet = false;
358
- let mut budget = MAX_RECV_PER_WAKE;
359
- loop {
360
- if budget == 0 {
361
- break;
362
- }
363
- budget -= 1;
364
- let (len, from) = match socket.recv_from(&mut recv_buf) {
365
- Ok(v) => v,
366
- Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => break,
367
- Err(_) => break,
368
- };
369
- got_packet = true;
370
- let pkt = &mut recv_buf[..len];
371
- let hdr = match quiche::Header::from_slice(pkt, LOCAL_CONN_ID_LEN) {
372
- Ok(h) => h,
373
- Err(_) => continue,
374
- };
375
-
376
- let scid = match routing.get(&hdr.dcid.to_vec()).cloned() {
377
- Some(s) => s,
378
- None => {
379
- if hdr.ty != quiche::Type::Initial {
380
- continue;
381
- }
382
- // Cap concurrent connections to bound memory under a flood.
383
- if clients.len() >= MAX_CONNECTIONS {
384
- continue;
385
- }
386
-
387
- let token = hdr.token.as_deref().unwrap_or(&[]);
388
- if token.is_empty() {
389
- // No address validation yet: reply with a stateless Retry.
390
- // We create no connection state (and do not amplify) for a
391
- // source that has not proven it owns its address.
392
- let new_scid = random_scid();
393
- let new_scid_id = quiche::ConnectionId::from_ref(&new_scid);
394
- let retry_token = mint_token(&token_secret, &hdr.dcid, &from);
395
- if let Ok(len) = quiche::retry(
396
- &hdr.scid,
397
- &hdr.dcid,
398
- &new_scid_id,
399
- &retry_token,
400
- hdr.version,
401
- &mut send_buf,
402
- ) {
403
- let _ = socket.send_to(&send_buf[..len], from);
404
- }
405
- continue;
406
- }
407
-
408
- // The client echoed a Retry token: validate it before we
409
- // allocate any connection state.
410
- let Some(odcid) = validate_token(&token_secret, &from, token) else {
411
- continue;
412
- };
413
- // Our Retry SCID, echoed back as this Initial's DCID.
414
- let scid_bytes = hdr.dcid.to_vec();
415
- let scid_id = quiche::ConnectionId::from_ref(&scid_bytes);
416
- let conn =
417
- match quiche::accept(&scid_id, Some(&odcid), local_addr, from, &mut config)
418
- {
419
- Ok(c) => c,
420
- Err(_) => continue,
421
- };
422
- let key = scid_bytes;
423
- let session_id = next_session_id;
424
- next_session_id += 1;
425
- routing.insert(key.clone(), key.clone());
426
- sessions.insert(session_id, key.clone());
427
- clients.insert(
428
- key.clone(),
429
- ServerConn {
430
- conn,
431
- session: WtSession::new_server(from),
432
- session_id,
433
- closed_emitted: false,
434
- },
435
- );
436
- key
437
- }
438
- };
439
-
440
- if let Some(server) = clients.get_mut(&scid) {
441
- let info = quiche::RecvInfo {
442
- from,
443
- to: local_addr,
444
- };
445
- let _ = server.conn.recv(pkt, info);
446
- }
447
- }
448
-
449
- // 2. Fire elapsed timeouts for every connection. quiche's on_timeout is a
450
- // no-op unless a timer is actually due, and it must run even while packets
451
- // keep arriving so idle/half-open connections are reaped under a flood.
452
- let _ = got_packet;
453
- for server in clients.values_mut() {
454
- server.conn.on_timeout();
455
- }
456
-
457
- // 3. Drain commands.
458
- let mut shutdown = false;
459
- while let Ok(cmd) = rx.try_recv() {
460
- if matches!(cmd, ServerCommand::Shutdown) {
461
- shutdown = true;
462
- break;
463
- }
464
- apply_command(&mut clients, &sessions, cmd, &mut out);
465
- }
466
- if shutdown {
467
- for server in clients.values_mut() {
468
- let _ = server.conn.close(true, 0, b"server shutdown");
469
- flush_send(&mut server.conn, &socket, &mut send_buf);
470
- }
471
- return;
472
- }
473
-
474
- // 4. Drive every connection.
475
- let backpressured = shared.inflight.load(Ordering::Relaxed) >= MAX_INFLIGHT_BATCHES;
476
- for server in clients.values_mut() {
477
- let mut evs: Vec<Ev> = Vec::new();
478
- if server.conn.is_established() {
479
- server.session.on_established(&mut evs);
480
- }
481
- if !backpressured {
482
- server.session.on_datagrams(&mut server.conn, &mut evs);
483
- }
484
- let readable: Vec<u64> = server.conn.readable().collect();
485
- for id in readable {
486
- server
487
- .session
488
- .on_readable(&mut server.conn, id, backpressured, &mut evs);
489
- }
490
- server.session.flush(&mut server.conn, &mut evs);
491
-
492
- // If the session ended (app close, or a rejected/malformed CONNECT),
493
- // close the QUIC connection so it drains and gets reaped instead of
494
- // lingering as a zombie until the idle timeout.
495
- if server.session.is_closed() && !server.conn.is_closed() && !server.conn.is_draining()
496
- {
497
- let _ = server.conn.close(true, 0, b"session closed");
498
- }
499
-
500
- if let Some(sz) = server.conn.dgram_max_writable_len() {
501
- shared
502
- .max_datagram_size
503
- .store(sz.saturating_sub(1), Ordering::Relaxed);
504
- }
505
-
506
- for ev in evs {
507
- out.push(ServerMsg::Session(server.session_id, ev));
508
- }
509
-
510
- flush_send(&mut server.conn, &socket, &mut send_buf);
511
- }
512
-
513
- // 5. Reap closed connections (emit a final Closed for the session).
514
- for server in clients.values_mut() {
515
- if server.conn.is_closed() && !server.closed_emitted {
516
- server.closed_emitted = true;
517
- if !server.session.is_closed() {
518
- let (code, reason, remote) = closure_info(&server.conn);
519
- let mut evs = Vec::new();
520
- server.session.mark_closed(&mut evs, code, reason, remote);
521
- for ev in evs {
522
- out.push(ServerMsg::Session(server.session_id, ev));
523
- }
524
- }
525
- }
526
- }
527
- clients.retain(|_, s| {
528
- if s.conn.is_closed() {
529
- sessions.remove(&s.session_id);
530
- false
531
- } else {
532
- true
533
- }
534
- });
535
- routing.retain(|_, scid| clients.contains_key(scid));
536
-
537
- if !out.is_empty() {
538
- // The sink increments `inflight` before scheduling and the JS
539
- // callback decrements it, so every emit path stays balanced.
540
- sink.emit(out);
541
- }
542
- }
543
- }
544
-
545
- fn apply_command(
546
- clients: &mut HashMap<Vec<u8>, ServerConn>,
547
- sessions: &HashMap<u64, Vec<u8>>,
548
- cmd: ServerCommand,
549
- out: &mut Vec<ServerMsg>,
550
- ) {
551
- let session_id = match &cmd {
552
- ServerCommand::OpenStream { session, .. }
553
- | ServerCommand::Write { session, .. }
554
- | ServerCommand::Fin { session, .. }
555
- | ServerCommand::ResetStream { session, .. }
556
- | ServerCommand::StopSending { session, .. }
557
- | ServerCommand::SetPaused { session, .. }
558
- | ServerCommand::SendDatagram { session, .. }
559
- | ServerCommand::CloseSession { session, .. } => *session,
560
- ServerCommand::Shutdown => return,
561
- };
562
- let Some(scid) = sessions.get(&session_id) else {
563
- return;
564
- };
565
- let Some(server) = clients.get_mut(scid) else {
566
- return;
567
- };
568
- // Session-scoped events produced by commands are surfaced on the next drive
569
- // iteration via the normal event path; here we just mutate session state.
570
- let mut evs: Vec<Ev> = Vec::new();
571
- match cmd {
572
- ServerCommand::OpenStream {
573
- request_id, bidi, ..
574
- } => server.session.open_stream(bidi, request_id, &mut evs),
575
- ServerCommand::Write {
576
- id,
577
- data,
578
- request_id,
579
- ..
580
- } => server.session.stream_write(id, data, request_id, &mut evs),
581
- ServerCommand::Fin { id, .. } => server.session.stream_fin(id),
582
- ServerCommand::ResetStream { id, code, .. } => {
583
- server.session.stream_reset(&mut server.conn, id, code)
584
- }
585
- ServerCommand::StopSending { id, code, .. } => {
586
- server
587
- .session
588
- .stream_stop_sending(&mut server.conn, id, code)
589
- }
590
- ServerCommand::SetPaused { id, paused, .. } => server.session.set_paused(id, paused),
591
- ServerCommand::SendDatagram {
592
- data, request_id, ..
593
- } => server
594
- .session
595
- .send_datagram(&mut server.conn, &data, request_id, &mut evs),
596
- ServerCommand::CloseSession { code, reason, .. } => server.session.close(code, reason),
597
- ServerCommand::Shutdown => {}
598
- }
599
- // Surface events produced synchronously by the command (StreamOpened,
600
- // WriteAck, DatagramAck), tagged with the session id.
601
- for ev in evs {
602
- out.push(ServerMsg::Session(session_id, ev));
603
- }
604
- }
605
-
606
- fn flush_send(conn: &mut quiche::Connection, socket: &UdpSocket, out: &mut [u8]) {
607
- loop {
608
- match conn.send(out) {
609
- Ok((write, info)) => match socket.send_to(&out[..write], info.to) {
610
- Ok(_) => {}
611
- Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
612
- // Kernel send buffer is full. Stop draining rather than
613
- // discarding packets quiche already accounted as sent; its
614
- // loss recovery retransmits the frames on a later flush.
615
- return;
616
- }
617
- Err(_) => return,
618
- },
619
- Err(quiche::Error::Done) => return,
620
- Err(_) => return,
621
- }
622
- }
623
- }
624
-
625
- fn closure_info(conn: &quiche::Connection) -> (u32, Vec<u8>, bool) {
626
- if let Some(err) = conn.peer_error() {
627
- return (err.error_code as u32, err.reason.clone(), true);
628
- }
629
- if let Some(err) = conn.local_error() {
630
- return (err.error_code as u32, err.reason.clone(), false);
631
- }
632
- (0, Vec::new(), true)
633
- }
634
-
635
- #[cfg(test)]
636
- mod tests {
637
- use super::*;
638
-
639
- fn addr(s: &str) -> SocketAddr {
640
- s.parse().expect("addr")
641
- }
642
-
643
- #[test]
644
- fn token_roundtrip_recovers_dcid() {
645
- let secret = [7u8; 32];
646
- let dcid = b"\x11\x22\x33\x44\x55\x66\x77\x88";
647
- let src = addr("192.0.2.10:4433");
648
- let token = mint_token(&secret, dcid, &src);
649
- let recovered = validate_token(&secret, &src, &token).expect("valid token");
650
- assert_eq!(recovered.as_ref(), &dcid[..]);
651
- }
652
-
653
- #[test]
654
- fn token_rejected_for_different_source_address() {
655
- let secret = [7u8; 32];
656
- let dcid = b"abcdefghij";
657
- let token = mint_token(&secret, dcid, &addr("192.0.2.10:4433"));
658
- // Spoofed source IP: the whole point of the Retry.
659
- assert!(validate_token(&secret, &addr("192.0.2.11:4433"), &token).is_none());
660
- // Same IP, different port: still not the address the token was minted for.
661
- assert!(validate_token(&secret, &addr("192.0.2.10:5555"), &token).is_none());
662
- }
663
-
664
- #[test]
665
- fn token_rejected_under_a_different_secret() {
666
- let dcid = b"abcdefghij";
667
- let src = addr("198.51.100.7:443");
668
- let token = mint_token(&[1u8; 32], dcid, &src);
669
- // A server that restarted (new secret) rejects the stale token.
670
- assert!(validate_token(&[2u8; 32], &src, &token).is_none());
671
- }
672
-
673
- #[test]
674
- fn forged_and_truncated_tokens_are_rejected() {
675
- let secret = [9u8; 32];
676
- let src = addr("198.51.100.7:443");
677
- // Attacker who does not know the secret guesses the layout with a zero tag.
678
- let mut forged = Vec::new();
679
- forged.extend_from_slice(b"rwt1");
680
- forged.extend_from_slice(b"deadbeefdcid");
681
- forged.extend_from_slice(&[0u8; TOKEN_TAG_LEN]);
682
- assert!(validate_token(&secret, &src, &forged).is_none());
683
- // Too short to hold a tag, wrong prefix, empty.
684
- assert!(validate_token(&secret, &src, b"rwt1short").is_none());
685
- assert!(validate_token(&secret, &src, b"nope").is_none());
686
- assert!(validate_token(&secret, &src, b"").is_none());
687
- // A valid token with a single tag byte flipped.
688
- let mut token = mint_token(&secret, b"abcdefghij", &src);
689
- let last = token.len() - 1;
690
- token[last] ^= 0xff;
691
- assert!(validate_token(&secret, &src, &token).is_none());
692
- }
693
-
694
- #[test]
695
- fn hmac_is_deterministic_and_key_dependent() {
696
- assert_eq!(
697
- hmac_sha256(&[0u8; 32], b"msg"),
698
- hmac_sha256(&[0u8; 32], b"msg")
699
- );
700
- assert_ne!(
701
- hmac_sha256(&[0u8; 32], b"msg"),
702
- hmac_sha256(&[1u8; 32], b"msg")
703
- );
704
- // Known RFC 4231 test case 1: key=0x0b*20, data="Hi There".
705
- let key = [0x0bu8; 20];
706
- let tag = hmac_sha256(&key, b"Hi There");
707
- let expected =
708
- hex_to_bytes("b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7");
709
- assert_eq!(&tag[..], &expected[..]);
710
- }
711
-
712
- fn hex_to_bytes(s: &str) -> Vec<u8> {
713
- (0..s.len())
714
- .step_by(2)
715
- .map(|i| u8::from_str_radix(&s[i..i + 2], 16).unwrap())
716
- .collect()
717
- }
718
- }
1
+ // SPDX-License-Identifier: Apache-2.0
2
+ //! The WebTransport **server** driver: one thread owning a UDP socket and a
3
+ //! table of QUIC connections, each running a server-role [`WtSession`]. It
4
+ //! accepts Extended CONNECTs, surfaces each established session (and its stream
5
+ //! / datagram events) to JS tagged with a session id, and routes per-session
6
+ //! commands back down.
7
+ //!
8
+ //! Like the client driver, the whole thing runs inside a `catch_unwind` panic
9
+ //! boundary and honours the shared in-flight backpressure counter so a hostile
10
+ //! peer cannot balloon the neon event queue.
11
+
12
+ use std::collections::HashMap;
13
+ use std::net::SocketAddr;
14
+ use std::sync::atomic::Ordering;
15
+ use std::sync::mpsc::Receiver;
16
+ use std::sync::Arc;
17
+
18
+ use mio::net::UdpSocket;
19
+ use mio::{Events, Interest, Poll};
20
+
21
+ use crate::config::build_server_config;
22
+ use crate::driver::{DriverShared, SOCKET_TOKEN};
23
+ use crate::session::{Ev, WtSession};
24
+
25
+ const LOCAL_CONN_ID_LEN: usize = 16;
26
+ const MAX_INFLIGHT_BATCHES: i64 = 128;
27
+
28
+ /// Hard cap on concurrent QUIC connections so a hostile client (or spoofed
29
+ /// source addresses) cannot grow the connection table without bound.
30
+ const MAX_CONNECTIONS: usize = 16_384;
31
+
32
+ /// Maximum UDP packets read per event-loop wake before yielding to the rest of
33
+ /// the loop (timeouts, commands, reaping). Bounds per-wake work so a sustained
34
+ /// inbound flood cannot starve `Shutdown` handling or idle-connection reaping.
35
+ const MAX_RECV_PER_WAKE: usize = 1024;
36
+
37
+ /// Everything the server thread needs to start listening.
38
+ pub struct ServerSetup {
39
+ pub host: String,
40
+ pub port: u16,
41
+ pub cert_path: String,
42
+ pub key_path: String,
43
+ /// Bind with `SO_REUSEPORT` (Unix) so several processes (e.g. Node `cluster`
44
+ /// workers) can share one listening port and have the kernel load-balance
45
+ /// connections across them.
46
+ pub reuse_port: bool,
47
+ }
48
+
49
+ /// Bind a non-blocking UDP socket, optionally with `SO_REUSEPORT` for clustering.
50
+ fn bind_udp(addr: SocketAddr, reuse_port: bool) -> std::io::Result<UdpSocket> {
51
+ use socket2::{Domain, Protocol, Socket, Type};
52
+ let domain = if addr.is_ipv4() {
53
+ Domain::IPV4
54
+ } else {
55
+ Domain::IPV6
56
+ };
57
+ let sock = Socket::new(domain, Type::DGRAM, Some(Protocol::UDP))?;
58
+ sock.set_nonblocking(true)?;
59
+ #[cfg(unix)]
60
+ if reuse_port {
61
+ sock.set_reuse_port(true)?;
62
+ }
63
+ let _ = reuse_port; // SO_REUSEPORT is Unix-only
64
+ sock.bind(&addr.into())?;
65
+ Ok(UdpSocket::from_std(sock.into()))
66
+ }
67
+
68
+ /// Commands from JS into the server thread. All session-scoped commands carry the
69
+ /// session id assigned when the session was established.
70
+ pub enum ServerCommand {
71
+ OpenStream {
72
+ session: u64,
73
+ request_id: u64,
74
+ bidi: bool,
75
+ },
76
+ Write {
77
+ session: u64,
78
+ id: u64,
79
+ data: Vec<u8>,
80
+ request_id: u64,
81
+ },
82
+ Fin {
83
+ session: u64,
84
+ id: u64,
85
+ },
86
+ ResetStream {
87
+ session: u64,
88
+ id: u64,
89
+ code: u64,
90
+ },
91
+ StopSending {
92
+ session: u64,
93
+ id: u64,
94
+ code: u64,
95
+ },
96
+ SetPaused {
97
+ session: u64,
98
+ id: u64,
99
+ paused: bool,
100
+ },
101
+ SendDatagram {
102
+ session: u64,
103
+ data: Vec<u8>,
104
+ request_id: u64,
105
+ },
106
+ CloseSession {
107
+ session: u64,
108
+ code: u32,
109
+ reason: Vec<u8>,
110
+ },
111
+ /// Tear the whole server down.
112
+ Shutdown,
113
+ }
114
+
115
+ /// Messages from the server thread out to JS.
116
+ pub enum ServerMsg {
117
+ /// The server is bound and listening on this UDP port.
118
+ Listening(u16),
119
+ /// A fatal server-level error (setup failure).
120
+ ServerError(String),
121
+ /// The server stopped.
122
+ ServerClosed,
123
+ /// A session-scoped event (`ev`) for session `session`.
124
+ Session(u64, Ev),
125
+ }
126
+
127
+ /// Sink implemented by the neon layer to deliver [`ServerMsg`]s to JS.
128
+ pub trait ServerEventSink: Send {
129
+ fn emit(&self, messages: Vec<ServerMsg>);
130
+ }
131
+
132
+ struct ServerConn {
133
+ conn: quiche::Connection,
134
+ session: WtSession,
135
+ session_id: u64,
136
+ closed_emitted: bool,
137
+ }
138
+
139
+ /// Server thread entry point, wrapped in a panic boundary.
140
+ pub fn run(
141
+ setup: ServerSetup,
142
+ mut poll: Poll,
143
+ rx: Receiver<ServerCommand>,
144
+ sink: Box<dyn ServerEventSink>,
145
+ shared: Arc<DriverShared>,
146
+ ) {
147
+ let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
148
+ run_inner(setup, &mut poll, rx, sink.as_ref(), &shared);
149
+ }));
150
+ shared.closed.store(true, Ordering::Relaxed);
151
+ if let Err(payload) = result {
152
+ let msg = payload
153
+ .downcast_ref::<&str>()
154
+ .map(|s| (*s).to_string())
155
+ .or_else(|| payload.downcast_ref::<String>().cloned())
156
+ .unwrap_or_else(|| "unknown panic".to_string());
157
+ sink.emit(vec![
158
+ ServerMsg::ServerError(format!("rwebtransport server panic: {msg}")),
159
+ ServerMsg::ServerClosed,
160
+ ]);
161
+ } else {
162
+ sink.emit(vec![ServerMsg::ServerClosed]);
163
+ }
164
+ }
165
+
166
+ /// Length of the authentication tag appended to a Retry token.
167
+ const TOKEN_TAG_LEN: usize = 16;
168
+
169
+ /// A serialized source-address identity (IP + port) used as the address the
170
+ /// token is bound to. A spoofed source can never receive the Retry, and the tag
171
+ /// is keyed by a per-process secret it does not know, so it cannot forge one.
172
+ fn addr_identity(src: &SocketAddr) -> Vec<u8> {
173
+ let mut id = match src.ip() {
174
+ std::net::IpAddr::V4(a) => a.octets().to_vec(),
175
+ std::net::IpAddr::V6(a) => a.octets().to_vec(),
176
+ };
177
+ id.extend_from_slice(&src.port().to_be_bytes());
178
+ id
179
+ }
180
+
181
+ /// HMAC-SHA256 (RFC 2104) over `data` keyed by `secret`, built on BoringSSL's
182
+ /// SHA-256. Infallible: `boring::sha::sha256` cannot fail.
183
+ fn hmac_sha256(secret: &[u8], data: &[u8]) -> [u8; 32] {
184
+ const BLOCK: usize = 64;
185
+ let mut key = [0u8; BLOCK];
186
+ if secret.len() > BLOCK {
187
+ key[..32].copy_from_slice(&boring::sha::sha256(secret));
188
+ } else {
189
+ key[..secret.len()].copy_from_slice(secret);
190
+ }
191
+ let mut ipad = [0x36u8; BLOCK];
192
+ let mut opad = [0x5cu8; BLOCK];
193
+ for i in 0..BLOCK {
194
+ ipad[i] ^= key[i];
195
+ opad[i] ^= key[i];
196
+ }
197
+ let mut inner = Vec::with_capacity(BLOCK + data.len());
198
+ inner.extend_from_slice(&ipad);
199
+ inner.extend_from_slice(data);
200
+ let inner_hash = boring::sha::sha256(&inner);
201
+ let mut outer = Vec::with_capacity(BLOCK + 32);
202
+ outer.extend_from_slice(&opad);
203
+ outer.extend_from_slice(&inner_hash);
204
+ boring::sha::sha256(&outer)
205
+ }
206
+
207
+ /// Constant-time byte comparison so token validation does not leak the tag via
208
+ /// timing.
209
+ fn constant_time_eq(a: &[u8], b: &[u8]) -> bool {
210
+ if a.len() != b.len() {
211
+ return false;
212
+ }
213
+ let mut diff = 0u8;
214
+ for (x, y) in a.iter().zip(b.iter()) {
215
+ diff |= x ^ y;
216
+ }
217
+ diff == 0
218
+ }
219
+
220
+ /// Mint a stateless Retry token that authenticates the client's source address
221
+ /// and carries the original destination connection id. The token is
222
+ /// `b"rwt1" || orig_dcid || HMAC(secret, addr || orig_dcid)[..16]`. Because the
223
+ /// tag is keyed by a secret known only to this process, a spoofed source cannot
224
+ /// forge a token it never received, which is what makes the Retry actually
225
+ /// prevent source-address spoofing (reflection) and state exhaustion rather than
226
+ /// just being a formality.
227
+ fn mint_token(secret: &[u8], orig_dcid: &[u8], src: &SocketAddr) -> Vec<u8> {
228
+ let mut mac_input = addr_identity(src);
229
+ mac_input.extend_from_slice(orig_dcid);
230
+ let tag = hmac_sha256(secret, &mac_input);
231
+ let mut token = Vec::with_capacity(4 + orig_dcid.len() + TOKEN_TAG_LEN);
232
+ token.extend_from_slice(b"rwt1");
233
+ token.extend_from_slice(orig_dcid);
234
+ token.extend_from_slice(&tag[..TOKEN_TAG_LEN]);
235
+ token
236
+ }
237
+
238
+ /// Validate a Retry token against `src` and recover the original destination
239
+ /// connection id. Fails closed on any mismatch (forged/replayed/truncated).
240
+ fn validate_token<'a>(
241
+ secret: &[u8],
242
+ src: &SocketAddr,
243
+ token: &'a [u8],
244
+ ) -> Option<quiche::ConnectionId<'a>> {
245
+ let rest = token.strip_prefix(b"rwt1")?;
246
+ if rest.len() < TOKEN_TAG_LEN {
247
+ return None;
248
+ }
249
+ let (orig_dcid, tag) = rest.split_at(rest.len() - TOKEN_TAG_LEN);
250
+ let mut mac_input = addr_identity(src);
251
+ mac_input.extend_from_slice(orig_dcid);
252
+ let expected = hmac_sha256(secret, &mac_input);
253
+ if !constant_time_eq(&expected[..TOKEN_TAG_LEN], tag) {
254
+ return None;
255
+ }
256
+ Some(quiche::ConnectionId::from_ref(orig_dcid))
257
+ }
258
+
259
+ /// A per-process random secret keying the Retry-token HMAC. Regenerated on every
260
+ /// start, so tokens are unforgeable and do not survive a restart.
261
+ fn random_secret() -> [u8; 32] {
262
+ let mut b = [0u8; 32];
263
+ if getrandom::getrandom(&mut b).is_err() {
264
+ let seed: u128 = std::time::SystemTime::now()
265
+ .duration_since(std::time::UNIX_EPOCH)
266
+ .map(|d| d.as_nanos())
267
+ .unwrap_or(0);
268
+ let s = seed.to_le_bytes();
269
+ for (i, slot) in b.iter_mut().enumerate() {
270
+ *slot = s[i % s.len()];
271
+ }
272
+ }
273
+ b
274
+ }
275
+
276
+ fn random_scid() -> [u8; LOCAL_CONN_ID_LEN] {
277
+ let mut b = [0u8; LOCAL_CONN_ID_LEN];
278
+ if getrandom::getrandom(&mut b).is_err() {
279
+ let seed: u128 = std::time::SystemTime::now()
280
+ .duration_since(std::time::UNIX_EPOCH)
281
+ .map(|d| d.as_nanos())
282
+ .unwrap_or(0);
283
+ b.copy_from_slice(&seed.to_le_bytes());
284
+ }
285
+ b
286
+ }
287
+
288
+ fn run_inner(
289
+ setup: ServerSetup,
290
+ poll: &mut Poll,
291
+ rx: Receiver<ServerCommand>,
292
+ sink: &dyn ServerEventSink,
293
+ shared: &Arc<DriverShared>,
294
+ ) {
295
+ let bind: SocketAddr = match format!("{}:{}", setup.host, setup.port).parse() {
296
+ Ok(a) => a,
297
+ Err(e) => {
298
+ sink.emit(vec![ServerMsg::ServerError(format!(
299
+ "invalid bind addr: {e}"
300
+ ))]);
301
+ return;
302
+ }
303
+ };
304
+ let mut socket = match bind_udp(bind, setup.reuse_port) {
305
+ Ok(s) => s,
306
+ Err(e) => {
307
+ sink.emit(vec![ServerMsg::ServerError(format!("bind failed: {e}"))]);
308
+ return;
309
+ }
310
+ };
311
+ let local_addr = match socket.local_addr() {
312
+ Ok(a) => a,
313
+ Err(e) => {
314
+ sink.emit(vec![ServerMsg::ServerError(format!("local addr: {e}"))]);
315
+ return;
316
+ }
317
+ };
318
+ let mut config = match build_server_config(&setup.cert_path, &setup.key_path) {
319
+ Ok(c) => c,
320
+ Err(e) => {
321
+ sink.emit(vec![ServerMsg::ServerError(e)]);
322
+ return;
323
+ }
324
+ };
325
+ if let Err(e) = poll
326
+ .registry()
327
+ .register(&mut socket, SOCKET_TOKEN, Interest::READABLE)
328
+ {
329
+ sink.emit(vec![ServerMsg::ServerError(format!("register: {e}"))]);
330
+ return;
331
+ }
332
+
333
+ sink.emit(vec![ServerMsg::Listening(local_addr.port())]);
334
+
335
+ let mut events = Events::with_capacity(1024);
336
+ let mut recv_buf = vec![0u8; 65_535];
337
+ let mut send_buf = vec![0u8; 1350];
338
+
339
+ let mut clients: HashMap<Vec<u8>, ServerConn> = HashMap::new();
340
+ let mut routing: HashMap<Vec<u8>, Vec<u8>> = HashMap::new();
341
+ let mut sessions: HashMap<u64, Vec<u8>> = HashMap::new();
342
+ let mut next_session_id: u64 = 1;
343
+
344
+ // Per-process secret keying the stateless Retry token (see mint_token).
345
+ let token_secret = random_secret();
346
+
347
+ loop {
348
+ let timeout = clients.values().filter_map(|c| c.conn.timeout()).min();
349
+ if poll.poll(&mut events, timeout).is_err() {
350
+ continue;
351
+ }
352
+
353
+ let mut out: Vec<ServerMsg> = Vec::new();
354
+
355
+ // 1. Read datagrams and route them, up to a per-wake budget so a flood
356
+ // cannot starve the rest of the loop (commands, timeouts, reaping).
357
+ let mut got_packet = false;
358
+ let mut budget = MAX_RECV_PER_WAKE;
359
+ loop {
360
+ if budget == 0 {
361
+ break;
362
+ }
363
+ budget -= 1;
364
+ let (len, from) = match socket.recv_from(&mut recv_buf) {
365
+ Ok(v) => v,
366
+ Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => break,
367
+ Err(_) => break,
368
+ };
369
+ got_packet = true;
370
+ let pkt = &mut recv_buf[..len];
371
+ let hdr = match quiche::Header::from_slice(pkt, LOCAL_CONN_ID_LEN) {
372
+ Ok(h) => h,
373
+ Err(_) => continue,
374
+ };
375
+
376
+ let scid = match routing.get(&hdr.dcid.to_vec()).cloned() {
377
+ Some(s) => s,
378
+ None => {
379
+ if hdr.ty != quiche::Type::Initial {
380
+ continue;
381
+ }
382
+ // Cap concurrent connections to bound memory under a flood.
383
+ if clients.len() >= MAX_CONNECTIONS {
384
+ continue;
385
+ }
386
+
387
+ let token = hdr.token.as_deref().unwrap_or(&[]);
388
+ if token.is_empty() {
389
+ // No address validation yet: reply with a stateless Retry.
390
+ // We create no connection state (and do not amplify) for a
391
+ // source that has not proven it owns its address.
392
+ let new_scid = random_scid();
393
+ let new_scid_id = quiche::ConnectionId::from_ref(&new_scid);
394
+ let retry_token = mint_token(&token_secret, &hdr.dcid, &from);
395
+ if let Ok(len) = quiche::retry(
396
+ &hdr.scid,
397
+ &hdr.dcid,
398
+ &new_scid_id,
399
+ &retry_token,
400
+ hdr.version,
401
+ &mut send_buf,
402
+ ) {
403
+ let _ = socket.send_to(&send_buf[..len], from);
404
+ }
405
+ continue;
406
+ }
407
+
408
+ // The client echoed a Retry token: validate it before we
409
+ // allocate any connection state.
410
+ let Some(odcid) = validate_token(&token_secret, &from, token) else {
411
+ continue;
412
+ };
413
+ // Our Retry SCID, echoed back as this Initial's DCID.
414
+ let scid_bytes = hdr.dcid.to_vec();
415
+ let scid_id = quiche::ConnectionId::from_ref(&scid_bytes);
416
+ let conn =
417
+ match quiche::accept(&scid_id, Some(&odcid), local_addr, from, &mut config)
418
+ {
419
+ Ok(c) => c,
420
+ Err(_) => continue,
421
+ };
422
+ let key = scid_bytes;
423
+ let session_id = next_session_id;
424
+ next_session_id += 1;
425
+ routing.insert(key.clone(), key.clone());
426
+ sessions.insert(session_id, key.clone());
427
+ clients.insert(
428
+ key.clone(),
429
+ ServerConn {
430
+ conn,
431
+ session: WtSession::new_server(from),
432
+ session_id,
433
+ closed_emitted: false,
434
+ },
435
+ );
436
+ key
437
+ }
438
+ };
439
+
440
+ if let Some(server) = clients.get_mut(&scid) {
441
+ let info = quiche::RecvInfo {
442
+ from,
443
+ to: local_addr,
444
+ };
445
+ let _ = server.conn.recv(pkt, info);
446
+ }
447
+ }
448
+
449
+ // 2. Fire elapsed timeouts for every connection. quiche's on_timeout is a
450
+ // no-op unless a timer is actually due, and it must run even while packets
451
+ // keep arriving so idle/half-open connections are reaped under a flood.
452
+ let _ = got_packet;
453
+ for server in clients.values_mut() {
454
+ server.conn.on_timeout();
455
+ }
456
+
457
+ // 3. Drain commands.
458
+ let mut shutdown = false;
459
+ while let Ok(cmd) = rx.try_recv() {
460
+ if matches!(cmd, ServerCommand::Shutdown) {
461
+ shutdown = true;
462
+ break;
463
+ }
464
+ apply_command(&mut clients, &sessions, cmd, &mut out);
465
+ }
466
+ if shutdown {
467
+ for server in clients.values_mut() {
468
+ let _ = server.conn.close(true, 0, b"server shutdown");
469
+ flush_send(&mut server.conn, &socket, &mut send_buf);
470
+ }
471
+ return;
472
+ }
473
+
474
+ // 4. Drive every connection.
475
+ let backpressured = shared.inflight.load(Ordering::Relaxed) >= MAX_INFLIGHT_BATCHES;
476
+ for server in clients.values_mut() {
477
+ let mut evs: Vec<Ev> = Vec::new();
478
+ if server.conn.is_established() {
479
+ server.session.on_established(&mut evs);
480
+ }
481
+ if !backpressured {
482
+ server.session.on_datagrams(&mut server.conn, &mut evs);
483
+ }
484
+ let readable: Vec<u64> = server.conn.readable().collect();
485
+ for id in readable {
486
+ server
487
+ .session
488
+ .on_readable(&mut server.conn, id, backpressured, &mut evs);
489
+ }
490
+ server.session.flush(&mut server.conn, &mut evs);
491
+
492
+ // If the session ended (app close, or a rejected/malformed CONNECT),
493
+ // close the QUIC connection so it drains and gets reaped instead of
494
+ // lingering as a zombie until the idle timeout.
495
+ if server.session.is_closed() && !server.conn.is_closed() && !server.conn.is_draining()
496
+ {
497
+ let _ = server.conn.close(true, 0, b"session closed");
498
+ }
499
+
500
+ if let Some(sz) = server.conn.dgram_max_writable_len() {
501
+ shared
502
+ .max_datagram_size
503
+ .store(sz.saturating_sub(1), Ordering::Relaxed);
504
+ }
505
+
506
+ for ev in evs {
507
+ out.push(ServerMsg::Session(server.session_id, ev));
508
+ }
509
+
510
+ flush_send(&mut server.conn, &socket, &mut send_buf);
511
+ }
512
+
513
+ // 5. Reap closed connections (emit a final Closed for the session).
514
+ for server in clients.values_mut() {
515
+ if server.conn.is_closed() && !server.closed_emitted {
516
+ server.closed_emitted = true;
517
+ if !server.session.is_closed() {
518
+ let (code, reason, remote) = closure_info(&server.conn);
519
+ let mut evs = Vec::new();
520
+ server.session.mark_closed(&mut evs, code, reason, remote);
521
+ for ev in evs {
522
+ out.push(ServerMsg::Session(server.session_id, ev));
523
+ }
524
+ }
525
+ }
526
+ }
527
+ clients.retain(|_, s| {
528
+ if s.conn.is_closed() {
529
+ sessions.remove(&s.session_id);
530
+ false
531
+ } else {
532
+ true
533
+ }
534
+ });
535
+ routing.retain(|_, scid| clients.contains_key(scid));
536
+
537
+ if !out.is_empty() {
538
+ // The sink increments `inflight` before scheduling and the JS
539
+ // callback decrements it, so every emit path stays balanced.
540
+ sink.emit(out);
541
+ }
542
+ }
543
+ }
544
+
545
+ fn apply_command(
546
+ clients: &mut HashMap<Vec<u8>, ServerConn>,
547
+ sessions: &HashMap<u64, Vec<u8>>,
548
+ cmd: ServerCommand,
549
+ out: &mut Vec<ServerMsg>,
550
+ ) {
551
+ let session_id = match &cmd {
552
+ ServerCommand::OpenStream { session, .. }
553
+ | ServerCommand::Write { session, .. }
554
+ | ServerCommand::Fin { session, .. }
555
+ | ServerCommand::ResetStream { session, .. }
556
+ | ServerCommand::StopSending { session, .. }
557
+ | ServerCommand::SetPaused { session, .. }
558
+ | ServerCommand::SendDatagram { session, .. }
559
+ | ServerCommand::CloseSession { session, .. } => *session,
560
+ ServerCommand::Shutdown => return,
561
+ };
562
+ let Some(scid) = sessions.get(&session_id) else {
563
+ return;
564
+ };
565
+ let Some(server) = clients.get_mut(scid) else {
566
+ return;
567
+ };
568
+ // Session-scoped events produced by commands are surfaced on the next drive
569
+ // iteration via the normal event path; here we just mutate session state.
570
+ let mut evs: Vec<Ev> = Vec::new();
571
+ match cmd {
572
+ ServerCommand::OpenStream {
573
+ request_id, bidi, ..
574
+ } => server.session.open_stream(bidi, request_id, &mut evs),
575
+ ServerCommand::Write {
576
+ id,
577
+ data,
578
+ request_id,
579
+ ..
580
+ } => server.session.stream_write(id, data, request_id, &mut evs),
581
+ ServerCommand::Fin { id, .. } => server.session.stream_fin(id),
582
+ ServerCommand::ResetStream { id, code, .. } => {
583
+ server.session.stream_reset(&mut server.conn, id, code)
584
+ }
585
+ ServerCommand::StopSending { id, code, .. } => {
586
+ server
587
+ .session
588
+ .stream_stop_sending(&mut server.conn, id, code)
589
+ }
590
+ ServerCommand::SetPaused { id, paused, .. } => server.session.set_paused(id, paused),
591
+ ServerCommand::SendDatagram {
592
+ data, request_id, ..
593
+ } => server
594
+ .session
595
+ .send_datagram(&mut server.conn, &data, request_id, &mut evs),
596
+ ServerCommand::CloseSession { code, reason, .. } => server.session.close(code, reason),
597
+ ServerCommand::Shutdown => {}
598
+ }
599
+ // Surface events produced synchronously by the command (StreamOpened,
600
+ // WriteAck, DatagramAck), tagged with the session id.
601
+ for ev in evs {
602
+ out.push(ServerMsg::Session(session_id, ev));
603
+ }
604
+ }
605
+
606
+ fn flush_send(conn: &mut quiche::Connection, socket: &UdpSocket, out: &mut [u8]) {
607
+ loop {
608
+ match conn.send(out) {
609
+ Ok((write, info)) => match socket.send_to(&out[..write], info.to) {
610
+ Ok(_) => {}
611
+ Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
612
+ // Kernel send buffer is full. Stop draining rather than
613
+ // discarding packets quiche already accounted as sent; its
614
+ // loss recovery retransmits the frames on a later flush.
615
+ return;
616
+ }
617
+ Err(_) => return,
618
+ },
619
+ Err(quiche::Error::Done) => return,
620
+ Err(_) => return,
621
+ }
622
+ }
623
+ }
624
+
625
+ fn closure_info(conn: &quiche::Connection) -> (u32, Vec<u8>, bool) {
626
+ if let Some(err) = conn.peer_error() {
627
+ return (err.error_code as u32, err.reason.clone(), true);
628
+ }
629
+ if let Some(err) = conn.local_error() {
630
+ return (err.error_code as u32, err.reason.clone(), false);
631
+ }
632
+ (0, Vec::new(), true)
633
+ }
634
+
635
+ #[cfg(test)]
636
+ mod tests {
637
+ use super::*;
638
+
639
+ fn addr(s: &str) -> SocketAddr {
640
+ s.parse().expect("addr")
641
+ }
642
+
643
+ #[test]
644
+ fn token_roundtrip_recovers_dcid() {
645
+ let secret = [7u8; 32];
646
+ let dcid = b"\x11\x22\x33\x44\x55\x66\x77\x88";
647
+ let src = addr("192.0.2.10:4433");
648
+ let token = mint_token(&secret, dcid, &src);
649
+ let recovered = validate_token(&secret, &src, &token).expect("valid token");
650
+ assert_eq!(recovered.as_ref(), &dcid[..]);
651
+ }
652
+
653
+ #[test]
654
+ fn token_rejected_for_different_source_address() {
655
+ let secret = [7u8; 32];
656
+ let dcid = b"abcdefghij";
657
+ let token = mint_token(&secret, dcid, &addr("192.0.2.10:4433"));
658
+ // Spoofed source IP: the whole point of the Retry.
659
+ assert!(validate_token(&secret, &addr("192.0.2.11:4433"), &token).is_none());
660
+ // Same IP, different port: still not the address the token was minted for.
661
+ assert!(validate_token(&secret, &addr("192.0.2.10:5555"), &token).is_none());
662
+ }
663
+
664
+ #[test]
665
+ fn token_rejected_under_a_different_secret() {
666
+ let dcid = b"abcdefghij";
667
+ let src = addr("198.51.100.7:443");
668
+ let token = mint_token(&[1u8; 32], dcid, &src);
669
+ // A server that restarted (new secret) rejects the stale token.
670
+ assert!(validate_token(&[2u8; 32], &src, &token).is_none());
671
+ }
672
+
673
+ #[test]
674
+ fn forged_and_truncated_tokens_are_rejected() {
675
+ let secret = [9u8; 32];
676
+ let src = addr("198.51.100.7:443");
677
+ // Attacker who does not know the secret guesses the layout with a zero tag.
678
+ let mut forged = Vec::new();
679
+ forged.extend_from_slice(b"rwt1");
680
+ forged.extend_from_slice(b"deadbeefdcid");
681
+ forged.extend_from_slice(&[0u8; TOKEN_TAG_LEN]);
682
+ assert!(validate_token(&secret, &src, &forged).is_none());
683
+ // Too short to hold a tag, wrong prefix, empty.
684
+ assert!(validate_token(&secret, &src, b"rwt1short").is_none());
685
+ assert!(validate_token(&secret, &src, b"nope").is_none());
686
+ assert!(validate_token(&secret, &src, b"").is_none());
687
+ // A valid token with a single tag byte flipped.
688
+ let mut token = mint_token(&secret, b"abcdefghij", &src);
689
+ let last = token.len() - 1;
690
+ token[last] ^= 0xff;
691
+ assert!(validate_token(&secret, &src, &token).is_none());
692
+ }
693
+
694
+ #[test]
695
+ fn hmac_is_deterministic_and_key_dependent() {
696
+ assert_eq!(
697
+ hmac_sha256(&[0u8; 32], b"msg"),
698
+ hmac_sha256(&[0u8; 32], b"msg")
699
+ );
700
+ assert_ne!(
701
+ hmac_sha256(&[0u8; 32], b"msg"),
702
+ hmac_sha256(&[1u8; 32], b"msg")
703
+ );
704
+ // Known RFC 4231 test case 1: key=0x0b*20, data="Hi There".
705
+ let key = [0x0bu8; 20];
706
+ let tag = hmac_sha256(&key, b"Hi There");
707
+ let expected =
708
+ hex_to_bytes("b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7");
709
+ assert_eq!(&tag[..], &expected[..]);
710
+ }
711
+
712
+ fn hex_to_bytes(s: &str) -> Vec<u8> {
713
+ (0..s.len())
714
+ .step_by(2)
715
+ .map(|i| u8::from_str_radix(&s[i..i + 2], 16).unwrap())
716
+ .collect()
717
+ }
718
+ }