opensnitch/daemon/ui/config/config.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

136 lines
4.1 KiB
Go

package config
import (
"encoding/json"
"fmt"
"io/ioutil"
"os"
"reflect"
"github.com/evilsocket/opensnitch/daemon/log"
"github.com/evilsocket/opensnitch/daemon/log/loggers"
"github.com/evilsocket/opensnitch/daemon/procmon/audit"
"github.com/evilsocket/opensnitch/daemon/procmon/ebpf"
"github.com/evilsocket/opensnitch/daemon/statistics"
)
type (
// ServerTLSOptions struct
ServerTLSOptions struct {
CACert string `json:"CACert"`
ServerCert string `json:"ServerCert"`
ServerKey string `json:"ServerKey"`
ClientCert string `json:"ClientCert"`
ClientKey string `json:"ClientKey"`
// https://pkg.go.dev/crypto/tls#ClientAuthType
ClientAuthType string `json:"ClientAuthType"`
// https://pkg.go.dev/crypto/tls#Config
SkipVerify bool `json:"SkipVerify"`
// https://pkg.go.dev/crypto/tls#Conn.VerifyHostname
// VerifyHostname bool
// https://pkg.go.dev/crypto/tls#example-Config-VerifyConnection
// VerifyConnection bool
// VerifyPeerCertificate bool
}
// ServerAuth struct
ServerAuth struct {
// token?, google?, simple-tls, mutual-tls
Type string `json:"Type"`
TLSOptions ServerTLSOptions `json:"TLSOptions"`
}
// ServerConfig struct
ServerConfig struct {
Address string `json:"Address"`
Authentication ServerAuth `json:"Authentication"`
LogFile string `json:"LogFile"`
Loggers []loggers.LoggerConfig `json:"Loggers"`
}
// RulesOptions struct
RulesOptions struct {
Path string `json:"Path"`
EnableChecksums bool `json:"EnableChecksums"`
}
// FwOptions struct
FwOptions struct {
Firewall string `json:"Firewall"`
ConfigPath string `json:"ConfigPath"`
MonitorInterval string `json:"MonitorInterval"`
QueueNum uint16 `json:"QueueNum"`
QueueBypass bool `json:"QueueBypass"`
}
TasksOptions struct {
ConfigPath string `json:"ConfigPath"`
}
// InternalOptions struct
InternalOptions struct {
GCPercent int `json:"GCPercent"`
FlushConnsOnStart bool `json:"FlushConnsOnStart"`
}
)
// Config holds the values loaded from configFile
type Config struct {
LogLevel *int32 `json:"LogLevel"`
Firewall string `json:"Firewall"`
DefaultAction string `json:"DefaultAction"`
DefaultDuration string `json:"DefaultDuration"`
ProcMonitorMethod string `json:"ProcMonitorMethod"`
FwOptions FwOptions `json:"FwOptions"`
Audit audit.Config `json:"Audit"`
Ebpf ebpf.Config `json:"Ebpf"`
Server ServerConfig `json:"Server"`
Rules RulesOptions `json:"Rules"`
Internal InternalOptions `json:"Internal"`
Stats statistics.StatsConfig `json:"Stats"`
TasksOptions TasksOptions `json:"Tasks"`
InterceptUnknown bool `json:"InterceptUnknown"`
LogUTC bool `json:"LogUTC"`
LogMicro bool `json:"LogMicro"`
}
// Parse determines if the given configuration is ok.
func Parse(rawConfig interface{}) (conf Config, err error) {
if vt := reflect.ValueOf(rawConfig).Kind(); vt == reflect.String {
err = json.Unmarshal([]byte((rawConfig.(string))), &conf)
} else {
err = json.Unmarshal(rawConfig.([]uint8), &conf)
}
return conf, err
}
func Marshal(conf Config) ([]byte, error) {
return json.Marshal(conf)
}
// Load loads the content of a file from disk.
func Load(configFile string) ([]byte, error) {
raw, err := ioutil.ReadFile(configFile)
if err != nil || len(raw) == 0 {
return nil, err
}
return raw, nil
}
// Save writes daemon configuration to disk.
func Save(configFile, rawConfig string) (err error) {
if _, err = Parse(rawConfig); err != nil {
return fmt.Errorf("Error parsing configuration %s: %s", rawConfig, err)
}
if err = os.Chmod(configFile, 0600); err != nil {
log.Warning("unable to set permissions to default config: %s", err)
}
if err = ioutil.WriteFile(configFile, []byte(rawConfig), 0644); err != nil {
log.Error("writing configuration to disk: %s", err)
return err
}
return nil
}