rwebtransport 0.2.2 → 0.2.5
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.
- package/Cargo.lock +523 -140
- package/Cargo.toml +5 -5
- package/README.md +8 -4
- package/crates/echo-server/src/bin/gen-test-cert.rs +1 -1
- package/crates/native/Cargo.toml +2 -0
- package/crates/native/src/config.rs +69 -8
- package/crates/native/src/driver.rs +253 -90
- package/crates/native/src/lib.rs +80 -57
- package/crates/native/src/parser_memory.rs +203 -0
- package/crates/native/src/server.rs +215 -183
- package/crates/native/src/session.rs +1341 -243
- package/crates/native/src/test_support.rs +119 -0
- package/crates/wtcore/Cargo.toml +1 -0
- package/crates/wtcore/src/h3.rs +250 -46
- package/dist/index.js +218 -75
- package/dist/index.js.map +7 -1
- package/dist/index.mjs +214 -69
- package/dist/index.mjs.map +7 -1
- package/dist/native.d.ts +10 -4
- package/dist/server.d.ts +1 -0
- package/package.json +84 -78
- package/prebuilds/darwin-arm64/rwebtransport.node +0 -0
- package/prebuilds/linux-arm64/rwebtransport.node +0 -0
- package/prebuilds/linux-x64/rwebtransport.node +0 -0
- package/prebuilds/win32-x64/rwebtransport.node +0 -0
- package/scripts/build-linux-prebuilt.sh +46 -0
- package/scripts/build-ts.js +41 -0
- package/scripts/build.js +10 -3
- package/vendor/quiche/AGENTS.md +10 -0
- package/vendor/quiche/Cargo.lock +239 -248
- package/vendor/quiche/Cargo.toml +23 -10
- package/vendor/quiche/examples/Makefile +4 -4
- package/vendor/quiche/examples/client.rs +10 -28
- package/vendor/quiche/examples/http3-client.rs +20 -34
- package/vendor/quiche/examples/http3-server.rs +47 -78
- package/vendor/quiche/examples/server.rs +19 -49
- package/vendor/quiche/include/quiche.h +35 -4
- package/vendor/quiche/src/build.rs +17 -0
- package/vendor/quiche/src/cid.rs +129 -61
- package/vendor/quiche/src/crypto/boringssl.rs +98 -86
- package/vendor/quiche/src/crypto/mod.rs +64 -77
- package/vendor/quiche/src/dgram.rs +2 -3
- package/vendor/quiche/src/error.rs +22 -20
- package/vendor/quiche/src/ffi.rs +558 -280
- package/vendor/quiche/src/flowcontrol.rs +0 -7
- package/vendor/quiche/src/frame.rs +134 -135
- package/vendor/quiche/src/h3/ffi.rs +73 -60
- package/vendor/quiche/src/h3/frame.rs +70 -90
- package/vendor/quiche/src/h3/mod.rs +1024 -593
- package/vendor/quiche/src/h3/qpack/decoder.rs +248 -34
- package/vendor/quiche/src/h3/qpack/dynamic_table.rs +859 -0
- package/vendor/quiche/src/h3/qpack/encoder.rs +14 -17
- package/vendor/quiche/src/h3/qpack/mod.rs +48 -0
- package/vendor/quiche/src/h3/qpack/static_table.rs +86 -73
- package/vendor/quiche/src/h3/stream.rs +1009 -194
- package/vendor/quiche/src/lib.rs +1361 -1195
- package/vendor/quiche/src/minmax.rs +2 -6
- package/vendor/quiche/src/packet.rs +420 -552
- package/vendor/quiche/src/path.rs +202 -72
- package/vendor/quiche/src/pmtud.rs +18 -16
- package/vendor/quiche/src/ranges.rs +184 -82
- package/vendor/quiche/src/recovery/AGENTS.md +5 -2
- package/vendor/quiche/src/recovery/bandwidth.rs +59 -40
- package/vendor/quiche/src/recovery/bytes_in_flight.rs +2 -2
- package/vendor/quiche/src/recovery/congestion/cubic.rs +38 -47
- package/vendor/quiche/src/recovery/congestion/delivery_rate.rs +54 -60
- package/vendor/quiche/src/recovery/congestion/hystart.rs +6 -10
- package/vendor/quiche/src/recovery/congestion/mod.rs +110 -42
- package/vendor/quiche/src/recovery/congestion/prr.rs +4 -1
- package/vendor/quiche/src/recovery/congestion/recovery.rs +91 -95
- package/vendor/quiche/src/recovery/congestion/reno.rs +17 -12
- package/vendor/quiche/src/recovery/congestion/test_sender.rs +8 -27
- package/vendor/quiche/src/recovery/gcongestion/bbr/bandwidth_sampler.rs +159 -247
- package/vendor/quiche/src/recovery/gcongestion/bbr/windowed_filter.rs +9 -14
- package/vendor/quiche/src/recovery/gcongestion/bbr2/drain.rs +18 -15
- package/vendor/quiche/src/recovery/gcongestion/bbr2/mode.rs +43 -28
- package/vendor/quiche/src/recovery/gcongestion/bbr2/network_model.rs +349 -76
- package/vendor/quiche/src/recovery/gcongestion/bbr2/probe_bw.rs +147 -195
- package/vendor/quiche/src/recovery/gcongestion/bbr2/probe_rtt.rs +29 -27
- package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/global_min.rs +180 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/global_min_tests.rs +221 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/hmm.rs +395 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/hmm_tests.rs +473 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/mod.rs +175 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr2/startup.rs +33 -26
- package/vendor/quiche/src/recovery/gcongestion/bbr2.rs +107 -60
- package/vendor/quiche/src/recovery/gcongestion/mod.rs +64 -11
- package/vendor/quiche/src/recovery/gcongestion/pacer.rs +34 -25
- package/vendor/quiche/src/recovery/gcongestion/recovery.rs +81 -86
- package/vendor/quiche/src/recovery/mod.rs +414 -173
- package/vendor/quiche/src/recovery/rtt.rs +8 -5
- package/vendor/quiche/src/stream/mod.rs +864 -133
- package/vendor/quiche/src/stream/recv_buf.rs +476 -172
- package/vendor/quiche/src/stream/send_buf.rs +343 -81
- package/vendor/quiche/src/test_utils.rs +78 -64
- package/vendor/quiche/src/tests.rs +2559 -1335
- package/vendor/quiche/src/tls/boringssl.rs +60 -63
- package/vendor/quiche/src/tls/mod.rs +146 -193
- package/vendor/quiche/src/transport_params.rs +87 -103
|
@@ -14,6 +14,7 @@ use std::net::SocketAddr;
|
|
|
14
14
|
use std::sync::atomic::Ordering;
|
|
15
15
|
use std::sync::mpsc::Receiver;
|
|
16
16
|
use std::sync::Arc;
|
|
17
|
+
use std::time::{Duration, Instant};
|
|
17
18
|
|
|
18
19
|
use mio::net::UdpSocket;
|
|
19
20
|
use mio::{Events, Interest, Poll};
|
|
@@ -21,20 +22,22 @@ use mio::{Events, Interest, Poll};
|
|
|
21
22
|
use wtcore::h3;
|
|
22
23
|
|
|
23
24
|
use crate::config::build_server_config;
|
|
24
|
-
use crate::driver::{
|
|
25
|
-
|
|
25
|
+
use crate::driver::{
|
|
26
|
+
is_udp_port_unreachable, DriverShared, MAX_INFLIGHT_BATCHES, MAX_RECV_PER_WAKE,
|
|
27
|
+
MAX_RECV_UDP_PAYLOAD, SOCKET_TOKEN,
|
|
28
|
+
};
|
|
29
|
+
use crate::parser_memory::ParserMemory;
|
|
30
|
+
use crate::session::{Ev, ReceiveBudget, WtSession};
|
|
26
31
|
|
|
27
32
|
const LOCAL_CONN_ID_LEN: usize = 16;
|
|
28
|
-
const MAX_INFLIGHT_BATCHES: i64 = 128;
|
|
29
33
|
|
|
30
|
-
///
|
|
31
|
-
|
|
32
|
-
const
|
|
34
|
+
/// Cap live transport state, including incomplete handshakes and draining connections.
|
|
35
|
+
const MAX_CONNECTIONS: usize = 256;
|
|
36
|
+
const SESSION_SETUP_TIMEOUT: Duration = Duration::from_secs(10);
|
|
33
37
|
|
|
34
|
-
///
|
|
35
|
-
///
|
|
36
|
-
|
|
37
|
-
const MAX_RECV_PER_WAKE: usize = 1024;
|
|
38
|
+
/// Aggregate allocation capacity of HTTP/3, classification and capsule parser
|
|
39
|
+
/// buffers across all connections, including handshakes and draining sessions.
|
|
40
|
+
const MAX_PARSER_MEMORY: usize = 64 * 1024 * 1024;
|
|
38
41
|
|
|
39
42
|
/// Everything the server thread needs to start listening.
|
|
40
43
|
pub struct ServerSetup {
|
|
@@ -160,7 +163,8 @@ struct ServerConn {
|
|
|
160
163
|
conn: quiche::Connection,
|
|
161
164
|
session: WtSession,
|
|
162
165
|
session_id: u64,
|
|
163
|
-
|
|
166
|
+
setup_deadline: Option<Instant>,
|
|
167
|
+
max_datagram_size: usize,
|
|
164
168
|
}
|
|
165
169
|
|
|
166
170
|
/// Server thread entry point, wrapped in a panic boundary.
|
|
@@ -197,10 +201,17 @@ const TOKEN_TAG_LEN: usize = 16;
|
|
|
197
201
|
/// token is bound to. A spoofed source can never receive the Retry, and the tag
|
|
198
202
|
/// is keyed by a per-process secret it does not know, so it cannot forge one.
|
|
199
203
|
fn addr_identity(src: &SocketAddr) -> Vec<u8> {
|
|
200
|
-
let mut id =
|
|
201
|
-
|
|
202
|
-
std::net::IpAddr::
|
|
203
|
-
|
|
204
|
+
let mut id = Vec::with_capacity(19);
|
|
205
|
+
match src.ip() {
|
|
206
|
+
std::net::IpAddr::V4(a) => {
|
|
207
|
+
id.push(4);
|
|
208
|
+
id.extend_from_slice(&a.octets());
|
|
209
|
+
}
|
|
210
|
+
std::net::IpAddr::V6(a) => {
|
|
211
|
+
id.push(6);
|
|
212
|
+
id.extend_from_slice(&a.octets());
|
|
213
|
+
}
|
|
214
|
+
}
|
|
204
215
|
id.extend_from_slice(&src.port().to_be_bytes());
|
|
205
216
|
id
|
|
206
217
|
}
|
|
@@ -231,85 +242,55 @@ fn hmac_sha256(secret: &[u8], data: &[u8]) -> [u8; 32] {
|
|
|
231
242
|
boring::sha::sha256(&outer)
|
|
232
243
|
}
|
|
233
244
|
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
if a.len() != b.len() {
|
|
238
|
-
return false;
|
|
239
|
-
}
|
|
240
|
-
let mut diff = 0u8;
|
|
241
|
-
for (x, y) in a.iter().zip(b.iter()) {
|
|
242
|
-
diff |= x ^ y;
|
|
243
|
-
}
|
|
244
|
-
diff == 0
|
|
245
|
+
struct RetryTokens {
|
|
246
|
+
secret: [u8; 32],
|
|
247
|
+
started: Instant,
|
|
245
248
|
}
|
|
246
249
|
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
/// `b"rwt1" || orig_dcid || HMAC(secret, addr || orig_dcid)[..16]`. Because the
|
|
250
|
-
/// tag is keyed by a secret known only to this process, a spoofed source cannot
|
|
251
|
-
/// forge a token it never received, which is what makes the Retry actually
|
|
252
|
-
/// prevent source-address spoofing (reflection) and state exhaustion rather than
|
|
253
|
-
/// just being a formality.
|
|
254
|
-
fn mint_token(secret: &[u8], orig_dcid: &[u8], src: &SocketAddr) -> Vec<u8> {
|
|
255
|
-
let mut mac_input = addr_identity(src);
|
|
256
|
-
mac_input.extend_from_slice(orig_dcid);
|
|
257
|
-
let tag = hmac_sha256(secret, &mac_input);
|
|
258
|
-
let mut token = Vec::with_capacity(4 + orig_dcid.len() + TOKEN_TAG_LEN);
|
|
259
|
-
token.extend_from_slice(b"rwt1");
|
|
260
|
-
token.extend_from_slice(orig_dcid);
|
|
261
|
-
token.extend_from_slice(&tag[..TOKEN_TAG_LEN]);
|
|
262
|
-
token
|
|
263
|
-
}
|
|
250
|
+
impl RetryTokens {
|
|
251
|
+
const TTL: Duration = Duration::from_secs(10);
|
|
264
252
|
|
|
265
|
-
///
|
|
266
|
-
///
|
|
267
|
-
fn
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
|
|
271
|
-
)
|
|
272
|
-
let rest = token.strip_prefix(b"rwt1")?;
|
|
273
|
-
if rest.len() < TOKEN_TAG_LEN {
|
|
274
|
-
return None;
|
|
275
|
-
}
|
|
276
|
-
let (orig_dcid, tag) = rest.split_at(rest.len() - TOKEN_TAG_LEN);
|
|
277
|
-
let mut mac_input = addr_identity(src);
|
|
278
|
-
mac_input.extend_from_slice(orig_dcid);
|
|
279
|
-
let expected = hmac_sha256(secret, &mac_input);
|
|
280
|
-
if !constant_time_eq(&expected[..TOKEN_TAG_LEN], tag) {
|
|
281
|
-
return None;
|
|
253
|
+
/// Authenticate the timestamp and original DCID, binding the token to both
|
|
254
|
+
/// the source address and the DCID that this Retry issued.
|
|
255
|
+
fn tag(&self, src: &SocketAddr, retry_scid: &[u8], body: &[u8]) -> [u8; 32] {
|
|
256
|
+
let mut input = addr_identity(src);
|
|
257
|
+
input.extend_from_slice(retry_scid);
|
|
258
|
+
input.extend_from_slice(body);
|
|
259
|
+
hmac_sha256(&self.secret, &input)
|
|
282
260
|
}
|
|
283
|
-
Some(quiche::ConnectionId::from_ref(orig_dcid))
|
|
284
|
-
}
|
|
285
261
|
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
|
|
289
|
-
|
|
290
|
-
|
|
291
|
-
let seed: u128 = std::time::SystemTime::now()
|
|
292
|
-
.duration_since(std::time::UNIX_EPOCH)
|
|
293
|
-
.map(|d| d.as_nanos())
|
|
294
|
-
.unwrap_or(0);
|
|
295
|
-
let s = seed.to_le_bytes();
|
|
296
|
-
for (i, slot) in b.iter_mut().enumerate() {
|
|
297
|
-
*slot = s[i % s.len()];
|
|
298
|
-
}
|
|
262
|
+
fn mint(&self, src: &SocketAddr, retry_scid: &[u8], orig_dcid: &[u8]) -> Vec<u8> {
|
|
263
|
+
let mut token = self.started.elapsed().as_secs().to_be_bytes().to_vec();
|
|
264
|
+
token.extend_from_slice(orig_dcid);
|
|
265
|
+
token.extend_from_slice(&self.tag(src, retry_scid, &token)[..TOKEN_TAG_LEN]);
|
|
266
|
+
token
|
|
299
267
|
}
|
|
300
|
-
b
|
|
301
|
-
}
|
|
302
268
|
|
|
303
|
-
fn
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
269
|
+
fn validate<'a>(
|
|
270
|
+
&self,
|
|
271
|
+
src: &SocketAddr,
|
|
272
|
+
retry_scid: &[u8],
|
|
273
|
+
token: &'a [u8],
|
|
274
|
+
) -> Option<quiche::ConnectionId<'a>> {
|
|
275
|
+
const TIMESTAMP_LEN: usize = size_of::<u64>();
|
|
276
|
+
if retry_scid.len() != LOCAL_CONN_ID_LEN
|
|
277
|
+
|| !(TIMESTAMP_LEN + 8 + TOKEN_TAG_LEN
|
|
278
|
+
..=TIMESTAMP_LEN + quiche::MAX_CONN_ID_LEN + TOKEN_TAG_LEN)
|
|
279
|
+
.contains(&token.len())
|
|
280
|
+
{
|
|
281
|
+
return None;
|
|
282
|
+
}
|
|
283
|
+
let (body, tag) = token.split_at(token.len() - TOKEN_TAG_LEN);
|
|
284
|
+
let (issued, orig_dcid) = body.split_at(TIMESTAMP_LEN);
|
|
285
|
+
let issued = u64::from_be_bytes(issued.try_into().ok()?);
|
|
286
|
+
let age = self.started.elapsed().as_secs().checked_sub(issued)?;
|
|
287
|
+
if age > Self::TTL.as_secs()
|
|
288
|
+
|| !boring::memcmp::eq(&self.tag(src, retry_scid, body)[..TOKEN_TAG_LEN], tag)
|
|
289
|
+
{
|
|
290
|
+
return None;
|
|
291
|
+
}
|
|
292
|
+
Some(quiche::ConnectionId::from_ref(orig_dcid))
|
|
311
293
|
}
|
|
312
|
-
b
|
|
313
294
|
}
|
|
314
295
|
|
|
315
296
|
fn run_inner(
|
|
@@ -319,7 +300,12 @@ fn run_inner(
|
|
|
319
300
|
sink: &dyn ServerEventSink,
|
|
320
301
|
shared: &Arc<DriverShared>,
|
|
321
302
|
) {
|
|
322
|
-
let bind: SocketAddr = match
|
|
303
|
+
let bind: SocketAddr = match setup
|
|
304
|
+
.host
|
|
305
|
+
.trim_matches(['[', ']'])
|
|
306
|
+
.parse::<std::net::IpAddr>()
|
|
307
|
+
.map(|ip| SocketAddr::new(ip, setup.port))
|
|
308
|
+
{
|
|
323
309
|
Ok(a) => a,
|
|
324
310
|
Err(e) => {
|
|
325
311
|
sink.emit(vec![ServerMsg::ServerError(format!(
|
|
@@ -357,6 +343,17 @@ fn run_inner(
|
|
|
357
343
|
return;
|
|
358
344
|
}
|
|
359
345
|
|
|
346
|
+
let mut secret = [0; 32];
|
|
347
|
+
if let Err(e) = getrandom::fill(&mut secret) {
|
|
348
|
+
sink.emit(vec![ServerMsg::ServerError(format!(
|
|
349
|
+
"Retry key generation: {e}"
|
|
350
|
+
))]);
|
|
351
|
+
return;
|
|
352
|
+
}
|
|
353
|
+
let tokens = RetryTokens {
|
|
354
|
+
secret,
|
|
355
|
+
started: Instant::now(),
|
|
356
|
+
};
|
|
360
357
|
sink.emit(vec![ServerMsg::Listening(local_addr.port())]);
|
|
361
358
|
|
|
362
359
|
let mut events = Events::with_capacity(1024);
|
|
@@ -367,33 +364,53 @@ fn run_inner(
|
|
|
367
364
|
let mut routing: HashMap<Vec<u8>, Vec<u8>> = HashMap::new();
|
|
368
365
|
let mut sessions: HashMap<u64, Vec<u8>> = HashMap::new();
|
|
369
366
|
let mut next_session_id: u64 = 1;
|
|
367
|
+
let parser_memory = ParserMemory::new(MAX_PARSER_MEMORY);
|
|
370
368
|
|
|
371
|
-
|
|
372
|
-
let
|
|
369
|
+
let mut udp_pending = false;
|
|
370
|
+
let mut read_pending = false;
|
|
371
|
+
let mut next_connection: usize = 0;
|
|
373
372
|
|
|
374
373
|
loop {
|
|
375
|
-
let
|
|
376
|
-
if
|
|
377
|
-
|
|
374
|
+
let can_read = shared.inflight.load(Ordering::Relaxed) < MAX_INFLIGHT_BATCHES;
|
|
375
|
+
let timeout = if udp_pending || (read_pending && can_read) {
|
|
376
|
+
Some(Duration::ZERO)
|
|
377
|
+
} else {
|
|
378
|
+
let now = Instant::now();
|
|
379
|
+
clients
|
|
380
|
+
.values()
|
|
381
|
+
.flat_map(|c| {
|
|
382
|
+
[
|
|
383
|
+
c.conn.timeout(),
|
|
384
|
+
c.setup_deadline.map(|d| d.saturating_duration_since(now)),
|
|
385
|
+
]
|
|
386
|
+
})
|
|
387
|
+
.flatten()
|
|
388
|
+
.min()
|
|
389
|
+
};
|
|
390
|
+
if let Err(e) = poll.poll(&mut events, timeout) {
|
|
391
|
+
if e.kind() == std::io::ErrorKind::Interrupted {
|
|
392
|
+
continue;
|
|
393
|
+
}
|
|
394
|
+
sink.emit(vec![ServerMsg::ServerError(format!("poll error: {e}"))]);
|
|
395
|
+
return;
|
|
378
396
|
}
|
|
379
397
|
|
|
380
398
|
let mut out: Vec<ServerMsg> = Vec::new();
|
|
381
399
|
|
|
382
400
|
// 1. Read datagrams and route them, up to a per-wake budget so a flood
|
|
383
401
|
// cannot starve the rest of the loop (commands, timeouts, reaping).
|
|
384
|
-
let mut got_packet = false;
|
|
385
402
|
let mut budget = MAX_RECV_PER_WAKE;
|
|
386
|
-
|
|
387
|
-
if budget == 0 {
|
|
388
|
-
break;
|
|
389
|
-
}
|
|
403
|
+
while budget > 0 {
|
|
390
404
|
budget -= 1;
|
|
391
405
|
let (len, from) = match socket.recv_from(&mut recv_buf) {
|
|
392
406
|
Ok(v) => v,
|
|
393
407
|
Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => break,
|
|
408
|
+
Err(ref e) if is_udp_port_unreachable(e) => continue,
|
|
394
409
|
Err(_) => break,
|
|
395
410
|
};
|
|
396
|
-
|
|
411
|
+
if len > MAX_RECV_UDP_PAYLOAD {
|
|
412
|
+
continue;
|
|
413
|
+
}
|
|
397
414
|
let pkt = &mut recv_buf[..len];
|
|
398
415
|
let hdr = match quiche::Header::from_slice(pkt, LOCAL_CONN_ID_LEN) {
|
|
399
416
|
Ok(h) => h,
|
|
@@ -403,11 +420,17 @@ fn run_inner(
|
|
|
403
420
|
let scid = match routing.get(&hdr.dcid.to_vec()).cloned() {
|
|
404
421
|
Some(s) => s,
|
|
405
422
|
None => {
|
|
406
|
-
if hdr.ty != quiche::Type::Initial
|
|
423
|
+
if hdr.ty != quiche::Type::Initial
|
|
424
|
+
|| len < 1200
|
|
425
|
+
|| !quiche::version_is_supported(hdr.version)
|
|
426
|
+
|| hdr.dcid.len() < 8
|
|
427
|
+
{
|
|
407
428
|
continue;
|
|
408
429
|
}
|
|
409
430
|
// Cap concurrent connections to bound memory under a flood.
|
|
410
|
-
if clients.len() >= MAX_CONNECTIONS
|
|
431
|
+
if clients.len() >= MAX_CONNECTIONS
|
|
432
|
+
|| shared.inflight.load(Ordering::Relaxed) >= MAX_INFLIGHT_BATCHES
|
|
433
|
+
{
|
|
411
434
|
continue;
|
|
412
435
|
}
|
|
413
436
|
|
|
@@ -416,9 +439,12 @@ fn run_inner(
|
|
|
416
439
|
// No address validation yet: reply with a stateless Retry.
|
|
417
440
|
// We create no connection state (and do not amplify) for a
|
|
418
441
|
// source that has not proven it owns its address.
|
|
419
|
-
let new_scid =
|
|
442
|
+
let mut new_scid = [0; LOCAL_CONN_ID_LEN];
|
|
443
|
+
if getrandom::fill(&mut new_scid).is_err() {
|
|
444
|
+
continue;
|
|
445
|
+
}
|
|
420
446
|
let new_scid_id = quiche::ConnectionId::from_ref(&new_scid);
|
|
421
|
-
let retry_token =
|
|
447
|
+
let retry_token = tokens.mint(&from, &new_scid, &hdr.dcid);
|
|
422
448
|
if let Ok(len) = quiche::retry(
|
|
423
449
|
&hdr.scid,
|
|
424
450
|
&hdr.dcid,
|
|
@@ -434,7 +460,7 @@ fn run_inner(
|
|
|
434
460
|
|
|
435
461
|
// The client echoed a Retry token: validate it before we
|
|
436
462
|
// allocate any connection state.
|
|
437
|
-
let Some(odcid) =
|
|
463
|
+
let Some(odcid) = tokens.validate(&from, &hdr.dcid, token) else {
|
|
438
464
|
continue;
|
|
439
465
|
};
|
|
440
466
|
// Our Retry SCID, echoed back as this Initial's DCID.
|
|
@@ -460,9 +486,11 @@ fn run_inner(
|
|
|
460
486
|
setup.supported_protocols.clone(),
|
|
461
487
|
setup.allowed_origins.clone(),
|
|
462
488
|
setup.response_headers.clone(),
|
|
489
|
+
parser_memory.clone(),
|
|
463
490
|
),
|
|
464
491
|
session_id,
|
|
465
|
-
|
|
492
|
+
setup_deadline: Some(Instant::now() + SESSION_SETUP_TIMEOUT),
|
|
493
|
+
max_datagram_size: 0,
|
|
466
494
|
},
|
|
467
495
|
);
|
|
468
496
|
key
|
|
@@ -477,13 +505,24 @@ fn run_inner(
|
|
|
477
505
|
let _ = server.conn.recv(pkt, info);
|
|
478
506
|
}
|
|
479
507
|
}
|
|
508
|
+
udp_pending = budget == 0;
|
|
480
509
|
|
|
481
510
|
// 2. Fire elapsed timeouts for every connection. quiche's on_timeout is a
|
|
482
511
|
// no-op unless a timer is actually due, and it must run even while packets
|
|
483
512
|
// keep arriving so idle/half-open connections are reaped under a flood.
|
|
484
|
-
let
|
|
513
|
+
let now = Instant::now();
|
|
485
514
|
for server in clients.values_mut() {
|
|
486
515
|
server.conn.on_timeout();
|
|
516
|
+
if server
|
|
517
|
+
.setup_deadline
|
|
518
|
+
.is_some_and(|deadline| now >= deadline)
|
|
519
|
+
{
|
|
520
|
+
// The deadline covers both QUIC handshake and Extended CONNECT.
|
|
521
|
+
server.setup_deadline = None;
|
|
522
|
+
let _ = server
|
|
523
|
+
.conn
|
|
524
|
+
.close(true, h3::H3_NO_ERROR, b"session setup timed out");
|
|
525
|
+
}
|
|
487
526
|
}
|
|
488
527
|
|
|
489
528
|
// 3. Drain commands.
|
|
@@ -504,20 +543,34 @@ fn run_inner(
|
|
|
504
543
|
}
|
|
505
544
|
|
|
506
545
|
// 4. Drive every connection.
|
|
507
|
-
let
|
|
508
|
-
|
|
546
|
+
let can_read = shared.inflight.load(Ordering::Relaxed) < MAX_INFLIGHT_BATCHES;
|
|
547
|
+
let mut budget = ReceiveBudget::new();
|
|
548
|
+
let mut ordered: Vec<_> = clients.values_mut().collect();
|
|
549
|
+
let start = next_connection.checked_rem(ordered.len()).unwrap_or(0);
|
|
550
|
+
ordered.rotate_left(start);
|
|
551
|
+
read_pending = false;
|
|
552
|
+
for (index, server) in ordered.into_iter().enumerate() {
|
|
553
|
+
if server.conn.is_closed() || server.conn.local_error().is_some() {
|
|
554
|
+
flush_send(&mut server.conn, &socket, &mut send_buf);
|
|
555
|
+
continue;
|
|
556
|
+
}
|
|
509
557
|
let mut evs: Vec<Ev> = Vec::new();
|
|
510
558
|
if server.conn.is_established() {
|
|
511
|
-
server
|
|
512
|
-
|
|
513
|
-
|
|
514
|
-
server.session.on_datagrams(&mut server.conn, &mut evs);
|
|
559
|
+
server
|
|
560
|
+
.session
|
|
561
|
+
.on_established(server.conn.reliable_stream_reset_negotiated());
|
|
515
562
|
}
|
|
516
|
-
|
|
517
|
-
for id in readable {
|
|
563
|
+
if can_read && !budget.exhausted() {
|
|
518
564
|
server
|
|
519
565
|
.session
|
|
520
|
-
.
|
|
566
|
+
.read_pending(&mut server.conn, &mut budget, &mut evs);
|
|
567
|
+
if budget.exhausted() {
|
|
568
|
+
next_connection = start + index + 1;
|
|
569
|
+
read_pending = true;
|
|
570
|
+
}
|
|
571
|
+
}
|
|
572
|
+
if server.session.is_ready() {
|
|
573
|
+
server.setup_deadline = None;
|
|
521
574
|
}
|
|
522
575
|
server.session.flush(&mut server.conn, &mut evs);
|
|
523
576
|
|
|
@@ -529,13 +582,18 @@ fn run_inner(
|
|
|
529
582
|
let _ = server.conn.close(true, h3::H3_NO_ERROR, b"");
|
|
530
583
|
}
|
|
531
584
|
|
|
532
|
-
if
|
|
533
|
-
|
|
534
|
-
|
|
535
|
-
.
|
|
585
|
+
if server.session.is_ready() && !server.session.is_closed() {
|
|
586
|
+
let size = server.session.max_datagram_size(&server.conn);
|
|
587
|
+
if size != server.max_datagram_size {
|
|
588
|
+
server.max_datagram_size = size;
|
|
589
|
+
evs.push(Ev::DatagramSize(size));
|
|
590
|
+
}
|
|
536
591
|
}
|
|
537
592
|
|
|
538
593
|
for ev in evs {
|
|
594
|
+
if std::env::var_os("RWT_DEBUG").is_some() && matches!(ev, Ev::Error(_)) {
|
|
595
|
+
eprintln!("[rwt-server] {ev:?}");
|
|
596
|
+
}
|
|
539
597
|
out.push(ServerMsg::Session(server.session_id, ev));
|
|
540
598
|
}
|
|
541
599
|
|
|
@@ -544,24 +602,21 @@ fn run_inner(
|
|
|
544
602
|
|
|
545
603
|
// 5. Reap closed connections (emit a final Closed for the session).
|
|
546
604
|
for server in clients.values_mut() {
|
|
547
|
-
if server.conn.is_closed() && !server.
|
|
548
|
-
|
|
549
|
-
if
|
|
550
|
-
|
|
551
|
-
|
|
552
|
-
|
|
553
|
-
|
|
554
|
-
|
|
555
|
-
|
|
556
|
-
|
|
557
|
-
if let Some(msg) = err {
|
|
558
|
-
evs.push(Ev::Error(msg));
|
|
559
|
-
}
|
|
560
|
-
server.session.mark_closed(&mut evs, code, reason, remote);
|
|
561
|
-
}
|
|
562
|
-
for ev in evs {
|
|
563
|
-
out.push(ServerMsg::Session(server.session_id, ev));
|
|
605
|
+
if server.conn.is_closed() && server.session.is_ready() && !server.session.is_closed() {
|
|
606
|
+
let mut evs = Vec::new();
|
|
607
|
+
if let Some((code, reason)) = server.session.local_close_info() {
|
|
608
|
+
// Locally initiated graceful WebTransport close: surface the
|
|
609
|
+
// WT code/reason (the wire close used H3_NO_ERROR).
|
|
610
|
+
server.session.mark_closed(&mut evs, code, reason, false);
|
|
611
|
+
} else {
|
|
612
|
+
let (code, reason, remote, err) = closure_info(&server.conn);
|
|
613
|
+
if let Some(msg) = err {
|
|
614
|
+
evs.push(Ev::Error(msg));
|
|
564
615
|
}
|
|
616
|
+
server.session.mark_closed(&mut evs, code, reason, remote);
|
|
617
|
+
}
|
|
618
|
+
for ev in evs {
|
|
619
|
+
out.push(ServerMsg::Session(server.session_id, ev));
|
|
565
620
|
}
|
|
566
621
|
}
|
|
567
622
|
}
|
|
@@ -648,7 +703,7 @@ fn apply_command(
|
|
|
648
703
|
context,
|
|
649
704
|
length,
|
|
650
705
|
..
|
|
651
|
-
} => evs.push(
|
|
706
|
+
} => evs.push(server.session.build_keying_material(
|
|
652
707
|
&mut server.conn,
|
|
653
708
|
request_id,
|
|
654
709
|
&label,
|
|
@@ -742,54 +797,31 @@ mod tests {
|
|
|
742
797
|
}
|
|
743
798
|
|
|
744
799
|
#[test]
|
|
745
|
-
fn
|
|
746
|
-
let
|
|
747
|
-
|
|
800
|
+
fn retry_token_authenticates_address_and_connection() {
|
|
801
|
+
let mut tokens = RetryTokens {
|
|
802
|
+
secret: [7; 32],
|
|
803
|
+
started: Instant::now(),
|
|
804
|
+
};
|
|
748
805
|
let src = addr("192.0.2.10:4433");
|
|
749
|
-
let
|
|
750
|
-
let
|
|
751
|
-
|
|
752
|
-
|
|
753
|
-
|
|
754
|
-
|
|
755
|
-
|
|
756
|
-
|
|
757
|
-
|
|
758
|
-
|
|
759
|
-
|
|
760
|
-
|
|
761
|
-
|
|
762
|
-
assert!(
|
|
763
|
-
|
|
764
|
-
|
|
765
|
-
|
|
766
|
-
|
|
767
|
-
|
|
768
|
-
let src = addr("198.51.100.7:443");
|
|
769
|
-
let token = mint_token(&[1u8; 32], dcid, &src);
|
|
770
|
-
// A server that restarted (new secret) rejects the stale token.
|
|
771
|
-
assert!(validate_token(&[2u8; 32], &src, &token).is_none());
|
|
772
|
-
}
|
|
773
|
-
|
|
774
|
-
#[test]
|
|
775
|
-
fn forged_and_truncated_tokens_are_rejected() {
|
|
776
|
-
let secret = [9u8; 32];
|
|
777
|
-
let src = addr("198.51.100.7:443");
|
|
778
|
-
// Attacker who does not know the secret guesses the layout with a zero tag.
|
|
779
|
-
let mut forged = Vec::new();
|
|
780
|
-
forged.extend_from_slice(b"rwt1");
|
|
781
|
-
forged.extend_from_slice(b"deadbeefdcid");
|
|
782
|
-
forged.extend_from_slice(&[0u8; TOKEN_TAG_LEN]);
|
|
783
|
-
assert!(validate_token(&secret, &src, &forged).is_none());
|
|
784
|
-
// Too short to hold a tag, wrong prefix, empty.
|
|
785
|
-
assert!(validate_token(&secret, &src, b"rwt1short").is_none());
|
|
786
|
-
assert!(validate_token(&secret, &src, b"nope").is_none());
|
|
787
|
-
assert!(validate_token(&secret, &src, b"").is_none());
|
|
788
|
-
// A valid token with a single tag byte flipped.
|
|
789
|
-
let mut token = mint_token(&secret, b"abcdefghij", &src);
|
|
790
|
-
let last = token.len() - 1;
|
|
791
|
-
token[last] ^= 0xff;
|
|
792
|
-
assert!(validate_token(&secret, &src, &token).is_none());
|
|
806
|
+
let dcid = b"original id";
|
|
807
|
+
let scid = [42; LOCAL_CONN_ID_LEN];
|
|
808
|
+
let token = tokens.mint(&src, &scid, dcid);
|
|
809
|
+
assert_eq!(tokens.validate(&src, &scid, &token).unwrap().as_ref(), dcid);
|
|
810
|
+
assert!(tokens
|
|
811
|
+
.validate(&addr("192.0.2.11:4433"), &scid, &token)
|
|
812
|
+
.is_none());
|
|
813
|
+
assert!(tokens
|
|
814
|
+
.validate(&addr("192.0.2.10:1234"), &scid, &token)
|
|
815
|
+
.is_none());
|
|
816
|
+
assert!(tokens
|
|
817
|
+
.validate(&src, &[41; LOCAL_CONN_ID_LEN], &token)
|
|
818
|
+
.is_none());
|
|
819
|
+
assert!(tokens.validate(&src, &scid, &token[..7]).is_none());
|
|
820
|
+
let mut altered = token.clone();
|
|
821
|
+
*altered.last_mut().unwrap() ^= 1;
|
|
822
|
+
assert!(tokens.validate(&src, &scid, &altered).is_none());
|
|
823
|
+
tokens.started -= RetryTokens::TTL + Duration::from_secs(1);
|
|
824
|
+
assert!(tokens.validate(&src, &scid, &token).is_none());
|
|
793
825
|
}
|
|
794
826
|
|
|
795
827
|
#[test]
|