Files
codex/codex-rs/linux-sandbox/src/managed_tcp_dns.rs
T
viyatb-oai 7194b21776 Add opt-in transparent TCP routing for Linux sandboxes (#61372)
## Why

Native TCP clients need to reach managed network destinations without implementing proxy support themselves.

## What changed

- Add `--transparent-tcp` to the Linux sandbox command, using a bundled TCP stack, private TUN interface, and DNS stub to route native IPv4 and IPv6 connections through the attributed managed SOCKS proxy.
- Preserve original hostnames for proxy policy checks and cancel pending approval connections when their native sockets close.
- Expose `--linux-sandbox-transparent-tcp` and `--tcp-upstream-proxy` on `codex exec-server` for transparent routing and a mandatory HTTP CONNECT next hop without direct fallback.
- Require private network and PID namespaces, private procfs, system `bwrap`, and access to `/dev/net/tun`; reject incompatible launcher options and untrusted proxy ports.

## Testing

Add integration coverage for native hostname and IPv6 connections, SOCKS attribution, pending connection cancellation, policy denials, and filesystem and host-loopback isolation. Extend launcher and executor tests for option validation and managed-policy propagation.

GitOrigin-RevId: 96bd7726e5369efceb65320face56aa85ae3deb8
2026-11-13 20:24:37 +00:00

178 lines
6.3 KiB
Rust

//! Assign stable per-command addresses to names. Addresses never change owners
//! while the command runs, including after the client's DNS cache expires.
use hickory_proto::op::Header;
use hickory_proto::op::Message;
use hickory_proto::op::MessageType;
use hickory_proto::op::OpCode;
use hickory_proto::op::Query;
use hickory_proto::op::ResponseCode;
use hickory_proto::rr::DNSClass;
use hickory_proto::rr::RData;
use hickory_proto::rr::Record;
use hickory_proto::rr::RecordType;
use hickory_proto::serialize::binary::BinDecodable;
use hickory_proto::serialize::binary::BinDecoder;
use hickory_proto::serialize::binary::BinEncodable;
use indexmap::IndexSet;
use std::io;
use std::io::Read;
use std::io::Write;
use std::net::IpAddr;
use std::net::Ipv4Addr;
use std::net::Ipv6Addr;
use std::net::TcpListener;
use std::net::TcpStream;
use std::net::UdpSocket;
use std::sync::Arc;
use std::sync::Mutex;
use std::thread;
use std::time::Duration;
const MAX_NAMES: usize = 8192;
const V4_BASE: u32 = u32::from_be_bytes([198, 18, 0, 0]);
const V6_BASE: u128 = 0xfdc0_de00_0000_0000_0000_0000_0000_0000;
#[derive(Default)]
pub(super) struct Names {
// Append only: both synthetic address families encode the same one-based index.
names: IndexSet<String>,
}
impl Names {
pub(super) fn lookup(&self, ip: IpAddr) -> io::Result<Option<String>> {
let id = match ip.to_canonical() {
IpAddr::V4(ip) if u32::from(ip) & 0xfffe_0000 == V4_BASE => u32::from(ip) - V4_BASE,
IpAddr::V6(ip) if u128::from(ip) >> 32 == V6_BASE >> 32 => u128::from(ip) as u32,
_ => return Ok(None),
};
let name = id
.checked_sub(1)
.and_then(|index| self.names.get_index(index as usize));
name.cloned()
.map(Some)
.ok_or_else(|| io::Error::other("unassigned synthetic address"))
}
fn id(&mut self, host: String) -> Option<u32> {
let index = match self.names.get_index_of(&host) {
Some(index) => index,
None if self.names.len() < MAX_NAMES => self.names.insert_full(host).0,
None => return None,
};
Some(index as u32 + 1)
}
fn answer(&mut self, packet: &[u8]) -> Option<Vec<u8>> {
if packet.len() > 4096 {
return None;
}
// Decode one question only. EDNS and other trailing bytes never go to a resolver
// or into the reply, and untrusted section counts never size an allocation.
let mut decoder = BinDecoder::new(packet);
let header = Header::read(&mut decoder).ok()?;
if header.message_type != MessageType::Query
|| header.op_code != OpCode::Query
|| header.counts.queries != 1
|| header.counts.answers != 0
|| header.counts.authorities != 0
{
return None;
}
let start = decoder.index();
let query = Query::read(&mut decoder).ok()?;
// The first question has no earlier name to reference. Reject compression
// and labels that would require escapes when converted to a SOCKS hostname.
if query.to_bytes().ok()? != decoder.slice_from(start).ok()?
|| !query
.name
.iter()
.flatten()
.all(|b| b.is_ascii_alphanumeric() || matches!(b, b'-' | b'_'))
{
return None;
}
let mut reply = Message::response(header.id, OpCode::Query);
reply.metadata.recursion_desired = header.recursion_desired;
reply.metadata.recursion_available = true;
if query.query_class == DNSClass::IN
&& matches!(query.query_type, RecordType::A | RecordType::AAAA)
&& !query.name.is_root()
{
let host = query
.name
.to_ascii()
.trim_end_matches('.')
.to_ascii_lowercase();
if let Some(id) = self.id(host) {
let ip = if query.query_type == RecordType::A {
IpAddr::V4(Ipv4Addr::from(V4_BASE + id))
} else {
IpAddr::V6(Ipv6Addr::from(V6_BASE + u128::from(id)))
};
reply.add_answer(Record::from_rdata(query.name.clone(), 60, RData::from(ip)));
} else {
reply.metadata.response_code = ResponseCode::ServFail;
}
}
reply.add_query(query);
reply.to_vec().ok()
}
}
pub(super) fn serve(names: Arc<Mutex<Names>>, udp: UdpSocket, tcp: TcpListener) -> io::Result<()> {
let udp_names = Arc::clone(&names);
thread::Builder::new().spawn(move || {
let mut buf = [0; 4096];
while let Ok((n, peer)) = udp.recv_from(&mut buf) {
let reply = udp_names
.lock()
.ok()
.and_then(|mut table| table.answer(&buf[..n]));
if let Some(reply) = reply {
let _ = udp.send_to(&reply, peer);
}
}
})?;
// Fixed workers bound concurrent DNS-over-TCP exchanges. Some resolvers
// pipeline A and AAAA queries on the same connection.
for _ in 0..4 {
let listener = tcp.try_clone()?;
let names = Arc::clone(&names);
thread::Builder::new().spawn(move || {
while let Ok(stream) = crate::managed_tcp::accept_with_backoff(&listener) {
let _ = answer_tcp(stream, &names);
}
})?;
}
Ok(())
}
fn answer_tcp(mut stream: TcpStream, names: &Mutex<Names>) -> io::Result<()> {
let timeout = Some(Duration::from_secs(2));
stream.set_read_timeout(timeout)?;
stream.set_write_timeout(timeout)?;
let mut buf = [0; 4096];
for _ in 0..32 {
let mut size = [0; 2];
stream.read_exact(&mut size)?;
let query = buf
.get_mut(..usize::from(u16::from_be_bytes(size)))
.ok_or_else(|| io::Error::other("oversized DNS query"))?;
stream.read_exact(query)?;
let reply = names
.lock()
.map_err(|_| io::Error::other("DNS name table is unavailable"))?
.answer(query)
.ok_or_else(|| io::Error::other("invalid DNS query"))?;
stream.write_all(&(reply.len() as u16).to_be_bytes())?;
stream.write_all(&reply)?;
}
Ok(())
}
#[cfg(test)]
#[path = "managed_tcp_tests.rs"]
mod tests;