mirror of
https://github.com/fosrl/olm.git
synced 2026-02-08 05:56:41 +00:00
390 lines
9.6 KiB
Go
390 lines
9.6 KiB
Go
//go:build windows
|
|
|
|
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"flag"
|
|
"fmt"
|
|
"net"
|
|
"os"
|
|
"os/exec"
|
|
"os/signal"
|
|
"runtime"
|
|
"strconv"
|
|
"syscall"
|
|
|
|
"github.com/fosrl/newt/logger"
|
|
"github.com/fosrl/olm/websocket"
|
|
"golang.org/x/sys/windows"
|
|
"golang.zx2c4.com/wireguard/device"
|
|
"golang.zx2c4.com/wireguard/ipc"
|
|
"golang.zx2c4.com/wireguard/tun"
|
|
"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
|
|
)
|
|
|
|
// ConfigureInterface configures a network interface with an IP address and brings it up
|
|
func ConfigureInterface(interfaceName string, wgData WgData) error {
|
|
var ipAddr string = wgData.TunnelIP
|
|
var destIP string = wgData.ServerIP
|
|
|
|
if runtime.GOOS == "windows" {
|
|
return configureWindows(interfaceName, ipAddr, destIP)
|
|
}
|
|
|
|
return fmt.Errorf("unsupported operating system: %s", runtime.GOOS)
|
|
}
|
|
|
|
func configureWindows(interfaceName string, ipAddr, destIP string) error {
|
|
logger.Info("Configuring Windows interface: %s", interfaceName)
|
|
|
|
// Parse the IP address and network
|
|
ip, ipNet, err := net.ParseCIDR(ipAddr)
|
|
if err != nil {
|
|
return fmt.Errorf("invalid IP address: %v", err)
|
|
}
|
|
|
|
// Set the IP address using netsh
|
|
// Windows uses the 'netsh' command to configure network interfaces
|
|
maskBits, _ := ipNet.Mask.Size()
|
|
|
|
// create a mask string like 255.255.255.0 from the maskBits
|
|
mask := net.CIDRMask(maskBits, 32)
|
|
maskIP := net.IP(mask)
|
|
|
|
cmd := exec.Command("netsh", "interface", "ipv4", "set", "address",
|
|
fmt.Sprintf("name=%s", interfaceName),
|
|
"source=static",
|
|
fmt.Sprintf("addr=%s", ip.String()),
|
|
fmt.Sprintf("mask=%s", maskIP.String()))
|
|
|
|
logger.Info("Running command: %v", cmd)
|
|
out, err := cmd.CombinedOutput()
|
|
if err != nil {
|
|
return fmt.Errorf("netsh command failed: %v, output: %s", err, out)
|
|
}
|
|
|
|
// Add a route to the destination IP
|
|
cmd = exec.Command("netsh", "interface", "ipv4", "add", "route",
|
|
fmt.Sprintf("%s/32", destIP),
|
|
fmt.Sprintf("interface=%s", interfaceName),
|
|
"metric=1")
|
|
|
|
logger.Info("Running command: %v", cmd)
|
|
out, err = cmd.CombinedOutput()
|
|
if err != nil {
|
|
return fmt.Errorf("netsh route command failed: %v, output: %s", err, out)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func main() {
|
|
var (
|
|
endpoint string
|
|
id string
|
|
secret string
|
|
mtu string
|
|
mtuInt int
|
|
dns string
|
|
privateKey wgtypes.Key
|
|
err error
|
|
logLevel string
|
|
interfaceName string
|
|
)
|
|
|
|
stopHolepunch = make(chan struct{})
|
|
stopRegister = make(chan struct{})
|
|
|
|
// Check OS
|
|
if runtime.GOOS != "windows" {
|
|
fmt.Println("This version of olm is only for Windows systems")
|
|
os.Exit(1)
|
|
}
|
|
|
|
// if PANGOLIN_ENDPOINT, OLM_ID, and OLM_SECRET are set as environment variables, they will be used as default values
|
|
endpoint = os.Getenv("PANGOLIN_ENDPOINT")
|
|
id = os.Getenv("OLM_ID")
|
|
secret = os.Getenv("OLM_SECRET")
|
|
mtu = os.Getenv("MTU")
|
|
dns = os.Getenv("DNS")
|
|
logLevel = os.Getenv("LOG_LEVEL")
|
|
interfaceName = os.Getenv("INTERFACE")
|
|
|
|
if endpoint == "" {
|
|
flag.StringVar(&endpoint, "endpoint", "", "Endpoint of your Pangolin server")
|
|
}
|
|
if id == "" {
|
|
flag.StringVar(&id, "id", "", "Olm ID")
|
|
}
|
|
if secret == "" {
|
|
flag.StringVar(&secret, "secret", "", "Olm secret")
|
|
}
|
|
if mtu == "" {
|
|
flag.StringVar(&mtu, "mtu", "1280", "MTU to use")
|
|
}
|
|
if dns == "" {
|
|
flag.StringVar(&dns, "dns", "8.8.8.8", "DNS server to use")
|
|
}
|
|
if logLevel == "" {
|
|
flag.StringVar(&logLevel, "log-level", "INFO", "Log level (DEBUG, INFO, WARN, ERROR, FATAL)")
|
|
}
|
|
if interfaceName == "" {
|
|
flag.StringVar(&interfaceName, "interface", "olm", "Name of the WireGuard interface")
|
|
}
|
|
|
|
// do a --version check
|
|
version := flag.Bool("version", false, "Print the version")
|
|
flag.Parse()
|
|
|
|
if *version {
|
|
fmt.Println("Olm Windows version replaceme")
|
|
os.Exit(0)
|
|
}
|
|
|
|
logger.Init()
|
|
loggerLevel := parseLogLevel(logLevel)
|
|
logger.GetLogger().SetLevel(parseLogLevel(logLevel))
|
|
|
|
// parse the mtu string into an int
|
|
mtuInt, err = strconv.Atoi(mtu)
|
|
if err != nil {
|
|
logger.Fatal("Failed to parse MTU: %v", err)
|
|
}
|
|
|
|
privateKey, err = wgtypes.GeneratePrivateKey()
|
|
if err != nil {
|
|
logger.Fatal("Failed to generate private key: %v", err)
|
|
}
|
|
|
|
// Create a new olm
|
|
olm, err := websocket.NewClient(
|
|
id, // CLI arg takes precedence
|
|
secret, // CLI arg takes precedence
|
|
endpoint,
|
|
)
|
|
if err != nil {
|
|
logger.Fatal("Failed to create olm: %v", err)
|
|
}
|
|
|
|
sourcePort, err := FindAvailableUDPPort(49152, 65535)
|
|
if err != nil {
|
|
fmt.Printf("Error finding available port: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
// Create TUN device and network stack
|
|
var dev *device.Device
|
|
var wgData WgData
|
|
var holePunchData HolePunchData
|
|
var uapi net.Listener
|
|
var tdev tun.Device
|
|
|
|
olm.RegisterHandler("olm/terminate", func(msg websocket.WSMessage) {
|
|
logger.Info("Received terminate message")
|
|
olm.Close()
|
|
})
|
|
|
|
olm.RegisterHandler("olm/wg/update", func(msg websocket.WSMessage) {
|
|
jsonData, err := json.Marshal(msg.Data)
|
|
if err != nil {
|
|
logger.Info("Error marshaling data: %v", err)
|
|
return
|
|
}
|
|
if err := json.Unmarshal(jsonData, &wgData); err != nil {
|
|
logger.Info("Error unmarshaling target data: %v", err)
|
|
return
|
|
}
|
|
endpoint, err := resolveDomain(wgData.Endpoint)
|
|
if err != nil {
|
|
logger.Error("Failed to resolve endpoint: %v", err)
|
|
return
|
|
}
|
|
// Configure WireGuard
|
|
config := fmt.Sprintf(`private_key=%s
|
|
public_key=%s
|
|
allowed_ip=%s/32
|
|
endpoint=%s
|
|
persistent_keepalive_interval=1`, fixKey(privateKey.String()), fixKey(wgData.PublicKey), wgData.ServerIP, endpoint)
|
|
err = dev.IpcSet(config)
|
|
if err != nil {
|
|
logger.Error("Failed to configure WireGuard device: %v", err)
|
|
}
|
|
})
|
|
|
|
// Register handlers for different message types
|
|
olm.RegisterHandler("olm/wg/connect", func(msg websocket.WSMessage) {
|
|
logger.Info("Received message: %v", msg.Data)
|
|
close(stopRegister)
|
|
// if there is an existing tunnel then close it
|
|
if dev != nil {
|
|
logger.Info("Got new message. Closing existing tunnel!")
|
|
dev.Close()
|
|
}
|
|
jsonData, err := json.Marshal(msg.Data)
|
|
if err != nil {
|
|
logger.Info("Error marshaling data: %v", err)
|
|
return
|
|
}
|
|
if err := json.Unmarshal(jsonData, &wgData); err != nil {
|
|
logger.Info("Error unmarshaling target data: %v", err)
|
|
return
|
|
}
|
|
|
|
// Windows-specific TUN device creation
|
|
tdev, err = tun.CreateTUN(interfaceName, mtuInt)
|
|
if err != nil {
|
|
logger.Error("Failed to create TUN device: %v", err)
|
|
return
|
|
}
|
|
|
|
realInterfaceName, err2 := tdev.Name()
|
|
if err2 == nil {
|
|
interfaceName = realInterfaceName
|
|
}
|
|
|
|
// Create the WireGuard device
|
|
dev = device.NewDevice(tdev, NewFixedPortBind(uint16(sourcePort)), device.NewLogger(
|
|
mapToWireGuardLogLevel(loggerLevel),
|
|
"wireguard: ",
|
|
))
|
|
|
|
// Setup UAPI for Windows
|
|
uapi, err = ipc.UAPIListen(interfaceName)
|
|
if err != nil {
|
|
logger.Error("Failed to listen on uapi socket: %v", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
errs := make(chan error)
|
|
go func() {
|
|
for {
|
|
conn, err := uapi.Accept()
|
|
if err != nil {
|
|
errs <- err
|
|
return
|
|
}
|
|
go dev.IpcHandle(conn)
|
|
}
|
|
}()
|
|
logger.Info("UAPI listener started")
|
|
|
|
host, err := resolveDomain(wgData.Endpoint)
|
|
if err != nil {
|
|
logger.Error("Failed to resolve endpoint: %v", err)
|
|
return
|
|
}
|
|
|
|
// Configure WireGuard
|
|
config := fmt.Sprintf(`private_key=%s
|
|
public_key=%s
|
|
allowed_ip=%s/32
|
|
endpoint=%s
|
|
persistent_keepalive_interval=1`, fixKey(privateKey.String()), fixKey(wgData.PublicKey), wgData.ServerIP, host)
|
|
err = dev.IpcSet(config)
|
|
if err != nil {
|
|
logger.Error("Failed to configure WireGuard device: %v", err)
|
|
}
|
|
|
|
// Bring up the device
|
|
err = dev.Up()
|
|
if err != nil {
|
|
logger.Error("Failed to bring up WireGuard device: %v", err)
|
|
}
|
|
|
|
// Configure the interface
|
|
err = ConfigureInterface(realInterfaceName, wgData)
|
|
if err != nil {
|
|
logger.Error("Failed to configure interface: %v", err)
|
|
}
|
|
|
|
close(stopHolepunch)
|
|
// Monitor the connection for activity
|
|
monitorConnection(dev, func() {
|
|
host, err := resolveDomain(endpoint)
|
|
if err != nil {
|
|
logger.Error("Failed to resolve endpoint: %v", err)
|
|
return
|
|
}
|
|
// Configure WireGuard
|
|
config := fmt.Sprintf(`private_key=%s
|
|
public_key=%s
|
|
allowed_ip=%s/32
|
|
endpoint=%s:21820
|
|
persistent_keepalive_interval=1`, fixKey(privateKey.String()), fixKey(wgData.PublicKey), wgData.ServerIP, host)
|
|
err = dev.IpcSet(config)
|
|
if err != nil {
|
|
logger.Error("Failed to configure WireGuard device: %v", err)
|
|
}
|
|
logger.Info("Adjusted to point to relay!")
|
|
})
|
|
logger.Info("WireGuard device created.")
|
|
})
|
|
|
|
olm.RegisterHandler("olm/wg/holepunch", func(msg websocket.WSMessage) {
|
|
logger.Info("Received message: %v", msg.Data)
|
|
|
|
jsonData, err := json.Marshal(msg.Data)
|
|
if err != nil {
|
|
logger.Info("Error marshaling data: %v", err)
|
|
return
|
|
}
|
|
|
|
if err := json.Unmarshal(jsonData, &holePunchData); err != nil {
|
|
logger.Info("Error unmarshaling target data: %v", err)
|
|
return
|
|
}
|
|
|
|
gerbilServerPubKey = holePunchData.ServerPubKey
|
|
})
|
|
|
|
olm.OnConnect(func() error {
|
|
publicKey := privateKey.PublicKey()
|
|
logger.Debug("Public key: %s", publicKey)
|
|
|
|
go keepSendingRegistration(olm, publicKey.String())
|
|
|
|
logger.Info("Sent registration message")
|
|
return nil
|
|
})
|
|
|
|
olm.OnTokenUpdate(func(token string) {
|
|
olmToken = token
|
|
})
|
|
|
|
// Connect to the WebSocket server
|
|
if err := olm.Connect(); err != nil {
|
|
logger.Fatal("Failed to connect to server: %v", err)
|
|
}
|
|
defer olm.Close()
|
|
|
|
go keepSendingUDPHolePunch(endpoint, id, sourcePort)
|
|
|
|
// Wait for interrupt signal
|
|
sigCh := make(chan os.Signal, 1)
|
|
signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM, windows.SIGTERM)
|
|
<-sigCh
|
|
|
|
select {
|
|
case <-stopHolepunch:
|
|
// Channel already closed, do nothing
|
|
default:
|
|
close(stopHolepunch)
|
|
}
|
|
|
|
select {
|
|
case <-stopRegister:
|
|
// Channel already closed
|
|
default:
|
|
close(stopRegister)
|
|
}
|
|
|
|
if uapi != nil {
|
|
uapi.Close()
|
|
}
|
|
|
|
if dev != nil {
|
|
dev.Close()
|
|
}
|
|
}
|