region-proxy 1.2.5

A CLI tool to create a SOCKS proxy through AWS EC2 in any region
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use anyhow::{bail, Context, Result};
use std::process::Command;
use tracing::{debug, info};

fn get_active_network_service() -> Result<String> {
    let output = Command::new("networksetup")
        .arg("-listallnetworkservices")
        .output()
        .context("Failed to list network services")?;

    let stdout = String::from_utf8_lossy(&output.stdout);

    let preferred_services = [
        "Wi-Fi",
        "Ethernet",
        "USB 10/100/1000 LAN",
        "Thunderbolt Ethernet",
    ];

    for service in preferred_services {
        if stdout.contains(service) {
            let status = Command::new("networksetup")
                .arg("-getinfo")
                .arg(service)
                .output();

            if let Ok(status_output) = status {
                let status_str = String::from_utf8_lossy(&status_output.stdout);
                if status_str.contains("IP address:") && !status_str.contains("IP address: none") {
                    debug!("Found active network service: {}", service);
                    return Ok(service.to_string());
                }
            }
        }
    }

    Ok("Wi-Fi".to_string())
}

pub fn enable_socks_proxy(port: u16) -> Result<()> {
    let service = get_active_network_service()?;
    info!("Enabling SOCKS proxy on {} (localhost:{})", service, port);

    let status = Command::new("networksetup")
        .arg("-setsocksfirewallproxy")
        .arg(&service)
        .arg("localhost")
        .arg(port.to_string())
        .status()
        .context("Failed to set SOCKS proxy")?;

    if !status.success() {
        bail!("networksetup command failed");
    }

    let status = Command::new("networksetup")
        .arg("-setsocksfirewallproxystate")
        .arg(&service)
        .arg("on")
        .status()
        .context("Failed to enable SOCKS proxy")?;

    if !status.success() {
        bail!("Failed to enable SOCKS proxy state");
    }

    info!("SOCKS proxy enabled");
    Ok(())
}

pub fn disable_socks_proxy() -> Result<()> {
    let service = get_active_network_service()?;
    info!("Disabling SOCKS proxy on {}", service);

    let status = Command::new("networksetup")
        .arg("-setsocksfirewallproxystate")
        .arg(&service)
        .arg("off")
        .status()
        .context("Failed to disable SOCKS proxy")?;

    if !status.success() {
        bail!("Failed to disable SOCKS proxy state");
    }

    info!("SOCKS proxy disabled");
    Ok(())
}

pub fn is_socks_proxy_enabled() -> Result<bool> {
    let service = get_active_network_service()?;

    let output = Command::new("networksetup")
        .arg("-getsocksfirewallproxy")
        .arg(&service)
        .output()
        .context("Failed to get SOCKS proxy status")?;

    let stdout = String::from_utf8_lossy(&output.stdout);
    Ok(stdout.contains("Enabled: Yes"))
}