A modern terminal with a built-in multiplexer: close it and your sessions keep running. Run shells and tons of AI agents across your machines, then pick them up from desktop, browser, TUI and more. Written in Rust with no UI framework: interface drawn straight on the GPU. No Electron, GPUI or webview.
Rust agentagent-orchestrationaiai-agentsclaude-codecodexcoding-agentlinuxmacosmultiplayermultiplexerrustterminalterminal-emulatorterminal-multiplexertmuxtuiweztermwindows
security: bound TLS handshakes and log admission failures
RoversX255dfd1cbf99
diff --git a/wezterm-mux-server/src/ossl.rs b/wezterm-mux-server/src/ossl.rsindex fed3d7d3..20a8e111 100644--- a/wezterm-mux-server/src/ossl.rs+++ b/wezterm-mux-server/src/ossl.rs@@ -3,11 +3,85 @@ use async_ossl::AsyncSslStream;use config::TlsDomainServer;use openssl::ssl::{SslAcceptor, SslFiletype, SslMethod, SslStream, SslVerifyMode};use openssl::x509::X509;-use std::net::TcpListener;+use std::net::{TcpListener, TcpStream};use std::path::Path;+use std::sync::atomic::{AtomicUsize, Ordering};use std::sync::Arc;+use std::time::{Duration, Instant};use wezterm_mux_server_impl::PKI;+const TLS_HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(15);+const MAX_TLS_HANDSHAKES: usize = 16;+/// At most one warning per five seconds per listener, even under a flood.+#[derive(Default)]+struct AdmissionWarnings {+ last: Option<Instant>,+ rejected: usize,+}+impl AdmissionWarnings {+ fn rejected(&mut self, now: Instant) -> Option<usize> {+ self.rejected = self.rejected.saturating_add(1);+ if self+ .last+ .is_some_and(|last| now.duration_since(last) < Duration::from_secs(5))+ {+ return None;+ }+ self.last = Some(now);+ Some(std::mem::take(&mut self.rejected))+ }+}++struct HandshakePermit(Arc<AtomicUsize>);+impl HandshakePermit {+ fn acquire(count: &Arc<AtomicUsize>) -> Option<Self> {+ count+ .fetch_update(Ordering::AcqRel, Ordering::Acquire, |n| {+ (n < MAX_TLS_HANDSHAKES).then_some(n + 1)+ })+ .ok()?;+ Some(Self(Arc::clone(count)))+ }+}+impl Drop for HandshakePermit {+ fn drop(&mut self) {+ self.0.fetch_sub(1, Ordering::AcqRel);+ }+}++async fn accept_with_deadline(+ acceptor: Arc<SslAcceptor>,+ stream: TcpStream,+ timeout: Duration,+ permit: HandshakePermit,+) -> anyhow::Result<SslStream<TcpStream>> {+ stream.set_read_timeout(Some(timeout))?;+ stream.set_write_timeout(Some(timeout))?;+ let guard = stream.try_clone()?;+ let handshake = smol::unblock(move || {+ // Keep the slot until the blocking operation actually exits, including+ // after its asynchronous waiter has timed out.+ let _permit = permit;+ acceptor.accept(stream)+ });+ let outcome = smol::future::or(async { Some(handshake.await) }, async {+ smol::Timer::after(timeout).await;+ None+ })+ .await;+ let tls = match outcome {+ Some(Ok(tls)) => tls,+ Some(Err(error)) => return Err(anyhow!("TLS handshake failed: {error}")),+ None => {+ let _ = guard.shutdown(std::net::Shutdown::Both);+ anyhow::bail!("TLS handshake deadline exceeded");+ }+ };+ tls.get_ref().set_read_timeout(None)?;+ tls.get_ref().set_write_timeout(None)?;+ Ok(tls)+}+struct OpenSSLNetListener {acceptor: Arc<SslAcceptor>,listener: TcpListener,@@ -69,43 +143,51 @@ impl OpenSSLNetListener {}fn run(&mut self) {+ let pending = Arc::new(AtomicUsize::new(0));+ let mut warnings = AdmissionWarnings::default();for stream in self.listener.incoming() {match stream {Ok(stream) => {+ let Some(permit) = HandshakePermit::acquire(&pending) else {+ if let Some(rejected) = warnings.rejected(Instant::now()) {+ log::warn!("TLS handshake capacity ({MAX_TLS_HANDSHAKES}) reached: rejected {rejected} new connections since the last warning; pending handshakes have a {}s deadline", TLS_HANDSHAKE_TIMEOUT.as_secs());+ }+ continue;+ };stream.set_nodelay(true).ok();let acceptor = self.acceptor.clone();-- match acceptor.accept(stream) {- Ok(stream) => {- if let Err(err) = Self::verify_peer_cert(&stream) {- // One bad client is one refused connection,- // not the end of the listener.- log::error!("problem with peer cert: {}", err);- continue;+ wezterm_mux_server_impl::connections::spawn(async move {+ let stream = match accept_with_deadline(+ acceptor,+ stream,+ TLS_HANDSHAKE_TIMEOUT,+ permit,+ )+ .await+ {+ Ok(stream) => stream,+ Err(err) => {+ log::warn!("{err}");+ return;}- wezterm_mux_server_impl::connections::spawn(async move {- log::debug!("Making new AsyncSslStream");- if let Err(err) = wezterm_mux_server_impl::dispatch::process(- AsyncSslStream::new(stream),- wezterm_mux_server_impl::sessionhandler::ConnectionPeer::Tls,- )- .await- {- log::error!("process: {err:?}");- }- });+ };+ if let Err(err) = Self::verify_peer_cert(&stream) {+ log::error!("problem with peer cert: {err}");+ return;}- Err(e) => {- log::error!("failed TlsAcceptor: {}", e);+ if let Err(err) = wezterm_mux_server_impl::dispatch::process(+ AsyncSslStream::new(stream),+ wezterm_mux_server_impl::sessionhandler::ConnectionPeer::Tls,+ )+ .await+ {+ log::error!("process: {err:?}");}- }+ });}Err(err) => {- // As above: a failed accept (a peer that reset before- // we got to it, a moment without descriptors) is not- // the end of the listener.- log::error!("accept failed: {}", err);- std::thread::sleep(std::time::Duration::from_millis(100));+ log::error!("accept failed: {err}");+ std::thread::sleep(Duration::from_millis(100));}}}@@ -189,3 +271,115 @@ pub fn spawn_tls_listener(tls_server: &TlsDomainServer) -> Result<(), Error> {});Ok(())}++#[cfg(test)]+pub(crate) mod deadline_tests {+ use super::*;+ pub(crate) fn test_acceptor() -> SslAcceptor {+ use openssl::{+ asn1::Asn1Time, hash::MessageDigest, pkey::PKey, rsa::Rsa, x509::X509NameBuilder,+ };+ let key = PKey::from_rsa(Rsa::generate(2048).unwrap()).unwrap();+ let mut name = X509NameBuilder::new().unwrap();+ name.append_entry_by_text("CN", "localhost").unwrap();+ let name = name.build();+ let mut cert = X509::builder().unwrap();+ cert.set_version(2).unwrap();+ cert.set_subject_name(&name).unwrap();+ cert.set_issuer_name(&name).unwrap();+ cert.set_pubkey(&key).unwrap();+ cert.set_not_before(&Asn1Time::days_from_now(0).unwrap())+ .unwrap();+ cert.set_not_after(&Asn1Time::days_from_now(1).unwrap())+ .unwrap();+ cert.sign(&key, MessageDigest::sha256()).unwrap();+ let mut acceptor = SslAcceptor::mozilla_modern(SslMethod::tls()).unwrap();+ acceptor.set_private_key(&key).unwrap();+ acceptor.set_certificate(&cert.build()).unwrap();+ acceptor.build()+ }++ #[test]+ fn valid_tls_connection_completes_and_clears_handshake_timeouts() {+ use std::io::{Read, Write};+ let listener = TcpListener::bind("127.0.0.1:0").unwrap();+ let address = listener.local_addr().unwrap();+ let client = std::thread::spawn(move || {+ let mut connector = openssl::ssl::SslConnector::builder(SslMethod::tls()).unwrap();+ // This fixture tests transport scheduling; production peer validation remains mandatory.+ connector.set_verify(SslVerifyMode::NONE);+ let mut stream = connector+ .build()+ .connect("localhost", TcpStream::connect(address).unwrap())+ .unwrap();+ stream.write_all(b"ping").unwrap();+ });+ let (stream, _) = listener.accept().unwrap();+ let count = Arc::new(AtomicUsize::new(0));+ let mut tls = smol::block_on(accept_with_deadline(+ Arc::new(test_acceptor()),+ stream,+ Duration::from_secs(3),+ HandshakePermit::acquire(&count).unwrap(),+ ))+ .unwrap();+ assert_eq!(tls.get_ref().read_timeout().unwrap(), None);+ assert_eq!(tls.get_ref().write_timeout().unwrap(), None);+ let mut bytes = [0; 4];+ tls.read_exact(&mut bytes).unwrap();+ assert_eq!(&bytes, b"ping");+ assert_eq!(count.load(Ordering::Acquire), 0);+ assert!(+ OpenSSLNetListener::verify_peer_cert(&tls).is_err(),+ "transport success must not bypass client certificate authentication"+ );+ client.join().unwrap();+ }++ #[test]+ fn admission_warnings_are_rate_limited_and_count_rejections() {+ let start = Instant::now();+ let mut warnings = AdmissionWarnings::default();+ assert_eq!(warnings.rejected(start), Some(1));+ for _ in 0..100 {+ assert_eq!(warnings.rejected(start + Duration::from_secs(1)), None);+ }+ assert_eq!(warnings.rejected(start + Duration::from_secs(5)), Some(101));+ }++ #[test]+ fn stalled_handshakes_expire_and_admission_is_bounded() {+ let count = Arc::new(AtomicUsize::new(0));+ let permits: Vec<_> = (0..MAX_TLS_HANDSHAKES - 1)+ .map(|_| HandshakePermit::acquire(&count).unwrap())+ .collect();+ let last_permit = HandshakePermit::acquire(&count).unwrap();+ assert!(HandshakePermit::acquire(&count).is_none());+ let listener = TcpListener::bind("127.0.0.1:0").unwrap();+ let _silent = TcpStream::connect(listener.local_addr().unwrap()).unwrap();+ let (stream, _) = listener.accept().unwrap();+ let acceptor = Arc::new(test_acceptor());+ let start = std::time::Instant::now();+ assert!(smol::block_on(accept_with_deadline(+ acceptor,+ stream,+ Duration::from_millis(100),+ last_permit+ ))+ .is_err());+ assert!(start.elapsed() >= Duration::from_millis(80));+ assert!(start.elapsed() < Duration::from_secs(2));+ while count.load(Ordering::Acquire) != MAX_TLS_HANDSHAKES - 1+ && start.elapsed() < Duration::from_secs(2)+ {+ std::thread::sleep(Duration::from_millis(5));+ }+ assert_eq!(count.load(Ordering::Acquire), MAX_TLS_HANDSHAKES - 1);+ let replacement =+ HandshakePermit::acquire(&count).expect("expired connection frees admission");+ assert!(HandshakePermit::acquire(&count).is_none());+ drop(replacement);+ drop(permits);+ assert_eq!(count.load(Ordering::Acquire), 0);+ }+}