1#![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
43pub 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
51pub 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
62pub 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
86pub 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
115pub 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
141pub 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
161pub 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
195pub 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
229pub 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
255pub 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
273pub 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
290pub 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
304pub 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
325pub 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
345pub 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
378pub 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
392pub 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
429pub 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
439pub 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}