ResiLien
/
wesher
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rename WgState to State and NewWgState to New 

This also caused renaming local variables to avoid
conflicting with the wg package name itself.
This commit is contained in:
kaiyou 2020-05-07 14:40:22 +02:00 committed by Leo Antunes
parent 5d1acc1fab
commit b0e41d5c35
3 changed files with 57 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
main.go
View File

@ -33,7 +33,7 @@ func main() {
} }
logrus.SetLevel(logLevel) logrus.SetLevel(logLevel)
wg, err := wg.NewWGConfig(config.Interface, config.WireguardPort) wgstate, err := wg.New(config.Interface, config.WireguardPort)
if err != nil { if err != nil {
logrus.WithError(err).Fatal("could not instantiate wireguard controller") logrus.WithError(err).Fatal("could not instantiate wireguard controller")
} }
@ -43,10 +43,10 @@ func main() {
logrus.WithError(err).Fatal("could not create cluster") logrus.WithError(err).Fatal("could not create cluster")
} }
wg.AssignOverlayAddr((*net.IPNet)(config.OverlayNet), cluster.LocalName) wgstate.AssignOverlayAddr((*net.IPNet)(config.OverlayNet), cluster.LocalName)
localNode := common.Node{} localNode := common.Node{}
localNode.OverlayAddr = wg.OverlayAddr localNode.OverlayAddr = wgstate.OverlayAddr
localNode.PubKey = wg.PubKey.String() localNode.PubKey = wgstate.PubKey.String()
cluster.Update(localNode) cluster.Update(localNode)
nodec := cluster.Members() // avoid deadlocks by starting before join nodec := cluster.Members() // avoid deadlocks by starting before join
@ -76,9 +76,9 @@ func main() {
nodes = append(nodes, node) nodes = append(nodes, node)
logrus.Infof("\taddr: %s, overlay: %s, pubkey: %s", node.Addr, node.OverlayAddr, node.PubKey) logrus.Infof("\taddr: %s, overlay: %s, pubkey: %s", node.Addr, node.OverlayAddr, node.PubKey)
} }
if err := wg.SetUpInterface(nodes); err != nil { if err := wgstate.SetUpInterface(nodes); err != nil {
logrus.WithError(err).Error("could not up interface") logrus.WithError(err).Error("could not up interface")
wg.DownInterface() wgstate.DownInterface()
} }
if !config.NoEtcHosts { if !config.NoEtcHosts {
if err := writeToEtcHosts(nodes); err != nil { if err := writeToEtcHosts(nodes); err != nil {
@ -93,7 +93,7 @@ func main() {
logrus.WithError(err).Error("could not remove stale hosts entries") logrus.WithError(err).Error("could not remove stale hosts entries")
} }
} }
if err := wg.DownInterface(); err != nil { if err := wgstate.DownInterface(); err != nil {
logrus.WithError(err).Error("could not down interface") logrus.WithError(err).Error("could not down interface")
} }
os.Exit(0) os.Exit(0)

54
wg/wireguard.go
View File

@ -12,8 +12,8 @@ import (
"golang.zx2c4.com/wireguard/wgctrl/wgtypes" "golang.zx2c4.com/wireguard/wgctrl/wgtypes"
) )
// WgState holds the configured state of a Wesher Wireguard interface // State holds the configured state of a Wesher Wireguard interface
type WgState struct { type State struct {
iface string iface string
client *wgctrl.Client client *wgctrl.Client
OverlayAddr net.IPNet OverlayAddr net.IPNet
@ -22,10 +22,10 @@ type WgState struct {
PubKey wgtypes.Key PubKey wgtypes.Key
} }
// NewWGConfig creates a new Wesher Wireguard state // New creates a new Wesher Wireguard state
// The Wireguard keys are generated for every new interface // The Wireguard keys are generated for every new interface
// The interface must later be setup using SetUpInterface // The interface must later be setup using SetUpInterface
func NewWGConfig(iface string, port int) (*WgState, error) { func New(iface string, port int) (*State, error) {
client, err := wgctrl.New() client, err := wgctrl.New()
if err != nil { if err != nil {
return nil, errors.Wrap(err, "could not instantiate wireguard client") return nil, errors.Wrap(err, "could not instantiate wireguard client")
@ -37,14 +37,14 @@ func NewWGConfig(iface string, port int) (*WgState, error) {
} }
pubKey := privKey.PublicKey() pubKey := privKey.PublicKey()
wgState := WgState{ state := State{
iface: iface, iface: iface,
client: client, client: client,
Port: port, Port: port,
PrivKey: privKey, PrivKey: privKey,
PubKey: pubKey, PubKey: pubKey,
} }
return &wgState, nil return &state, nil
} }
// AssignOverlayAddr assigns a new address to the interface // AssignOverlayAddr assigns a new address to the interface
@ -52,7 +52,7 @@ func NewWGConfig(iface string, port int) (*WgState, error) {
// provided name deterministically // provided name deterministically
// Currently, the address is assigned by hashing the name and mapping that // Currently, the address is assigned by hashing the name and mapping that
// hash in the target network space // hash in the target network space
func (wg *WgState) AssignOverlayAddr(ipnet *net.IPNet, name string) { func (s *State) AssignOverlayAddr(ipnet *net.IPNet, name string) {
// TODO: this is way too brittle and opaque // TODO: this is way too brittle and opaque
bits, size := ipnet.Mask.Size() bits, size := ipnet.Mask.Size()
ip := make([]byte, len(ipnet.IP)) ip := make([]byte, len(ipnet.IP))
@ -66,21 +66,21 @@ func (wg *WgState) AssignOverlayAddr(ipnet *net.IPNet, name string) {
ip[len(ip)-i] = hb[len(hb)-i] ip[len(ip)-i] = hb[len(hb)-i]
} }
wg.OverlayAddr = net.IPNet{ s.OverlayAddr = net.IPNet{
IP: net.IP(ip), IP: net.IP(ip),
Mask: net.CIDRMask(size, size), // either /32 or /128, depending if ipv4 or ipv6 Mask: net.CIDRMask(size, size), // either /32 or /128, depending if ipv4 or ipv6
} }
} }
// DownInterface shuts down the associated network interface // DownInterface shuts down the associated network interface
func (wg *WgState) DownInterface() error { func (s *State) DownInterface() error {
if _, err := wg.client.Device(wg.iface); err != nil { if _, err := s.client.Device(s.iface); err != nil {
if os.IsNotExist(err) { if os.IsNotExist(err) {
return nil // device already gone; noop return nil // device already gone; noop
} }
return err return err
} }
link, err := netlink.LinkByName(wg.iface) link, err := netlink.LinkByName(s.iface)
if err != nil { if err != nil {
return err return err
} }
@ -88,39 +88,39 @@ func (wg *WgState) DownInterface() error {
} }
// SetUpInterface creates and setup the associated network interface // SetUpInterface creates and setup the associated network interface
func (wg *WgState) SetUpInterface(nodes []common.Node) error { func (s *State) SetUpInterface(nodes []common.Node) error {
if err := netlink.LinkAdd(&wireguard{LinkAttrs: netlink.LinkAttrs{Name: wg.iface}}); err != nil && !os.IsExist(err) { if err := netlink.LinkAdd(&wireguard{LinkAttrs: netlink.LinkAttrs{Name: s.iface}}); err != nil && !os.IsExist(err) {
return errors.Wrapf(err, "could not create interface %s", wg.iface) return errors.Wrapf(err, "could not create interface %s", s.iface)
} }
peerCfgs, err := wg.nodesToPeerConfigs(nodes) peerCfgs, err := s.nodesToPeerConfigs(nodes)
if err != nil { if err != nil {
return errors.Wrap(err, "error converting received node information to wireguard format") return errors.Wrap(err, "error converting received node information to wireguard format")
} }
if err := wg.client.ConfigureDevice(wg.iface, wgtypes.Config{ if err := s.client.ConfigureDevice(s.iface, wgtypes.Config{
PrivateKey: &wg.PrivKey, PrivateKey: &s.PrivKey,
ListenPort: &wg.Port, ListenPort: &s.Port,
ReplacePeers: true, ReplacePeers: true,
Peers: peerCfgs, Peers: peerCfgs,
}); err != nil { }); err != nil {
return errors.Wrapf(err, "could not set wireguard configuration for %s", wg.iface) return errors.Wrapf(err, "could not set wireguard configuration for %s", s.iface)
} }
link, err := netlink.LinkByName(wg.iface) link, err := netlink.LinkByName(s.iface)
if err != nil { if err != nil {
return errors.Wrapf(err, "could not get link information for %s", wg.iface) return errors.Wrapf(err, "could not get link information for %s", s.iface)
} }
if err := netlink.AddrReplace(link, &netlink.Addr{ if err := netlink.AddrReplace(link, &netlink.Addr{
IPNet: &wg.OverlayAddr, IPNet: &s.OverlayAddr,
}); err != nil { }); err != nil {
return errors.Wrapf(err, "could not set address for %s", wg.iface) return errors.Wrapf(err, "could not set address for %s", s.iface)
} }
// TODO: make MTU configurable? // TODO: make MTU configurable?
if err := netlink.LinkSetMTU(link, 1420); err != nil { if err := netlink.LinkSetMTU(link, 1420); err != nil {
return errors.Wrapf(err, "could not set MTU for %s", wg.iface) return errors.Wrapf(err, "could not set MTU for %s", s.iface)
} }
if err := netlink.LinkSetUp(link); err != nil { if err := netlink.LinkSetUp(link); err != nil {
return errors.Wrapf(err, "could not enable interface %s", wg.iface) return errors.Wrapf(err, "could not enable interface %s", s.iface)
} }
for _, node := range nodes { for _, node := range nodes {
netlink.RouteAdd(&netlink.Route{ netlink.RouteAdd(&netlink.Route{
@ -133,7 +133,7 @@ func (wg *WgState) SetUpInterface(nodes []common.Node) error {
return nil return nil
} }
func (wg *WgState) nodesToPeerConfigs(nodes []common.Node) ([]wgtypes.PeerConfig, error) { func (s *State) nodesToPeerConfigs(nodes []common.Node) ([]wgtypes.PeerConfig, error) {
peerCfgs := make([]wgtypes.PeerConfig, len(nodes)) peerCfgs := make([]wgtypes.PeerConfig, len(nodes))
for i, node := range nodes { for i, node := range nodes {
pubKey, err := wgtypes.ParseKey(node.PubKey) pubKey, err := wgtypes.ParseKey(node.PubKey)
@ -145,7 +145,7 @@ func (wg *WgState) nodesToPeerConfigs(nodes []common.Node) ([]wgtypes.PeerConfig
ReplaceAllowedIPs: true, ReplaceAllowedIPs: true,
Endpoint: &net.UDPAddr{ Endpoint: &net.UDPAddr{
IP: node.Addr, IP: node.Addr,
Port: wg.Port, Port: s.Port,
}, },
AllowedIPs: []net.IPNet{ AllowedIPs: []net.IPNet{
node.OverlayAddr, node.OverlayAddr,

46
wg/wireguard_test.go
View File

@ -6,7 +6,7 @@ import (
"testing" "testing"
) )
func Test_wgState_assignOverlayAddr(t *testing.T) { func Test_State_AssignOverlayAddr(t *testing.T) {
type args struct { type args struct {
ipnet *net.IPNet ipnet *net.IPNet
name string name string
@ -31,11 +31,11 @@ func Test_wgState_assignOverlayAddr(t *testing.T) {
} }
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
wg := &WgState{} s := &State{}
wg.AssignOverlayAddr(tt.args.ipnet, tt.args.name) s.AssignOverlayAddr(tt.args.ipnet, tt.args.name)
if !reflect.DeepEqual(wg.OverlayAddr.IP.String(), tt.want) { if !reflect.DeepEqual(s.OverlayAddr.IP.String(), tt.want) {
t.Errorf("assignOverlayAddr() set = %s, want %s", wg.OverlayAddr, tt.want) t.Errorf("assignOverlayAddr() set = %s, want %s", s.OverlayAddr, tt.want)
} }
}) })
} }
@ -43,38 +43,38 @@ func Test_wgState_assignOverlayAddr(t *testing.T) {
// This is just to ensure - if we ever change the hashing function - that it spreads the results in a way that at least // This is just to ensure - if we ever change the hashing function - that it spreads the results in a way that at least
// avoids the most obvious collisions. // avoids the most obvious collisions.
func Test_wgState_assignOverlayAddr_no_obvious_collisions(t *testing.T) { func Test_State_AssignOverlayAddr_no_obvious_collisions(t *testing.T) {
_, ipnet, _ := net.ParseCIDR("10.0.0.0/24") _, ipnet, _ := net.ParseCIDR("10.0.0.0/24")
assignments := make(map[string]string) assignments := make(map[string]string)
for _, n := range []string{"test", "test1", "test2", "1test", "2test"} { for _, n := range []string{"test", "test1", "test2", "1test", "2test"} {
wg := &WgState{} s := &State{}
wg.AssignOverlayAddr(ipnet, n) s.AssignOverlayAddr(ipnet, n)
if assigned, ok := assignments[wg.OverlayAddr.String()]; ok { if assigned, ok := assignments[s.OverlayAddr.String()]; ok {
t.Errorf("IP assignment collision: hash(%s) = hash(%s)", n, assigned) t.Errorf("IP assignment collision: hash(%s) = hash(%s)", n, assigned)
} }
assignments[wg.OverlayAddr.String()] = n assignments[s.OverlayAddr.String()] = n
} }
} }
// This should ensure the obvious fact that the same name should map to the same IP if called twice. // This should ensure the obvious fact that the same name should map to the same IP if called twice.
func Test_wgState_assignOverlayAddr_consistent(t *testing.T) { func Test_State_AssignOverlayAddr_consistent(t *testing.T) {
_, ipnet, _ := net.ParseCIDR("10.0.0.0/8") _, ipnet, _ := net.ParseCIDR("10.0.0.0/8")
wg1 := &WgState{} s1 := &State{}
wg1.AssignOverlayAddr(ipnet, "test") s1.AssignOverlayAddr(ipnet, "test")
wg2 := &WgState{} s2 := &State{}
wg2.AssignOverlayAddr(ipnet, "test") s2.AssignOverlayAddr(ipnet, "test")
if wg1.OverlayAddr.String() != wg2.OverlayAddr.String() { if s1.OverlayAddr.String() != s2.OverlayAddr.String() {
t.Errorf("assignOverlayAddr() %s != %s", wg1.OverlayAddr, wg2.OverlayAddr) t.Errorf("assignOverlayAddr() %s != %s", s1.OverlayAddr, s2.OverlayAddr)
} }
} }
func Test_wgState_assignOverlayAddr_repeatable(t *testing.T) { func Test_State_AssignOverlayAddr_repeatable(t *testing.T) {
_, ipnet, _ := net.ParseCIDR("10.0.0.0/8") _, ipnet, _ := net.ParseCIDR("10.0.0.0/8")
wg := &WgState{} s := &State{}
wg.AssignOverlayAddr(ipnet, "test") s.AssignOverlayAddr(ipnet, "test")
gen1 := wg.OverlayAddr.String() gen1 := s.OverlayAddr.String()
wg.AssignOverlayAddr(ipnet, "test") s.AssignOverlayAddr(ipnet, "test")
gen2 := wg.OverlayAddr.String() gen2 := s.OverlayAddr.String()
if gen1 != gen2 { if gen1 != gen2 {
t.Errorf("assignOverlayAddr() %s != %s", gen1, gen2) t.Errorf("assignOverlayAddr() %s != %s", gen1, gen2)
} }