mirror of
https://github.com/gravitl/netmaker.git
synced 2024-09-22 08:16:07 +08:00
196 lines
4.8 KiB
Go
196 lines
4.8 KiB
Go
package proxy
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/binary"
|
|
"fmt"
|
|
"log"
|
|
"net"
|
|
"runtime"
|
|
"strconv"
|
|
|
|
"github.com/c-robinson/iplib"
|
|
"github.com/gravitl/netmaker/nm-proxy/common"
|
|
"github.com/gravitl/netmaker/nm-proxy/packet"
|
|
"github.com/gravitl/netmaker/nm-proxy/wg"
|
|
)
|
|
|
|
func NewProxy(config Config) *Proxy {
|
|
p := &Proxy{Config: config}
|
|
p.Ctx, p.Cancel = context.WithCancel(context.Background())
|
|
return p
|
|
}
|
|
|
|
// proxyToRemote proxies everything from Wireguard to the RemoteKey peer
|
|
func (p *Proxy) ProxyToRemote() {
|
|
buf := make([]byte, 1500)
|
|
for {
|
|
select {
|
|
case <-p.Ctx.Done():
|
|
log.Printf("stopped proxying to remote peer %s due to closed connection\n", p.Config.RemoteKey)
|
|
return
|
|
default:
|
|
|
|
n, err := p.LocalConn.Read(buf)
|
|
if err != nil {
|
|
log.Println("ERRR READ: ", err)
|
|
continue
|
|
}
|
|
|
|
if peerI, ok := common.Peers[p.Config.RemoteKey]; ok {
|
|
log.Println("PROCESSING PKT BEFORE SENDING")
|
|
|
|
buf, n, err = packet.ProcessPacketBeforeSending(buf, n, peerI.Config.RemoteWgPort)
|
|
if err != nil {
|
|
log.Println("failed to process pkt before sending: ", err)
|
|
}
|
|
} else {
|
|
log.Printf("Peer: %s not found in config\n", p.Config.RemoteKey)
|
|
}
|
|
// test(n, buf)
|
|
log.Printf("PROXING TO REMOTE!!!---> %s >>>>> %s\n", p.Config.ProxyServer.Server.LocalAddr().String(), p.RemoteConn.RemoteAddr().String())
|
|
host, port, _ := net.SplitHostPort(p.RemoteConn.RemoteAddr().String())
|
|
portInt, _ := strconv.Atoi(port)
|
|
_, err = p.Config.ProxyServer.Server.WriteToUDP(buf[:n], &net.UDPAddr{
|
|
IP: net.ParseIP(host),
|
|
Port: portInt,
|
|
})
|
|
if err != nil {
|
|
log.Println("Failed to send to remote: ", err)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func test(n int, data []byte) {
|
|
var localWgPort uint16
|
|
//portBuf := data[n-2 : n+1]
|
|
portBuf := data[2:4]
|
|
reader := bytes.NewReader(portBuf)
|
|
err := binary.Read(reader, binary.BigEndian, &localWgPort)
|
|
if err != nil {
|
|
log.Println("Failed to read port buffer: ", err)
|
|
}
|
|
log.Println("TEST WFGPO: ", localWgPort)
|
|
}
|
|
|
|
// proxyToLocal proxies everything from the RemoteKey peer to local Wireguard
|
|
func (p *Proxy) ProxyToLocal() {
|
|
|
|
buf := make([]byte, 1500)
|
|
for {
|
|
select {
|
|
case <-p.Ctx.Done():
|
|
log.Printf("stopped proxying from remote peer %s due to closed connection\n", p.Config.RemoteKey)
|
|
return
|
|
default:
|
|
|
|
n, err := p.RemoteConn.Read(buf)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
log.Printf("PROXING TO LOCAL!!!---> %s <<<<<<<< %s\n", p.LocalConn.LocalAddr().String(), p.RemoteConn.RemoteAddr().String())
|
|
_, err = p.LocalConn.Write(buf[:n])
|
|
if err != nil {
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (p *Proxy) updateEndpoint() error {
|
|
udpAddr, err := net.ResolveUDPAddr("udp", p.LocalConn.LocalAddr().String())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
log.Println("--------> UDPADDR: ", udpAddr)
|
|
// add local proxy connection as a Wireguard peer
|
|
err = p.Config.WgInterface.UpdatePeer(p.Config.RemoteKey, p.Config.AllowedIps, wg.DefaultWgKeepAlive,
|
|
udpAddr, p.Config.PreSharedKey)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (p *Proxy) Start(remoteConn net.Conn) error {
|
|
p.RemoteConn = remoteConn
|
|
|
|
var err error
|
|
addr, err := GetFreeIp("127.0.0.1/8")
|
|
if err != nil {
|
|
log.Println("Failed to get freeIp: ", err)
|
|
return err
|
|
}
|
|
wgAddr := "127.0.0.1"
|
|
if runtime.GOOS == "darwin" {
|
|
wgAddr = addr
|
|
}
|
|
wgPort, err := p.Config.WgInterface.GetListenPort()
|
|
if err != nil {
|
|
log.Printf("Failed to get listen port for iface: %s,Err: %v\n", p.Config.WgInterface.Name, err)
|
|
return err
|
|
}
|
|
|
|
p.LocalConn, err = net.DialUDP("udp", &net.UDPAddr{
|
|
IP: net.ParseIP(addr),
|
|
Port: common.NmProxyPort,
|
|
}, &net.UDPAddr{
|
|
IP: net.ParseIP(wgAddr),
|
|
Port: *wgPort,
|
|
})
|
|
if err != nil {
|
|
log.Fatalf("failed dialing to local Wireguard port,Err: %v\n", err)
|
|
}
|
|
|
|
log.Printf("Dialing to local Wireguard port %s --> %s\n", p.LocalConn.LocalAddr().String(), p.LocalConn.RemoteAddr().String())
|
|
err = p.updateEndpoint()
|
|
if err != nil {
|
|
log.Printf("error while updating Wireguard peer endpoint [%s] %v\n", p.Config.RemoteKey, err)
|
|
return err
|
|
}
|
|
|
|
go p.ProxyToRemote()
|
|
|
|
return nil
|
|
}
|
|
|
|
func GetFreeIp(cidrAddr string) (string, error) {
|
|
//ensure AddressRange is valid
|
|
if _, _, err := net.ParseCIDR(cidrAddr); err != nil {
|
|
log.Println("UniqueAddress encountered an error")
|
|
return "", err
|
|
}
|
|
net4 := iplib.Net4FromStr(cidrAddr)
|
|
newAddrs := net4.FirstAddress()
|
|
log.Println("COUNT: ", net4.Count())
|
|
for {
|
|
if runtime.GOOS == "darwin" {
|
|
_, err := common.RunCmd(fmt.Sprintf("ifconfig lo0 alias %s 255.255.255.255", newAddrs.String()), true)
|
|
if err != nil {
|
|
log.Println("Failed to add alias: ", err)
|
|
}
|
|
}
|
|
|
|
conn, err := net.DialUDP("udp", &net.UDPAddr{
|
|
IP: net.ParseIP(newAddrs.String()),
|
|
Port: 51722,
|
|
}, &net.UDPAddr{
|
|
IP: net.ParseIP("127.0.0.1"),
|
|
Port: 51820,
|
|
})
|
|
if err == nil {
|
|
conn.Close()
|
|
return newAddrs.String(), nil
|
|
}
|
|
|
|
newAddrs, err = net4.NextIP(newAddrs)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
}
|
|
}
|