Package to setup system wide HTTP(S) Proxy on Desktop Platforms

x/sysproxy/doc.go

@@ -0,0 +1,39 @@
+/*
+Package sysproxy provides a simple interface to set/unset system-wide proxy settings.
+
+# Platform Support
+Currently this package supports desktop platforms only. The following platforms are supported:
+- macOS
+- Linux (Gnome is the only supported desktop environment for now.)
+- Windows
+
+# Usage
+
+- To set up system-wide proxy settings, use the `SetProxy` function. This function takes two arguments: the IP address and the port of the proxy server.
+`SetProxy(ip string, port string) error`
+
+- To unset system-wide proxy settings, use the `UnsetProxy` function.
+`UnsetProxy() error`
+
+You need to also clean up the proxy settings when you are done with the proxy server. This is important because the proxy settings will remain in place even after the proxy server is stopped.
+The following example demonstrates how to safely unset proxy upon program termination:
+
+```go
+func main () {
+	// Create channels to receive signals
+	done := make(chan bool, 1)
+	sigs := make(chan os.Signal, 1)
+	sysproxy.SafeCloseProxy(done, sigs)
+
+	// Your code here
+
+	// Send a signal to the program to terminate
+	sigs<-syscall.SIGTERM
+	// Wait for the program to terminate
+	<-done
+}
+
+```
+*/
+
+package sysproxy

x/sysproxy/sysproxy.go

@@ -0,0 +1,27 @@
+package sysproxy
+
+import (
+	"fmt"
+	"os"
+	"os/signal"
+	"syscall"
+)
+
+func SafeCloseProxy(done chan bool, sigs chan os.Signal) {
+	// Channel to indicate the program can stop
+	// Register the channel to receive notifications of the specified signals
+	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
+	// Start a goroutine to handle the signals
+	// This goroutine executes a blocking receive for signals
+	go func() {
+		sig := <-sigs
+		fmt.Println(sig)
+		// Here you can call your cleanup or exit function
+		if err := UnsetProxy(); err != nil {
+			fmt.Println("Error setting up proxy:", err)
+		} else {
+			fmt.Println("Proxy unset successful")
+		}
+		done <- true
+	}()
+}

x/sysproxy/sysproxy_darwin.go

@@ -0,0 +1,101 @@
+//go:build darwin
+
+package sysproxy
+
+import (
+	"bytes"
+	"fmt"
+	"os/exec"
+	"strings"
+)
+
+func SetProxy(ip string, port string) error {
+	// Execute macOS specific commands to set proxy
+	// Get the active network interface
+	activeInterface, err := getActiveNetworkInterfaceMacOS()
+	if err != nil {
+		return err
+	}
+
+	// Set the web proxy and secure web proxy
+	if err := setProxyMacOS("web", activeInterface, ip, port); err != nil {
+		return err
+	}
+	if err := setProxyMacOS("secureweb", activeInterface, ip, port); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func UnsetProxy() error {
+	// Execute macOS specific commands to unset proxy
+	// Get the active network interface
+	activeInterface, err := getActiveNetworkInterfaceMacOS()
+	if err != nil {
+		return err
+	}
+
+	// Set the web proxy and secure web proxy
+	if err := removeProxyMacOS("web", activeInterface); err != nil {
+		return err
+	}
+	if err := removeProxyMacOS("secureweb", activeInterface); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// getActiveNetworkInterface finds the active network interface using shell commands.
+func getActiveNetworkInterfaceMacOS() (string, error) {
+	cmd := "sh -c \"networksetup -listnetworkserviceorder | grep `route -n get 0.0.0.0 | grep 'interface' | cut -d ':' -f2` -B 1 | head -n 1 | cut -d ' ' -f2\""
+	out, err := exec.Command("bash", "-c", cmd).Output()
+	if err != nil {
+		return "", err
+	}
+	return strings.TrimSpace(string(out)), nil
+}
+
+// setProxyMacOS sets the specified type of proxy on the given network interface.
+func setProxyMacOS(proxyType string, interfaceName string, ip string, port string) error {
+	var cmdStr string
+	if proxyType == "web" {
+		cmdStr = fmt.Sprintf("networksetup -setwebproxy \"%s\" %s %s", interfaceName, ip, port)
+	} else if proxyType == "secureweb" {
+		cmdStr = fmt.Sprintf("networksetup -setsecurewebproxy \"%s\" %s %s", interfaceName, ip, port)
+	} else {
+		return fmt.Errorf("unknown proxy type: %s", proxyType)
+	}
+
+	cmd := exec.Command("bash", "-c", cmdStr)
+	var stderr bytes.Buffer
+	cmd.Stderr = &stderr
+
+	err := cmd.Run()
+	if err != nil {
+		return fmt.Errorf("%v: %s", err, stderr.String())
+	}
+	return nil
+}
+
+func removeProxyMacOS(proxyType string, interfaceName string) error {
+	var cmdStr string
+	if proxyType == "web" {
+		cmdStr = fmt.Sprintf("networksetup -setwebproxystate \"%s\" off", interfaceName)
+	} else if proxyType == "secureweb" {
+		cmdStr = fmt.Sprintf("networksetup -setsecurewebproxystate \"%s\" off", interfaceName)
+	} else {
+		return fmt.Errorf("unknown proxy type: %s", proxyType)
+	}
+
+	cmd := exec.Command("bash", "-c", cmdStr)
+	var stderr bytes.Buffer
+	cmd.Stderr = &stderr
+
+	err := cmd.Run()
+	if err != nil {
+		return fmt.Errorf("%v: %s", err, stderr.String())
+	}
+	return nil
+}

x/sysproxy/sysproxy_linux.go

@@ -0,0 +1,73 @@
+//go:build linux
+
+package sysproxy
+
+import (
+	"fmt"
+	"os/exec"
+)
+
+func SetProxy(ip string, port string) error {
+	// Execute Linux specific commands to set proxy
+	if err := setManualMode(); err != nil {
+		return err
+	}
+	if err := setHttpProxy(ip, port); err != nil {
+		return err
+	}
+	if err := setHttpsProxy(ip, port); err != nil {
+		return err
+	}
+	if err := setFtpProxy(ip, port); err != nil {
+		return err
+	}
+	return nil
+}
+
+func setManualMode() error {
+	return execCommand("gsettings", "set", "org.gnome.system.proxy", "mode", "manual")
+}
+
+func setHttpProxy(ip string, port string) error {
+	if err := execCommand("gsettings", "set", "org.gnome.system.proxy.http", "host", ip); err != nil {
+		return err
+	}
+	if err := execCommand("gsettings", "set", "org.gnome.system.proxy.http", "port", port); err != nil {
+		return err
+	}
+	return nil
+}
+
+func setHttpsProxy(ip string, port string) error {
+	if err := execCommand("gsettings", "set", "org.gnome.system.proxy.https", "host", ip); err != nil {
+		return err
+	}
+	if err := execCommand("gsettings", "set", "org.gnome.system.proxy.https", "port", port); err != nil {
+		return err
+	}
+	return nil
+}
+
+func setFtpProxy(ip string, port string) error {
+	if err := execCommand("gsettings", "set", "org.gnome.system.proxy.ftp", "host", ip); err != nil {
+		return err
+	}
+	if err := execCommand("gsettings", "set", "org.gnome.system.proxy.ftp", "port", port); err != nil {
+		return err
+	}
+	return nil
+}
+
+func UnsetProxy() error {
+	// Execute Linux specific commands to unset proxy
+	return execCommand("gsettings", "set", "org.gnome.system.proxy", "mode", "none")
+}
+
+func execCommand(name string, arg ...string) error {
+	cmd := exec.Command(name, arg...)
+	err := cmd.Run()
+	if err != nil {
+		return fmt.Errorf("failed to execute command: %w", err)
+	}
+	return nil
+}

x/sysproxy/sysproxy_other.go

@@ -0,0 +1,13 @@
+//go:build !linux && !windows && !darwin
+
+package sysproxy
+
+// SetProxy does nothing on unsupported platforms.
+func SetProxy(ip string, port string) error {
+	return nil
+}
+
+// SetProxy does nothing on unsupported platforms.
+func UnsetProxy() error {
+	return nil
+}

x/sysproxy/sysproxy_windows.go

@@ -0,0 +1,108 @@
+//go:build windows
+
+package sysproxy
+
+import (
+	"errors"
+	"fmt"
+
+	"golang.org/x/sys/windows"
+	"golang.org/x/sys/windows/registry"
+)
+
+var (
+	modwininet            = windows.NewLazySystemDLL("wininet.dll")
+	procInternetSetOption = modwininet.NewProc("InternetSetOptionW")
+)
+
+const (
+	INTERNET_OPTION_SETTINGS_CHANGED = 39
+	INTERNET_OPTION_REFRESH          = 37
+)
+
+func internetSetOption(hInternet uintptr, dwOption int, lpBuffer uintptr, dwBufferLength uint32) bool {
+	ret, _, _ := procInternetSetOption.Call(
+		hInternet,
+		uintptr(dwOption),
+		lpBuffer,
+		uintptr(dwBufferLength),
+	)
+	return ret != 0
+}
+
+func resetWininetProxySettings() error {
+	result1 := internetSetOption(0, INTERNET_OPTION_SETTINGS_CHANGED, 0, 0)
+	result2 := internetSetOption(0, INTERNET_OPTION_REFRESH, 0, 0)
+
+	if result1 && result2 {
+		fmt.Println("Operation successful")
+		return nil
+	} else {
+		fmt.Println("Operation failed")
+		return errors.New("Wininet setting change operation failed")
+	}
+}
+
+func SetProxy(ip string, port string) error {
+	key, err := registry.OpenKey(registry.CURRENT_USER, `Software\Microsoft\Windows\CurrentVersion\Internet Settings`, registry.SET_VALUE)
+	if err != nil {
+		return err
+	}
+	defer key.Close()
+
+	values := map[string]interface{}{
+		"MigrateProxy":  1,
+		"ProxyEnable":   1,
+		"ProxyHttp1.1":  0,
+		"ProxyServer":   fmt.Sprintf("%s:%s", ip, port),
+		"ProxyOverride": "*.local;<local>",
+	}
+
+	for name, value := range values {
+		switch v := value.(type) {
+		case int:
+			err = key.SetDWordValue(name, uint32(v))
+		case string:
+			err = key.SetStringValue(name, v)
+		default:
+			return fmt.Errorf("unsupported value type")
+		}
+		if err != nil {
+			return err
+		}
+	}
+
+	// Refresh the settings
+	err = resetWininetProxySettings()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func UnsetProxy() error {
+	key, err := registry.OpenKey(registry.CURRENT_USER, `Software\Microsoft\Windows\CurrentVersion\Internet Settings`, registry.SET_VALUE)
+	if err != nil {
+		return err
+	}
+	defer key.Close()
+
+	// Set ProxyEnable to 0 and ProxyServer to an empty string
+	err = key.SetDWordValue("ProxyEnable", 0)
+	if err != nil {
+		return err
+	}
+	err = key.SetStringValue("ProxyServer", "")
+	if err != nil {
+		return err
+	}
+
+	// Refresh the settings
+	err = resetWininetProxySettings()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}