Nfqueue bypass option skips the enqueue of packets to userspace if no application is listening to the queue. https://wiki.nftables.org/wiki-nftables/index.php/Queueing_to_userspace If this flag is not specified, and for example the daemon dies unexpectedly, all the outbound traffic will be blocked. Up until now we've been using this flag by default not to block network traffic if the daemon dies or is killed for some reason. But some users want to use precisely this behaviour (#884, #1183, #1201). Now you can configure it, to block connections if the daemon unexpectedly dies. The option is on by default in the configuration (QueueBypass: true). If this item is not present in the daemon config file, then it'll be false.
203 lines
5.4 KiB
Go
203 lines
5.4 KiB
Go
package iptables
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"os/exec"
|
|
"regexp"
|
|
"strings"
|
|
"sync"
|
|
|
|
"github.com/evilsocket/opensnitch/daemon/firewall/common"
|
|
"github.com/evilsocket/opensnitch/daemon/firewall/config"
|
|
"github.com/evilsocket/opensnitch/daemon/log"
|
|
"github.com/evilsocket/opensnitch/daemon/ui/protocol"
|
|
"github.com/golang/protobuf/jsonpb"
|
|
)
|
|
|
|
// Action is the modifier we apply to a rule.
|
|
type Action string
|
|
|
|
const (
|
|
// Name is the name that identifies this firewall
|
|
Name = "iptables"
|
|
// SystemRulePrefix prefix added to each system rule
|
|
SystemRulePrefix = "opensnitch-filter"
|
|
)
|
|
|
|
// Actions we apply to the firewall.
|
|
const (
|
|
ADD = Action("-A")
|
|
INSERT = Action("-I")
|
|
DELETE = Action("-D")
|
|
FLUSH = Action("-F")
|
|
NEWCHAIN = Action("-N")
|
|
DELCHAIN = Action("-X")
|
|
POLICY = Action("-P")
|
|
|
|
DROP = Action("DROP")
|
|
ACCEPT = Action("ACCEPT")
|
|
)
|
|
|
|
// SystemRule blabla
|
|
type SystemRule struct {
|
|
Rule *config.FwRule
|
|
Table string
|
|
Chain string
|
|
}
|
|
|
|
// SystemChains keeps track of the fw rules that have been added to the system.
|
|
type SystemChains struct {
|
|
Rules map[string]*SystemRule
|
|
sync.RWMutex
|
|
}
|
|
|
|
// Iptables struct holds the fields of the iptables fw
|
|
type Iptables struct {
|
|
regexRulesQuery *regexp.Regexp
|
|
regexSystemRulesQuery *regexp.Regexp
|
|
bin string
|
|
bin6 string
|
|
chains SystemChains
|
|
bypassQueue bool
|
|
common.Common
|
|
config.Config
|
|
|
|
sync.Mutex
|
|
}
|
|
|
|
// Fw initializes a new Iptables object
|
|
func Fw() (*Iptables, error) {
|
|
if err := IsAvailable(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
reRulesQuery, _ := regexp.Compile(`NFQUEUE.*ctstate NEW,RELATED.*NFQUEUE num.*`)
|
|
reSystemRulesQuery, _ := regexp.Compile(SystemRulePrefix + ".*")
|
|
|
|
ipt := &Iptables{
|
|
bin: "iptables",
|
|
bin6: "ip6tables",
|
|
regexRulesQuery: reRulesQuery,
|
|
regexSystemRulesQuery: reSystemRulesQuery,
|
|
chains: SystemChains{
|
|
Rules: make(map[string]*SystemRule),
|
|
},
|
|
}
|
|
return ipt, nil
|
|
}
|
|
|
|
// Name returns the firewall name
|
|
func (ipt *Iptables) Name() string {
|
|
return Name
|
|
}
|
|
|
|
// Init inserts the firewall rules and starts monitoring for firewall
|
|
// changes.
|
|
func (ipt *Iptables) Init(qNum uint16, configPath, monitorInterval string, bypassQueue bool) {
|
|
if ipt.IsRunning() {
|
|
return
|
|
}
|
|
ipt.bypassQueue = bypassQueue
|
|
ipt.SetQueueNum(qNum)
|
|
ipt.SetRulesCheckerInterval(monitorInterval)
|
|
ipt.ErrChan = make(chan string, 100)
|
|
|
|
// In order to clean up any existing firewall rule before start,
|
|
// we need to load the fw configuration first to know what rules
|
|
// were configured.
|
|
ipt.NewSystemFwConfig(configPath, ipt.preloadConfCallback, ipt.reloadRulesCallback)
|
|
ipt.LoadDiskConfiguration(!common.ReloadConf)
|
|
|
|
// start from a clean state
|
|
ipt.CleanRules(false)
|
|
ipt.EnableInterception()
|
|
ipt.AddSystemRules(!common.ReloadRules, common.BackupChains)
|
|
|
|
ipt.Running = true
|
|
}
|
|
|
|
// Stop deletes the firewall rules, allowing network traffic.
|
|
func (ipt *Iptables) Stop() {
|
|
ipt.ErrChan = make(chan string, 100)
|
|
if ipt.Running == false {
|
|
return
|
|
}
|
|
ipt.StopConfigWatcher()
|
|
ipt.StopCheckingRules()
|
|
ipt.CleanRules(log.GetLogLevel() == log.DEBUG)
|
|
|
|
ipt.Running = false
|
|
}
|
|
|
|
// IsAvailable checks if iptables is installed in the system.
|
|
// If it's not, we'll default to nftables.
|
|
func IsAvailable() error {
|
|
_, err := exec.Command("iptables", []string{"-V"}...).CombinedOutput()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// EnableInterception adds fw rules to intercept connections.
|
|
func (ipt *Iptables) EnableInterception() {
|
|
if err4, err6 := ipt.QueueConnections(common.EnableRule, true); err4 != nil || err6 != nil {
|
|
log.Fatal("Error while running conntrack firewall rule: %s %s", err4, err6)
|
|
} else if err4, err6 = ipt.QueueDNSResponses(common.EnableRule, true); err4 != nil || err6 != nil {
|
|
log.Error("Error while running DNS firewall rule: %s %s", err4, err6)
|
|
}
|
|
// start monitoring firewall rules to intercept network traffic
|
|
ipt.NewRulesChecker(ipt.AreRulesLoaded, ipt.reloadRulesCallback)
|
|
}
|
|
|
|
// DisableInterception removes firewall rules to intercept outbound connections.
|
|
func (ipt *Iptables) DisableInterception(logErrors bool) {
|
|
ipt.StopCheckingRules()
|
|
ipt.QueueDNSResponses(!common.EnableRule, logErrors)
|
|
ipt.QueueConnections(!common.EnableRule, logErrors)
|
|
}
|
|
|
|
// CleanRules deletes the rules we added.
|
|
func (ipt *Iptables) CleanRules(logErrors bool) {
|
|
ipt.DisableInterception(logErrors)
|
|
ipt.DeleteSystemRules(common.ForcedDelRules, common.BackupChains, logErrors)
|
|
}
|
|
|
|
// Serialize converts the configuration from json to protobuf
|
|
func (ipt *Iptables) Serialize() (*protocol.SysFirewall, error) {
|
|
sysfw := &protocol.SysFirewall{}
|
|
jun := jsonpb.Unmarshaler{
|
|
AllowUnknownFields: true,
|
|
}
|
|
rawConfig, err := json.Marshal(&ipt.SysConfig)
|
|
if err != nil {
|
|
log.Error("nfables.Serialize() struct to string error: %s", err)
|
|
return nil, err
|
|
}
|
|
// string to proto
|
|
if err := jun.Unmarshal(strings.NewReader(string(rawConfig)), sysfw); err != nil {
|
|
log.Error("nfables.Serialize() string to protobuf error: %s", err)
|
|
return nil, err
|
|
}
|
|
|
|
return sysfw, nil
|
|
}
|
|
|
|
// Deserialize converts a protocolbuffer structure to json.
|
|
func (ipt *Iptables) Deserialize(sysfw *protocol.SysFirewall) ([]byte, error) {
|
|
jun := jsonpb.Marshaler{
|
|
OrigName: true,
|
|
EmitDefaults: false,
|
|
Indent: " ",
|
|
}
|
|
|
|
var b bytes.Buffer
|
|
if err := jun.Marshal(&b, sysfw); err != nil {
|
|
log.Error("nfables.Deserialize() error 2: %s", err)
|
|
return nil, err
|
|
}
|
|
return b.Bytes(), nil
|
|
|
|
//return nil, fmt.Errorf("iptables.Deserialize() not implemented")
|
|
}
|