283 lines
7.6 KiB
Go
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)
|
|
}
|