158 lines
3.1 KiB
Go
158 lines
3.1 KiB
Go
// TODO: slice bounds checking
|
|
// TODO: authentication
|
|
// TODO: encryption
|
|
package main
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"fmt"
|
|
"log"
|
|
"net"
|
|
"os"
|
|
"sync"
|
|
|
|
"baalvpn/shared"
|
|
)
|
|
|
|
type Peer struct {
|
|
RealAddr *net.UDPAddr
|
|
InternalIP string
|
|
}
|
|
|
|
var (
|
|
peers = map[string]*Peer{}
|
|
peersMutex sync.Mutex
|
|
nextIP = 3
|
|
conn *net.UDPConn
|
|
)
|
|
|
|
func main() {
|
|
if os.Geteuid() != 0 {
|
|
panic("root permissions needed")
|
|
}
|
|
|
|
receivePackets()
|
|
}
|
|
|
|
func receivePackets() {
|
|
log.Println("Listening for packets...")
|
|
|
|
listenAddr, err := net.ResolveUDPAddr("udp", ":38000")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
conn, err = net.ListenUDP("udp", listenAddr)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
defer conn.Close()
|
|
|
|
for {
|
|
buffer := make([]byte, 50000)
|
|
n, addr, err := conn.ReadFromUDP(buffer)
|
|
if err != nil {
|
|
log.Println(err)
|
|
continue
|
|
}
|
|
if n == 0 {
|
|
continue
|
|
}
|
|
|
|
go receivePacket(buffer[:n], addr)
|
|
}
|
|
}
|
|
|
|
func receivePacket(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:])
|
|
|
|
// idk if it needs to lock the mutex
|
|
peer := peers[addr.IP.String()]
|
|
|
|
switch pktType {
|
|
case shared.REQ_REGISTER:
|
|
peersMutex.Lock()
|
|
defer peersMutex.Unlock()
|
|
|
|
// TODO
|
|
internalIP := fmt.Sprintf("10.1.0.%d", nextIP)
|
|
|
|
if destPeer, ok := peers[addr.IP.String()]; ok {
|
|
internalIP = destPeer.InternalIP
|
|
} else {
|
|
peers[addr.IP.String()] = &Peer{
|
|
RealAddr: addr,
|
|
InternalIP: internalIP,
|
|
}
|
|
nextIP++
|
|
}
|
|
|
|
resp := shared.BuildPkt(shared.RESP_REGISTER, net.ParseIP(internalIP).To4())
|
|
sendTo(addr, resp)
|
|
case shared.REQ_DATA:
|
|
frame := pkt[4:]
|
|
etherType := binary.BigEndian.Uint16(frame[12:14])
|
|
payload := frame[14:]
|
|
|
|
switch etherType {
|
|
case 0x0800: // IPv4
|
|
destIP := net.IP(payload[16:20]).String()
|
|
if destPeer := getPeerByInternalIP(destIP); destPeer != nil {
|
|
log.Println(peer.InternalIP + " -> " + destIP)
|
|
resp := shared.BuildPkt(shared.RESP_DATA, frame)
|
|
sendTo(peer.RealAddr, resp)
|
|
} else {
|
|
log.Println(peer.InternalIP + " -/> " + destIP + " (unrecognized IP)")
|
|
}
|
|
case 0x0806: // ARP
|
|
log.Println(peer.InternalIP + " -> *")
|
|
resp := shared.BuildPkt(shared.RESP_DATA, frame)
|
|
broadcast(resp, peer.InternalIP)
|
|
case 0x86dd: // IPv6
|
|
destIP := net.IP(payload[24:40]).String()
|
|
log.Println(peer.InternalIP + " -/> " + destIP + " (IPv6)") // TODO
|
|
default:
|
|
log.Printf("unhandled EtherType: 0x%x\n", etherType)
|
|
}
|
|
default:
|
|
log.Println("unknown packet type")
|
|
}
|
|
}
|
|
|
|
func broadcast(pkt []byte, except string) {
|
|
peersMutex.Lock()
|
|
defer peersMutex.Unlock()
|
|
for _, p := range peers {
|
|
if p.RealAddr.IP.String() == except {
|
|
continue
|
|
}
|
|
sendTo(p.RealAddr, pkt)
|
|
}
|
|
}
|
|
|
|
func sendTo(addr *net.UDPAddr, pkt []byte) {
|
|
if _, err := conn.WriteToUDP(pkt, addr); err != nil {
|
|
log.Println(err)
|
|
}
|
|
}
|
|
|
|
func getPeerByInternalIP(internalIP string) *Peer {
|
|
peersMutex.Lock()
|
|
defer peersMutex.Unlock()
|
|
for _, p := range peers {
|
|
if p.InternalIP == internalIP {
|
|
return p
|
|
}
|
|
}
|
|
return nil
|
|
}
|