egress.rs 79.2%

171 of 216 lines run, 15 of 33 functions · run #177 on main · run missed

//! Allow-listed egress for a microVM job (oxygenflow#55). The VM has no
//! network device: `flow-init` serves a proxy on the guest's 127.0.0.1
//! and relays each connection over vsock to this end, a Unix socket that
//! Firecracker connects for the guest. Here each `CONNECT host:443` is
//! checked against the sandbox's allow-list, the host is resolved (the
//! guest never resolves), any address that is not public is refused, the
//! decision goes into the job log, and the bytes are relayed untouched (no
//! TLS is opened here).

use std::io::{Read, Write};
use std::net::{IpAddr, SocketAddr, TcpStream, ToSocketAddrs};
use std::os::unix::net::{UnixListener, UnixStream};
use std::path::Path;
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::sync::{mpsc, Arc};
use std::time::Duration;

/// The vsock port the guest's relay connects to on the host (CID 2).
pub const VSOCK_PORT: u32 = 3128;
/// Where the job's tools find the proxy inside the guest.
pub const GUEST_PROXY: &str = "http://127.0.0.1:3128";
/// The only port relayed: TLS.
const PORT: u16 = 443;
/// Connections at once, per job.
const MAX_OPEN: usize = 64;
const CONNECT_TIMEOUT: Duration = Duration::from_secs(10);
/// The longest request head read.
const MAX_HEAD: usize = 8 * 1024;

/// What a CONNECT asked for, or why it was refused.
#[derive(Debug, PartialEq, Eq)]
pub enum Ask {
    Connect { host: String, port: u16 },
    Refused(String),
}

/// Read a request head: `CONNECT host:port HTTP/1.x`, and only that.
pub fn parse_head(head: &str) -> Ask {
    let line = head.lines().next().unwrap_or("");
    let mut parts = line.split_whitespace();
    let (method, target, version) = (parts.next().unwrap_or(""), parts.next().unwrap_or(""), parts.next().unwrap_or(""));
    if method != "CONNECT" {
        return Ask::Refused(format!("only https is relayed (CONNECT), not {method:?}"));
    }
    if !version.starts_with("HTTP/1.") {
        return Ask::Refused("not an HTTP/1 request".into());
    }
    let Some((host, port)) = target.rsplit_once(':') else { return Ask::Refused(format!("CONNECT {target:?} names no port")) };
    let Ok(port) = port.parse::<u16>() else { return Ask::Refused(format!("CONNECT {target:?} has no valid port")) };
    let host = host.trim_start_matches('[').trim_end_matches(']').trim_end_matches('.').to_ascii_lowercase();
    if host.is_empty() {
        return Ask::Refused("CONNECT names no host".into());
    }
    Ask::Connect { host, port }
}

/// Whether the job may go to `host:port`: the port is 443, the host is a
/// name (an address is refused: the allow-list names hosts) the list allows.
pub fn decide(allow: &[String], host: &str, port: u16) -> Result<(), String> {
    if port != PORT {
        return Err(format!("only port {PORT} is relayed"));
    }
    if host.parse::<IpAddr>().is_ok() {
        return Err("an address, not a name: the allow-list names hosts".into());
    }
    if !flow_core::egress_allows(allow, host) {
        return Err("not in the sandbox's egress allow-list".into());
    }
    Ok(())
}

/// Whether an address is on the public internet: not loopback, private,
/// shared (CGNAT), link-local (cloud metadata among them), multicast,
/// unspecified or documentation, nor an IPv6 local range or a mapped form.
pub fn public(ip: IpAddr) -> bool {
    match ip {
        IpAddr::V4(v4) => {
            let o = v4.octets();
            !(v4.is_loopback()
                || v4.is_private()
                || v4.is_link_local()
                || v4.is_multicast()
                || v4.is_broadcast()
                || v4.is_unspecified()
                || v4.is_documentation()
                || o[0] == 0
                || (o[0] == 100 && (o[1] & 0xc0) == 64)
                || (o[0] == 192 && o[1] == 0 && o[2] == 0)
                || o[0] >= 240)
        }
        IpAddr::V6(v6) => {
            if let Some(v4) = v6.to_ipv4_mapped() {
                return public(IpAddr::V4(v4));
            }
            let s = v6.segments();
            !(v6.is_loopback()
                || v6.is_unspecified()
                || v6.is_multicast()
                || (s[0] & 0xfe00) == 0xfc00
                || (s[0] & 0xffc0) == 0xfe80
                || (s[0] == 0x64 && s[1] == 0xff9b)
                || (s[0] == 0x2001 && s[1] == 0x0db8))
        }
    }
}

/// The proxy for one job: listening until dropped.
pub struct Proxy {
    stop: Arc<AtomicBool>,
    path: std::path::PathBuf,
}

impl Drop for Proxy {
    fn drop(&mut self) {
        self.stop.store(true, Ordering::SeqCst);
        // Wake the accept loop so it sees the stop.
        let _ = UnixStream::connect(&self.path);
        let _ = std::fs::remove_file(&self.path);
    }
}

/// Listen on `socket` (Firecracker's `uds_path` and `_3128`) for the
/// guest's connections; each decision is sent to `log` as a line.
pub fn start(socket: &Path, allow: Vec<String>, log: mpsc::Sender<String>) -> std::io::Result<Proxy> {
    let _ = std::fs::remove_file(socket);
    let listener = UnixListener::bind(socket)?;
    let stop = Arc::new(AtomicBool::new(false));
    let open = Arc::new(AtomicUsize::new(0));
    let allow = Arc::new(allow);
    let s = stop.clone();
    std::thread::spawn(move || {
        for conn in listener.incoming() {
            if s.load(Ordering::SeqCst) {
                break;
            }
            let Ok(conn) = conn else { continue };
            if open.load(Ordering::SeqCst) >= MAX_OPEN {
                let _ = refuse(conn, "too many connections at once");
                let _ = log.send(format!("egress: refused a connection: {MAX_OPEN} already open"));
                continue;
            }
            open.fetch_add(1, Ordering::SeqCst);
            let (allow, log, open) = (allow.clone(), log.clone(), open.clone());
            std::thread::spawn(move || {
                serve(conn, &allow, &log);
                open.fetch_sub(1, Ordering::SeqCst);
            });
        }
    });
    Ok(Proxy { stop, path: socket.to_path_buf() })
}

fn refuse(mut conn: UnixStream, why: &str) -> std::io::Result<()> {
    let body = format!("{why}\n");
    write!(conn, "HTTP/1.1 403 Forbidden\r\nContent-Type: text/plain\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}", body.len())
}

/// Read up to the blank line that ends a request head.
fn read_head(conn: &mut UnixStream) -> std::io::Result<String> {
    let mut head = Vec::new();
    let mut byte = [0u8; 1];
    while !head.ends_with(b"\r\n\r\n") {
        if head.len() >= MAX_HEAD || conn.read(&mut byte)? == 0 {
            break;
        }
        head.push(byte[0]);
    }
    Ok(String::from_utf8_lossy(&head).into_owned())
}

fn serve(mut conn: UnixStream, allow: &[String], log: &mpsc::Sender<String>) {
    let _ = conn.set_read_timeout(Some(Duration::from_secs(30)));
    let head = match read_head(&mut conn) {
        Ok(h) => h,
        Err(_) => return,
    };
    let (host, port) = match parse_head(&head) {
        Ask::Connect { host, port } => (host, port),
        Ask::Refused(why) => {
            let _ = log.send(format!("egress: refused: {why}"));
            let _ = refuse(conn, &why);
            return;
        }
    };
    if let Err(why) = decide(allow, &host, port) {
        let _ = log.send(format!("egress: refused {host}:{port}: {why}"));
        let _ = refuse(conn, &format!("{host}:{port}: {why}"));
        return;
    }
    let addrs: Vec<SocketAddr> = match (host.as_str(), port).to_socket_addrs() {
        Ok(a) => a.collect(),
        Err(e) => {
            let _ = log.send(format!("egress: refused {host}:{port}: it could not be resolved ({e})"));
            let _ = refuse(conn, &format!("{host} could not be resolved"));
            return;
        }
    };
    if let Some(bad) = addrs.iter().find(|a| !public(a.ip())) {
        let why = format!("it resolves to {}, which is not a public address", bad.ip());
        let _ = log.send(format!("egress: refused {host}:{port}: {why}"));
        let _ = refuse(conn, &format!("{host}: {why}"));
        return;
    }
    let out = addrs.iter().find_map(|a| TcpStream::connect_timeout(a, CONNECT_TIMEOUT).ok());
    let Some(out) = out else {
        let _ = log.send(format!("egress: {host}:{port} is allowed but did not answer"));
        let _ = conn.write_all(b"HTTP/1.1 502 Bad Gateway\r\nConnection: close\r\n\r\n");
        return;
    };
    let _ = log.send(format!("egress: allowed {host}:{port}"));
    if conn.write_all(b"HTTP/1.1 200 Connection established\r\n\r\n").is_err() {
        return;
    }
    let _ = conn.set_read_timeout(None);
    relay(conn, out);
}

/// Copy both ways until either side closes.
fn relay(guest: UnixStream, out: TcpStream) {
    let (Ok(mut guest_r), Ok(mut out_w)) = (guest.try_clone(), out.try_clone()) else { return };
    let up = std::thread::spawn(move || {
        let _ = std::io::copy(&mut guest_r, &mut out_w);
        let _ = out_w.shutdown(std::net::Shutdown::Write);
    });
    let (mut out_r, mut guest_w) = (out, guest);
    let _ = std::io::copy(&mut out_r, &mut guest_w);
    let _ = guest_w.shutdown(std::net::Shutdown::Write);
    let _ = up.join();
}

#[cfg(test)]
mod tests {
    use super::*;

    fn allow() -> Vec<String> {
        vec!["*.googleapis.com".into(), "registry.opentofu.org".into()]
    }

    #[test]
    fn only_connect_to_an_allowed_name_on_443_is_let_through() {
        assert_eq!(
            parse_head("CONNECT storage.googleapis.com:443 HTTP/1.1\r\nHost: x\r\n\r\n"),
            Ask::Connect { host: "storage.googleapis.com".into(), port: 443 }
        );
        assert!(matches!(parse_head("GET http://example.com/ HTTP/1.1\r\n\r\n"), Ask::Refused(w) if w.contains("only https")));
        assert!(matches!(parse_head("CONNECT example.com HTTP/1.1\r\n\r\n"), Ask::Refused(w) if w.contains("no port")));
        assert_eq!(decide(&allow(), "storage.googleapis.com", 443), Ok(()));
        assert_eq!(decide(&allow(), "registry.opentofu.org", 443), Ok(()));
        assert!(decide(&allow(), "example.com", 443).unwrap_err().contains("allow-list"));
        assert!(decide(&allow(), "registry.opentofu.org", 22).unwrap_err().contains("only port 443"));
        assert!(decide(&allow(), "142.250.1.1", 443).unwrap_err().contains("names hosts"));
    }

    #[test]
    fn private_addresses_are_not_public() {
        for ip in [
            "127.0.0.1",
            "10.1.2.3",
            "192.168.1.1",
            "172.16.0.1",
            "169.254.169.254",
            "100.64.0.1",
            "0.0.0.0",
            "::1",
            "fd00::1",
            "fe80::1",
            "::ffff:10.0.0.1",
        ] {
            assert!(!public(ip.parse().unwrap()), "{ip}");
        }
        for ip in ["142.250.1.1", "2a00:1450:4009::200e"] {
            assert!(public(ip.parse().unwrap()), "{ip}");
        }
    }

    #[test]
    fn the_proxy_refuses_and_logs_a_host_not_allowed() {
        let dir = tempfile::tempdir().unwrap();
        let sock = dir.path().join("v.sock_3128");
        let (tx, rx) = mpsc::channel();
        let proxy = start(&sock, allow(), tx).unwrap();
        let ask = |head: &str| {
            let mut c = UnixStream::connect(&sock).unwrap();
            c.write_all(head.as_bytes()).unwrap();
            let mut answer = String::new();
            c.read_to_string(&mut answer).unwrap();
            answer
        };
        let a = ask("CONNECT example.com:443 HTTP/1.1\r\n\r\n");
        assert!(a.starts_with("HTTP/1.1 403") && a.contains("not in the sandbox's egress allow-list"), "{a}");
        assert_eq!(
            rx.recv_timeout(Duration::from_secs(5)).unwrap(),
            "egress: refused example.com:443: not in the sandbox's egress allow-list"
        );
        let a = ask("GET http://storage.googleapis.com/ HTTP/1.1\r\n\r\n");
        assert!(a.starts_with("HTTP/1.1 403"), "{a}");
        assert!(rx.recv_timeout(Duration::from_secs(5)).unwrap().contains("only https"));
        drop(proxy);
        assert!(!sock.exists(), "the socket goes with the job");
    }
}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

1		//! Allow-listed egress for a microVM job (oxygenflow#55). The VM has no
2		//! network device: `flow-init` serves a proxy on the guest's 127.0.0.1
3		//! and relays each connection over vsock to this end, a Unix socket that
4		//! Firecracker connects for the guest. Here each `CONNECT host:443` is
5		//! checked against the sandbox's allow-list, the host is resolved (the
6		//! guest never resolves), any address that is not public is refused, the
7		//! decision goes into the job log, and the bytes are relayed untouched (no
8		//! TLS is opened here).
9
10		use std::io::{Read, Write};
11		use std::net::{IpAddr, SocketAddr, TcpStream, ToSocketAddrs};
12		use std::os::unix::net::{UnixListener, UnixStream};
13		use std::path::Path;
14		use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
15		use std::sync::{mpsc, Arc};
16		use std::time::Duration;
17
18		/// The vsock port the guest's relay connects to on the host (CID 2).
19		pub const VSOCK_PORT: u32 = 3128;
20		/// Where the job's tools find the proxy inside the guest.
21		pub const GUEST_PROXY: &str = "http://127.0.0.1:3128";
22		/// The only port relayed: TLS.
23		const PORT: u16 = 443;
24		/// Connections at once, per job.
25		const MAX_OPEN: usize = 64;
26		const CONNECT_TIMEOUT: Duration = Duration::from_secs(10);
27		/// The longest request head read.
28		const MAX_HEAD: usize = 8 * 1024;
29
30		/// What a CONNECT asked for, or why it was refused.
31		#[derive(Debug, PartialEq, Eq)]
32		pub enum Ask {
33		Connect { host: String, port: u16 },
34		Refused(String),
35		}
36
37		/// Read a request head: `CONNECT host:port HTTP/1.x`, and only that.
38	5×	pub fn parse_head(head: &str) -> Ask {
39	5×	let line = head.lines().next().unwrap_or("");
40	5×	let mut parts = line.split_whitespace();
41	5×	let (method, target, version) = (parts.next().unwrap_or(""), parts.next().unwrap_or(""), parts.next().unwrap_or(""));
42	5×	if method != "CONNECT" {
43	2×	return Ask::Refused(format!("only https is relayed (CONNECT), not {method:?}"));
44	3×	}
45	3×	if !version.starts_with("HTTP/1.") {
46	0×	return Ask::Refused("not an HTTP/1 request".into());
47	3×	}
48	3×	let Some((host, port)) = target.rsplit_once(':') else { return Ask::Refused(format!("CONNECT {target:?} names no port")) };
49	2×	let Ok(port) = port.parse::<u16>() else { return Ask::Refused(format!("CONNECT {target:?} has no valid port")) };
50	2×	let host = host.trim_start_matches('[').trim_end_matches(']').trim_end_matches('.').to_ascii_lowercase();
51	2×	if host.is_empty() {
52	0×	return Ask::Refused("CONNECT names no host".into());
53	2×	}
54	2×	Ask::Connect { host, port }
55	5×	}
56
57		/// Whether the job may go to `host:port`: the port is 443, the host is a
58		/// name (an address is refused: the allow-list names hosts) the list allows.
59	6×	pub fn decide(allow: &[String], host: &str, port: u16) -> Result<(), String> {
60	6×	if port != PORT {
61	1×	return Err(format!("only port {PORT} is relayed"));
62	5×	}
63	5×	if host.parse::<IpAddr>().is_ok() {
64	1×	return Err("an address, not a name: the allow-list names hosts".into());
65	4×	}
66	4×	if !flow_core::egress_allows(allow, host) {
67	2×	return Err("not in the sandbox's egress allow-list".into());
68	2×	}
69	2×	Ok(())
70	6×	}
71
72		/// Whether an address is on the public internet: not loopback, private,
73		/// shared (CGNAT), link-local (cloud metadata among them), multicast,
74		/// unspecified or documentation, nor an IPv6 local range or a mapped form.
75	14×	pub fn public(ip: IpAddr) -> bool {
76	14×	match ip {
77	9×	IpAddr::V4(v4) => {
78	9×	let o = v4.octets();
79	9×	!(v4.is_loopback()
80	8×	\|\| v4.is_private()
81	4×	\|\| v4.is_link_local()
82	3×	\|\| v4.is_multicast()
83	3×	\|\| v4.is_broadcast()
84	3×	\|\| v4.is_unspecified()
85	2×	\|\| v4.is_documentation()
86	2×	\|\| o[0] == 0
87	2×	\|\| (o[0] == 100 && (o[1] & 0xc0) == 64)
88	1×	\|\| (o[0] == 192 && o[1] == 0 && o[2] == 0)
89	1×	\|\| o[0] >= 240)
90		}
91	5×	IpAddr::V6(v6) => {
92	5×	if let Some(v4) = v6.to_ipv4_mapped() {
93	1×	return public(IpAddr::V4(v4));
94	4×	}
95	4×	let s = v6.segments();
96	4×	!(v6.is_loopback()
97	3×	\|\| v6.is_unspecified()
98	3×	\|\| v6.is_multicast()
99	3×	\|\| (s[0] & 0xfe00) == 0xfc00
100	2×	\|\| (s[0] & 0xffc0) == 0xfe80
101	1×	\|\| (s[0] == 0x64 && s[1] == 0xff9b)
102	1×	\|\| (s[0] == 0x2001 && s[1] == 0x0db8))
103		}
104		}
105	14×	}
106
107		/// The proxy for one job: listening until dropped.
108		pub struct Proxy {
109		stop: Arc<AtomicBool>,
110		path: std::path::PathBuf,
111		}
112
113		impl Drop for Proxy {
114	1×	fn drop(&mut self) {
115	1×	self.stop.store(true, Ordering::SeqCst);
116		// Wake the accept loop so it sees the stop.
117	1×	let _ = UnixStream::connect(&self.path);
118	1×	let _ = std::fs::remove_file(&self.path);
119	1×	}
120		}
121
122		/// Listen on `socket` (Firecracker's `uds_path` and `_3128`) for the
123		/// guest's connections; each decision is sent to `log` as a line.
124	1×	pub fn start(socket: &Path, allow: Vec<String>, log: mpsc::Sender<String>) -> std::io::Result<Proxy> {
125	1×	let _ = std::fs::remove_file(socket);
126	1×	let listener = UnixListener::bind(socket)?;
127	1×	let stop = Arc::new(AtomicBool::new(false));
128	1×	let open = Arc::new(AtomicUsize::new(0));
129	1×	let allow = Arc::new(allow);
130	1×	let s = stop.clone();
131	1×	std::thread::spawn(move \|\| {
132	3×	for conn in listener.incoming() {
133	3×	if s.load(Ordering::SeqCst) {
134	1×	break;
135	2×	}
136	2×	let Ok(conn) = conn else { continue };
137	2×	if open.load(Ordering::SeqCst) >= MAX_OPEN {
138	0×	let _ = refuse(conn, "too many connections at once");
139	0×	let _ = log.send(format!("egress: refused a connection: {MAX_OPEN} already open"));
140	0×	continue;
141	2×	}
142	2×	open.fetch_add(1, Ordering::SeqCst);
143	2×	let (allow, log, open) = (allow.clone(), log.clone(), open.clone());
144	2×	std::thread::spawn(move \|\| {
145	2×	serve(conn, &allow, &log);
146	2×	open.fetch_sub(1, Ordering::SeqCst);
147	2×	});
148		}
149	1×	});
150	1×	Ok(Proxy { stop, path: socket.to_path_buf() })
151	1×	}
152
153	2×	fn refuse(mut conn: UnixStream, why: &str) -> std::io::Result<()> {
154	2×	let body = format!("{why}\n");
155	2×	write!(conn, "HTTP/1.1 403 Forbidden\r\nContent-Type: text/plain\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}", body.len())
156	2×	}
157
158		/// Read up to the blank line that ends a request head.
159	2×	fn read_head(conn: &mut UnixStream) -> std::io::Result<String> {
160	2×	let mut head = Vec::new();
161	2×	let mut byte = [0u8; 1];
162	85×	while !head.ends_with(b"\r\n\r\n") {
163	83×	if head.len() >= MAX_HEAD \|\| conn.read(&mut byte)? == 0 {
164	0×	break;
165	83×	}
166	83×	head.push(byte[0]);
167		}
168	2×	Ok(String::from_utf8_lossy(&head).into_owned())
169	2×	}
170
171	2×	fn serve(mut conn: UnixStream, allow: &[String], log: &mpsc::Sender<String>) {
172	2×	let _ = conn.set_read_timeout(Some(Duration::from_secs(30)));
173	2×	let head = match read_head(&mut conn) {
174	2×	Ok(h) => h,
175	0×	Err(_) => return,
176		};
177	2×	let (host, port) = match parse_head(&head) {
178	1×	Ask::Connect { host, port } => (host, port),
179	1×	Ask::Refused(why) => {
180	1×	let _ = log.send(format!("egress: refused: {why}"));
181	1×	let _ = refuse(conn, &why);
182	1×	return;
183		}
184		};
185	1×	if let Err(why) = decide(allow, &host, port) {
186	1×	let _ = log.send(format!("egress: refused {host}:{port}: {why}"));
187	1×	let _ = refuse(conn, &format!("{host}:{port}: {why}"));
188	1×	return;
189	0×	}
190	0×	let addrs: Vec<SocketAddr> = match (host.as_str(), port).to_socket_addrs() {
191	0×	Ok(a) => a.collect(),
192	0×	Err(e) => {
193	0×	let _ = log.send(format!("egress: refused {host}:{port}: it could not be resolved ({e})"));
194	0×	let _ = refuse(conn, &format!("{host} could not be resolved"));
195	0×	return;
196		}
197		};
198	0×	if let Some(bad) = addrs.iter().find(\|a\| !public(a.ip())) {
199	0×	let why = format!("it resolves to {}, which is not a public address", bad.ip());
200	0×	let _ = log.send(format!("egress: refused {host}:{port}: {why}"));
201	0×	let _ = refuse(conn, &format!("{host}: {why}"));
202	0×	return;
203	0×	}
204	0×	let out = addrs.iter().find_map(\|a\| TcpStream::connect_timeout(a, CONNECT_TIMEOUT).ok());
205	0×	let Some(out) = out else {
206	0×	let _ = log.send(format!("egress: {host}:{port} is allowed but did not answer"));
207	0×	let _ = conn.write_all(b"HTTP/1.1 502 Bad Gateway\r\nConnection: close\r\n\r\n");
208	0×	return;
209		};
210	0×	let _ = log.send(format!("egress: allowed {host}:{port}"));
211	0×	if conn.write_all(b"HTTP/1.1 200 Connection established\r\n\r\n").is_err() {
212	0×	return;
213	0×	}
214	0×	let _ = conn.set_read_timeout(None);
215	0×	relay(conn, out);
216	2×	}
217
218		/// Copy both ways until either side closes.
219	0×	fn relay(guest: UnixStream, out: TcpStream) {
220	0×	let (Ok(mut guest_r), Ok(mut out_w)) = (guest.try_clone(), out.try_clone()) else { return };
221	0×	let up = std::thread::spawn(move \|\| {
222	0×	let _ = std::io::copy(&mut guest_r, &mut out_w);
223	0×	let _ = out_w.shutdown(std::net::Shutdown::Write);
224	0×	});
225	0×	let (mut out_r, mut guest_w) = (out, guest);
226	0×	let _ = std::io::copy(&mut out_r, &mut guest_w);
227	0×	let _ = guest_w.shutdown(std::net::Shutdown::Write);
228	0×	let _ = up.join();
229	0×	}
230
231		#[cfg(test)]
232		mod tests {
233		use super::*;
234
235	6×	fn allow() -> Vec<String> {
236	6×	vec!["*.googleapis.com".into(), "registry.opentofu.org".into()]
237	6×	}
238
239		#[test]
240	1×	fn only_connect_to_an_allowed_name_on_443_is_let_through() {
241	1×	assert_eq!(
242	1×	parse_head("CONNECT storage.googleapis.com:443 HTTP/1.1\r\nHost: x\r\n\r\n"),
243	1×	Ask::Connect { host: "storage.googleapis.com".into(), port: 443 }
244		);
245	1×	assert!(matches!(parse_head("GET http://example.com/ HTTP/1.1\r\n\r\n"), Ask::Refused(w) if w.contains("only https")));
246	1×	assert!(matches!(parse_head("CONNECT example.com HTTP/1.1\r\n\r\n"), Ask::Refused(w) if w.contains("no port")));
247	1×	assert_eq!(decide(&allow(), "storage.googleapis.com", 443), Ok(()));
248	1×	assert_eq!(decide(&allow(), "registry.opentofu.org", 443), Ok(()));
249	1×	assert!(decide(&allow(), "example.com", 443).unwrap_err().contains("allow-list"));
250	1×	assert!(decide(&allow(), "registry.opentofu.org", 22).unwrap_err().contains("only port 443"));
251	1×	assert!(decide(&allow(), "142.250.1.1", 443).unwrap_err().contains("names hosts"));
252	1×	}
253
254		#[test]
255	1×	fn private_addresses_are_not_public() {
256	11×	for ip in [
257	1×	"127.0.0.1",
258	1×	"10.1.2.3",
259	1×	"192.168.1.1",
260	1×	"172.16.0.1",
261	1×	"169.254.169.254",
262	1×	"100.64.0.1",
263	1×	"0.0.0.0",
264	1×	"::1",
265	1×	"fd00::1",
266	1×	"fe80::1",
267	1×	"::ffff:10.0.0.1",
268	1×	] {
269	11×	assert!(!public(ip.parse().unwrap()), "{ip}");
270		}
271	2×	for ip in ["142.250.1.1", "2a00:1450:4009::200e"] {
272	2×	assert!(public(ip.parse().unwrap()), "{ip}");
273		}
274	1×	}
275
276		#[test]
277	1×	fn the_proxy_refuses_and_logs_a_host_not_allowed() {
278	1×	let dir = tempfile::tempdir().unwrap();
279	1×	let sock = dir.path().join("v.sock_3128");
280	1×	let (tx, rx) = mpsc::channel();
281	1×	let proxy = start(&sock, allow(), tx).unwrap();
282	2×	let ask = \|head: &str\| {
283	2×	let mut c = UnixStream::connect(&sock).unwrap();
284	2×	c.write_all(head.as_bytes()).unwrap();
285	2×	let mut answer = String::new();
286	2×	c.read_to_string(&mut answer).unwrap();
287	2×	answer
288	2×	};
289	1×	let a = ask("CONNECT example.com:443 HTTP/1.1\r\n\r\n");
290	1×	assert!(a.starts_with("HTTP/1.1 403") && a.contains("not in the sandbox's egress allow-list"), "{a}");
291	1×	assert_eq!(
292	1×	rx.recv_timeout(Duration::from_secs(5)).unwrap(),
293		"egress: refused example.com:443: not in the sandbox's egress allow-list"
294		);
295	1×	let a = ask("GET http://storage.googleapis.com/ HTTP/1.1\r\n\r\n");
296	1×	assert!(a.starts_with("HTTP/1.1 403"), "{a}");
297	1×	assert!(rx.recv_timeout(Duration::from_secs(5)).unwrap().contains("only https"));
298	1×	drop(proxy);
299	1×	assert!(!sock.exists(), "the socket goes with the job");
300	1×	}
301		}

Coverage / crates/flow/src/egress.rs 79.2%

Keyboard