use crate::vpn::connector::Connector;
use crate::vpn::profile::WgProfile;
use crate::vpn::{Backend, ConnectionInfo, NetError, PeerStatus};
#[cfg(unix)]
use std::os::unix::fs::PermissionsExt;
use std::process::Command;
const IFACE: &str = "zakuro0";
#[derive(Default)]
pub struct NativeConnector;
pub fn mesh_ip() -> Option<String> {
crate::broker::discovery::get_mesh_ip()
}
#[cfg(unix)]
pub(crate) fn is_root() -> bool {
unsafe { libc::geteuid() == 0 }
}
#[cfg(not(unix))]
pub(crate) fn is_root() -> bool {
false
}
fn augmented_path() -> String {
augmented_path_from(&std::env::var("PATH").unwrap_or_default())
}
fn augmented_path_from(base: &str) -> String {
const BREW: &str = "/opt/homebrew/bin:/opt/homebrew/sbin:/usr/local/bin:/usr/local/sbin";
if base.is_empty() {
BREW.to_string()
} else {
format!("{BREW}:{base}")
}
}
fn find(bin: &str) -> Option<String> {
let out = Command::new("sh")
.arg("-c")
.arg(format!("command -v {}", bin))
.env("PATH", augmented_path())
.output()
.ok()?;
if !out.status.success() {
return None;
}
let p = String::from_utf8_lossy(&out.stdout).trim().to_string();
if p.is_empty() {
None
} else {
Some(p)
}
}
fn have(bin: &str) -> bool {
find(bin).is_some()
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum Readiness {
Missing,
NeedsRoot,
Ready,
}
pub(crate) fn readiness_of(root: bool, tools: bool) -> Readiness {
match (tools, root) {
(false, _) => Readiness::Missing,
(true, false) => Readiness::NeedsRoot,
(true, true) => Readiness::Ready,
}
}
pub(crate) fn readiness() -> Readiness {
readiness_of(is_root(), have("wg-quick") || have("wireguard-go"))
}
pub(crate) fn wg_quick_path() -> Option<String> {
find("wg-quick")
}
pub(crate) fn usable(r: Readiness, can_elevate: &dyn Fn() -> bool) -> bool {
match r {
Readiness::Ready => true,
Readiness::NeedsRoot => can_elevate(),
Readiness::Missing => false,
}
}
fn sudo_cached() -> bool {
Command::new("sudo")
.args(["-n", "true"])
.stdin(std::process::Stdio::null())
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.status()
.map(|s| s.success())
.unwrap_or(false)
}
fn can_elevate() -> bool {
use std::io::IsTerminal;
cfg!(target_os = "macos")
&& crate::vpn::host_ops_allowed("sudo -n true").is_ok()
&& have("sudo")
&& (sudo_cached() || std::io::stdin().is_terminal())
}
fn ensure_elevated(what: &str) -> Result<(), NetError> {
if is_root() {
return Ok(());
}
crate::vpn::host_ops_allowed("sudo -v")?;
if sudo_cached() {
return Ok(());
}
eprintln!(
" zc needs administrator rights to {what} (WireGuard); sudo will ask for your password"
);
let ok = Command::new("sudo")
.arg("-v")
.status()
.map(|s| s.success())
.unwrap_or(false);
if ok {
Ok(())
} else {
Err(NetError::Backend(format!(
"sudo was refused, so zc could not {what}; re-run with `sudo zc connect`, or start Docker Desktop and use `zc connect --docker`"
)))
}
}
fn privileged(program: &str, args: &[&str], envs: &[(&str, String)]) -> Command {
if is_root() {
let mut cmd = Command::new(program);
cmd.args(args);
for (k, v) in envs {
cmd.env(k, v);
}
cmd
} else {
let mut cmd = Command::new("sudo");
cmd.args(["-n", "env"]);
for (k, v) in envs {
cmd.arg(format!("{k}={v}"));
}
cmd.arg(program).args(args);
cmd
}
}
fn wg_device() -> String {
if !cfg!(target_os = "macos") {
return IFACE.to_string();
}
let name_file = format!("/var/run/wireguard/{IFACE}.name");
privileged("cat", &[&name_file], &[])
.stdin(std::process::Stdio::null())
.output()
.ok()
.filter(|o| o.status.success())
.and_then(|o| device_from_name_file(&String::from_utf8_lossy(&o.stdout)))
.unwrap_or_else(|| IFACE.to_string())
}
fn device_from_name_file(text: &str) -> Option<String> {
let name = text.trim();
(name.starts_with("utun") && name[4..].chars().all(|c| c.is_ascii_digit()) && name.len() > 4)
.then(|| name.to_string())
}
fn wg_show(field: Option<&str>) -> Option<String> {
let wg_bin = find("wg").unwrap_or_else(|| "wg".to_string());
let device = wg_device();
let mut args = vec!["show", device.as_str()];
args.extend(field);
let out = privileged(&wg_bin, &args, &[("PATH", augmented_path())])
.stdin(std::process::Stdio::null())
.output()
.ok()?;
out.status
.success()
.then(|| String::from_utf8_lossy(&out.stdout).into_owned())
}
pub(crate) fn latest_handshakes() -> Option<String> {
if !is_root() && !sudo_cached() {
return None;
}
wg_show(Some("latest-handshakes"))
}
fn address_is_local(address: &str) -> bool {
let ip = address.split('/').next().unwrap_or(address);
crate::vpn::local_mesh().is_some_and(|m| m.ip == ip)
}
fn install_conf(conf_text: &str) -> Result<(), NetError> {
if is_root() {
std::fs::create_dir_all("/etc/wireguard")
.map_err(|e| NetError::Backend(format!("mkdir /etc/wireguard: {}", e)))?;
std::fs::write(conf_path(), conf_text)
.map_err(|e| NetError::Backend(format!("writing conf: {}", e)))?;
#[cfg(unix)]
std::fs::set_permissions(conf_path(), std::fs::Permissions::from_mode(0o600))
.map_err(|e| NetError::Backend(format!("chmod conf: {}", e)))?;
return Ok(());
}
use std::io::Write;
let script = format!(
"mkdir -p /etc/wireguard && umask 077 && cat > {}",
conf_path().display()
);
let mut child = privileged("sh", &["-c", &script], &[])
.stdin(std::process::Stdio::piped())
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::piped())
.spawn()
.map_err(|e| NetError::Backend(format!("writing conf via sudo: {}", e)))?;
if let Some(mut stdin) = child.stdin.take() {
stdin
.write_all(conf_text.as_bytes())
.map_err(|e| NetError::Backend(format!("writing conf via sudo: {}", e)))?;
}
let out = child
.wait_with_output()
.map_err(|e| NetError::Backend(format!("writing conf via sudo: {}", e)))?;
if out.status.success() {
Ok(())
} else {
Err(NetError::Backend(format!(
"writing conf via sudo: {}",
String::from_utf8_lossy(&out.stderr).trim()
)))
}
}
fn conf_path() -> std::path::PathBuf {
std::path::PathBuf::from("/etc/wireguard").join(format!("{}.conf", IFACE))
}
fn wg_quick(action: &str) -> Result<String, NetError> {
crate::vpn::host_ops_allowed(&format!("wg-quick {action} {IFACE}"))?;
let wg_quick_bin = find("wg-quick").unwrap_or_else(|| "wg-quick".to_string());
let mut envs = vec![("PATH", augmented_path())];
if cfg!(target_os = "macos") {
envs.push((
"WG_QUICK_USERSPACE_IMPLEMENTATION",
"wireguard-go".to_string(),
));
}
let mut cmd = privileged(&wg_quick_bin, &[action, IFACE], &envs);
cmd.stdin(std::process::Stdio::null());
crate::vpn::vlog(&format!("run: {} {} {}", wg_quick_bin, action, IFACE));
let out = cmd
.output()
.map_err(|e| NetError::Backend(format!("wg-quick: {}", e)))?;
let stdout = String::from_utf8_lossy(&out.stdout);
let stderr = String::from_utf8_lossy(&out.stderr);
if crate::vpn::verbose() {
for l in stdout.lines().chain(stderr.lines()) {
crate::vpn::vlog(&format!("wg-quick {}: {}", action, l));
}
}
if out.status.success() {
Ok(stdout.to_string())
} else {
Err(NetError::Backend(stderr.trim().to_string()))
}
}
impl Connector for NativeConnector {
fn available(&self) -> bool {
usable(readiness(), &can_elevate)
}
fn connect(&self, profile: &WgProfile) -> Result<ConnectionInfo, NetError> {
crate::vpn::host_ops_allowed("native connect")?;
let conf_text = profile
.to_conf()
.map_err(|e| NetError::Backend(format!("invalid profile: {}", e)))?;
ensure_elevated("bring the mesh tunnel up")?;
install_conf(&conf_text)?;
let _ = wg_quick("down"); wg_quick("up")?;
crate::vpn::vlog("verifying tunnel via wg show");
let shown = wg_show(None);
if crate::vpn::verbose() {
for l in shown.as_deref().unwrap_or("(wg show failed)").lines() {
crate::vpn::vlog(&format!("wg show: {}", l));
}
}
let up = shown.is_some();
if !up {
return Err(NetError::Backend(
"tunnel did not come up (run `zc vpn connect --verbose` for details)".into(),
));
}
let address = profile.interface.address.clone();
crate::vpn::vlog(&format!("tunnel up: {} address {}", IFACE, address));
let info = ConnectionInfo {
backend: Backend::Native,
address,
link: IFACE.to_string(),
peers: read_peers(),
host_routable: true,
proxy: None,
relay: None,
};
crate::vpn::state::save_or_warn(&info);
Ok(info)
}
fn status(&self) -> Result<Option<ConnectionInfo>, NetError> {
if crate::vpn::host_ops_allowed("wg show").is_err() {
return Ok(None);
}
let saved = crate::vpn::state::load();
if saved.as_ref().is_some_and(|s| address_is_local(&s.address)) {
return Ok(saved);
}
if wg_show(None).is_none() {
return Ok(None);
}
Ok(saved.or_else(|| {
crate::vpn::local_mesh().map(|m| ConnectionInfo {
backend: Backend::Native,
address: format!("{}/24", m.ip),
link: IFACE.to_string(),
peers: read_peers(),
host_routable: true,
proxy: None,
relay: None,
})
}))
}
fn disconnect(&self) -> Result<(), NetError> {
if !is_root() && !conf_path().exists() {
let _ = crate::vpn::state::clear();
return Ok(());
}
ensure_elevated("bring the mesh tunnel down")?;
let _ = wg_quick("down");
if crate::vpn::host_ops_allowed("rm the wg conf").is_ok() {
let conf = conf_path();
let _ = privileged("rm", &["-f", &conf.to_string_lossy()], &[])
.stdin(std::process::Stdio::null())
.output();
}
let _ = crate::vpn::state::clear();
Ok(())
}
}
fn read_peers() -> Vec<PeerStatus> {
let allowed = wg_show(Some("allowed-ips")).unwrap_or_default();
let hs = wg_show(Some("latest-handshakes"))
.map(|text| {
text.lines()
.filter_map(|l| l.split_whitespace().nth(1))
.filter_map(|s| s.parse::<u64>().ok())
.collect::<Vec<_>>()
})
.unwrap_or_default();
allowed
.lines()
.enumerate()
.filter_map(|(i, line)| {
let cidr = line.split_whitespace().nth(1)?;
let ip = cidr.split('/').next()?.to_string();
let secs = hs.get(i).copied();
Some(PeerStatus {
ip,
last_handshake_secs: secs.filter(|s| *s > 0),
reachable: secs.map(|s| s > 0).unwrap_or(false),
})
})
.collect()
}
#[cfg(test)]
mod tests {
static MESH_IP_ENV_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
struct MeshIpEnvGuard {
_guard: std::sync::MutexGuard<'static, ()>,
prev_mesh: Option<String>,
prev_wg: Option<String>,
}
impl MeshIpEnvGuard {
fn set(value: Option<&str>) -> Self {
let guard = MESH_IP_ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner());
let prev_mesh = std::env::var("ZAKURO_MESH_IP").ok();
let prev_wg = std::env::var("ZAKURO_WIREGUARD_IP").ok();
std::env::remove_var("ZAKURO_WIREGUARD_IP");
match value {
Some(v) => std::env::set_var("ZAKURO_MESH_IP", v),
None => std::env::remove_var("ZAKURO_MESH_IP"),
}
Self {
_guard: guard,
prev_mesh,
prev_wg,
}
}
}
impl Drop for MeshIpEnvGuard {
fn drop(&mut self) {
match &self.prev_mesh {
Some(v) => std::env::set_var("ZAKURO_MESH_IP", v),
None => std::env::remove_var("ZAKURO_MESH_IP"),
}
match &self.prev_wg {
Some(v) => std::env::set_var("ZAKURO_WIREGUARD_IP", v),
None => std::env::remove_var("ZAKURO_WIREGUARD_IP"),
}
}
}
#[test]
fn mesh_ip_agrees_with_discovery_get_mesh_ip_under_env_override() {
let _env = MeshIpEnvGuard::set(Some("10.13.13.42"));
assert_eq!(
super::mesh_ip(),
crate::broker::discovery::get_mesh_ip(),
"mesh_ip() must be the same detector as discovery::get_mesh_ip()"
);
assert_eq!(super::mesh_ip().as_deref(), Some("10.13.13.42"));
let ip = super::mesh_ip().expect("override always resolves");
assert!(!ip.contains('/'), "mesh_ip must strip any prefix length");
assert!(!ip.contains("://"), "mesh_ip must not be a URL");
}
#[test]
fn mesh_ip_agrees_with_discovery_get_mesh_ip_in_the_ambient_environment() {
let _env = MeshIpEnvGuard::set(None);
assert_eq!(super::mesh_ip(), crate::broker::discovery::get_mesh_ip());
}
#[test]
fn wg_quick_is_refused_in_unit_tests() {
assert!(matches!(
super::wg_quick("down"),
Err(crate::vpn::NetError::Refused(_))
));
}
#[test]
fn name_file_yields_the_utun_device() {
use super::device_from_name_file;
assert_eq!(device_from_name_file("utun7\n").as_deref(), Some("utun7"));
assert_eq!(device_from_name_file("utun12").as_deref(), Some("utun12"));
assert_eq!(device_from_name_file(""), None);
assert_eq!(device_from_name_file("utun"), None);
assert_eq!(device_from_name_file("utun7; rm -rf x"), None);
}
#[test]
fn homebrew_dirs_precede_the_system_bash() {
let p = super::augmented_path_from("/usr/bin:/bin:/opt/homebrew/bin");
let dirs: Vec<_> = p.split(':').collect();
let brew = dirs.iter().position(|d| *d == "/opt/homebrew/bin").unwrap();
let system = dirs.iter().position(|d| *d == "/bin").unwrap();
assert!(brew < system, "{p}");
assert_eq!(
super::augmented_path_from(""),
"/opt/homebrew/bin:/opt/homebrew/sbin:/usr/local/bin:/usr/local/sbin"
);
}
#[test]
fn readiness_separates_missing_tools_from_missing_root() {
use super::{readiness_of, Readiness};
assert_eq!(readiness_of(false, false), Readiness::Missing);
assert_eq!(readiness_of(true, false), Readiness::Missing);
assert_eq!(readiness_of(false, true), Readiness::NeedsRoot);
assert_eq!(readiness_of(true, true), Readiness::Ready);
}
#[test]
fn needs_root_is_usable_only_when_sudo_can_be_asked() {
use super::{usable, Readiness};
assert!(usable(Readiness::NeedsRoot, &|| true));
assert!(!usable(Readiness::NeedsRoot, &|| false));
let never = || -> bool { panic!("probed sudo without needing it") };
assert!(usable(Readiness::Ready, &never));
assert!(!usable(Readiness::Missing, &never));
}
#[test]
fn privileged_wraps_in_sudo_when_not_root() {
if super::is_root() {
return;
}
let cmd = super::privileged("wg-quick", &["up", "zakuro0"], &[("PATH", "/p".into())]);
assert_eq!(cmd.get_program(), "sudo");
let args: Vec<_> = cmd
.get_args()
.map(|a| a.to_string_lossy().into_owned())
.collect();
assert_eq!(args, ["-n", "env", "PATH=/p", "wg-quick", "up", "zakuro0"]);
}
#[test]
fn sudo_is_refused_in_unit_tests() {
if super::is_root() {
return;
}
assert!(matches!(
super::ensure_elevated("test"),
Err(crate::vpn::NetError::Refused(_))
));
}
#[test]
fn native_connect_is_refused_in_unit_tests() {
use crate::vpn::connector::Connector;
let profile: crate::vpn::profile::WgProfile = serde_json::from_str(
r#"{
"interface": { "private_key": "MKCl4DM7FbX1sFUiFd8VqKzdIGUMwJ28rTgFYezsclc=", "address": "10.13.13.6/24" },
"peer": { "public_key": "/Lzp+YIUBrNgdABzyR221uhfx2uOWi4m5ZAdgxXzhFs=",
"endpoint": "144.202.121.242:51822", "allowed_ips": "10.13.13.0/24",
"persistent_keepalive": 25 }
}"#,
)
.expect("sample profile parses");
assert!(matches!(
super::NativeConnector.connect(&profile),
Err(crate::vpn::NetError::Refused(_))
));
}
}