mirror of
https://github.com/mountain-loop/yaak.git
synced 2026-11-17 14:11:23 +01:00
496 lines
19 KiB
Rust
496 lines
19 KiB
Rust
//! The macOS system proxy: `networksetup` pointing the web and secure web proxies of every
|
|
//! enabled network service at `127.0.0.1:<port>`. Reading needs no rights; changing needs an
|
|
//! administrator, which the privileged helper is, and which the password dialog and `sudo`
|
|
//! borrow for one script. Each path saves the settings it replaces and puts them back when
|
|
//! turned off. Everything here blocks, the password dialog included, so async callers go
|
|
//! through `spawn_blocking`.
|
|
|
|
use crate::helper::HelperState;
|
|
use serde::{Deserialize, Serialize};
|
|
use std::path::Path;
|
|
use ts_rs::TS;
|
|
use yaak_proxy_helper::networksetup::{
|
|
NETWORKSETUP, Networksetup, Snapshot, disable_commands, enable_commands, read_services,
|
|
};
|
|
|
|
pub use yaak_proxy_helper::networksetup::{ProxySetting, ServiceProxy};
|
|
|
|
/// How a change gets administrator rights.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, TS)]
|
|
#[serde(rename_all = "snake_case")]
|
|
#[ts(export, export_to = "gen_rpc.ts")]
|
|
pub enum SystemProxyBackend {
|
|
/// The privileged helper, approved once in System Settings. No prompt.
|
|
Helper,
|
|
/// The standard macOS password dialog, through `osascript`.
|
|
AdminPrompt,
|
|
/// `sudo` in the terminal running the CLI daemon.
|
|
Sudo,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, TS)]
|
|
#[serde(rename_all = "camelCase")]
|
|
#[ts(export, export_to = "gen_rpc.ts")]
|
|
pub struct SystemProxyStatus {
|
|
/// Every enabled network service sends HTTP and HTTPS to `127.0.0.1:<port>`.
|
|
pub enabled: bool,
|
|
/// The port checked against.
|
|
pub port: u16,
|
|
pub services: Vec<ServiceProxy>,
|
|
pub backend: SystemProxyBackend,
|
|
/// The privileged helper's registration, which decides the backend.
|
|
pub helper: HelperState,
|
|
/// This platform has a system proxy the app can set.
|
|
pub supported: bool,
|
|
}
|
|
|
|
/// Where the password dialog and `sudo` save the settings they replace, in the proxy data
|
|
/// directory. The helper keeps its own, as root.
|
|
pub const SNAPSHOT_FILE: &str = "system-proxy-snapshot.json";
|
|
|
|
#[cfg_attr(not(target_os = "macos"), allow(dead_code))]
|
|
fn load_snapshot(path: &Path) -> Result<Option<Snapshot>, String> {
|
|
match std::fs::read(path) {
|
|
Ok(bytes) => serde_json::from_slice(&bytes)
|
|
.map(Some)
|
|
.map_err(|e| format!("Failed to read {}: {e}", path.display())),
|
|
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(None),
|
|
Err(e) => Err(format!("Failed to read {}: {e}", path.display())),
|
|
}
|
|
}
|
|
|
|
/// The port the password dialog or `sudo` last pointed the system proxy at, while they have
|
|
/// settings saved to put back.
|
|
pub fn saved_port(snapshot_path: &Path) -> Option<u16> {
|
|
// Port 0 holds only settings no service matched, which route nothing.
|
|
load_snapshot(snapshot_path).ok().flatten().map(|s| s.port).filter(|p| *p != 0)
|
|
}
|
|
|
|
#[cfg_attr(not(target_os = "macos"), allow(dead_code))]
|
|
fn save_snapshot(path: &Path, snapshot: &Snapshot) -> Result<(), String> {
|
|
let json = serde_json::to_vec_pretty(snapshot).map_err(|e| e.to_string())?;
|
|
let tmp = path.with_extension("tmp");
|
|
std::fs::write(&tmp, json)
|
|
.and_then(|()| std::fs::rename(&tmp, path))
|
|
.map_err(|e| format!("Failed to save {}: {e}", path.display()))
|
|
}
|
|
|
|
#[cfg_attr(not(target_os = "macos"), allow(dead_code))]
|
|
fn remove_snapshot(path: &Path) -> Result<(), String> {
|
|
match std::fs::remove_file(path) {
|
|
Ok(()) => Ok(()),
|
|
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(()),
|
|
Err(e) => Err(format!("Failed to delete {}: {e}", path.display())),
|
|
}
|
|
}
|
|
|
|
/// The password-dialog and `sudo` paths: reads through `ns`, and changes through `run`, which
|
|
/// gets administrator rights for the whole list at once. Turning on saves the settings it
|
|
/// replaces at `snapshot_path` first; turning off puts them back and deletes the file.
|
|
#[cfg_attr(not(target_os = "macos"), allow(dead_code))]
|
|
fn set_scripted(
|
|
ns: &impl Networksetup,
|
|
run: impl FnOnce(&[Vec<String>]) -> Result<(), String>,
|
|
enabled: bool,
|
|
port: u16,
|
|
snapshot_path: &Path,
|
|
) -> Result<(), String> {
|
|
if enabled {
|
|
let services = read_services(ns, false)?;
|
|
let saved = load_snapshot(snapshot_path)?;
|
|
let mut snapshot = saved.clone().unwrap_or_default();
|
|
snapshot.extend(&services, port);
|
|
// Saved before anything changes, so a crash after the change still restores.
|
|
save_snapshot(snapshot_path, &snapshot)?;
|
|
if let Err(e) = run(&enable_commands(&services, port)) {
|
|
// Usually cancelled, with nothing changed, and a snapshot kept would go stale, so
|
|
// what was there before goes back. Once anything points at us, it is what puts the
|
|
// rest back.
|
|
let changed = read_services(ns, false)?.iter().any(|s| s.points_at(port));
|
|
if !changed {
|
|
match saved {
|
|
Some(saved) => save_snapshot(snapshot_path, &saved)?,
|
|
None => remove_snapshot(snapshot_path)?,
|
|
}
|
|
}
|
|
return Err(e);
|
|
}
|
|
return Ok(());
|
|
}
|
|
|
|
// Disabled services too: one disabled since it was pointed at us would point at us again
|
|
// once re-enabled.
|
|
let services = read_services(ns, true)?;
|
|
let mut snapshot = load_snapshot(snapshot_path)?;
|
|
let (commands, used_up) = disable_commands(&services, snapshot.as_ref(), port);
|
|
if commands.is_empty() && !used_up {
|
|
return Ok(());
|
|
}
|
|
// Saved first, so a restore cut short is finished by the next one.
|
|
if let Some(snapshot) = snapshot.as_mut() {
|
|
snapshot.mark_restoring(&commands, &services);
|
|
save_snapshot(snapshot_path, snapshot)?;
|
|
}
|
|
if !commands.is_empty() {
|
|
run(&commands)?;
|
|
}
|
|
match snapshot {
|
|
Some(snapshot) if used_up => match snapshot.leftover(&services) {
|
|
// Kept for when the service is back, and merged into the next capture.
|
|
Some(leftover) => {
|
|
let names: Vec<&str> = leftover.services.iter().map(|s| s.name.as_str()).collect();
|
|
log::warn!("Keeping saved proxy settings no service matched: {}", names.join(", "));
|
|
save_snapshot(snapshot_path, &leftover)
|
|
}
|
|
None => remove_snapshot(snapshot_path),
|
|
},
|
|
Some(mut snapshot) => {
|
|
snapshot.restoring.clear();
|
|
save_snapshot(snapshot_path, &snapshot)
|
|
}
|
|
None => Ok(()),
|
|
}
|
|
}
|
|
|
|
/// The calls as one `sh` script that stops at the first failure.
|
|
#[cfg_attr(not(target_os = "macos"), allow(dead_code))]
|
|
fn script(commands: &[Vec<String>]) -> String {
|
|
commands
|
|
.iter()
|
|
.map(|args| {
|
|
std::iter::once(NETWORKSETUP.to_string())
|
|
.chain(args.iter().map(|a| shell_quote(a)))
|
|
.collect::<Vec<_>>()
|
|
.join(" ")
|
|
})
|
|
.collect::<Vec<_>>()
|
|
.join(" && ")
|
|
}
|
|
|
|
#[cfg_attr(not(target_os = "macos"), allow(dead_code))]
|
|
fn shell_quote(s: &str) -> String {
|
|
format!("'{}'", s.replace('\'', r"'\''"))
|
|
}
|
|
|
|
/// `script` inside an AppleScript string literal.
|
|
#[cfg_attr(not(target_os = "macos"), allow(dead_code))]
|
|
fn applescript_string(s: &str) -> String {
|
|
format!("\"{}\"", s.replace('\\', r"\\").replace('"', "\\\""))
|
|
}
|
|
|
|
#[cfg(target_os = "macos")]
|
|
mod imp {
|
|
use super::*;
|
|
use std::process::{Command, Output, Stdio};
|
|
|
|
fn check(output: &Output, program: &str) -> Result<(), String> {
|
|
if output.status.success() {
|
|
return Ok(());
|
|
}
|
|
let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
|
|
Err(if stderr.is_empty() {
|
|
format!("{program} exited with {}", output.status)
|
|
} else {
|
|
stderr
|
|
})
|
|
}
|
|
|
|
pub fn run_privileged(script: &str, backend: SystemProxyBackend) -> Result<(), String> {
|
|
match backend {
|
|
SystemProxyBackend::Helper => {
|
|
Err("The helper changes the system proxy itself, not by script".to_string())
|
|
}
|
|
SystemProxyBackend::AdminPrompt => {
|
|
let source = format!(
|
|
"do shell script {} with prompt {} with administrator privileges",
|
|
applescript_string(script),
|
|
applescript_string("Yaak Proxy wants to change your system proxy settings."),
|
|
);
|
|
let output = Command::new("/usr/bin/osascript")
|
|
.args(["-e", &source])
|
|
.output()
|
|
.map_err(|e| format!("Failed to run osascript: {e}"))?;
|
|
// -128 is the dialog's Cancel button.
|
|
if String::from_utf8_lossy(&output.stderr).contains("(-128)") {
|
|
return Err("Cancelled in the password dialog".to_string());
|
|
}
|
|
check(&output, "osascript")
|
|
}
|
|
SystemProxyBackend::Sudo => {
|
|
// sudo asks on the terminal, so the daemon's own stdin stays attached.
|
|
let output = Command::new("/usr/bin/sudo")
|
|
.args(["/bin/sh", "-c", script])
|
|
.stdin(Stdio::inherit())
|
|
.output()
|
|
.map_err(|e| format!("Failed to run sudo: {e}"))?;
|
|
check(&output, "sudo")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Which services point where, judged against `port`.
|
|
#[cfg(target_os = "macos")]
|
|
pub fn status(
|
|
port: u16,
|
|
backend: SystemProxyBackend,
|
|
helper: HelperState,
|
|
) -> Result<SystemProxyStatus, String> {
|
|
let ns = yaak_proxy_helper::networksetup::SystemNetworksetup;
|
|
let services = read_services(&ns, false)?;
|
|
let enabled = !services.is_empty()
|
|
&& services.iter().all(|s| s.http.points_at(port) && s.https.points_at(port));
|
|
Ok(SystemProxyStatus { enabled, port, services, backend, helper, supported: true })
|
|
}
|
|
|
|
/// Points every enabled service at `127.0.0.1:<port>`, or puts back the settings that were
|
|
/// there, turning off any other proxy still pointing at `port`. Turning off with nothing
|
|
/// pointing at `port` asks for nothing. `snapshot_path` is where the password dialog and
|
|
/// `sudo` keep the settings they replace.
|
|
#[cfg(target_os = "macos")]
|
|
pub fn set(
|
|
enabled: bool,
|
|
port: u16,
|
|
backend: SystemProxyBackend,
|
|
snapshot_path: &Path,
|
|
) -> Result<(), String> {
|
|
if port == 0 {
|
|
return Err("The system proxy needs a port".to_string());
|
|
}
|
|
match backend {
|
|
SystemProxyBackend::Helper => crate::helper::set(enabled, port),
|
|
SystemProxyBackend::AdminPrompt | SystemProxyBackend::Sudo => set_scripted(
|
|
&yaak_proxy_helper::networksetup::SystemNetworksetup,
|
|
|commands| imp::run_privileged(&script(commands), backend),
|
|
enabled,
|
|
port,
|
|
snapshot_path,
|
|
),
|
|
}
|
|
}
|
|
|
|
#[cfg(not(target_os = "macos"))]
|
|
pub fn status(
|
|
port: u16,
|
|
backend: SystemProxyBackend,
|
|
helper: HelperState,
|
|
) -> Result<SystemProxyStatus, String> {
|
|
Ok(SystemProxyStatus {
|
|
enabled: false,
|
|
port,
|
|
services: Vec::new(),
|
|
backend,
|
|
helper,
|
|
supported: false,
|
|
})
|
|
}
|
|
|
|
#[cfg(not(target_os = "macos"))]
|
|
pub fn set(
|
|
enabled: bool,
|
|
_port: u16,
|
|
_backend: SystemProxyBackend,
|
|
_snapshot_path: &Path,
|
|
) -> Result<(), String> {
|
|
if !enabled {
|
|
return Ok(());
|
|
}
|
|
Err("Setting the system proxy is only supported on macOS".to_string())
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use yaak_proxy_helper::networksetup::HOST;
|
|
use yaak_proxy_helper::networksetup::fake::FakeNetworksetup;
|
|
|
|
fn setting(enabled: bool, server: &str, port: u16) -> ProxySetting {
|
|
ProxySetting { enabled, server: server.into(), port }
|
|
}
|
|
|
|
/// Runs the "privileged" commands against the fake, counting the prompts.
|
|
fn runner<'a>(
|
|
ns: &'a FakeNetworksetup,
|
|
prompts: &'a std::cell::Cell<usize>,
|
|
) -> impl FnOnce(&[Vec<String>]) -> Result<(), String> + 'a {
|
|
move |commands| {
|
|
prompts.set(prompts.get() + 1);
|
|
yaak_proxy_helper::networksetup::apply(ns, commands)
|
|
}
|
|
}
|
|
|
|
fn fake() -> FakeNetworksetup {
|
|
FakeNetworksetup::new(vec![
|
|
("Wi-Fi", setting(true, "corp-proxy", 3128), setting(false, "corp-proxy", 3129)),
|
|
("Ethernet", ProxySetting::default(), ProxySetting::default()),
|
|
])
|
|
}
|
|
|
|
#[test]
|
|
fn the_password_path_restores_what_it_replaced() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let path = dir.path().join(SNAPSHOT_FILE);
|
|
let ns = fake();
|
|
let before = ns.proxies();
|
|
let prompts = std::cell::Cell::new(0);
|
|
|
|
set_scripted(&ns, runner(&ns, &prompts), true, 9090, &path).unwrap();
|
|
assert!(ns.proxies().iter().all(|s| s.http.points_at(9090) && s.https.points_at(9090)));
|
|
assert!(load_snapshot(&path).unwrap().is_some());
|
|
|
|
set_scripted(&ns, runner(&ns, &prompts), false, 9090, &path).unwrap();
|
|
assert_eq!(ns.proxies()[0], before[0]);
|
|
assert!(!ns.proxies()[1].points_at(9090));
|
|
assert!(!path.exists());
|
|
assert_eq!(prompts.get(), 2);
|
|
}
|
|
|
|
#[test]
|
|
fn a_stale_reset_after_a_crash_uses_the_snapshot() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let path = dir.path().join(SNAPSHOT_FILE);
|
|
let ns = fake();
|
|
let before = ns.proxies();
|
|
let prompts = std::cell::Cell::new(0);
|
|
set_scripted(&ns, runner(&ns, &prompts), true, 9090, &path).unwrap();
|
|
|
|
// The app crashed; the next launch resets the configured port, now another one, which
|
|
// leaves the snapshot alone, and then the port it saved.
|
|
assert_eq!(saved_port(&path), Some(9090));
|
|
set_scripted(&ns, runner(&ns, &prompts), false, 8080, &path).unwrap();
|
|
assert!(path.exists());
|
|
set_scripted(&ns, runner(&ns, &prompts), false, 9090, &path).unwrap();
|
|
assert_eq!(ns.proxies()[0], before[0]);
|
|
assert!(!path.exists());
|
|
}
|
|
|
|
#[test]
|
|
fn a_stale_reset_at_an_old_port_leaves_live_routing_alone() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let path = dir.path().join(SNAPSHOT_FILE);
|
|
let ns = fake();
|
|
let before = ns.proxies();
|
|
let prompts = std::cell::Cell::new(0);
|
|
// A crash left a disabled service on 9090; the new engine routes on 9191.
|
|
set_scripted(&ns, runner(&ns, &prompts), true, 9090, &path).unwrap();
|
|
ns.set_enabled("Ethernet", false);
|
|
set_scripted(&ns, runner(&ns, &prompts), true, 9191, &path).unwrap();
|
|
|
|
set_scripted(&ns, runner(&ns, &prompts), false, 9090, &path).unwrap();
|
|
assert!(ns.proxies()[0].http.points_at(9191), "live routing kept");
|
|
assert!(!ns.proxies()[1].points_at(9090), "the stale port cleared");
|
|
assert!(path.exists());
|
|
|
|
set_scripted(&ns, runner(&ns, &prompts), false, 9191, &path).unwrap();
|
|
assert_eq!(ns.proxies()[0], before[0]);
|
|
assert!(!path.exists());
|
|
}
|
|
|
|
#[test]
|
|
fn the_password_path_restores_a_renamed_service_and_keeps_an_unplugged_one() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let path = dir.path().join(SNAPSHOT_FILE);
|
|
let ns = fake();
|
|
let before = ns.proxies();
|
|
let prompts = std::cell::Cell::new(0);
|
|
set_scripted(&ns, runner(&ns, &prompts), true, 9090, &path).unwrap();
|
|
ns.rename("Wi-Fi", "Office Wi-Fi");
|
|
ns.remove("Ethernet");
|
|
|
|
set_scripted(&ns, runner(&ns, &prompts), false, 9090, &path).unwrap();
|
|
let wifi = &ns.proxies()[0];
|
|
assert_eq!((&wifi.http, &wifi.https), (&before[0].http, &before[0].https));
|
|
// Ethernet's settings stay saved, without counting as routing.
|
|
let kept = load_snapshot(&path).unwrap().unwrap();
|
|
assert_eq!(kept.services.len(), 1);
|
|
assert_eq!(kept.services[0].name, "Ethernet");
|
|
assert_eq!(saved_port(&path), None);
|
|
}
|
|
|
|
#[test]
|
|
fn a_partly_applied_change_keeps_its_snapshot() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let path = dir.path().join(SNAPSHOT_FILE);
|
|
let ns = fake();
|
|
let before = ns.proxies();
|
|
let prompts = std::cell::Cell::new(0);
|
|
// Wi-Fi is changed, then Ethernet fails.
|
|
*ns.failing.lock().unwrap() = Some("Ethernet".into());
|
|
assert!(set_scripted(&ns, runner(&ns, &prompts), true, 9090, &path).is_err());
|
|
assert!(ns.proxies()[0].points_at(9090));
|
|
assert!(path.exists());
|
|
|
|
*ns.failing.lock().unwrap() = None;
|
|
set_scripted(&ns, runner(&ns, &prompts), false, 9090, &path).unwrap();
|
|
assert_eq!(ns.proxies()[0], before[0]);
|
|
}
|
|
|
|
#[test]
|
|
fn turning_off_with_nothing_pointing_at_us_asks_for_nothing() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let path = dir.path().join(SNAPSHOT_FILE);
|
|
let ns = fake();
|
|
let prompts = std::cell::Cell::new(0);
|
|
set_scripted(&ns, runner(&ns, &prompts), false, 9090, &path).unwrap();
|
|
assert_eq!(prompts.get(), 0);
|
|
assert!(ns.changes.lock().unwrap().is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn a_cancelled_prompt_keeps_no_snapshot() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let path = dir.path().join(SNAPSHOT_FILE);
|
|
let ns = fake();
|
|
let cancel = |_: &[Vec<String>]| Err("Cancelled in the password dialog".to_string());
|
|
assert!(set_scripted(&ns, cancel, true, 9090, &path).is_err());
|
|
assert!(!path.exists());
|
|
assert!(ns.changes.lock().unwrap().is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn turning_on_again_keeps_the_first_snapshot() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let path = dir.path().join(SNAPSHOT_FILE);
|
|
let ns = fake();
|
|
let before = ns.proxies();
|
|
let prompts = std::cell::Cell::new(0);
|
|
set_scripted(&ns, runner(&ns, &prompts), true, 9090, &path).unwrap();
|
|
// A second enable, the engine on a new port, must not save ours as the user's.
|
|
set_scripted(&ns, runner(&ns, &prompts), true, 9191, &path).unwrap();
|
|
let cancel = |_: &[Vec<String>]| Err("Cancelled in the password dialog".to_string());
|
|
assert!(set_scripted(&ns, cancel, true, 9191, &path).is_err());
|
|
assert!(path.exists(), "a cancelled re-enable keeps the original snapshot");
|
|
set_scripted(&ns, runner(&ns, &prompts), false, 9191, &path).unwrap();
|
|
assert_eq!(ns.proxies()[0], before[0]);
|
|
}
|
|
|
|
#[test]
|
|
fn a_disabled_service_pointing_at_us_is_turned_off() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let path = dir.path().join(SNAPSHOT_FILE);
|
|
let ns = fake();
|
|
let prompts = std::cell::Cell::new(0);
|
|
set_scripted(&ns, runner(&ns, &prompts), true, 9090, &path).unwrap();
|
|
ns.set_enabled("Ethernet", false);
|
|
set_scripted(&ns, runner(&ns, &prompts), false, 9090, &path).unwrap();
|
|
let ethernet = &ns.proxies()[1];
|
|
assert!(!ethernet.points_at(9090));
|
|
assert_eq!(ethernet.http.server, HOST);
|
|
}
|
|
|
|
#[test]
|
|
fn quotes_service_names() {
|
|
let commands = vec![vec![
|
|
"-setwebproxystate".to_string(),
|
|
"Bob's \"LAN\"".to_string(),
|
|
"off".into(),
|
|
]];
|
|
let script = script(&commands);
|
|
assert_eq!(script, r#"/usr/sbin/networksetup '-setwebproxystate' 'Bob'\''s "LAN"' 'off'"#);
|
|
assert_eq!(
|
|
applescript_string(&script),
|
|
r#""/usr/sbin/networksetup '-setwebproxystate' 'Bob'\\''s \"LAN\"' 'off'""#
|
|
);
|
|
}
|
|
}
|