chore: remove unused skill file for PR fixes

- switch back to let mut args: Args = Args::parse()

Cargo.toml

@@ -16,7 +16,7 @@ smoltcp = "0"
 libc = "0"
 polling = "3"
 dhcproto = { git = "https://github.com/bluecatengineering/dhcproto.git", branch = "master" }
-vmnet = "0.5.1"
+vmnet = "0.5.0"
 clap = { version = "4", features = ["derive"] }
 mac_address = "1"
 privdrop = "0"
@@ -33,8 +33,6 @@ ipnet = "2"
 oslog = "0.2.0"
 log = "0.4.29"
 serial_test = "3"
-coarsetime = "0.1.37"
-pnet_datalink = "0.35.0"
 
 [profile.release]
 debug = true

lib/dhcp_snooper.rs

@@ -2,22 +2,14 @@ use dhcproto::Decodable;
 use dhcproto::v4::{DhcpOption, MessageType, OptionCode};
 use smoltcp::wire::Ipv4Address;
 use std::collections::HashSet;
-use std::time::Duration;
+use std::time::{Duration, Instant};
 
 #[derive(Default)]
 pub struct DhcpSnooper {
     vm_lease: Option<Lease>,
-    uncertainty_duration: Duration,
 }
 
 impl DhcpSnooper {
-    pub fn new(uncertainty_duration: Duration) -> Self {
-        DhcpSnooper {
-            uncertainty_duration,
-            ..Default::default()
-        }
-    }
-
     pub fn register_dhcp_reply(&mut self, dhcp_packet: &[u8]) {
         let mut decoder = dhcproto::v4::Decoder::new(dhcp_packet);
 
@@ -40,12 +32,11 @@ impl DhcpSnooper {
                     _ => HashSet::new(),
                 };
 
-                let mut lease_duration = Duration::from_secs(*lease_time as u64);
-
-                // Adjust for uncertainty caused by using a coarse clock
-                lease_duration = lease_duration.saturating_sub(self.uncertainty_duration);
-
-                self.vm_lease = Some(Lease::new(message.yiaddr(), lease_duration, dns_ips))
+                self.vm_lease = Some(Lease::new(
+                    message.yiaddr(),
+                    Duration::from_secs(*lease_time as u64),
+                    dns_ips,
+                ))
             }
             Some(MessageType::Nak) => {
                 self.vm_lease = None;
@@ -75,7 +66,7 @@ impl DhcpSnooper {
 #[derive(Debug)]
 pub struct Lease {
     address: Ipv4Address,
-    valid_until: coarsetime::Instant,
+    valid_until: Instant,
     dns_ips: HashSet<Ipv4Address>,
 }
 
@@ -83,7 +74,7 @@ impl Lease {
     pub fn new(address: Ipv4Address, lease_time: Duration, dns_ips: HashSet<Ipv4Address>) -> Lease {
         Lease {
             address,
-            valid_until: coarsetime::Instant::recent() + lease_time.into(),
+            valid_until: Instant::now() + lease_time,
             dns_ips,
         }
     }
@@ -93,7 +84,7 @@ impl Lease {
     }
 
     pub fn valid(&self) -> bool {
-        coarsetime::Instant::recent() < self.valid_until
+        Instant::now() < self.valid_until
     }
 
     pub fn valid_ip_source(&self, address: Ipv4Address) -> bool {

lib/host.rs

@@ -1,8 +1,6 @@
 use anyhow::{Context, Result, anyhow};
 use clap::ValueEnum;
 use log::info;
-use smoltcp::wire::EthernetAddress;
-use std::net::IpAddr;
 use std::net::Ipv4Addr;
 use std::os::unix::io::{AsRawFd, RawFd};
 use std::os::unix::net::UnixDatagram;
@@ -30,7 +28,6 @@ pub struct Host {
     new_packets_rx: UnixDatagram,
     callback_can_continue_tx: SyncSender<()>,
     pub gateway_ip: smoltcp::wire::Ipv4Address,
-    pub gateway_mac: EthernetAddress,
     pub max_packet_size: u64,
     pub read_max_packets: u64,
     finalized: bool,
@@ -52,43 +49,16 @@ impl Host {
         .context("failed to initialize vmnet interface")?;
 
         // Retrieve first IP (gateway) used for this interface
-        let Some(Parameter::StartAddress(start_address)) =
+        let Some(Parameter::StartAddress(gateway_ip)) =
             interface.parameters().get(ParameterKind::StartAddress)
         else {
             return Err(anyhow!(
                 "failed to retrieve vmnet's interface start address"
             ));
         };
-        let start_address = Ipv4Addr::from_str(&start_address)
+        let gateway_ip = Ipv4Addr::from_str(&gateway_ip)
             .context("failed to parse vmnet's interface start address")?;
 
-        // Retrieve last IP used for this interface and calculate the prefix
-        let Some(Parameter::EndAddress(end_address)) =
-            interface.parameters().get(ParameterKind::EndAddress)
-        else {
-            return Err(anyhow!("failed to retrieve vmnet's interface end address"));
-        };
-        let end_address = Ipv4Addr::from_str(&end_address)
-            .context("failed to parse vmnet's interface end address")?;
-
-        let Some(prefix) = Self::ipv4_range_prefix(start_address, end_address) else {
-            return Err(anyhow!(
-                "failed to resolve vmnet's interface: prefix ambiguity for {}–{}",
-                start_address,
-                end_address
-            ));
-        };
-
-        // Figure out the gateway's interface MAC address
-        let Some(gateway_mac) = Self::interface_mac_for_ip(start_address, prefix) else {
-            return Err(anyhow!(
-                "failed to resolve vmnet's interface: no interface found with {}/{} CIDR",
-                start_address,
-                prefix
-            ));
-        };
-        let gateway_mac = EthernetAddress(gateway_mac.octets());
-
         // Retrieve max packet size for this interface
         let Some(Parameter::MaxPacketSize(max_packet_size)) =
             interface.parameters().get(ParameterKind::MaxPacketSize)
@@ -134,39 +104,12 @@ impl Host {
             interface,
             new_packets_rx,
             callback_can_continue_tx,
-            gateway_ip: start_address,
-            gateway_mac,
+            gateway_ip,
             max_packet_size,
             read_max_packets,
             finalized: false,
         })
     }
-
-    fn interface_mac_for_ip(ip: Ipv4Addr, prefix: u8) -> Option<pnet_datalink::MacAddr> {
-        for iface in pnet_datalink::interfaces() {
-            if iface
-                .ips
-                .iter()
-                .any(|network| network.ip() == IpAddr::V4(ip) && network.prefix() == prefix)
-                && let Some(mac) = iface.mac
-            {
-                return Some(mac);
-            }
-        }
-
-        None
-    }
-
-    fn ipv4_range_prefix(start_address: Ipv4Addr, end_address: Ipv4Addr) -> Option<u8> {
-        let start_address = start_address.to_bits();
-        let end_address = end_address.to_bits();
-
-        if start_address > end_address {
-            return None;
-        }
-
-        Some((start_address ^ end_address).leading_zeros() as u8)
-    }
 }
 
 impl Host {

lib/poller.rs

@@ -9,7 +9,6 @@ use std::time::Duration;
 pub struct Poller<'poller> {
     poller: polling::Poller,
     events: polling::Events,
-    timeout: Duration,
     vm_fd: BorrowedFd<'poller>,
     host_fd: BorrowedFd<'poller>,
 }
@@ -23,17 +22,12 @@ enum EventKey {
 }
 
 impl Poller<'_> {
-    pub fn new<'poller>(
-        vm_fd: RawFd,
-        host_fd: RawFd,
-        timeout: Duration,
-    ) -> Result<Poller<'poller>> {
+    pub fn new<'poller>(vm_fd: RawFd, host_fd: RawFd) -> Result<Poller<'poller>> {
         let poller = polling::Poller::new()?;
 
         Ok(Poller {
             poller,
             events: polling::Events::new(),
-            timeout,
             vm_fd: unsafe { BorrowedFd::borrow_raw(vm_fd) },
             host_fd: unsafe { BorrowedFd::borrow_raw(host_fd) },
         })
@@ -65,7 +59,8 @@ impl Poller<'_> {
     }
 
     pub fn wait(&mut self) -> Result<(bool, bool, bool)> {
-        self.poller.wait(&mut self.events, Some(self.timeout))?;
+        self.poller
+            .wait(&mut self.events, Some(Duration::from_millis(100)))?;
 
         let vm_readable = self
             .events

lib/proxy/host.rs

@@ -1,9 +1,7 @@
+use crate::proxy::Proxy;
 use crate::proxy::udp_packet_helper::UdpPacketHelper;
-use crate::proxy::{Action, Proxy};
 use anyhow::{Context, Result};
-use ipnet::Ipv4Net;
-use smoltcp::wire::{ArpPacket, EthernetFrame, EthernetProtocol, Ipv4Packet, UdpPacket};
-use std::net::Ipv4Addr;
+use smoltcp::wire::{EthernetFrame, EthernetProtocol, Ipv4Packet, UdpPacket};
 
 impl Proxy<'_> {
     pub(crate) fn process_frame_from_host(&mut self, frame: &EthernetFrame<&[u8]>) -> Result<()> {
@@ -38,42 +36,14 @@ impl Proxy<'_> {
         }
     }
 
-    pub(crate) fn allowed_from_host(&self, frame: &EthernetFrame<&[u8]>) -> Option<()> {
-        if frame.src_addr() == self.host.gateway_mac {
-            return allowed_host_ethertype(frame);
-        }
-
-        match self.rules_mac.get(frame.src_addr().as_bytes()) {
-            Some(Action::Block) => return None,
-            Some(Action::Allow) => return allowed_host_ethertype(frame),
-            None => {}
-        }
-
+    fn allowed_from_host(&mut self, frame: &EthernetFrame<&[u8]>) -> Option<()> {
         match frame.ethertype() {
-            EthernetProtocol::Arp => {
-                let arp_pkt = ArpPacket::new_checked(frame.payload()).ok()?;
-                let source_protocol_addr: [u8; 4] =
-                    arp_pkt.source_protocol_addr().try_into().ok()?;
-
-                self.allowed_peer_ip_from_host(Ipv4Addr::from(source_protocol_addr))
-            }
-            EthernetProtocol::Ipv4 => {
-                let ipv4_pkt = Ipv4Packet::new_checked(frame.payload()).ok()?;
-                self.allowed_peer_ip_from_host(ipv4_pkt.src_addr())
-            }
+            EthernetProtocol::Arp => Some(()),
+            EthernetProtocol::Ipv4 => Some(()),
             _ => None,
         }
     }
 
-    fn allowed_peer_ip_from_host(&self, peer_ip: Ipv4Addr) -> Option<()> {
-        let peer_net = Ipv4Net::from(peer_ip);
-
-        match self.rules.get_lpm(&peer_net).map(|(_, action)| action) {
-            Some(Action::Allow) => Some(()),
-            Some(Action::Block) | None => None,
-        }
-    }
-
     fn snoop(&mut self, frame: &EthernetFrame<&[u8]>) {
         if frame.ethertype() != EthernetProtocol::Ipv4 {
             return;
@@ -104,10 +74,3 @@ impl Proxy<'_> {
         self.dhcp_snooper.register_dhcp_reply(udp_pkt.payload());
     }
 }
-
-fn allowed_host_ethertype(frame: &EthernetFrame<&[u8]>) -> Option<()> {
-    match frame.ethertype() {
-        EthernetProtocol::Arp | EthernetProtocol::Ipv4 => Some(()),
-        _ => None,
-    }
-}

lib/proxy/mod.rs

@@ -14,13 +14,10 @@ pub use exposed_port::ExposedPort;
 use ipnet::Ipv4Net;
 use mac_address::MacAddress;
 use port_forwarder::PortForwarder;
-use prefix_trie::{Prefix, PrefixMap};
+use prefix_trie::{Prefix, PrefixMap, PrefixSet};
 use smoltcp::wire::EthernetFrame;
-use std::collections::HashMap;
 use std::io::ErrorKind;
 use std::os::unix::io::{AsRawFd, RawFd};
-use std::str::FromStr;
-use std::time::Duration;
 use vmnet::Batch;
 
 pub struct Proxy<'proxy> {
@@ -30,44 +27,10 @@ pub struct Proxy<'proxy> {
     vm_mac_address: smoltcp::wire::EthernetAddress,
     dhcp_snooper: DhcpSnooper,
     rules: PrefixMap<Ipv4Net, Action>,
-    rules_mac: HashMap<[u8; 6], Action>,
     enobufs_encountered: bool,
     port_forwarder: PortForwarder,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Target {
-    Prefix(Ipv4Net),
-    MacAddress(MacAddress),
-    Host,
-}
-
-impl Target {
-    pub fn is_ipv4_default_route(&self) -> bool {
-        matches!(self, Target::Prefix(prefix) if *prefix == Ipv4Net::zero())
-    }
-
-    pub fn is_mac_address(&self) -> bool {
-        matches!(self, Target::MacAddress(_))
-    }
-}
-
-impl FromStr for Target {
-    type Err = ipnet::AddrParseError;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        if s == "@host" {
-            return Ok(Target::Host);
-        }
-
-        if let Ok(mac_address) = MacAddress::from_str(s) {
-            return Ok(Target::MacAddress(mac_address));
-        }
-
-        Ipv4Net::from_str(s).map(Target::Prefix)
-    }
-}
-
 #[derive(Debug, Clone, PartialEq)]
 pub(crate) enum Action {
     Block,
@@ -79,50 +42,26 @@ impl Proxy<'_> {
         vm_fd: RawFd,
         vm_mac_address: MacAddress,
         vm_net_type: NetType,
-        allow: Vec<Target>,
-        block: Vec<Target>,
+        allow: PrefixSet<Ipv4Net>,
+        block: PrefixSet<Ipv4Net>,
         exposed_ports: Vec<ExposedPort>,
     ) -> Result<Proxy<'proxy>> {
         let vm = VM::new(vm_fd)?;
-        let enable_isolation = !allow.iter().any(Target::is_ipv4_default_route)
-            && !allow.iter().chain(block.iter()).any(Target::is_mac_address);
-        let host = Host::new(vm_net_type, enable_isolation)?;
-        let poller_timeout = Duration::from_millis(100);
-        let poller = Poller::new(vm.as_raw_fd(), host.as_raw_fd(), poller_timeout)?;
+        let host = Host::new(vm_net_type, !allow.contains(&Ipv4Net::zero()))?;
+        let poller = Poller::new(vm.as_raw_fd(), host.as_raw_fd())?;
 
         // Craft packet filter rules
         //
         // SECURITY: blocking rules must always take precedence
         // over allowing rules when prefixes are identical.
         let mut rules = PrefixMap::new();
-        let mut rules_mac = HashMap::new();
 
-        for allow_target in allow {
-            let allow_prefix = match allow_target {
-                Target::Prefix(prefix) => prefix,
-                Target::Host => host.gateway_ip.into(),
-                Target::MacAddress(mac_address) => {
-                    rules_mac.insert(mac_address.bytes(), Action::Allow);
-
-                    continue;
-                }
-            };
-
-            rules.insert(allow_prefix, Action::Allow);
+        for allow_net in allow {
+            rules.insert(allow_net, Action::Allow);
         }
 
-        for block_target in block {
-            let block_prefix = match block_target {
-                Target::Prefix(prefix) => prefix,
-                Target::Host => host.gateway_ip.into(),
-                Target::MacAddress(mac_address) => {
-                    rules_mac.insert(mac_address.bytes(), Action::Block);
-
-                    continue;
-                }
-            };
-
-            rules.insert(block_prefix, Action::Block);
+        for block_net in block {
+            rules.insert(block_net, Action::Block);
         }
 
         Ok(Proxy {
@@ -130,9 +69,8 @@ impl Proxy<'_> {
             host,
             poller,
             vm_mac_address: smoltcp::wire::EthernetAddress(vm_mac_address.bytes()),
-            dhcp_snooper: DhcpSnooper::new(poller_timeout),
+            dhcp_snooper: Default::default(),
             rules,
-            rules_mac,
             enobufs_encountered: false,
             port_forwarder: PortForwarder::new(exposed_ports),
         })
@@ -154,9 +92,6 @@ impl Proxy<'_> {
         loop {
             let (vm_readable, host_readable, interrupt) = self.poller.wait()?;
 
-            // Update coarse time for the DHCP snooper
-            coarsetime::Instant::update();
-
             if vm_readable {
                 self.read_from_vm(buf.as_mut_slice())?;
             }
@@ -184,9 +119,6 @@ impl Proxy<'_> {
         loop {
             match self.vm.read(buf) {
                 Ok(n) => {
-                    // Update coarse time for the DHCP snooper
-                    coarsetime::Instant::update();
-
                     if let Ok(frame) = EthernetFrame::new_checked(&buf[..n]) {
                         self.process_frame_from_vm(frame)?;
                     }
@@ -206,9 +138,6 @@ impl Proxy<'_> {
         loop {
             match self.host.read(batch, bufs) {
                 Ok(pktcnt) => {
-                    // Update coarse time for the DHCP snooper
-                    coarsetime::Instant::update();
-
                     for buf in batch.packet_sized_bufs(bufs).take(pktcnt) {
                         if let Ok(pkt) = EthernetFrame::new_checked(buf) {
                             self.process_frame_from_host(&pkt)?;
@@ -235,7 +164,7 @@ mod tests {
     use ipnet::Ipv4Net;
     use mac_address::MacAddress;
     use nix::sys::socket::{AddressFamily, SockFlag, SockType, socketpair};
-    use prefix_trie::PrefixMap;
+    use prefix_trie::{PrefixMap, PrefixSet};
     use serial_test::serial;
     use smoltcp::wire::{Ipv4Address, Ipv4Packet};
     use std::collections::HashSet;
@@ -279,27 +208,6 @@ mod tests {
         assert!(allowed_from_vm_ipv4(&proxy, vm_ip, "33.33.33.34").is_none());
     }
 
-    #[test]
-    #[serial]
-    fn test_allow_host() {
-        let vm_ip = Ipv4Address::from_str("192.168.0.2").unwrap();
-        let proxy = create_proxy(vm_ip, vec!["@host"], vec!["0.0.0.0/0"]);
-
-        assert_eq!(
-            proxy.rules,
-            PrefixMap::from_iter(vec![
-                (proxy.host.gateway_ip.into(), Action::Allow),
-                (Ipv4Net::from_str("0.0.0.0/0").unwrap(), Action::Block),
-            ])
-        );
-
-        // Access to global IPs should be disallowed because of --block=0.0.0.0/0
-        assert!(allowed_from_vm_ipv4(&proxy, vm_ip, "8.8.8.8").is_none());
-
-        // Despite the above, access to host IP address should be possible because of --allow=@host
-        assert!(allowed_from_vm_ipv4(&proxy, vm_ip, &proxy.host.gateway_ip.to_string()).is_some());
-    }
-
     fn create_proxy<'test>(vm_ip: Ipv4Address, allow: Vec<&str>, block: Vec<&str>) -> Proxy<'test> {
         let (vm_fd, _) = socketpair(
             AddressFamily::Unix,
@@ -314,14 +222,16 @@ mod tests {
             vm_fd.as_raw_fd(),
             MacAddress::from_str("02:00:00:00:00:01").unwrap(),
             NetType::Nat,
-            allow
-                .into_iter()
-                .map(|cidr| cidr.parse().unwrap())
-                .collect(),
-            block
-                .into_iter()
-                .map(|cidr| cidr.parse().unwrap())
-                .collect(),
+            PrefixSet::from_iter(
+                allow
+                    .into_iter()
+                    .map(|cidr| Ipv4Net::from_str(cidr).unwrap()),
+            ),
+            PrefixSet::from_iter(
+                block
+                    .into_iter()
+                    .map(|cidr| Ipv4Net::from_str(cidr).unwrap()),
+            ),
             Vec::default(),
         )
         .unwrap();
@@ -344,6 +254,6 @@ mod tests {
 
         let ipv4_pkt = Ipv4Packet::new_unchecked(buf.as_slice());
 
-        proxy.allowed_from_vm_ipv4(ipv4_pkt, false)
+        proxy.allowed_from_vm_ipv4(ipv4_pkt)
     }
 }

lib/proxy/vm.rs

@@ -21,17 +21,11 @@ impl Proxy<'_> {
             .context("failed to write to the host")
     }
 
-    pub(crate) fn allowed_from_vm(&self, frame: &EthernetFrame<&[u8]>) -> Option<()> {
+    fn allowed_from_vm(&self, frame: &EthernetFrame<&[u8]>) -> Option<()> {
         if frame.src_addr() != self.vm_mac_address {
             return None;
         }
 
-        let dst_mac_allowed = match self.rules_mac.get(frame.dst_addr().as_bytes()) {
-            Some(Action::Block) => return None,
-            Some(Action::Allow) => true,
-            None => false,
-        };
-
         match frame.ethertype() {
             EthernetProtocol::Arp => {
                 let arp_pkt = ArpPacket::new_checked(frame.payload()).ok()?;
@@ -39,7 +33,7 @@ impl Proxy<'_> {
             }
             EthernetProtocol::Ipv4 => {
                 let ipv4_pkt = Ipv4Packet::new_checked(frame.payload()).ok()?;
-                self.allowed_from_vm_ipv4(ipv4_pkt, dst_mac_allowed)
+                self.allowed_from_vm_ipv4(ipv4_pkt)
             }
             _ => None,
         }
@@ -64,21 +58,13 @@ impl Proxy<'_> {
         None
     }
 
-    pub(crate) fn allowed_from_vm_ipv4(
-        &self,
-        ipv4_pkt: Ipv4Packet<&[u8]>,
-        dst_mac_allowed: bool,
-    ) -> Option<()> {
+    pub(crate) fn allowed_from_vm_ipv4(&self, ipv4_pkt: Ipv4Packet<&[u8]>) -> Option<()> {
         // Is this packet coming from VM's IP address that we've learned from DHCP snooping?
         if let Some(lease) = &self.dhcp_snooper.lease()
             && lease.valid_ip_source(ipv4_pkt.src_addr())
         {
             let dst_addr = ipv4_pkt.dst_addr();
 
-            if dst_mac_allowed {
-                return Some(());
-            }
-
             // Filter traffic based on user-specified rules first
             if !self.rules.is_empty() {
                 let dst_net = Ipv4Net::from(dst_addr);

src/main.rs

@@ -1,19 +1,22 @@
-use anyhow::{Context, anyhow};
+use anyhow::{Context, Error, anyhow};
 use clap::Parser;
+use ipnet::Ipv4Net;
 use log::LevelFilter;
 use nix::sys::signal::{SigHandler, Signal, signal};
 use oslog::OsLogger;
+use prefix_trie::PrefixSet;
 use privdrop::PrivDrop;
 use softnet::NetType;
 use softnet::proxy::ExposedPort;
 use softnet::proxy::Proxy;
-use softnet::proxy::Target;
 use std::borrow::Cow;
 use std::env;
+use std::net::{Ipv4Addr, SocketAddr, ToSocketAddrs};
 use std::os::raw::c_int;
 use std::os::unix::io::RawFd;
 use std::os::unix::process::CommandExt;
 use std::process::{Command, ExitCode};
+use std::str::FromStr;
 use system_configuration::core_foundation::base::TCFType;
 use system_configuration::core_foundation::dictionary::CFDictionary;
 use system_configuration::core_foundation::number::CFNumber;
@@ -22,6 +25,67 @@ use system_configuration::preferences::SCPreferences;
 use system_configuration::sys::preferences::{SCPreferencesCommitChanges, SCPreferencesSetValue};
 use uzers::{get_current_groupname, get_current_username, get_effective_uid};
 
+#[derive(Debug, Clone)]
+enum AllowBlockEntry {
+    Net(Ipv4Net),
+    Domain(String),
+}
+
+impl FromStr for AllowBlockEntry {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let trimmed = s.trim();
+        if trimmed.is_empty() {
+            return Err(anyhow!("empty allow/block entry"));
+        }
+
+        if let Ok(net) = trimmed.parse::<Ipv4Net>() {
+            return Ok(AllowBlockEntry::Net(net));
+        }
+
+        if let Ok(addr) = trimmed.parse::<Ipv4Addr>() {
+            return Ok(AllowBlockEntry::Net(Ipv4Net::from(addr)));
+        }
+
+        Ok(AllowBlockEntry::Domain(trimmed.to_string()))
+    }
+}
+
+fn resolve_allow_block_entries(
+    kind: &str,
+    entries: Vec<AllowBlockEntry>,
+) -> anyhow::Result<Vec<Ipv4Net>> {
+    let mut nets = Vec::new();
+
+    for entry in entries {
+        match entry {
+            AllowBlockEntry::Net(net) => nets.push(net),
+            AllowBlockEntry::Domain(domain) => {
+                // A-record resolution happens here via ToSocketAddrs, then we keep only IPv4s.
+                let resolved: Vec<Ipv4Net> = (domain.as_str(), 0)
+                    .to_socket_addrs()
+                    .with_context(|| format!("failed to resolve {kind} entry {domain}"))?
+                    .filter_map(|addr| match addr {
+                        SocketAddr::V4(v4) => Some(Ipv4Net::from(*v4.ip())),
+                        SocketAddr::V6(_) => None,
+                    })
+                    .collect();
+
+                if resolved.is_empty() {
+                    return Err(anyhow!(
+                        "no IPv4 addresses found for {kind} entry {domain}"
+                    ));
+                }
+
+                nets.extend(resolved);
+            }
+        }
+    }
+
+    Ok(nets)
+}
+
 #[derive(Parser, Debug)]
 struct Args {
     #[clap(
@@ -51,34 +115,32 @@ struct Args {
 
     #[clap(
         long,
-        help = "Comma-separated list of CIDRs to allow the traffic to \
-        (e.g. --allow=192.168.0.0/24 may be used to allow a LAN access for a VM), \
-        plus supported @-aliases. Currently the only supported @-alias is @host, \
-        which matches the vmnet bridge gateway IP. \
+        help = "Comma-separated list of CIDRs, IPs, or domains to allow the traffic to \
+        (e.g. --allow=192.168.0.0/24 or --allow=example.com). Domains are resolved to A records \
+        at startup. \
         When used with --block, the longest prefix match always wins. \
         In case an identical prefix is both --allow'ed and --block'ed, \
         blocking will take precedence. --allow=0.0.0.0/0 is a special case, \
         it additionally disables bridge isolation (even when --block=0.0.0.0/0 is specified).",
-        value_name = "comma-separated CIDRs, MAC addresses or @-aliases",
+        value_name = "comma-separated CIDRs/IPs/domains",
         use_value_delimiter = true,
         action = clap::ArgAction::Set
     )]
-    allow: Vec<Target>,
+    allow: Vec<AllowBlockEntry>,
 
     #[clap(
         long,
-        help = "Comma-separated list of CIDRs to block the traffic to \
+        help = "Comma-separated list of CIDRs, IPs, or domains to block the traffic to \
         (e.g. --block=0.0.0.0/0 may be used to establish a default deny policy \
-        that is further relaxed with --allow), plus supported @-aliases. \
-        Currently the only supported @-alias is @host, which matches the vmnet bridge gateway IP. \
-        When used with --allow, the longest prefix match always wins. \
-        In case an identical prefix is both --allow'ed and --block'ed, \
-        blocking will take precedence.",
-        value_name = "comma-separated CIDRs, MAC addresses or @-aliases",
+        that is further relaxed with --allow). Domains are resolved to A records at startup. \
+        When used with --allow, \
+        the longest prefix match always wins. In case the same prefix is both \
+        --allow'ed and --block'ed, blocking takes precedence.",
+        value_name = "comma-separated CIDRs/IPs/domains",
         use_value_delimiter = true,
         action = clap::ArgAction::Set
     )]
-    block: Vec<Target>,
+    block: Vec<AllowBlockEntry>,
 
     #[clap(
         long,
@@ -148,7 +210,7 @@ fn try_main() -> anyhow::Result<()> {
     // [2]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/kqueue.2.html
     unsafe { signal(Signal::SIGINT, SigHandler::SigIgn) }?;
 
-    let args: Args = Args::parse();
+    let mut args: Args = Args::parse();
 
     // No need to run anything, just return
     // so that the invoker process knows we
@@ -191,6 +253,9 @@ fn try_main() -> anyhow::Result<()> {
         ));
     }
 
+    let allow = resolve_allow_block_entries("allow", std::mem::take(&mut args.allow))?;
+    let block = resolve_allow_block_entries("block", std::mem::take(&mut args.block))?;
+
     // Set bootpd(8) min/max lease time while still having the root privileges
     set_bootpd_lease_time(args.bootpd_lease_time);
 
@@ -199,8 +264,8 @@ fn try_main() -> anyhow::Result<()> {
         args.vm_fd as RawFd,
         args.vm_mac_address,
         args.vm_net_type,
-        args.allow,
-        args.block,
+        PrefixSet::from_iter(allow),
+        PrefixSet::from_iter(block),
         args.expose,
     )
     .context("failed to initialize proxy")?;
@@ -252,3 +317,24 @@ fn set_bootpd_lease_time(lease_time: u32) {
         SCPreferencesCommitChanges(prefs.as_concrete_TypeRef());
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{AllowBlockEntry, resolve_allow_block_entries};
+    use ipnet::Ipv4Net;
+    use std::net::Ipv4Addr;
+
+    #[test]
+    fn resolve_domain_to_ipv4_nets_dns_google() {
+        let nets = resolve_allow_block_entries(
+            "allow",
+            vec![AllowBlockEntry::Domain("dns.google".to_string())],
+        )
+        .unwrap();
+
+        assert!(
+            nets.contains(&Ipv4Net::from(Ipv4Addr::new(8, 8, 8, 8)))
+                || nets.contains(&Ipv4Net::from(Ipv4Addr::new(8, 8, 4, 4)))
+        );
+    }
+}