common.go 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424
  1. package functions
  2. import (
  3. "bytes"
  4. "encoding/json"
  5. "errors"
  6. "fmt"
  7. "io"
  8. "log"
  9. "net"
  10. "net/http"
  11. "os"
  12. "path/filepath"
  13. "strconv"
  14. "strings"
  15. "time"
  16. "github.com/gravitl/netmaker/logger"
  17. "github.com/gravitl/netmaker/models"
  18. "github.com/gravitl/netmaker/netclient/config"
  19. "github.com/gravitl/netmaker/netclient/daemon"
  20. "github.com/gravitl/netmaker/netclient/local"
  21. "github.com/gravitl/netmaker/netclient/ncutils"
  22. "github.com/gravitl/netmaker/netclient/wireguard"
  23. "golang.zx2c4.com/wireguard/wgctrl"
  24. )
  25. // LINUX_APP_DATA_PATH - linux path
  26. const LINUX_APP_DATA_PATH = "/etc/netmaker"
  27. // HTTP_TIMEOUT - timeout in seconds for http requests
  28. const HTTP_TIMEOUT = 30
  29. // HTTPClient - http client to be reused by all
  30. var HTTPClient http.Client
  31. // SetHTTPClient -sets http client with sane default
  32. func SetHTTPClient() {
  33. HTTPClient = http.Client{
  34. Timeout: HTTP_TIMEOUT * time.Second,
  35. }
  36. }
  37. // ListPorts - lists ports of WireGuard devices
  38. func ListPorts() error {
  39. wgclient, err := wgctrl.New()
  40. if err != nil {
  41. return err
  42. }
  43. defer wgclient.Close()
  44. devices, err := wgclient.Devices()
  45. if err != nil {
  46. return err
  47. }
  48. fmt.Println("Here are your ports:")
  49. for _, i := range devices {
  50. fmt.Println(i.ListenPort)
  51. }
  52. return err
  53. }
  54. func getPrivateAddr() (string, error) {
  55. var local string
  56. conn, err := net.Dial("udp", "8.8.8.8:80")
  57. if err == nil {
  58. defer conn.Close()
  59. localAddr := conn.LocalAddr().(*net.UDPAddr)
  60. localIP := localAddr.IP
  61. local = localIP.String()
  62. }
  63. if local == "" {
  64. local, err = getPrivateAddrBackup()
  65. }
  66. if local == "" {
  67. err = errors.New("could not find local ip")
  68. }
  69. if net.ParseIP(local).To16() != nil {
  70. local = "[" + local + "]"
  71. }
  72. return local, err
  73. }
  74. func getPrivateAddrBackup() (string, error) {
  75. ifaces, err := net.Interfaces()
  76. if err != nil {
  77. return "", err
  78. }
  79. var local string
  80. found := false
  81. for _, i := range ifaces {
  82. if i.Flags&net.FlagUp == 0 {
  83. continue // interface down
  84. }
  85. if i.Flags&net.FlagLoopback != 0 {
  86. continue // loopback interface
  87. }
  88. addrs, err := i.Addrs()
  89. if err != nil {
  90. return "", err
  91. }
  92. for _, addr := range addrs {
  93. var ip net.IP
  94. switch v := addr.(type) {
  95. case *net.IPNet:
  96. if !found {
  97. ip = v.IP
  98. local = ip.String()
  99. found = true
  100. }
  101. case *net.IPAddr:
  102. if !found {
  103. ip = v.IP
  104. local = ip.String()
  105. found = true
  106. }
  107. }
  108. }
  109. }
  110. if !found {
  111. err := errors.New("local ip address not found")
  112. return "", err
  113. }
  114. return local, err
  115. }
  116. func getInterfaces() (*[]models.Iface, error) {
  117. ifaces, err := net.Interfaces()
  118. if err != nil {
  119. return nil, err
  120. }
  121. var data []models.Iface
  122. var link models.Iface
  123. for _, iface := range ifaces {
  124. if iface.Flags&net.FlagUp == 0 {
  125. continue // interface down
  126. }
  127. if iface.Flags&net.FlagLoopback != 0 {
  128. continue // loopback interface
  129. }
  130. addrs, err := iface.Addrs()
  131. if err != nil {
  132. return nil, err
  133. }
  134. for _, addr := range addrs {
  135. link.Name = iface.Name
  136. _, cidr, err := net.ParseCIDR(addr.String())
  137. if err != nil {
  138. continue
  139. }
  140. link.Address = *cidr
  141. data = append(data, link)
  142. }
  143. }
  144. return &data, nil
  145. }
  146. // GetNode - gets node locally
  147. func GetNode(network string) models.Node {
  148. modcfg, err := config.ReadConfig(network)
  149. if err != nil {
  150. log.Fatalf("Error: %v", err)
  151. }
  152. return modcfg.Node
  153. }
  154. // Uninstall - uninstalls networks from client
  155. func Uninstall() error {
  156. networks, err := ncutils.GetSystemNetworks()
  157. if err != nil {
  158. logger.Log(1, "unable to retrieve networks: ", err.Error())
  159. logger.Log(1, "continuing uninstall without leaving networks")
  160. } else {
  161. for _, network := range networks {
  162. err = LeaveNetwork(network)
  163. if err != nil {
  164. logger.Log(1, "encounter issue leaving network", network, ":", err.Error())
  165. }
  166. }
  167. }
  168. err = nil
  169. // clean up OS specific stuff
  170. if ncutils.IsWindows() {
  171. daemon.CleanupWindows()
  172. } else if ncutils.IsMac() {
  173. daemon.CleanupMac()
  174. } else if ncutils.IsLinux() {
  175. daemon.CleanupLinux()
  176. } else if ncutils.IsFreeBSD() {
  177. daemon.CleanupFreebsd()
  178. } else if !ncutils.IsKernel() {
  179. logger.Log(1, "manual cleanup required")
  180. }
  181. return err
  182. }
  183. // LeaveNetwork - client exits a network
  184. func LeaveNetwork(network string) error {
  185. cfg, err := config.ReadConfig(network)
  186. if err != nil {
  187. return err
  188. }
  189. logger.Log(2, "deleting node from server")
  190. if err := deleteNodeFromServer(cfg); err != nil {
  191. logger.Log(0, "error deleting node from server", err.Error())
  192. }
  193. logger.Log(2, "deleting wireguard interface")
  194. if err := deleteLocalNetwork(cfg); err != nil {
  195. logger.Log(0, "error deleting wireguard interface", err.Error())
  196. }
  197. logger.Log(2, "deleting configuration files")
  198. if err := WipeLocal(cfg); err != nil {
  199. logger.Log(0, "error deleting local network files", err.Error())
  200. }
  201. logger.Log(2, "removing dns entries")
  202. if err := removeHostDNS(cfg.Node.Interface, ncutils.IsWindows()); err != nil {
  203. logger.Log(0, "failed to delete dns entries for", cfg.Node.Interface, err.Error())
  204. }
  205. logger.Log(2, "restarting daemon")
  206. return daemon.Restart()
  207. }
  208. func deleteNodeFromServer(cfg *config.ClientConfig) error {
  209. node := cfg.Node
  210. if node.IsServer == "yes" {
  211. return errors.New("attempt to delete server node ... not permitted")
  212. }
  213. token, err := Authenticate(cfg)
  214. if err != nil {
  215. return fmt.Errorf("unable to authenticate %w", err)
  216. }
  217. url := "https://" + cfg.Server.API + "/api/nodes/" + cfg.Network + "/" + cfg.Node.ID
  218. response, err := API("", http.MethodDelete, url, token)
  219. if err != nil {
  220. return fmt.Errorf("error deleting node on server: %w", err)
  221. }
  222. if response.StatusCode != http.StatusOK {
  223. bodybytes, _ := io.ReadAll(response.Body)
  224. defer response.Body.Close()
  225. return fmt.Errorf("error deleting node from network %s on server %s %s", cfg.Network, response.Status, string(bodybytes))
  226. }
  227. return nil
  228. }
  229. func deleteLocalNetwork(cfg *config.ClientConfig) error {
  230. wgClient, wgErr := wgctrl.New()
  231. if wgErr != nil {
  232. return wgErr
  233. }
  234. removeIface := cfg.Node.Interface
  235. queryAddr := cfg.Node.PrimaryAddress()
  236. if ncutils.IsMac() {
  237. var macIface string
  238. macIface, wgErr = local.GetMacIface(queryAddr)
  239. if wgErr == nil && removeIface != "" {
  240. removeIface = macIface
  241. }
  242. }
  243. dev, devErr := wgClient.Device(removeIface)
  244. if devErr != nil {
  245. return fmt.Errorf("error flushing routes %w", devErr)
  246. }
  247. local.FlushPeerRoutes(removeIface, queryAddr, dev.Peers[:])
  248. _, cidr, cidrErr := net.ParseCIDR(cfg.NetworkSettings.AddressRange)
  249. if cidrErr != nil {
  250. return fmt.Errorf("error flushing routes %w", cidrErr)
  251. }
  252. local.RemoveCIDRRoute(removeIface, queryAddr, cidr)
  253. return nil
  254. }
  255. // DeleteInterface - delete an interface of a network
  256. func DeleteInterface(ifacename string, postdown string) error {
  257. return wireguard.RemoveConf(ifacename, true)
  258. }
  259. // WipeLocal - wipes local instance
  260. func WipeLocal(cfg *config.ClientConfig) error {
  261. if err := wireguard.RemoveConf(cfg.Node.Interface, true); err == nil {
  262. logger.Log(1, "network:", cfg.Node.Network, "removed WireGuard interface: ", cfg.Node.Interface)
  263. } else if strings.Contains(err.Error(), "does not exist") {
  264. err = nil
  265. }
  266. dir := ncutils.GetNetclientPathSpecific()
  267. fail := false
  268. files, err := filepath.Glob(dir + "*" + cfg.Node.Network)
  269. if err != nil {
  270. logger.Log(0, "no matching files", err.Error())
  271. fail = true
  272. }
  273. for _, file := range files {
  274. if err := os.Remove(file); err != nil {
  275. logger.Log(0, "failed to delete file", file, err.Error())
  276. fail = true
  277. }
  278. }
  279. if cfg.Node.Interface != "" {
  280. if ncutils.FileExists(dir + cfg.Node.Interface + ".conf") {
  281. if err := os.Remove(dir + cfg.Node.Interface + ".conf"); err != nil {
  282. logger.Log(0, err.Error())
  283. fail = true
  284. }
  285. }
  286. }
  287. if fail {
  288. return errors.New("not all files were deleted")
  289. }
  290. return nil
  291. }
  292. // GetNetmakerPath - gets netmaker path locally
  293. func GetNetmakerPath() string {
  294. return LINUX_APP_DATA_PATH
  295. }
  296. // API function to interact with netmaker api endpoints. response from endpoint is returned
  297. func API(data any, method, url, authorization string) (*http.Response, error) {
  298. var request *http.Request
  299. var err error
  300. if data != "" {
  301. payload, err := json.Marshal(data)
  302. if err != nil {
  303. return nil, fmt.Errorf("error encoding data %w", err)
  304. }
  305. request, err = http.NewRequest(method, url, bytes.NewBuffer(payload))
  306. if err != nil {
  307. return nil, fmt.Errorf("error creating http request %w", err)
  308. }
  309. request.Header.Set("Content-Type", "application/json")
  310. } else {
  311. request, err = http.NewRequest(method, url, nil)
  312. if err != nil {
  313. return nil, fmt.Errorf("error creating http request %w", err)
  314. }
  315. }
  316. if authorization != "" {
  317. request.Header.Set("authorization", "Bearer "+authorization)
  318. }
  319. request.Header.Set("requestfrom", "node")
  320. return HTTPClient.Do(request)
  321. }
  322. // Authenticate authenticates with api to permit subsequent interactions with the api
  323. func Authenticate(cfg *config.ClientConfig) (string, error) {
  324. pass, err := os.ReadFile(ncutils.GetNetclientPathSpecific() + "secret-" + cfg.Network)
  325. if err != nil {
  326. return "", fmt.Errorf("could not read secrets file %w", err)
  327. }
  328. data := models.AuthParams{
  329. MacAddress: cfg.Node.MacAddress,
  330. ID: cfg.Node.ID,
  331. Password: string(pass),
  332. }
  333. url := "https://" + cfg.Server.API + "/api/nodes/adm/" + cfg.Network + "/authenticate"
  334. response, err := API(data, http.MethodPost, url, "")
  335. if err != nil {
  336. return "", err
  337. }
  338. defer response.Body.Close()
  339. if response.StatusCode != http.StatusOK {
  340. bodybytes, _ := io.ReadAll(response.Body)
  341. return "", fmt.Errorf("failed to authenticate %s %s", response.Status, string(bodybytes))
  342. }
  343. resp := models.SuccessResponse{}
  344. if err := json.NewDecoder(response.Body).Decode(&resp); err != nil {
  345. return "", fmt.Errorf("error decoding respone %w", err)
  346. }
  347. tokenData := resp.Response.(map[string]interface{})
  348. token := tokenData["AuthToken"]
  349. return token.(string), nil
  350. }
  351. // RegisterWithServer calls the register endpoint with privatekey and commonname - api returns ca and client certificate
  352. func SetServerInfo(cfg *config.ClientConfig) error {
  353. cfg, err := config.ReadConfig(cfg.Network)
  354. if err != nil {
  355. return err
  356. }
  357. url := "https://" + cfg.Server.API + "/api/server/getserverinfo"
  358. logger.Log(1, "server at "+url)
  359. token, err := Authenticate(cfg)
  360. if err != nil {
  361. return err
  362. }
  363. response, err := API("", http.MethodGet, url, token)
  364. if err != nil {
  365. return err
  366. }
  367. if response.StatusCode != http.StatusOK {
  368. return errors.New(response.Status)
  369. }
  370. var resp models.ServerConfig
  371. if err := json.NewDecoder(response.Body).Decode(&resp); err != nil {
  372. return errors.New("unmarshal cert error " + err.Error())
  373. }
  374. // set broker information on register
  375. cfg.Server.Server = resp.Server
  376. cfg.Server.MQPort = resp.MQPort
  377. if err = config.ModServerConfig(&cfg.Server, cfg.Node.Network); err != nil {
  378. logger.Log(0, "error overwriting config with broker information: "+err.Error())
  379. }
  380. return nil
  381. }
  382. func informPortChange(node *models.Node) {
  383. if node.ListenPort == 0 {
  384. logger.Log(0, "network:", node.Network, "UDP hole punching enabled for node", node.Name)
  385. } else {
  386. logger.Log(0, "network:", node.Network, "node", node.Name, "is using port", strconv.Itoa(int(node.ListenPort)))
  387. }
  388. }