opensnitch/daemon/firewall/nftables/nftables.go
2025-09-06 12:47:21 +00:00

186 lines
5.1 KiB
Go

package nftables
import (
"bytes"
"encoding/json"
"strings"
"sync"
"github.com/evilsocket/opensnitch/daemon/firewall/common"
"github.com/evilsocket/opensnitch/daemon/firewall/config"
"github.com/evilsocket/opensnitch/daemon/firewall/iptables"
"github.com/evilsocket/opensnitch/daemon/log"
"github.com/evilsocket/opensnitch/daemon/ui/protocol"
"github.com/golang/protobuf/jsonpb"
"github.com/google/nftables"
)
// Action is the modifier we apply to a rule.
type Action string
// Actions we apply to the firewall.
const (
fwKey = "opensnitch-key"
InterceptionRuleKey = fwKey + "-interception"
SystemRuleKey = fwKey + "-system"
Name = "nftables"
)
// Nft holds the fields of our nftables firewall
type Nft struct {
Conn *nftables.Conn
chains iptables.SystemChains
bypassQueue bool
common.Common
config.Config
sync.Mutex
}
// NewNft creates a new nftables object
func NewNft() *nftables.Conn {
return &nftables.Conn{}
}
// Fw initializes a new nftables object
func Fw() (*Nft, error) {
n := &Nft{
chains: iptables.SystemChains{
Rules: make(map[string]*iptables.SystemRule),
},
}
return n, nil
}
// Name returns the name of the firewall
func (n *Nft) Name() string {
return Name
}
// Init inserts the firewall rules and starts monitoring for firewall
// changes.
func (n *Nft) Init(qNum uint16, configPath, monitorInterval string, bypassQueue bool) {
if n.IsRunning() {
return
}
n.bypassQueue = bypassQueue
n.Conn = NewNft()
n.ErrChan = make(chan string, 100)
InitMapsStore()
n.SetQueueNum(qNum)
n.SetRulesCheckerInterval(monitorInterval)
// 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.
n.NewSystemFwConfig(configPath, n.PreloadConfCallback, n.ReloadConfCallback)
n.LoadDiskConfiguration(!common.ReloadConf)
// start from a clean state
// The daemon may have exited unexpectedly, leaving residual fw rules, so we
// need to clean them up to avoid duplicated rules.
n.DelInterceptionRules()
n.AddSystemRules(!common.ReloadRules, common.BackupChains)
n.EnableInterception()
n.Running = true
}
// Stop deletes the firewall rules, allowing network traffic.
func (n *Nft) Stop() {
n.ErrChan = make(chan string, 100)
if n.IsRunning() == false {
return
}
n.StopConfigWatcher()
n.StopCheckingRules()
n.CleanRules(log.GetLogLevel() == log.DEBUG)
n.Lock()
n.Running = false
n.Unlock()
}
// EnableInterception adds firewall rules to intercept connections
func (n *Nft) EnableInterception() {
if err := n.AddInterceptionTables(); err != nil {
log.Error("Error while adding interception tables: %s", err)
return
}
if err := n.AddInterceptionChains(); err != nil {
log.Error("Error while adding interception chains: %s", err)
return
}
if err, _ := n.QueueDNSResponses(common.EnableRule, common.EnableRule); err != nil {
log.Error("Error while running DNS nftables rule: %s", err)
}
if err, _ := n.QueueConnections(common.EnableRule, common.EnableRule); err != nil {
log.Error("Error while running conntrack nftables rule: %s", err)
}
// start monitoring firewall rules to intercept network traffic.
n.NewRulesChecker(n.AreRulesLoaded, n.ReloadRulesCallback)
}
// DisableInterception removes firewall rules to intercept outbound connections.
func (n *Nft) DisableInterception(logErrors bool) {
n.StopCheckingRules()
n.DelInterceptionRules()
}
// CleanRules deletes the rules we added.
func (n *Nft) CleanRules(logErrors bool) {
n.DisableInterception(logErrors)
n.DeleteSystemRules(common.ForcedDelRules, common.RestoreChains, logErrors)
}
// Commit applies the queued changes, creating new objects (tables, chains, etc).
// You add rules, chains or tables, and after calling to Flush() they're added to the system.
// NOTE: it's very important not to call Flush() without queued tasks.
func (n *Nft) Commit() bool {
if err := n.Conn.Flush(); err != nil {
log.Warning("%s error applying changes: %s", logTag, err)
return false
}
return true
}
// Serialize converts the configuration from json to protobuf
func (n *Nft) Serialize() (*protocol.SysFirewall, error) {
sysfw := &protocol.SysFirewall{}
jun := jsonpb.Unmarshaler{
AllowUnknownFields: true,
}
rawConfig, err := json.Marshal(&n.SysConfig)
if err != nil {
log.Error("nftables.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("nftables.Serialize() string to protobuf error: %s", err)
return nil, err
}
return sysfw, nil
}
// Deserialize converts a protocolbuffer structure to byte array.
func (n *Nft) Deserialize(sysfw *protocol.SysFirewall) ([]byte, error) {
jun := jsonpb.Marshaler{
OrigName: true,
EmitDefaults: true,
Indent: " ",
}
// NOTE: '<' and '>' characters are encoded to unicode (\u003c).
// This has no effect on adding rules to nftables.
// Users can still write "<" if they want to, rules are added ok.
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
}