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 }