lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

wire_tests.rs (12374B)


      1 use super::*;
      2 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
      3 
      4 const UPGRADE: &[u8] = b"HTTP/1.1 101 Switching Protocols\r\n\r\n";
      5 const MAX_MESSAGE_BYTES: usize = 512 * 1024;
      6 
      7 fn upgraded() -> WireParser {
      8     let mut parser = WireParser::new(MAX_MESSAGE_BYTES);
      9     parser
     10         .consume(UPGRADE, |_| panic!("HTTP is not a frame"))
     11         .expect("upgrade");
     12     parser
     13 }
     14 
     15 fn header(length: u64) -> Vec<u8> {
     16     let mut bytes = vec![0x82, 127];
     17     bytes.extend(length.to_be_bytes());
     18     bytes
     19 }
     20 
     21 #[test]
     22 fn maximum_frame_length_is_admitted_and_next_byte_or_overflow_is_denied() {
     23     let maximum = MAX_MESSAGE_BYTES as u64;
     24     let mut parser = upgraded();
     25     parser
     26         .consume(&header(maximum), |_| true)
     27         .expect("exact limit");
     28     assert_eq!(parser.payload_remaining, maximum as usize);
     29     for length in [maximum + 1, 1 << 63, u64::MAX] {
     30         assert!(upgraded().consume(&header(length), |_| true).is_err());
     31     }
     32 }
     33 
     34 #[test]
     35 fn headers_payloads_and_upgrade_can_arrive_one_byte_at_a_time() {
     36     let mut parser = WireParser::new(MAX_MESSAGE_BYTES);
     37     let mut bytes = UPGRADE.to_vec();
     38     bytes.extend([0x01, 126, 0, 126]);
     39     bytes.extend([b'x'; 126]);
     40     bytes.extend([0x89, 0, 0x80, 2, b'y', b'z', 0x82, 0]);
     41     let mut frames = 0;
     42     let mut data = 0;
     43     for byte in bytes {
     44         parser
     45             .consume(&[byte], |is_data| {
     46                 frames += 1;
     47                 data += usize::from(is_data);
     48                 true
     49             })
     50             .expect("chopped ingress");
     51     }
     52     assert_eq!((frames, data), (4, 2));
     53     parser.eof().expect("complete frames");
     54 }
     55 
     56 #[test]
     57 fn zero_length_continuations_and_controls_each_require_admission() {
     58     let mut parser = upgraded();
     59     let mut admissions = 0;
     60     let error = parser
     61         .consume(&[0x01, 0, 0x00, 0, 0x89, 0, 0x80, 0], |is_data| {
     62             admissions += 1;
     63             assert_eq!(is_data, admissions == 1);
     64             admissions <= 3
     65         })
     66         .expect_err("fourth frame is denied");
     67     assert_eq!(error.kind(), io::ErrorKind::ConnectionAborted);
     68     assert_eq!(admissions, 4);
     69 }
     70 
     71 #[test]
     72 fn invalid_flags_masks_lengths_and_controls_fail_closed() {
     73     for bytes in [
     74         vec![0xc1, 0],
     75         vec![0x83, 0],
     76         vec![0x09, 0],
     77         vec![0x81, 0x80],
     78         vec![0x82, 126, 0, 125],
     79         header(65535),
     80         vec![0x89, 126, 0, 126],
     81     ] {
     82         assert!(
     83             upgraded().consume(&bytes, |_| true).is_err(),
     84             "accepted {bytes:?}"
     85         );
     86     }
     87 }
     88 
     89 #[test]
     90 fn upgrade_prefix_has_an_exact_fixed_bound() {
     91     let mut exact = vec![b'x'; MAX_UPGRADE_BYTES - 4];
     92     exact.extend(b"\r\n\r\n");
     93     let mut parser = WireParser::new(MAX_MESSAGE_BYTES);
     94     parser.consume(&exact, |_| true).expect("exact maximum");
     95     parser.eof().expect("upgrade boundary");
     96     let mut excessive = vec![b'x'];
     97     excessive.extend(exact);
     98     assert!(
     99         WireParser::new(MAX_MESSAGE_BYTES)
    100             .consume(&excessive, |_| true)
    101             .is_err()
    102     );
    103 }
    104 
    105 #[test]
    106 fn eof_rejects_partial_upgrade_header_and_payload() {
    107     assert!(WireParser::new(MAX_MESSAGE_BYTES).eof().is_err());
    108     for bytes in [vec![0x81], vec![0x82, 126, 0], vec![0x81, 2, b'x']] {
    109         let mut parser = upgraded();
    110         parser.consume(&bytes, |_| true).expect("partial input");
    111         assert_eq!(
    112             parser.eof().expect_err("truncation").kind(),
    113             io::ErrorKind::UnexpectedEof
    114         );
    115     }
    116     upgraded().eof().expect("frame boundary");
    117 }
    118 
    119 struct Authority {
    120     open: AtomicBool,
    121     charge: AtomicBool,
    122     bytes: AtomicUsize,
    123     frames: AtomicUsize,
    124     data: AtomicUsize,
    125     byte_limit: AtomicUsize,
    126     data_limit: AtomicUsize,
    127 }
    128 
    129 impl Admission for Authority {
    130     fn permits_address(&self, _: std::net::IpAddr) -> bool {
    131         true
    132     }
    133     fn admitted_read(&self, _: &Context<'_>) -> bool {
    134         self.open.load(Ordering::SeqCst)
    135     }
    136     fn admitted_write(&self, _: &Context<'_>) -> bool {
    137         self.open.load(Ordering::SeqCst)
    138     }
    139     fn charge(&self, bytes: usize, frames: usize, data: usize) -> bool {
    140         let bytes = self.bytes.fetch_add(bytes, Ordering::SeqCst) + bytes;
    141         self.frames.fetch_add(frames, Ordering::SeqCst);
    142         let data = self.data.fetch_add(data, Ordering::SeqCst) + data;
    143         self.charge.load(Ordering::SeqCst)
    144             && bytes <= self.byte_limit.load(Ordering::SeqCst)
    145             && data <= self.data_limit.load(Ordering::SeqCst)
    146     }
    147 }
    148 
    149 struct ControlledIo {
    150     bytes: Vec<u8>,
    151     offset: usize,
    152     reads: usize,
    153     writes: usize,
    154     shutdowns: usize,
    155     read_error: bool,
    156     revoke_after_read: bool,
    157     authority: Arc<Authority>,
    158 }
    159 
    160 impl AsyncRead for ControlledIo {
    161     fn poll_read(
    162         mut self: Pin<&mut Self>,
    163         _: &mut Context<'_>,
    164         output: &mut ReadBuf<'_>,
    165     ) -> Poll<io::Result<()>> {
    166         self.reads += 1;
    167         if self.read_error {
    168             return Poll::Ready(Err(io::Error::other("controlled read failure")));
    169         }
    170         let length = (self.bytes.len() - self.offset).min(output.remaining());
    171         output.put_slice(&self.bytes[self.offset..self.offset + length]);
    172         self.offset += length;
    173         if self.revoke_after_read {
    174             self.authority.open.store(false, Ordering::SeqCst);
    175         }
    176         Poll::Ready(Ok(()))
    177     }
    178 }
    179 
    180 impl AsyncWrite for ControlledIo {
    181     fn poll_write(
    182         mut self: Pin<&mut Self>,
    183         _: &mut Context<'_>,
    184         bytes: &[u8],
    185     ) -> Poll<io::Result<usize>> {
    186         self.writes += 1;
    187         Poll::Ready(Ok(bytes.len()))
    188     }
    189     fn poll_flush(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Result<()>> {
    190         self.writes += 1;
    191         Poll::Ready(Ok(()))
    192     }
    193     fn poll_shutdown(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Result<()>> {
    194         self.shutdowns += 1;
    195         Poll::Ready(Ok(()))
    196     }
    197 }
    198 
    199 fn metered(bytes: Vec<u8>) -> (MeteredIo<ControlledIo>, Arc<Authority>) {
    200     let authority = Arc::new(Authority {
    201         open: AtomicBool::new(true),
    202         charge: AtomicBool::new(true),
    203         bytes: AtomicUsize::new(0),
    204         frames: AtomicUsize::new(0),
    205         data: AtomicUsize::new(0),
    206         byte_limit: AtomicUsize::new(usize::MAX),
    207         data_limit: AtomicUsize::new(usize::MAX),
    208     });
    209     let inner = ControlledIo {
    210         bytes,
    211         offset: 0,
    212         reads: 0,
    213         writes: 0,
    214         shutdowns: 0,
    215         read_error: false,
    216         revoke_after_read: false,
    217         authority: authority.clone(),
    218     };
    219     (
    220         MeteredIo::new(inner, authority.clone(), MAX_MESSAGE_BYTES),
    221         authority,
    222     )
    223 }
    224 
    225 fn read_meter(
    226     meter: &mut MeteredIo<ControlledIo>,
    227     capacity: usize,
    228 ) -> (Poll<io::Result<()>>, usize) {
    229     let waker = futures::task::noop_waker();
    230     let mut context = Context::from_waker(&waker);
    231     let mut bytes = vec![0; capacity];
    232     let mut output = ReadBuf::new(&mut bytes);
    233     let result = Pin::new(meter).poll_read(&mut context, &mut output);
    234     (result, output.filled().len())
    235 }
    236 
    237 #[test]
    238 fn empty_output_never_reads_and_large_outputs_still_use_fixed_scratch_chunks() {
    239     let mut bytes = UPGRADE.to_vec();
    240     bytes.extend([0x82, 126, 0x13, 0x88]);
    241     bytes.extend([1; 5000]);
    242     let length = bytes.len();
    243     let (mut meter, _) = metered(bytes);
    244     assert!(matches!(
    245         read_meter(&mut meter, 0),
    246         (Poll::Ready(Ok(())), 0)
    247     ));
    248     assert_eq!(meter.inner.reads, 0);
    249     assert!(matches!(
    250         read_meter(&mut meter, 8192),
    251         (Poll::Ready(Ok(())), READ_CHUNK_BYTES)
    252     ));
    253     assert!(
    254         matches!(read_meter(&mut meter,8192),(Poll::Ready(Ok(())),n) if n==length-READ_CHUNK_BYTES)
    255     );
    256     assert!(matches!(
    257         read_meter(&mut meter, 8192),
    258         (Poll::Ready(Ok(())), 0)
    259     ));
    260 }
    261 
    262 #[test]
    263 fn read_errors_and_raw_admission_refusal_are_sticky_before_any_later_io() {
    264     for underlying_error in [false, true] {
    265         let (mut meter, authority) = metered(UPGRADE.to_vec());
    266         meter.inner.read_error = underlying_error;
    267         authority.charge.store(underlying_error, Ordering::SeqCst);
    268         assert!(matches!(
    269             read_meter(&mut meter, 4096),
    270             (Poll::Ready(Err(_)), 0)
    271         ));
    272         assert!(matches!(
    273             read_meter(&mut meter, 4096),
    274             (Poll::Ready(Err(_)), 0)
    275         ));
    276         assert_eq!(meter.inner.reads, 1);
    277         let waker = futures::task::noop_waker();
    278         let mut context = Context::from_waker(&waker);
    279         assert!(matches!(
    280             Pin::new(&mut meter).poll_write(&mut context, b"denied"),
    281             Poll::Ready(Err(_))
    282         ));
    283         assert!(matches!(
    284             Pin::new(&mut meter).poll_flush(&mut context),
    285             Poll::Ready(Err(_))
    286         ));
    287         assert_eq!(meter.inner.writes, 0);
    288         assert!(matches!(
    289             Pin::new(&mut meter).poll_shutdown(&mut context),
    290             Poll::Ready(Ok(()))
    291         ));
    292         assert_eq!(meter.inner.shutdowns, 1);
    293     }
    294 }
    295 
    296 #[test]
    297 fn revocation_during_a_ready_read_never_exposes_the_obtained_plaintext() {
    298     let (mut meter, _) = metered(UPGRADE.to_vec());
    299     meter.inner.revoke_after_read = true;
    300     assert!(matches!(
    301         read_meter(&mut meter, 4096),
    302         (Poll::Ready(Err(_)), 0)
    303     ));
    304     assert!(matches!(
    305         read_meter(&mut meter, 4096),
    306         (Poll::Ready(Err(_)), 0)
    307     ));
    308     assert_eq!(meter.inner.reads, 1);
    309 }
    310 
    311 #[test]
    312 fn revoked_write_and_flush_refuse_without_requiring_a_prior_failed_read() {
    313     let (mut meter, authority) = metered(UPGRADE.to_vec());
    314     authority.open.store(false, Ordering::SeqCst);
    315     let waker = futures::task::noop_waker();
    316     let mut context = Context::from_waker(&waker);
    317     assert!(matches!(
    318         Pin::new(&mut meter).poll_write(&mut context, b"denied"),
    319         Poll::Ready(Err(_))
    320     ));
    321     assert!(matches!(
    322         Pin::new(&mut meter).poll_flush(&mut context),
    323         Poll::Ready(Err(_))
    324     ));
    325     assert_eq!(meter.inner.writes, 0);
    326     assert!(matches!(
    327         read_meter(&mut meter, 4096),
    328         (Poll::Ready(Err(_)), 0)
    329     ));
    330     assert_eq!(meter.inner.reads, 0);
    331     assert!(matches!(
    332         Pin::new(&mut meter).poll_shutdown(&mut context),
    333         Poll::Ready(Ok(()))
    334     ));
    335 }
    336 
    337 #[test]
    338 fn truncated_payload_eof_is_terminal_at_the_meter_boundary() {
    339     let mut bytes = UPGRADE.to_vec();
    340     bytes.extend([0x81, 3, b'x']);
    341     let (mut meter, _) = metered(bytes);
    342     assert!(matches!(read_meter(&mut meter,4096),(Poll::Ready(Ok(())),n) if n>0));
    343     assert!(
    344         matches!(read_meter(&mut meter,4096),(Poll::Ready(Err(error)),0) if error.kind()==io::ErrorKind::UnexpectedEof)
    345     );
    346     assert!(matches!(
    347         read_meter(&mut meter, 4096),
    348         (Poll::Ready(Err(_)), 0)
    349     ));
    350     assert_eq!(meter.inner.reads, 2);
    351 }
    352 
    353 #[test]
    354 fn raw_upgrade_and_frame_overhead_are_charged_before_any_message_decode() {
    355     let mut bytes = UPGRADE.to_vec();
    356     bytes.extend([0x81, 0]);
    357     let length = bytes.len();
    358     let (mut meter, authority) = metered(bytes);
    359     authority.byte_limit.store(length, Ordering::SeqCst);
    360     assert!(
    361         matches!(read_meter(&mut meter, 4096), (Poll::Ready(Ok(())), count) if count == length)
    362     );
    363     assert_eq!(authority.bytes.load(Ordering::SeqCst), length);
    364     assert_eq!(authority.frames.load(Ordering::SeqCst), 1);
    365     assert_eq!(authority.data.load(Ordering::SeqCst), 1);
    366     meter.inner.bytes.extend([0x81, 0]);
    367     assert!(matches!(
    368         read_meter(&mut meter, 4096),
    369         (Poll::Ready(Err(_)), 0)
    370     ));
    371     assert!(meter.failed);
    372 }
    373 
    374 #[test]
    375 fn empty_data_frames_exhaust_the_original_attempt_allowance_before_decode() {
    376     let mut bytes = UPGRADE.to_vec();
    377     for _ in 0..4097 {
    378         bytes.extend([0x81, 0]);
    379     }
    380     let (mut meter, authority) = metered(bytes);
    381     authority.data_limit.store(4096, Ordering::SeqCst);
    382     loop {
    383         match read_meter(&mut meter, 4096) {
    384             (Poll::Ready(Ok(())), count) => assert!(count > 0),
    385             (Poll::Ready(Err(_)), 0) => break,
    386             other => panic!("unexpected read: {other:?}"),
    387         }
    388     }
    389     assert_eq!(authority.data.load(Ordering::SeqCst), 4097);
    390     assert_eq!(authority.frames.load(Ordering::SeqCst), 4097);
    391     let reads = meter.inner.reads;
    392     assert!(matches!(
    393         read_meter(&mut meter, 4096),
    394         (Poll::Ready(Err(_)), 0)
    395     ));
    396     assert_eq!(meter.inner.reads, reads);
    397 }