opensnitch/daemon/ui/config_utils.go
Gustavo Iñiguez Goia 66ee50bf7d
tasks: allow to load tasks from disk
Now it's possible to load tasks from disk.

There's a central file which contains the defined tasks:
/etc/opensnitchd/tasks/tasks.json

with this format:
{
    "tasks": [
        {
            "enabled": false,
            "name": "downloader",
            "configfile":
"/etc/opensnitchd/tasks/downloader/downloader.json",
        }
    ]
}

The field "name" defines the type of task to load, defined in each task.
It's static.

Whenever the tasks.json is modified, if the tasks are enabled, the task
configuration file defined in the "configfile" field will be loaded.

Configuration format of each task:

{
  "name": "downloader",
  "parent": "downloader",
  "data": {}
}

The field "name" is dynamic, unique, and identifies the instance of the
task. If there're two tasks configured with the same name, only one will
be loaded.
The "parent" field is used to know what's the base task. If it's not
specified, we'll try to use the "name" as the base task.

This allows you to run multiple instances of the same task with
different configurations: a downloader to update malware blocklists,
another to update IP blocklists, etc.

The "data" field depends of each task. It's generic, and each task is
responsible for defining it. For example for the Downloader task:

"data": {
    "interval": "1h",
    "timeout": "5s",
    "urls": [
        {
            "name": "adaway",
            "enabled": true,
            "remote": "https://adaway.o/hosts.txt",
            "localfile": "/tmp/blocklist/ads-adaway-hosts.txt"
        }
    ]
}

The tasks configuration file are also monitored for changes, and
whenever a change is detected the task is reloaded.

----

Notifications (WIP)

It's not yet fully defined and it'll change, but this is the state as
of today.

For real-time tasks, like pid-monitor, sockets monitor and node monitor,
the GUI initiates the task with a unique ID (a timestamp), to know who
is sending what, and display the data properly on the GUI.

For permanent tasks we use a unique ID defined for each task.

Right now, if we don't have the notifications channel opened and the
notification ID corresponds with one of the tasks, we'll post an alert
to the GUI, to display a desktop notification.

Each task can define if send notifications or not. For example:

{
  "name": "downloader",
  "data": {
      (...)
      "notify": {
          "enabled": true
      }
  }
}

then in each task, act accordingly to what is defined in the
configuration.
2025-09-11 12:19:38 +02:00

284 lines
9.6 KiB
Go

package ui
import (
"fmt"
"reflect"
"strings"
"runtime/debug"
"github.com/evilsocket/opensnitch/daemon/firewall"
"github.com/evilsocket/opensnitch/daemon/log"
"github.com/evilsocket/opensnitch/daemon/netlink"
"github.com/evilsocket/opensnitch/daemon/procmon"
"github.com/evilsocket/opensnitch/daemon/procmon/monitor"
"github.com/evilsocket/opensnitch/daemon/rule"
"github.com/evilsocket/opensnitch/daemon/ui/config"
)
func (c *Client) getSocketPath(socketPath string) string {
c.Lock()
defer c.Unlock()
if strings.HasPrefix(socketPath, "unix:") == true {
c.isUnixSocket = true
c.unixSockPrefix = "unix"
return socketPath[5:]
}
if strings.HasPrefix(socketPath, "unix-abstract:") == true {
c.isUnixSocket = true
c.unixSockPrefix = "unix-abstract"
return socketPath[14:]
}
c.isUnixSocket = false
return socketPath
}
func (c *Client) getCurrentSocketPath() string {
c.RLock()
defer c.RUnlock()
return c.socketPath
}
func (c *Client) setSocketPath(socketPath string) {
c.Lock()
defer c.Unlock()
c.socketPath = socketPath
}
func (c *Client) isProcMonitorEqual(newMonitorMethod string) bool {
c.RLock()
defer c.RUnlock()
return newMonitorMethod == c.config.ProcMonitorMethod
}
func (c *Client) loadDiskConfiguration(reload bool) {
// https://pkg.go.dev/github.com/fsnotify/fsnotify#Watcher.Add
// "A watch will be automatically removed if the watched path is deleted or renamed"
// "A path can only be watched once; watching it more than once is a no-op and will not return an error"
//
// Add the config file every time we read the file, to survive:
// - malformed json file
// - intermediate file removal (when writing we receive 2 write events, one of 0 bytes)
if err := c.configWatcher.Add(configFile); err != nil {
log.Error("[config] Could not watch path: %s", err)
}
raw, err := config.Load(configFile)
if err != nil || len(raw) == 0 {
// Sometimes we may receive 2 Write events on monitorConfigWorker,
// Which may lead to read 0 bytes.
log.Warning("[config] Error loading configuration from disk %s: %s", configFile, err)
return
}
err = c.loadConfiguration(reload, raw)
if err != nil {
log.Error("[client] error loading config file: %s", err.Error())
c.SendWarningAlert(err.Error())
return
}
if reload {
return
}
go c.monitorConfigWorker()
}
func (c *Client) loadConfiguration(reload bool, rawConfig []byte) (errf error) {
newConfig, err := config.Parse(rawConfig)
if err != nil {
return fmt.Errorf("parsing configuration %s: %s", configFile, err)
}
if err := c.reloadConfiguration(reload, &newConfig); err != nil {
errf = fmt.Errorf("%s", err.Msg)
}
// We need to use the new config, even if some of the new options failed,
// to avoid ending up running with an empty config.
// On reloadConfig we should fall back to a default option if anything fails.
c.Lock()
c.config = newConfig
c.Unlock()
return errf
}
func (c *Client) reloadConfiguration(reload bool, newConfig *config.Config) (err *monitor.Error) {
// firstly load config level, to detect further errors if any
if newConfig.LogLevel != nil {
log.SetLogLevel(int(*newConfig.LogLevel))
}
log.SetLogUTC(newConfig.LogUTC)
log.SetLogMicro(newConfig.LogMicro)
if newConfig.Server.LogFile != "" {
log.Debug("[config] using config.server.logfile: %s", newConfig.Server.LogFile)
log.Close()
log.OpenFile(newConfig.Server.LogFile)
}
if !reflect.DeepEqual(c.config.Server.Loggers, newConfig.Server.Loggers) {
log.Debug("[config] reloading config.server.loggers")
c.loggers.Stop()
c.loggers.Load(newConfig.Server.Loggers)
c.stats.SetLoggers(c.loggers)
} else {
log.Debug("[config] config.server.loggers not changed")
}
if !reflect.DeepEqual(newConfig.Stats, c.config.Stats) {
log.Debug("[config] reloading config.stats")
c.stats.SetLimits(newConfig.Stats)
} else {
log.Debug("[config] config.stats not changed")
}
// 1. disconnect from the server (GUI) if the new server addr is empty.
// 2. connect to the server (GUI) if the new server addr is not empty, and previous addr was empty.
// 3. reconnect if:
// - Auth options changed.
// - previous addr was not empty, new addr is not empty and new addr has changed.
reconnect := newConfig.Server.Authentication.Type != c.config.Server.Authentication.Type ||
!reflect.DeepEqual(newConfig.Server.Authentication.TLSOptions, c.config.Server.Authentication.TLSOptions)
connect := false
if newConfig.Server.Address == "" {
log.Debug("[config] config.server.address changed, disconnecting from %s", c.socketPath)
c.setSocketPath("")
}
if newConfig.Server.Address != "" && newConfig.Server.Address != c.config.Server.Address {
tempSocketPath := c.getSocketPath(newConfig.Server.Address)
log.Debug("[config] using new config.server.address: %s -> %s", c.config.Server.Address, newConfig.Server.Address)
if tempSocketPath != c.socketPath {
// disconnect, and let the connection poller reconnect to the new address
reconnect = true
}
c.setSocketPath(tempSocketPath)
// if we were not connected (i.e.: connection poller stopped), connect again.
if c.config.Server.Address == "" {
log.Debug("[config] previous address was empty, connected: %v, connecting to %s", c.Connected(), tempSocketPath)
c.config.Server.Address = newConfig.Server.Address
connect = true
}
}
log.Debug("[config] server.address old: %s, new: %s, reconnect: %v, connect: %v", c.config.Server.Address, newConfig.Server.Address, reconnect, connect)
if reconnect {
log.Debug("[config] config.server.address.* changed, disconnecting from %s", c.config.Server.Address)
c.disconnect()
}
if connect {
log.Debug("[config] config.server. changed, connecting to %s", c.socketPath)
c.Connect()
}
if newConfig.DefaultAction != "" {
clientDisconnectedRule.Action = rule.Action(newConfig.DefaultAction)
clientErrorRule.Action = rule.Action(newConfig.DefaultAction)
// TODO: reconfigure connected rule if changed, but not save it to disk.
//clientConnectedRule.Action = rule.Action(newConfig.DefaultAction)
}
if newConfig.DefaultDuration != "" {
clientDisconnectedRule.Duration = rule.Duration(newConfig.DefaultDuration)
clientErrorRule.Duration = rule.Duration(newConfig.DefaultDuration)
}
if newConfig.Internal.GCPercent > 0 && newConfig.Internal.GCPercent != c.config.Internal.GCPercent {
oldgcpercent := debug.SetGCPercent(newConfig.Internal.GCPercent)
log.Debug("[config] GC percent set to %d, previously was %d", newConfig.Internal.GCPercent, oldgcpercent)
} else {
log.Debug("[config] config.internal.gcpercent not changed")
}
// 1. load rules
c.rules.EnableChecksums(newConfig.Rules.EnableChecksums)
if newConfig.Rules.Path == "" || c.config.Rules.Path != newConfig.Rules.Path {
c.rules.Reload(newConfig.Rules.Path)
log.Debug("[config] reloading config.rules.path, old: <%s> new: <%s>", c.config.Rules.Path, newConfig.Rules.Path)
} else {
log.Debug("[config] config.rules.path not changed")
}
// 2. load proc mon method
reloadProc := false
if c.config.ProcMonitorMethod == "" ||
newConfig.ProcMonitorMethod != c.config.ProcMonitorMethod {
log.Debug("[config] reloading config.ProcMonMethod, old: %s -> new: %s", c.config.ProcMonitorMethod, newConfig.ProcMonitorMethod)
reloadProc = true
} else {
log.Debug("[config] config.ProcMonMethod not changed")
}
if reload && procmon.MethodIsEbpf() &&
!reflect.DeepEqual(newConfig.Ebpf, c.config.Ebpf) {
log.Debug("[config] reloading config.Ebpf: %v", newConfig.Ebpf)
reloadProc = true
} else {
log.Debug("[config] config.Ebpf.ModulesPath not changed")
}
if reload && procmon.MethodIsAudit() &&
!reflect.DeepEqual(newConfig.Audit, c.config.Audit) {
log.Debug("[config] reloading config.Audit: %v", newConfig.Audit)
reloadProc = true
} else {
log.Debug("[config] config.Audit not changed")
}
// 3. load fw
reloadFw := false
if c.GetFirewallType() != newConfig.Firewall ||
newConfig.FwOptions.ConfigPath != c.config.FwOptions.ConfigPath ||
newConfig.FwOptions.QueueNum != c.config.FwOptions.QueueNum ||
newConfig.FwOptions.MonitorInterval != c.config.FwOptions.MonitorInterval ||
newConfig.FwOptions.QueueBypass != c.config.FwOptions.QueueBypass {
log.Debug("[config] reloading config.firewall")
reloadFw = true
if err := firewall.Reload(
newConfig.Firewall,
newConfig.FwOptions.ConfigPath,
newConfig.FwOptions.MonitorInterval,
newConfig.FwOptions.QueueBypass,
newConfig.FwOptions.QueueNum,
); err != nil {
log.Error("[config] firewall reload error: %s", err)
}
} else {
log.Debug("[config] config.firewall not changed")
}
// 4. reload procmon if needed
if reloadProc {
err = monitor.ReconfigureMonitorMethod(newConfig.ProcMonitorMethod, newConfig.Ebpf, newConfig.Audit)
// override newConfig's procMon with the one configured on Reconfig,
// which should be the last known good one (or proc by default).
if err != nil && (err.What == monitor.EbpfErr || err.What == monitor.AuditdErr) {
newConfig.ProcMonitorMethod = procmon.GetMonitorMethod()
}
} else {
log.Debug("[config] config.procmon not changed")
}
if (reloadProc || reloadFw) && newConfig.Internal.FlushConnsOnStart {
log.Debug("[config] flushing established connections")
netlink.FlushConnections()
} else {
log.Debug("[config] not flushing established connections")
}
if newConfig.TasksOptions.ConfigPath != c.config.TasksOptions.ConfigPath {
log.Debug("[config] reloading TasksOptions.ConfigFile from %s", newConfig.TasksOptions.ConfigPath)
if err := TaskMgr.LoadTaskFile(newConfig.TasksOptions.ConfigPath); err != nil {
log.Debug("[config] config.TasksOptions reload error: %s", err)
}
} else {
log.Debug("[config] config.TasksOptions not changed")
}
return err
}