2021-10-06 03:02:09 +08:00
|
|
|
package logic
|
|
|
|
|
|
|
|
import (
|
2021-10-13 03:44:19 +08:00
|
|
|
"os"
|
|
|
|
"os/exec"
|
|
|
|
"strings"
|
|
|
|
|
2021-12-07 04:31:08 +08:00
|
|
|
"github.com/gravitl/netmaker/logger"
|
2021-10-06 03:02:09 +08:00
|
|
|
"github.com/gravitl/netmaker/models"
|
2021-10-13 03:44:19 +08:00
|
|
|
"github.com/gravitl/netmaker/netclient/ncutils"
|
2022-01-22 02:15:54 +08:00
|
|
|
"github.com/gravitl/netmaker/netclient/wireguard"
|
2022-10-28 19:32:22 +08:00
|
|
|
"github.com/gravitl/netmaker/nm-proxy/manager"
|
2022-11-20 12:05:29 +08:00
|
|
|
"github.com/gravitl/netmaker/servercfg"
|
2021-10-06 03:02:09 +08:00
|
|
|
"golang.zx2c4.com/wireguard/wgctrl"
|
2021-10-13 03:44:19 +08:00
|
|
|
"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
|
2021-10-06 03:02:09 +08:00
|
|
|
)
|
|
|
|
|
2022-01-18 06:44:12 +08:00
|
|
|
// RemoveConf - removes a configuration for a given WireGuard interface
|
|
|
|
func RemoveConf(iface string, printlog bool) error {
|
|
|
|
var err error
|
|
|
|
confPath := ncutils.GetNetclientPathSpecific() + iface + ".conf"
|
|
|
|
err = removeWGQuickConf(confPath, printlog)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2022-02-02 23:37:05 +08:00
|
|
|
// HasPeerConnected - checks if a client node has connected over WG
|
|
|
|
func HasPeerConnected(node *models.Node) bool {
|
|
|
|
client, err := wgctrl.New()
|
|
|
|
if err != nil {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
defer client.Close()
|
|
|
|
device, err := client.Device(node.Interface)
|
|
|
|
if err != nil {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
for _, peer := range device.Peers {
|
|
|
|
if peer.PublicKey.String() == node.PublicKey {
|
|
|
|
if peer.Endpoint != nil {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2022-02-15 00:01:33 +08:00
|
|
|
// IfaceDelta - checks if the new node causes an interface change
|
|
|
|
func IfaceDelta(currentNode *models.Node, newNode *models.Node) bool {
|
|
|
|
// single comparison statements
|
|
|
|
if newNode.Endpoint != currentNode.Endpoint ||
|
|
|
|
newNode.PublicKey != currentNode.PublicKey ||
|
|
|
|
newNode.Address != currentNode.Address ||
|
2022-04-20 02:42:04 +08:00
|
|
|
newNode.Address6 != currentNode.Address6 ||
|
2022-02-15 00:01:33 +08:00
|
|
|
newNode.IsEgressGateway != currentNode.IsEgressGateway ||
|
|
|
|
newNode.IsIngressGateway != currentNode.IsIngressGateway ||
|
|
|
|
newNode.IsRelay != currentNode.IsRelay ||
|
|
|
|
newNode.UDPHolePunch != currentNode.UDPHolePunch ||
|
|
|
|
newNode.IsPending != currentNode.IsPending ||
|
2022-02-17 23:33:48 +08:00
|
|
|
newNode.ListenPort != currentNode.ListenPort ||
|
2022-10-31 13:02:04 +08:00
|
|
|
newNode.LocalListenPort != currentNode.LocalListenPort ||
|
2022-02-17 09:26:20 +08:00
|
|
|
newNode.MTU != currentNode.MTU ||
|
2022-02-15 00:01:33 +08:00
|
|
|
newNode.PersistentKeepalive != currentNode.PersistentKeepalive ||
|
|
|
|
newNode.DNSOn != currentNode.DNSOn ||
|
2022-08-20 00:08:31 +08:00
|
|
|
newNode.Connected != currentNode.Connected ||
|
2022-02-15 00:01:33 +08:00
|
|
|
len(newNode.AllowedIPs) != len(currentNode.AllowedIPs) {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
|
|
|
// multi-comparison statements
|
|
|
|
if newNode.IsEgressGateway == "yes" {
|
|
|
|
if len(currentNode.EgressGatewayRanges) != len(newNode.EgressGatewayRanges) {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
for _, address := range newNode.EgressGatewayRanges {
|
|
|
|
if !StringSliceContains(currentNode.EgressGatewayRanges, address) {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if newNode.IsRelay == "yes" {
|
|
|
|
if len(currentNode.RelayAddrs) != len(newNode.RelayAddrs) {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
for _, address := range newNode.RelayAddrs {
|
|
|
|
if !StringSliceContains(currentNode.RelayAddrs, address) {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, address := range newNode.AllowedIPs {
|
|
|
|
if !StringSliceContains(currentNode.AllowedIPs, address) {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2022-01-18 06:44:12 +08:00
|
|
|
// == Private Functions ==
|
|
|
|
|
|
|
|
// gets the server peers locally
|
|
|
|
func getSystemPeers(node *models.Node) (map[string]string, error) {
|
2021-10-06 03:02:09 +08:00
|
|
|
peers := make(map[string]string)
|
|
|
|
|
|
|
|
client, err := wgctrl.New()
|
|
|
|
if err != nil {
|
|
|
|
return peers, err
|
|
|
|
}
|
2021-12-11 04:01:10 +08:00
|
|
|
defer client.Close()
|
2021-10-06 03:02:09 +08:00
|
|
|
device, err := client.Device(node.Interface)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2022-05-12 00:07:06 +08:00
|
|
|
if device.Peers != nil && len(device.Peers) > 0 {
|
2022-05-11 03:18:29 +08:00
|
|
|
for _, peer := range device.Peers {
|
|
|
|
if IsBase64(peer.PublicKey.String()) && peer.Endpoint != nil && CheckEndpoint(peer.Endpoint.String()) {
|
|
|
|
peers[peer.PublicKey.String()] = peer.Endpoint.String()
|
|
|
|
}
|
2021-10-06 03:02:09 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return peers, nil
|
|
|
|
}
|
2021-10-13 03:44:19 +08:00
|
|
|
func removeWGQuickConf(confPath string, printlog bool) error {
|
|
|
|
if _, err := ncutils.RunCmd("wg-quick down "+confPath, printlog); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
2021-10-13 22:02:04 +08:00
|
|
|
|
2021-12-11 04:01:10 +08:00
|
|
|
func setWGConfig(node *models.Node, peerupdate bool) error {
|
2022-08-19 23:25:39 +08:00
|
|
|
peers, err := GetPeerUpdate(node)
|
2021-11-13 00:24:29 +08:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
privkey, err := FetchPrivKey(node.ID)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if peerupdate {
|
2022-08-19 23:25:39 +08:00
|
|
|
if err := wireguard.SetPeers(node.Interface, node, peers.Peers); err != nil {
|
2022-03-20 18:25:12 +08:00
|
|
|
logger.Log(0, "error updating peers", err.Error())
|
2022-11-02 18:03:42 +08:00
|
|
|
return err
|
2022-03-20 18:25:12 +08:00
|
|
|
}
|
2022-11-02 18:03:42 +08:00
|
|
|
// logger.Log(0, "--------> UPDATE PEERS IN PROXY.....")
|
|
|
|
// ProxyMgmChan <- &manager.ManagerAction{
|
|
|
|
// Action: manager.UpdatePeer,
|
|
|
|
// Payload: manager.ManagerPayload{
|
|
|
|
// InterfaceName: node.Interface,
|
|
|
|
// Peers: peers.Peers,
|
|
|
|
// },
|
|
|
|
// }
|
|
|
|
|
2021-12-07 04:31:08 +08:00
|
|
|
logger.Log(2, "updated peers on server", node.Name)
|
2021-11-13 00:24:29 +08:00
|
|
|
} else {
|
2022-08-30 22:55:18 +08:00
|
|
|
err = wireguard.InitWireguard(node, privkey, peers.Peers)
|
2022-11-02 18:03:42 +08:00
|
|
|
if err != nil {
|
|
|
|
logger.Log(0, "failed to set wg config on server: ", node.Name, err.Error())
|
|
|
|
return err
|
|
|
|
}
|
2021-12-07 04:31:08 +08:00
|
|
|
logger.Log(3, "finished setting wg config on server", node.Name)
|
2022-11-02 18:03:42 +08:00
|
|
|
|
2021-11-13 00:24:29 +08:00
|
|
|
}
|
2022-11-20 12:05:29 +08:00
|
|
|
if servercfg.IsProxyEnabled() {
|
|
|
|
logger.Log(0, "--------> ADD/Update INTERFACE TO PROXY.....")
|
|
|
|
proxyPayload, err := GetPeersForProxy(node, false)
|
|
|
|
if err != nil {
|
|
|
|
logger.Log(0, "failed to get peers for proxy: ", err.Error())
|
|
|
|
} else {
|
2022-11-07 03:55:04 +08:00
|
|
|
|
2022-11-20 12:05:29 +08:00
|
|
|
ProxyMgmChan <- &manager.ManagerAction{
|
|
|
|
Action: manager.AddInterface,
|
|
|
|
Payload: proxyPayload,
|
|
|
|
}
|
2022-10-28 19:32:22 +08:00
|
|
|
}
|
|
|
|
}
|
2022-11-20 12:05:29 +08:00
|
|
|
|
2022-11-02 18:03:42 +08:00
|
|
|
return nil
|
2021-11-13 00:24:29 +08:00
|
|
|
}
|
|
|
|
|
2021-12-08 04:04:00 +08:00
|
|
|
func setWGKeyConfig(node *models.Node) error {
|
2021-10-14 03:15:20 +08:00
|
|
|
|
|
|
|
privatekey, err := wgtypes.GeneratePrivateKey()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
privkeystring := privatekey.String()
|
|
|
|
publickey := privatekey.PublicKey()
|
|
|
|
node.PublicKey = publickey.String()
|
|
|
|
|
|
|
|
err = StorePrivKey(node.ID, privkeystring)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if node.Action == models.NODE_UPDATE_KEY {
|
|
|
|
node.Action = models.NODE_NOOP
|
|
|
|
}
|
|
|
|
|
2021-12-11 04:01:10 +08:00
|
|
|
return setWGConfig(node, false)
|
2021-10-14 03:15:20 +08:00
|
|
|
}
|
2021-10-20 21:22:05 +08:00
|
|
|
|
|
|
|
func removeLocalServer(node *models.Node) error {
|
2022-03-23 02:29:20 +08:00
|
|
|
|
2021-10-20 21:22:05 +08:00
|
|
|
var err error
|
2022-03-23 02:29:20 +08:00
|
|
|
var ifacename = node.Interface
|
2021-11-23 22:30:11 +08:00
|
|
|
if err = RemovePrivKey(node.ID); err != nil {
|
2021-12-07 04:31:08 +08:00
|
|
|
logger.Log(1, "failed to remove server conf from db", node.ID)
|
2021-11-23 22:30:11 +08:00
|
|
|
}
|
2021-10-20 21:22:05 +08:00
|
|
|
if ifacename != "" {
|
|
|
|
if !ncutils.IsKernel() {
|
|
|
|
if err = RemoveConf(ifacename, true); err == nil {
|
2021-12-07 04:31:08 +08:00
|
|
|
logger.Log(1, "removed WireGuard interface:", ifacename)
|
2021-10-20 21:22:05 +08:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ipExec, err := exec.LookPath("ip")
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
out, err := ncutils.RunCmd(ipExec+" link del "+ifacename, false)
|
|
|
|
dontprint := strings.Contains(out, "does not exist") || strings.Contains(out, "Cannot find device")
|
|
|
|
if err != nil && !dontprint {
|
2021-12-07 04:31:08 +08:00
|
|
|
logger.Log(1, "error running command:", ipExec, "link del", ifacename)
|
|
|
|
logger.Log(1, out)
|
2021-10-20 21:22:05 +08:00
|
|
|
}
|
|
|
|
if node.PostDown != "" {
|
2022-09-10 02:15:10 +08:00
|
|
|
ncutils.RunCmd(node.PostDown, false)
|
2021-10-20 21:22:05 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
home := ncutils.GetNetclientPathSpecific()
|
|
|
|
if ncutils.FileExists(home + "netconfig-" + node.Network) {
|
|
|
|
_ = os.Remove(home + "netconfig-" + node.Network)
|
|
|
|
}
|
|
|
|
if ncutils.FileExists(home + "nettoken-" + node.Network) {
|
|
|
|
_ = os.Remove(home + "nettoken-" + node.Network)
|
|
|
|
}
|
|
|
|
if ncutils.FileExists(home + "secret-" + node.Network) {
|
|
|
|
_ = os.Remove(home + "secret-" + node.Network)
|
|
|
|
}
|
|
|
|
if ncutils.FileExists(home + "wgkey-" + node.Network) {
|
|
|
|
_ = os.Remove(home + "wgkey-" + node.Network)
|
|
|
|
}
|
|
|
|
if ncutils.FileExists(home + "nm-" + node.Network + ".conf") {
|
|
|
|
_ = os.Remove(home + "nm-" + node.Network + ".conf")
|
|
|
|
}
|
|
|
|
return err
|
|
|
|
}
|