145 lines
2.7 KiB
Go
145 lines
2.7 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"fmt"
|
|
"log"
|
|
"net"
|
|
"os"
|
|
"os/exec"
|
|
"sync"
|
|
|
|
"baalvpn/shared"
|
|
|
|
"github.com/songgao/packets/ethernet"
|
|
"github.com/songgao/water"
|
|
)
|
|
|
|
const IFACE_NAME = "baalvpn"
|
|
|
|
type Peer struct {
|
|
RealIP string
|
|
InternalIP string
|
|
}
|
|
|
|
var (
|
|
peers = map[string]*Peer{}
|
|
peersMutex sync.Mutex
|
|
nextIP = 3
|
|
)
|
|
|
|
func main() {
|
|
if os.Geteuid() != 0 {
|
|
panic("root permissions needed")
|
|
}
|
|
|
|
config := water.Config{DeviceType: water.TAP}
|
|
config.Name = IFACE_NAME
|
|
|
|
iface, err := water.New(config)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
if err := exec.Command("ip", "addr", "add", "10.1.0.10/24", "dev", IFACE_NAME).Run(); err != nil {
|
|
panic(err)
|
|
}
|
|
if err := exec.Command("ip", "link", "set", "dev", IFACE_NAME, "up").Run(); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
log.Println("Listening...")
|
|
|
|
go receivePackets()
|
|
sendPackets(iface)
|
|
}
|
|
|
|
func sendPackets(iface *water.Interface) {
|
|
var frame ethernet.Frame
|
|
for {
|
|
frame.Resize(1500)
|
|
n, err := iface.Read([]byte(frame))
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
frame = frame[:n]
|
|
|
|
if frame.Destination()[0]&0x01 == 0x01 {
|
|
log.Println("multicast")
|
|
continue
|
|
}
|
|
|
|
log.Printf("Dst: %s\n", frame.Destination())
|
|
log.Printf("Src: %s\n", frame.Source())
|
|
log.Printf("Ethertype: % x\n", frame.Ethertype())
|
|
log.Printf("Payload: % x\n", frame.Payload())
|
|
}
|
|
}
|
|
|
|
func receivePackets() {
|
|
listenAddr, err := net.ResolveUDPAddr("udp", ":38000")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
listener, err := net.ListenUDP("udp", listenAddr)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
defer listener.Close()
|
|
|
|
for {
|
|
buffer := make([]byte, 50000)
|
|
n, addr, err := listener.ReadFromUDP(buffer)
|
|
if err != nil {
|
|
log.Println(err)
|
|
continue
|
|
}
|
|
if n == 0 {
|
|
continue
|
|
}
|
|
|
|
go receivePacket(listener, buffer[:n], addr)
|
|
}
|
|
}
|
|
|
|
func receivePacket(c *net.UDPConn, pkt []byte, addr *net.UDPAddr) {
|
|
if len(pkt) < 4 {
|
|
log.Println("packet too short")
|
|
return
|
|
}
|
|
version := binary.LittleEndian.Uint16(pkt[0:])
|
|
if version != shared.PROTO_VERSION {
|
|
log.Println("mismatched packet version")
|
|
return
|
|
}
|
|
|
|
pktType := binary.LittleEndian.Uint16(pkt[2:])
|
|
|
|
peerIP := addr.IP.String()
|
|
|
|
switch pktType {
|
|
case shared.REQ_REGISTER:
|
|
peersMutex.Lock()
|
|
defer peersMutex.Unlock()
|
|
|
|
internalIP := fmt.Sprintf("10.1.0.%d", nextIP)
|
|
|
|
if peer, ok := peers[addr.IP.String()]; ok {
|
|
internalIP = peer.InternalIP
|
|
} else {
|
|
peers[addr.IP.String()] = &Peer{
|
|
RealIP: peerIP,
|
|
InternalIP: internalIP,
|
|
}
|
|
nextIP++
|
|
}
|
|
|
|
resp := shared.BuildPkt(shared.RESP_REGISTER, net.ParseIP(internalIP).To4())
|
|
if _, err := c.WriteToUDP(resp, addr); err != nil {
|
|
log.Printf("register WriteToUDP: %v\n", err)
|
|
}
|
|
default:
|
|
log.Println("unknown packet type")
|
|
}
|
|
}
|