263 lines
6.7 KiB
Go
263 lines
6.7 KiB
Go
// Package config provides functionality to load and monitor the system
|
|
// firewall rules.
|
|
// It's inherited by the different firewall packages (iptables, nftables).
|
|
//
|
|
// The firewall rules defined by the user are reloaded in these cases:
|
|
// - When the file system-fw.json changes.
|
|
// - When the firewall rules are not present when listing them.
|
|
package config
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"io/ioutil"
|
|
"os"
|
|
"sync"
|
|
|
|
"github.com/evilsocket/opensnitch/daemon/firewall/common"
|
|
"github.com/evilsocket/opensnitch/daemon/log"
|
|
"github.com/fsnotify/fsnotify"
|
|
)
|
|
|
|
var (
|
|
// DefaultConfigFile ..
|
|
DefaultConfigFile = "/etc/opensnitchd/system-fw.json"
|
|
)
|
|
|
|
// ExprValues holds the statements' options:
|
|
// "Name": "ct",
|
|
// "Values": [
|
|
// {
|
|
// "Key": "state",
|
|
// "Value": "established"
|
|
// },
|
|
// {
|
|
// "Key": "state",
|
|
// "Value": "related"
|
|
// }]
|
|
type ExprValues struct {
|
|
Key string
|
|
Value string
|
|
}
|
|
|
|
// ExprStatement holds the definition of matches to use against connections.
|
|
//{
|
|
// "Op": "!=",
|
|
// "Name": "tcp",
|
|
// "Values": [
|
|
// {
|
|
// "Key": "dport",
|
|
// "Value": "443"
|
|
// }
|
|
// ]
|
|
//}
|
|
type ExprStatement struct {
|
|
Op string // ==, !=, ... Only one per expression set.
|
|
Name string // tcp, udp, ct, daddr, log, ...
|
|
Values []*ExprValues // dport 8000
|
|
}
|
|
|
|
// Expressions holds the array of expressions that create the rules
|
|
type Expressions struct {
|
|
Statement *ExprStatement
|
|
}
|
|
|
|
// FwRule holds the fields of a rule
|
|
type FwRule struct {
|
|
*sync.RWMutex
|
|
// we need to keep old fields in the struct. Otherwise when receiving a conf from the GUI, the legacy rules would be deleted.
|
|
Chain string // TODO: deprecated, remove
|
|
Table string // TODO: deprecated, remove
|
|
Parameters string // TODO: deprecated, remove
|
|
UUID string
|
|
Description string
|
|
Target string
|
|
TargetParameters string
|
|
Expressions []*Expressions
|
|
Position uint64 `json:",string"`
|
|
Enabled bool
|
|
}
|
|
|
|
// FwChain holds the information that defines a firewall chain.
|
|
// It also contains the firewall table definition that it belongs to.
|
|
type FwChain struct {
|
|
// table fields
|
|
Table string
|
|
Family string
|
|
// chain fields
|
|
Name string
|
|
Description string
|
|
Priority string
|
|
Type string
|
|
Hook string
|
|
Policy string
|
|
Rules []*FwRule
|
|
}
|
|
|
|
// IsInvalid checks if the chain has been correctly configured.
|
|
func (fc *FwChain) IsInvalid() bool {
|
|
return fc.Name == "" || fc.Family == "" || fc.Table == ""
|
|
}
|
|
|
|
type rulesList struct {
|
|
Rule *FwRule
|
|
}
|
|
|
|
type chainsList struct {
|
|
Rule *FwRule // TODO: deprecated, remove
|
|
Chains []*FwChain
|
|
}
|
|
|
|
// SystemConfig holds the list of rules to be added to the system
|
|
type SystemConfig struct {
|
|
SystemRules []*chainsList
|
|
sync.RWMutex
|
|
Version uint32
|
|
Enabled bool
|
|
}
|
|
|
|
// Config holds the functionality to re/load the firewall configuration from disk.
|
|
// This is the configuration to manage the system firewall (iptables, nftables).
|
|
type Config struct {
|
|
watcher *fsnotify.Watcher
|
|
ctx context.Context
|
|
cancelMonitor context.CancelFunc
|
|
|
|
// preloadCallback is called before reloading the configuration,
|
|
// in order to delete old fw rules.
|
|
preloadCallback func()
|
|
// reloadCallback is called after the configuration is written.
|
|
reloadCallback func()
|
|
// preload will be called after daemon startup, whilst reload when a modification is performed.
|
|
file string
|
|
SysConfig SystemConfig
|
|
sync.Mutex
|
|
}
|
|
|
|
// NewSystemFwConfig initializes config fields
|
|
func (c *Config) NewSystemFwConfig(configPath string, preLoadCb, reLoadCb func()) (*Config, error) {
|
|
var err error
|
|
watcher, err := fsnotify.NewWatcher()
|
|
if err != nil {
|
|
log.Warning("Error creating firewall config watcher: %s", err)
|
|
return nil, err
|
|
}
|
|
|
|
c.Lock()
|
|
defer c.Unlock()
|
|
|
|
c.file = configPath
|
|
c.ctx, c.cancelMonitor = context.WithCancel(context.Background())
|
|
c.preloadCallback = preLoadCb
|
|
c.reloadCallback = reLoadCb
|
|
c.watcher = watcher
|
|
return c, nil
|
|
}
|
|
|
|
// SetConfigFile sets the absolute path to the configuration file to use.
|
|
// If it's empty, it'll be ignored (when changing the fw type for example).
|
|
func (c *Config) SetConfigFile(file string) {
|
|
if file == "" {
|
|
log.Debug("Firewall configuration file not provided, ignoring")
|
|
return
|
|
}
|
|
c.file = file
|
|
}
|
|
|
|
// LoadDiskConfiguration reads and loads the firewall configuration from disk
|
|
func (c *Config) LoadDiskConfiguration(reload bool) error {
|
|
c.Lock()
|
|
defer c.Unlock()
|
|
|
|
raw, err := ioutil.ReadFile(c.file)
|
|
if err != nil {
|
|
log.Error("Error reading firewall configuration from disk %s: %s", c.file, err)
|
|
return err
|
|
}
|
|
|
|
if err = c.loadConfiguration(raw); err != nil {
|
|
return err
|
|
}
|
|
// we need to monitor the configuration file for changes, regardless if it's
|
|
// malformed or not.
|
|
c.watcher.Remove(c.file)
|
|
if err := c.watcher.Add(c.file); err != nil {
|
|
log.Error("Could not watch firewall configuration: %s", err)
|
|
return err
|
|
}
|
|
|
|
if reload {
|
|
c.reloadCallback()
|
|
return nil
|
|
}
|
|
|
|
go c.monitorConfigWorker()
|
|
|
|
return nil
|
|
}
|
|
|
|
// loadConfigutation reads the system firewall rules from disk.
|
|
// Then the rules are added based on the configuration defined.
|
|
func (c *Config) loadConfiguration(rawConfig []byte) error {
|
|
c.SysConfig.Lock()
|
|
defer c.SysConfig.Unlock()
|
|
|
|
// delete old system rules, that may be different from the new ones
|
|
c.preloadCallback()
|
|
|
|
if err := json.Unmarshal(rawConfig, &c.SysConfig); err != nil {
|
|
// we only log the parser error, giving the user a chance to write a valid config
|
|
log.Error("Error parsing firewall configuration %s: %s", c.file, err)
|
|
return err
|
|
}
|
|
log.Info("fw configuration loaded")
|
|
|
|
return nil
|
|
}
|
|
|
|
// SaveConfiguration saves configuration to disk.
|
|
// This event dispatches a reload of the configuration.
|
|
func (c *Config) SaveConfiguration(rawConfig string) error {
|
|
conf, err := json.MarshalIndent([]byte(rawConfig), " ", " ")
|
|
if err != nil {
|
|
log.Error("saving json firewall configuration: %s %s", err, conf)
|
|
return err
|
|
}
|
|
|
|
if err = os.Chmod(c.file, 0600); err != nil {
|
|
log.Warning("unable to set system-fw.json permissions: %s", err)
|
|
}
|
|
if err = ioutil.WriteFile(c.file, []byte(rawConfig), 0600); err != nil {
|
|
log.Error("writing firewall configuration to disk: %s", err)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// StopConfigWatcher stops the configuration watcher and stops the subroutine.
|
|
func (c *Config) StopConfigWatcher() {
|
|
c.Lock()
|
|
defer c.Unlock()
|
|
|
|
c.cancelMonitor()
|
|
|
|
if c.watcher != nil {
|
|
c.watcher.Remove(c.file)
|
|
c.watcher.Close()
|
|
}
|
|
}
|
|
|
|
func (c *Config) monitorConfigWorker() {
|
|
for {
|
|
select {
|
|
case <-c.ctx.Done():
|
|
goto Exit
|
|
case event := <-c.watcher.Events:
|
|
if (event.Op&fsnotify.Write == fsnotify.Write) || (event.Op&fsnotify.Remove == fsnotify.Remove) {
|
|
c.LoadDiskConfiguration(common.ReloadConf)
|
|
}
|
|
}
|
|
}
|
|
Exit:
|
|
log.Debug("stop monitoring firewall config file")
|
|
}
|