opensnitch/daemon/firewall/nftables/rules.go
2025-09-11 11:30:14 +00:00

283 lines
7.6 KiB
Go

package nftables
import (
"fmt"
"github.com/evilsocket/opensnitch/daemon/firewall/nftables/exprs"
"github.com/evilsocket/opensnitch/daemon/log"
"github.com/google/nftables"
"github.com/google/nftables/binaryutil"
"github.com/google/nftables/expr"
"golang.org/x/sys/unix"
)
// QueueDNSResponses redirects DNS responses to us, in order to keep a cache
// of resolved domains.
// This rule must be added in top of the system rules, otherwise it may get bypassed.
// nft insert rule ip filter input udp sport 53 queue num 0 bypass
func (n *Nft) QueueDNSResponses(enable, logError bool) (error, error) {
if n.Conn == nil {
return nil, nil
}
families := []string{exprs.NFT_FAMILY_INET}
for _, fam := range families {
table := n.GetTable(exprs.TABLE_OPENSNITCH, fam)
chain := GetChain(exprs.CHAIN_FILTER_INPUT, table)
if table == nil {
log.Error("QueueDNSResponses() Error getting table: opensnitch-%s", fam)
continue
}
if chain == nil {
log.Error("QueueDNSResponses() Error getting chain: filter_input-%s-%s", table.Name, fam)
continue
}
// nft list ruleset -a
n.Conn.InsertRule(&nftables.Rule{
Position: 0,
Table: table,
Chain: chain,
Exprs: []expr.Any{
&expr.Meta{Key: expr.MetaKeyL4PROTO, Register: 1},
&expr.Cmp{
Op: expr.CmpOpEq,
Register: 1,
Data: []byte{unix.IPPROTO_UDP},
},
&expr.Payload{
DestRegister: 1,
Base: expr.PayloadBaseTransportHeader,
Offset: 0,
Len: 2,
},
&expr.Cmp{
Op: expr.CmpOpEq,
Register: 1,
Data: binaryutil.BigEndian.PutUint16(uint16(53)),
},
&expr.Queue{
Num: n.QueueNum,
Flag: n.getBypassFlag(),
},
},
// rule key, to allow get it later by key
UserData: []byte(InterceptionRuleKey),
})
}
// apply changes
if !n.Commit() {
return fmt.Errorf("Error adding DNS interception rules"), nil
}
return nil, nil
}
// QueueConnections inserts the firewall rule which redirects connections to us.
// Connections are queued until the user denies/accept them, or reaches a timeout.
// This rule must be added at the end of all the other rules, that way we can add
// rules above this one to exclude a service/app from being intercepted.
// nft insert rule ip mangle OUTPUT ct state new queue num 0 bypass
func (n *Nft) QueueConnections(enable, logError bool) (error, error) {
if n.Conn == nil {
return nil, fmt.Errorf("nftables QueueConnections: netlink connection not active")
}
table := n.GetTable(exprs.TABLE_OPENSNITCH, exprs.NFT_FAMILY_INET)
if table == nil {
return nil, fmt.Errorf("QueueConnections() Error getting table opensnitch-inet")
}
chain := GetChain(exprs.CHAIN_MANGLE_OUTPUT, table)
if chain == nil {
return nil, fmt.Errorf("QueueConnections() Error getting outputChain: mangle_output-%s-inet", table.Name)
}
n.Conn.AddRule(&nftables.Rule{
Position: 0,
Table: table,
Chain: chain,
Exprs: []expr.Any{
&expr.Meta{Key: expr.MetaKeyL4PROTO, Register: 1},
&expr.Cmp{
Op: expr.CmpOpNeq,
Register: 1,
Data: []byte{unix.IPPROTO_TCP},
},
&expr.Ct{Register: 1, SourceRegister: false, Key: expr.CtKeySTATE},
&expr.Bitwise{
SourceRegister: 1,
DestRegister: 1,
Len: 4,
Mask: binaryutil.NativeEndian.PutUint32(expr.CtStateBitNEW | expr.CtStateBitRELATED),
Xor: binaryutil.NativeEndian.PutUint32(0),
},
&expr.Cmp{Op: expr.CmpOpNeq, Register: 1, Data: []byte{0, 0, 0, 0}},
&expr.Queue{
Num: n.QueueNum,
Flag: n.getBypassFlag(),
},
},
// rule key, to allow get it later by key
UserData: []byte(InterceptionRuleKey),
})
/* nft --debug=netlink add rule inet mangle output tcp flags '& (fin|syn|rst|ack) == syn' queue bypass num 0
[ meta load l4proto => reg 1 ]
[ cmp eq reg 1 0x00000006 ]
[ payload load 1b @ transport header + 13 => reg 1 ]
[ bitwise reg 1 = ( reg 1 & 0x00000002 ) ^ 0x00000000 ]
[ cmp neq reg 1 0x00000000 ]
[ queue num 0 bypass ]
Intercept packets *only* with the SYN flag set.
Using 'ct state NEW' causes to intercept packets with other flags set, which
sometimes means that we receive outbound connections not in the expected order:
443:1.1.1.1 -> 192.168.123:12345 (bits ACK, ACK+PSH or SYN+ACK set)
*/
n.Conn.AddRule(&nftables.Rule{
Position: 0,
Table: table,
Chain: chain,
Exprs: []expr.Any{
&expr.Meta{Key: expr.MetaKeyL4PROTO, Register: 1},
&expr.Cmp{
Op: expr.CmpOpEq,
Register: 1,
Data: []byte{unix.IPPROTO_TCP},
},
&expr.Payload{
DestRegister: 1,
Base: expr.PayloadBaseTransportHeader,
Offset: 13,
Len: 1,
},
&expr.Bitwise{
DestRegister: 1,
SourceRegister: 1,
Len: 1,
Mask: []byte{0x17},
Xor: []byte{0x00},
},
&expr.Cmp{
Op: expr.CmpOpEq,
Register: 1,
Data: []byte{0x02},
},
&expr.Queue{
Num: n.QueueNum,
Flag: n.getBypassFlag(),
},
},
// rule key, to allow get it later by key
UserData: []byte(InterceptionRuleKey),
})
// apply changes
if !n.Commit() {
return fmt.Errorf("Error adding interception rule "), nil
}
return nil, nil
}
// InsertRule inserts a rule at the top of rules list.
func (n *Nft) InsertRule(chain, table, family string, position uint64, exprs *[]expr.Any) error {
tbl := n.GetTable(table, family)
if tbl == nil {
return fmt.Errorf("%s getting table: %s, %s", logTag, table, family)
}
chainKey := getChainKey(chain, tbl)
chn, chok := sysChains.Load(chainKey)
if !chok {
return fmt.Errorf("%s getting table: %s, %s", logTag, table, family)
}
rule := &nftables.Rule{
Position: position,
Table: tbl,
Chain: chn.(*nftables.Chain),
Exprs: *exprs,
UserData: []byte(SystemRuleKey),
}
n.Conn.InsertRule(rule)
if !n.Commit() {
return fmt.Errorf("rule not added")
}
return nil
}
// AddRule adds a rule to the system.
func (n *Nft) AddRule(chain, table, family string, position uint64, key string, exprs *[]expr.Any) (*nftables.Rule, error) {
tbl := n.GetTable(table, family)
if tbl == nil {
return nil, fmt.Errorf("getting %s table: %s, %s", logTag, table, family)
}
chainKey := getChainKey(chain, tbl)
chn, chok := sysChains.Load(chainKey)
if !chok {
return nil, fmt.Errorf("getting table: %s, %s", table, family)
}
rule := &nftables.Rule{
Position: position,
Table: tbl,
Chain: chn.(*nftables.Chain),
Exprs: *exprs,
UserData: []byte(key),
}
n.Conn.AddRule(rule)
if !n.Commit() {
return nil, fmt.Errorf("adding %s rule", logTag)
}
return rule, nil
}
func (n *Nft) delRulesByKey(key string) error {
chains, err := n.Conn.ListChains()
if err != nil {
return fmt.Errorf("error listing nftables chains (%s): %s", key, err)
}
for _, c := range chains {
rules, err := n.Conn.GetRule(c.Table, c)
if err != nil {
log.Warning("Error listing rules (%s): %s", key, err)
continue
}
delRules := 0
for _, r := range rules {
if string(r.UserData) != key {
continue
}
// just passing the r object doesn't work.
if err := n.Conn.DelRule(&nftables.Rule{
Table: c.Table,
Chain: c,
Handle: r.Handle,
}); err != nil {
log.Warning("[nftables] error deleting rule (%s): %s", key, err)
continue
}
delRules++
}
if delRules > 0 {
if !n.Commit() {
log.Warning("%s error deleting rules: %s", logTag, err)
}
}
if len(rules) == 0 || len(rules) == delRules {
_, chfound := sysChains.Load(getChainKey(c.Name, c.Table))
if chfound {
n.DelChain(c)
}
}
}
return nil
}
// DelInterceptionRules deletes our interception rules, by key.
func (n *Nft) DelInterceptionRules() {
n.delRulesByKey(InterceptionRuleKey)
}