Skip to main content

qualia_core_db/p2p/connectivity/
wss.rs

1//! Authenticated WebSocket binary-datagram relay (RFC 6455). Local TCP; not a public URL.
2
3#![cfg(not(target_arch = "wasm32"))]
4
5use std::io::{Read, Write};
6use std::net::{Shutdown, TcpListener, TcpStream};
7use std::time::Duration;
8
9use base64::engine::general_purpose::STANDARD;
10use base64::Engine;
11use hmac::{Hmac, KeyInit, Mac};
12use sha1::{Digest, Sha1};
13use sha2::Sha256;
14
15use crate::net::qdnf::errors::QdnfError;
16
17#[path = "wss_frame.rs"]
18mod wss_frame;
19
20pub use wss_frame::{
21    fresh_client_mask, io_from_qdnf, map_io, ReadCursor, WriteCursor, OP_BINARY, OP_CLOSE,
22    WIRE_CAP, WS_HDR_MAX,
23};
24
25const GUID: &[u8] = b"258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
26pub const MAX_FRAME: usize = 2048;
27pub const ENVELOPE_HDR: usize = 12;
28pub const MAX_PAYLOAD: usize = MAX_FRAME - ENVELOPE_HDR;
29pub const ENVELOPE_VERSION: u8 = 2;
30type HmacSha256 = Hmac<Sha256>;
31
32pub const ENV_CHILD: &str = "QDNF_WSS_RELAY_CHILD";
33pub const ENV_ADDR: &str = "QDNF_WSS_ADDR";
34pub const ENV_SECRET: &str = "QDNF_WSS_SECRET";
35
36#[derive(Debug, Clone, Copy, PartialEq, Eq)]
37pub enum FrameType {
38    Auth = 0,
39    Datagram = 1,
40    Close = 2,
41}
42
43/// RFC 6455 Sec-WebSocket-Accept: base64(SHA-1(key + GUID)).
44pub fn accept_key(sec_key: &str) -> String {
45    let mut h = Sha1::new();
46    h.update(sec_key.as_bytes());
47    h.update(GUID);
48    STANDARD.encode(h.finalize())
49}
50
51/// HMAC-SHA256 over `(circuit, gen)` under `secret` — per-circuit auth token.
52pub fn hmac_auth(secret: &[u8], circuit: u32, gen: u32) -> [u8; 32] {
53    let mut mac = HmacSha256::new_from_slice(secret).expect("hmac key");
54    mac.update(&circuit.to_be_bytes());
55    mac.update(&gen.to_be_bytes());
56    let out = mac.finalize().into_bytes();
57    let mut a = [0u8; 32];
58    a.copy_from_slice(&out);
59    a
60}
61
62/// Encodes a versioned frame envelope `(type, circuit, gen, len, payload)` into `out`; fails closed on capacity.
63pub fn encode_envelope(
64    typ: FrameType,
65    circuit: u32,
66    gen: u32,
67    payload: &[u8],
68    out: &mut [u8],
69) -> Result<usize, &'static str> {
70    if payload.len() > MAX_PAYLOAD {
71        return Err("capacity");
72    }
73    let n = ENVELOPE_HDR + payload.len();
74    if n > MAX_FRAME || out.len() < n {
75        return Err("capacity");
76    }
77    out[0] = ENVELOPE_VERSION;
78    out[1] = typ as u8;
79    out[2..6].copy_from_slice(&circuit.to_be_bytes());
80    out[6..10].copy_from_slice(&gen.to_be_bytes());
81    out[10..12].copy_from_slice(&(payload.len() as u16).to_be_bytes());
82    out[12..n].copy_from_slice(payload);
83    Ok(n)
84}
85
86/// Decodes a frame envelope; fails closed on bad version/obsolete format/truncation.
87pub fn decode_envelope(buf: &[u8]) -> Result<(FrameType, u32, u32, &[u8]), &'static str> {
88    if buf.len() < ENVELOPE_HDR {
89        return Err("envelope");
90    }
91    if buf[0] == 1 {
92        return Err("obsolete-u8-length");
93    }
94    if buf[0] != ENVELOPE_VERSION {
95        return Err("envelope");
96    }
97    let typ = match buf[1] {
98        0 => FrameType::Auth,
99        1 => FrameType::Datagram,
100        2 => FrameType::Close,
101        _ => return Err("type"),
102    };
103    let circuit = u32::from_be_bytes([buf[2], buf[3], buf[4], buf[5]]);
104    let gen = u32::from_be_bytes([buf[6], buf[7], buf[8], buf[9]]);
105    let len = u16::from_be_bytes([buf[10], buf[11]]) as usize;
106    if len > MAX_PAYLOAD {
107        return Err("capacity");
108    }
109    if buf.len() < ENVELOPE_HDR + len {
110        return Err("truncated");
111    }
112    Ok((typ, circuit, gen, &buf[ENVELOPE_HDR..ENVELOPE_HDR + len]))
113}
114
115/// Bound circuit/generation. Wrong circuit is unauthorized; older/other gen is stale.
116pub fn check_circuit_gen(
117    circuit: u32,
118    gen: u32,
119    expect_c: u32,
120    expect_g: u32,
121) -> Result<(), QdnfError> {
122    if circuit != expect_c {
123        return Err(QdnfError::Unauthorized);
124    }
125    if gen != expect_g {
126        return Err(QdnfError::StaleGeneration);
127    }
128    Ok(())
129}
130
131fn encode_env(
132    typ: FrameType,
133    circuit: u32,
134    gen: u32,
135    payload: &[u8],
136    out: &mut [u8],
137) -> Result<usize, QdnfError> {
138    encode_envelope(typ, circuit, gen, payload, out).map_err(|_| QdnfError::Capacity)
139}
140
141/// Seal an application envelope as a WS binary frame. Fresh mask only when idle.
142pub fn seal_datagram(
143    write: &mut WriteCursor,
144    circuit: u32,
145    gen: u32,
146    payload: &[u8],
147    client: bool,
148) -> Result<(), QdnfError> {
149    let mut env = [0u8; MAX_FRAME];
150    let n = encode_env(FrameType::Datagram, circuit, gen, payload, &mut env)?;
151    let mask = if write.pending() {
152        None
153    } else if client {
154        Some(fresh_client_mask()?)
155    } else {
156        None
157    };
158    write.seal(OP_BINARY, &env[..n], mask)
159}
160
161/// Seal an application Close envelope as RFC 6455 opcode 8. Same pending close
162/// resumes. A pending datagram is Conflict and is not aborted or resealed.
163pub fn seal_close(
164    write: &mut WriteCursor,
165    circuit: u32,
166    gen: u32,
167    client: bool,
168) -> Result<(), QdnfError> {
169    if write.pending() {
170        if write.sealed_opcode() == Some(OP_CLOSE) {
171            return Ok(());
172        }
173        return Err(QdnfError::Conflict);
174    }
175    let mut env = [0u8; ENVELOPE_HDR];
176    let n = encode_env(FrameType::Close, circuit, gen, &[], &mut env)?;
177    let mask = if client {
178        Some(fresh_client_mask()?)
179    } else {
180        None
181    };
182    write.seal(OP_CLOSE, &env[..n], mask)
183}
184
185fn decode_env(buf: &[u8]) -> Result<(FrameType, u32, u32, &[u8]), QdnfError> {
186    decode_envelope(buf).map_err(|e| match e {
187        "obsolete-u8-length" => QdnfError::Downgrade,
188        "capacity" => QdnfError::Capacity,
189        "truncated" => QdnfError::Truncated,
190        "type" => QdnfError::Unsupported,
191        _ => QdnfError::Malformed,
192    })
193}
194
195/// Receive one WS frame, decode the envelope, and refuse wrong circuit / stale gen.
196pub fn recv_checked<R: Read>(
197    stream: &mut R,
198    read: &mut ReadCursor,
199    circuit: u32,
200    gen: u32,
201    expect_masked: Option<bool>,
202    out: &mut [u8],
203) -> Result<(FrameType, usize), QdnfError> {
204    let mut env = [0u8; MAX_FRAME];
205    let (opcode, n) = read.recv(stream, &mut env, expect_masked)?;
206    let (typ, c, g, payload) = decode_env(&env[..n])?;
207    check_circuit_gen(c, g, circuit, gen)?;
208    if opcode == OP_CLOSE {
209        if typ != FrameType::Close {
210            return Err(QdnfError::Malformed);
211        }
212        return Ok((FrameType::Close, 0));
213    }
214    if opcode != OP_BINARY {
215        return Err(QdnfError::Unsupported);
216    }
217    if typ == FrameType::Close {
218        return Ok((FrameType::Close, 0));
219    }
220    if payload.len() > out.len() {
221        return Err(QdnfError::Capacity);
222    }
223    if !payload.is_empty() {
224        out[..payload.len()].copy_from_slice(payload);
225    }
226    Ok((typ, payload.len()))
227}
228
229/// Drives the client-side WSS handshake on `stream` with `key_b64`.
230pub fn client_handshake<S: Read + Write>(stream: &mut S, key_b64: &str) -> std::io::Result<()> {
231    let req = format!(
232        "GET /relay HTTP/1.1\r\nHost: localhost\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Key: {key_b64}\r\nSec-WebSocket-Version: 13\r\n\r\n"
233    );
234    stream.write_all(req.as_bytes())?;
235    stream.flush()?;
236    let mut buf = [0u8; 1024];
237    let n = stream.read(&mut buf)?;
238    let text = core::str::from_utf8(&buf[..n]).unwrap_or("");
239    if !text.contains("101") || !text.to_ascii_lowercase().contains("upgrade") {
240        return Err(std::io::Error::new(
241            std::io::ErrorKind::InvalidData,
242            "no 101",
243        ));
244    }
245    let expect = accept_key(key_b64);
246    if !text.contains(&expect) {
247        return Err(std::io::Error::new(
248            std::io::ErrorKind::InvalidData,
249            "bad accept",
250        ));
251    }
252    Ok(())
253}
254
255/// Drives the server-side handshake — reads the request, responds with the computed accept key.
256pub fn server_handshake<S: Read + Write>(stream: &mut S) -> std::io::Result<()> {
257    let mut buf = [0u8; 1024];
258    let n = stream.read(&mut buf)?;
259    let text = core::str::from_utf8(&buf[..n]).unwrap_or("");
260    let key = text
261        .lines()
262        .find_map(|l| l.strip_prefix("Sec-WebSocket-Key: "))
263        .ok_or_else(|| std::io::Error::new(std::io::ErrorKind::InvalidData, "no key"))?
264        .trim();
265    let accept = accept_key(key);
266    let resp = format!(
267        "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: {accept}\r\n\r\n"
268    );
269    stream.write_all(resp.as_bytes())?;
270    stream.flush()
271}
272
273/// Pair of already-upgraded WebSocket ends (same process).
274pub fn loopback_pair() -> std::io::Result<(TcpStream, TcpStream)> {
275    let listener = TcpListener::bind("127.0.0.1:0")?;
276    let addr = listener.local_addr()?;
277    let client = TcpStream::connect(addr)?;
278    let (server, _) = listener.accept()?;
279    client.set_read_timeout(Some(Duration::from_secs(2)))?;
280    server.set_read_timeout(Some(Duration::from_secs(2)))?;
281    let key = STANDARD.encode([7u8; 16]);
282    let mut c = client.try_clone()?;
283    let mut s = server.try_clone()?;
284    let th = std::thread::spawn(move || client_handshake(&mut c, &key));
285    server_handshake(&mut s)?;
286    th.join().unwrap()?;
287    Ok((client, server))
288}
289
290/// Sends a datagram frame on the circuit.
291pub fn send_datagram<W: Write>(
292    stream: &mut W,
293    circuit: u32,
294    gen: u32,
295    payload: &[u8],
296    client: bool,
297) -> std::io::Result<()> {
298    let mut write = WriteCursor::new();
299    seal_datagram(&mut write, circuit, gen, payload, client).map_err(io_from_qdnf)?;
300    write.flush(stream).map_err(io_from_qdnf)?;
301    stream.flush()
302}
303
304/// Receives a datagram frame; returns `(circuit, gen, payload)`.
305pub fn recv_datagram<R: Read>(stream: &mut R) -> std::io::Result<(u32, u32, Vec<u8>)> {
306    let mut read = ReadCursor::new();
307    let mut env = [0u8; MAX_FRAME];
308    let (opcode, n) = read.recv(stream, &mut env, None).map_err(io_from_qdnf)?;
309    if opcode != OP_BINARY {
310        return Err(io_from_qdnf(QdnfError::Malformed));
311    }
312    let (typ, c, g, p) = decode_envelope(&env[..n])
313        .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))?;
314    if typ != FrameType::Datagram {
315        return Err(std::io::Error::new(
316            std::io::ErrorKind::InvalidData,
317            "not datagram",
318        ));
319    }
320    let mut payload = vec![0u8; p.len()];
321    payload.copy_from_slice(p);
322    Ok((c, g, payload))
323}
324
325/// Sends the HMAC auth frame for `(circuit, gen)`.
326pub fn send_auth<W: Write>(
327    stream: &mut W,
328    secret: &[u8],
329    circuit: u32,
330    gen: u32,
331) -> std::io::Result<()> {
332    let tag = hmac_auth(secret, circuit, gen);
333    let mut env = [0u8; MAX_FRAME];
334    let n = encode_envelope(FrameType::Auth, circuit, gen, &tag, &mut env)
335        .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidInput, e))?;
336    let mut write = WriteCursor::new();
337    let mask = fresh_client_mask().map_err(io_from_qdnf)?;
338    write
339        .seal(OP_BINARY, &env[..n], Some(mask))
340        .map_err(io_from_qdnf)?;
341    write.flush(stream).map_err(io_from_qdnf)?;
342    stream.flush()
343}
344
345/// Reads and verifies the peer's auth frame; fails closed on mismatch.
346pub fn expect_auth<R: Read>(
347    stream: &mut R,
348    secret: &[u8],
349    circuit: u32,
350    gen: u32,
351) -> std::io::Result<()> {
352    let mut read = ReadCursor::new();
353    let mut body = [0u8; MAX_FRAME];
354    let (opcode, n) = read
355        .recv(stream, &mut body, Some(true))
356        .map_err(io_from_qdnf)?;
357    if opcode != OP_BINARY {
358        return Err(io_from_qdnf(QdnfError::Malformed));
359    }
360    let (typ, c, g, p) = decode_envelope(&body[..n])
361        .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))?;
362    if typ != FrameType::Auth || c != circuit || g != gen {
363        return Err(std::io::Error::new(
364            std::io::ErrorKind::InvalidData,
365            "auth header",
366        ));
367    }
368    let expect = hmac_auth(secret, circuit, gen);
369    if p != expect {
370        return Err(std::io::Error::new(
371            std::io::ErrorKind::PermissionDenied,
372            "hmac",
373        ));
374    }
375    Ok(())
376}
377
378/// Send opcode-8 Close with envelope `(circuit, gen)` then TCP half-close.
379pub fn close_and_shutdown(
380    stream: &mut TcpStream,
381    circuit: u32,
382    gen: u32,
383    client: bool,
384) -> std::io::Result<()> {
385    let mut write = WriteCursor::new();
386    seal_close(&mut write, circuit, gen, client).map_err(io_from_qdnf)?;
387    write.flush(stream).map_err(io_from_qdnf)?;
388    stream.flush()?;
389    stream.shutdown(Shutdown::Write)
390}
391
392/// Local two-client hub: first two accepted sockets exchange datagrams after HMAC.
393pub fn serve_pair(listener: TcpListener, secret: &[u8]) -> std::io::Result<()> {
394    listener.set_nonblocking(false)?;
395    let (mut a, _) = listener.accept()?;
396    let (mut b, _) = listener.accept()?;
397    a.set_read_timeout(Some(Duration::from_secs(5)))?;
398    b.set_read_timeout(Some(Duration::from_secs(5)))?;
399    server_handshake(&mut a)?;
400    server_handshake(&mut b)?;
401    expect_auth(&mut a, secret, 1, 1)?;
402    expect_auth(&mut b, secret, 1, 1)?;
403    a.set_read_timeout(Some(Duration::from_millis(400)))?;
404    b.set_read_timeout(Some(Duration::from_millis(400)))?;
405    let mut ab = false;
406    let mut ba = false;
407    for _ in 0..8 {
408        if !ab {
409            if let Ok((c, g, p)) = recv_datagram(&mut a) {
410                check_circuit_gen(c, g, 1, 1).map_err(io_from_qdnf)?;
411                send_datagram(&mut b, 1, 1, &p, false)?;
412                ab = true;
413            }
414        }
415        if !ba {
416            if let Ok((c, g, p)) = recv_datagram(&mut b) {
417                check_circuit_gen(c, g, 1, 1).map_err(io_from_qdnf)?;
418                send_datagram(&mut a, 1, 1, &p, false)?;
419                ba = true;
420            }
421        }
422        if ab && ba {
423            break;
424        }
425    }
426    Ok(())
427}
428
429/// TCP-connects to `addr` then performs client handshake + auth exchange under `secret`.
430pub fn dial(addr: std::net::SocketAddr, secret: &[u8]) -> std::io::Result<TcpStream> {
431    let mut s = TcpStream::connect(addr)?;
432    s.set_read_timeout(Some(Duration::from_secs(5)))?;
433    let key = STANDARD.encode([3u8; 16]);
434    client_handshake(&mut s, &key)?;
435    send_auth(&mut s, secret, 1, 1)?;
436    Ok(s)
437}
438
439/// Set after a successful local two-process WSS exchange.
440pub fn local_authenticated_wss_executed() -> bool {
441    crate::p2p::connectivity::two_process::local_wss_two_process_executed()
442}
443
444#[cfg(test)]
445mod tests {
446    use super::*;
447    use std::io::{self, Read, Write};
448
449    struct PartialWrite {
450        sink: Vec<u8>,
451        allow: usize,
452    }
453
454    impl Write for PartialWrite {
455        fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
456            if self.allow == 0 {
457                return Err(io::Error::new(io::ErrorKind::WouldBlock, "block"));
458            }
459            let n = buf.len().min(self.allow);
460            self.sink.extend_from_slice(&buf[..n]);
461            self.allow -= n;
462            Ok(n)
463        }
464        fn flush(&mut self) -> io::Result<()> {
465            Ok(())
466        }
467    }
468
469    struct PartialRead {
470        src: Vec<u8>,
471        off: usize,
472        allow: usize,
473    }
474
475    impl Read for PartialRead {
476        fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
477            if self.allow == 0 {
478                return Err(io::Error::new(io::ErrorKind::WouldBlock, "block"));
479            }
480            if self.off >= self.src.len() {
481                return Ok(0);
482            }
483            let n = buf.len().min(self.src.len() - self.off).min(self.allow);
484            buf[..n].copy_from_slice(&self.src[self.off..self.off + n]);
485            self.off += n;
486            self.allow -= n;
487            Ok(n)
488        }
489    }
490
491    #[test]
492    fn accept_key_rfc6455_sample() {
493        assert_eq!(
494            accept_key("dGhlIHNhbXBsZSBub25jZQ=="),
495            "s3pPLMBiTxaQ9kYGzzhZRbK+xOo="
496        );
497    }
498
499    #[test]
500    fn loopback_ws_datagram() {
501        let (mut c, mut s) = loopback_pair().unwrap();
502        send_datagram(&mut c, 1, 1, b"ping", true).unwrap();
503        let (_, _, p) = recv_datagram(&mut s).unwrap();
504        assert_eq!(p, b"ping");
505    }
506
507    #[test]
508    fn u16_length_keeps_256_and_rejects_oversize() {
509        let mut env = [0u8; MAX_FRAME];
510        let p256 = [0x5au8; 256];
511        let n = encode_envelope(FrameType::Datagram, 1, 1, &p256, &mut env).unwrap();
512        let (_, _, _, body) = decode_envelope(&env[..n]).unwrap();
513        assert_eq!(body, &p256);
514        let too_big = vec![0u8; MAX_PAYLOAD + 1];
515        assert_eq!(
516            encode_envelope(FrameType::Datagram, 1, 1, &too_big, &mut env),
517            Err("capacity")
518        );
519        let mut legacy = [0u8; 20];
520        legacy[0] = 1;
521        assert_eq!(decode_envelope(&legacy), Err("obsolete-u8-length"));
522        let mut oversize = [0u8; 4];
523        oversize[0] = 0x82;
524        oversize[1] = 127;
525        let mut read = ReadCursor::new();
526        let err = read
527            .recv(&mut &oversize[..], &mut [0u8; 8], None)
528            .unwrap_err();
529        assert_eq!(err, QdnfError::Unsupported);
530        let mut frag = [0u8; 4];
531        frag[0] = 0x02;
532        frag[1] = 1;
533        let mut read = ReadCursor::new();
534        let err = read.recv(&mut &frag[..], &mut [0u8; 8], None).unwrap_err();
535        assert_eq!(err, QdnfError::Unsupported);
536    }
537
538    #[test]
539    fn fresh_mask_differs_across_client_frames() {
540        let mut env = [0u8; MAX_FRAME];
541        let n = encode_envelope(FrameType::Datagram, 1, 1, b"abc", &mut env).unwrap();
542        let mut a = WriteCursor::new();
543        let mut b = WriteCursor::new();
544        let ma = fresh_client_mask().unwrap();
545        let mb = fresh_client_mask().unwrap();
546        a.seal(OP_BINARY, &env[..n], Some(ma)).unwrap();
547        b.seal(OP_BINARY, &env[..n], Some(mb)).unwrap();
548        let ga = a.client_mask().unwrap();
549        let gb = b.client_mask().unwrap();
550        assert_ne!(ga, gb);
551        assert_ne!(ga, [1, 2, 3, 4]);
552        assert_ne!(gb, [1, 2, 3, 4]);
553        assert_eq!(ga, ma);
554        assert_eq!(gb, mb);
555        let mut first = Vec::new();
556        let mut second = Vec::new();
557        let mut m1 = [1u8, 2, 3, 4];
558        let mut m2 = [1u8, 2, 3, 4];
559        for _ in 0..8 {
560            first.clear();
561            second.clear();
562            send_datagram(&mut first, 1, 1, b"one", true).unwrap();
563            send_datagram(&mut second, 1, 1, b"two", true).unwrap();
564            assert_eq!(first[1] & 0x80, 0x80);
565            assert_eq!(second[1] & 0x80, 0x80);
566            m1 = [first[2], first[3], first[4], first[5]];
567            m2 = [second[2], second[3], second[4], second[5]];
568            if m1 != m2 && m1 != [1, 2, 3, 4] && m2 != [1, 2, 3, 4] {
569                break;
570            }
571        }
572        assert_ne!(m1, m2);
573        assert_ne!(m1, [1, 2, 3, 4]);
574        assert_ne!(m2, [1, 2, 3, 4]);
575    }
576
577    #[test]
578    fn would_block_write_resumes_same_masked_payload() {
579        let mut env = [0u8; MAX_FRAME];
580        let n = encode_envelope(FrameType::Datagram, 7, 3, b"retain", &mut env).unwrap();
581        let mask = fresh_client_mask().unwrap();
582        let mut write = WriteCursor::new();
583        write.seal(OP_BINARY, &env[..n], Some(mask)).unwrap();
584        let sealed: Vec<u8> = write.sealed_bytes().to_vec();
585        assert_eq!(write.client_mask(), Some(mask));
586        let mut partial = PartialWrite {
587            sink: Vec::new(),
588            allow: 3,
589        };
590        assert_eq!(write.flush(&mut partial), Err(QdnfError::WouldBlock));
591        assert!(write.pending());
592        assert_eq!(write.sealed_bytes(), sealed.as_slice());
593        assert_eq!(write.accepted(), 3);
594        write
595            .seal(OP_BINARY, &env[..n], Some([1, 2, 3, 4]))
596            .unwrap();
597        assert_eq!(write.sealed_bytes(), sealed.as_slice());
598        assert_eq!(write.client_mask(), Some(mask));
599        partial.allow = sealed.len();
600        write.flush(&mut partial).unwrap();
601        assert!(!write.pending());
602        assert_eq!(partial.sink, sealed);
603    }
604
605    #[test]
606    fn would_block_read_resumes_same_frame() {
607        let mut env = [0u8; MAX_FRAME];
608        let n = encode_envelope(FrameType::Datagram, 1, 1, b"split-read", &mut env).unwrap();
609        let mut write = WriteCursor::new();
610        let mask = fresh_client_mask().unwrap();
611        write.seal(OP_BINARY, &env[..n], Some(mask)).unwrap();
612        let sealed: Vec<u8> = write.sealed_bytes().to_vec();
613        let mut src = PartialRead {
614            src: sealed,
615            off: 0,
616            allow: 2,
617        };
618        let mut read = ReadCursor::new();
619        let mut out = [0u8; MAX_FRAME];
620        assert_eq!(
621            read.recv(&mut src, &mut out, Some(true)),
622            Err(QdnfError::WouldBlock)
623        );
624        assert!(read.pending());
625        src.allow = 3;
626        assert_eq!(
627            read.recv(&mut src, &mut out, Some(true)),
628            Err(QdnfError::WouldBlock)
629        );
630        src.allow = usize::MAX;
631        let (opcode, got) = read.recv(&mut src, &mut out, Some(true)).unwrap();
632        assert_eq!(opcode, OP_BINARY);
633        let (typ, c, g, p) = decode_envelope(&out[..got]).unwrap();
634        assert_eq!(typ, FrameType::Datagram);
635        assert_eq!((c, g), (1, 1));
636        assert_eq!(p, b"split-read");
637        assert!(!read.pending());
638    }
639
640    #[test]
641    fn pending_datagram_then_seal_close_is_conflict() {
642        let mut env = [0u8; MAX_FRAME];
643        let n = encode_envelope(FrameType::Datagram, 1, 1, b"live", &mut env).unwrap();
644        let mut write = WriteCursor::new();
645        write
646            .seal(OP_BINARY, &env[..n], Some(fresh_client_mask().unwrap()))
647            .unwrap();
648        let sealed: Vec<u8> = write.sealed_bytes().to_vec();
649        let mut partial = PartialWrite {
650            sink: Vec::new(),
651            allow: 2,
652        };
653        assert_eq!(write.flush(&mut partial), Err(QdnfError::WouldBlock));
654        let off = write.accepted();
655        assert_eq!(seal_close(&mut write, 1, 1, true), Err(QdnfError::Conflict));
656        assert_eq!(write.sealed_bytes(), sealed.as_slice());
657        assert_eq!(write.accepted(), off);
658        assert_eq!(write.sealed_opcode(), Some(OP_BINARY));
659    }
660
661    #[test]
662    fn close_frame_then_shutdown() {
663        let mut write = WriteCursor::new();
664        seal_close(&mut write, 1, 1, true).unwrap();
665        assert_eq!(write.sealed_opcode(), Some(OP_CLOSE));
666        let sealed: Vec<u8> = write.sealed_bytes().to_vec();
667        assert_eq!(sealed[0], 0x88);
668        assert_eq!(sealed[1] & 0x80, 0x80);
669        let mut partial = PartialWrite {
670            sink: Vec::new(),
671            allow: 1,
672        };
673        assert_eq!(write.flush(&mut partial), Err(QdnfError::WouldBlock));
674        seal_close(&mut write, 1, 1, true).unwrap();
675        assert_eq!(write.sealed_bytes(), sealed.as_slice());
676        partial.allow = sealed.len();
677        write.flush(&mut partial).unwrap();
678        assert_eq!(partial.sink, sealed);
679
680        let (mut c, mut s) = loopback_pair().unwrap();
681        close_and_shutdown(&mut c, 1, 1, true).unwrap();
682        let mut read = ReadCursor::new();
683        let mut out = [0u8; MAX_FRAME];
684        let (opcode, got) = read.recv(&mut s, &mut out, Some(true)).unwrap();
685        assert_eq!(opcode, OP_CLOSE);
686        let (typ, circ, gen, p) = decode_envelope(&out[..got]).unwrap();
687        assert_eq!(typ, FrameType::Close);
688        assert_eq!((circ, gen), (1, 1));
689        assert!(p.is_empty());
690        let mut tail = [0u8; 1];
691        assert_eq!(s.read(&mut tail).unwrap(), 0);
692        assert!(c.write(&[1]).is_err());
693    }
694
695    #[test]
696    fn stale_generation_or_wrong_circuit_refused() {
697        let (mut c, mut s) = loopback_pair().unwrap();
698        send_datagram(&mut c, 1, 2, b"stale", true).unwrap();
699        let mut read = ReadCursor::new();
700        let mut out = [0u8; MAX_FRAME];
701        let err = recv_checked(&mut s, &mut read, 1, 1, Some(true), &mut out).unwrap_err();
702        assert_eq!(err, QdnfError::StaleGeneration);
703        send_datagram(&mut c, 9, 1, b"wrong", true).unwrap();
704        let mut read = ReadCursor::new();
705        let err = recv_checked(&mut s, &mut read, 1, 1, Some(true), &mut out).unwrap_err();
706        assert_eq!(err, QdnfError::Unauthorized);
707        send_datagram(&mut c, 1, 1, b"ok", true).unwrap();
708        let mut read = ReadCursor::new();
709        let (typ, n) = recv_checked(&mut s, &mut read, 1, 1, Some(true), &mut out).unwrap();
710        assert_eq!(typ, FrameType::Datagram);
711        assert_eq!(&out[..n], b"ok");
712        assert_eq!(
713            check_circuit_gen(1, 0, 1, 1),
714            Err(QdnfError::StaleGeneration)
715        );
716        assert_eq!(check_circuit_gen(2, 1, 1, 1), Err(QdnfError::Unauthorized));
717    }
718
719    #[test]
720    fn server_frames_unmasked() {
721        let mut wire = Vec::new();
722        send_datagram(&mut wire, 1, 1, b"srv", false).unwrap();
723        assert_eq!(wire[0], 0x82);
724        assert_eq!(wire[1] & 0x80, 0);
725        let mut env = [0u8; MAX_FRAME];
726        let n = encode_envelope(FrameType::Datagram, 1, 1, b"srv", &mut env).unwrap();
727        let mut write = WriteCursor::new();
728        write.seal(OP_BINARY, &env[..n], None).unwrap();
729        assert!(write.client_mask().is_none());
730        let mut sealed = write.sealed_bytes();
731        assert_eq!(sealed[1] & 0x80, 0);
732        let hdr = if n < 126 { 2 } else { 4 };
733        assert_eq!(&sealed[hdr..], &env[..n]);
734        let mut read = ReadCursor::new();
735        let mut out = [0u8; MAX_FRAME];
736        let (opcode, got) = read.recv(&mut sealed, &mut out, Some(false)).unwrap();
737        assert_eq!(opcode, OP_BINARY);
738        let (_, _, _, p) = decode_envelope(&out[..got]).unwrap();
739        assert_eq!(p, b"srv");
740        let mut masked = WriteCursor::new();
741        masked
742            .seal(OP_BINARY, &env[..n], Some([9, 8, 7, 6]))
743            .unwrap();
744        let mut masked_bytes = masked.sealed_bytes();
745        let mut read = ReadCursor::new();
746        let err = read
747            .recv(&mut masked_bytes, &mut out, Some(false))
748            .unwrap_err();
749        assert_eq!(err, QdnfError::Malformed);
750    }
751}