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 }