opensnitch/daemon/firewall/nftables/exprs/verdict.go
Gustavo Iñiguez Goia dad8c0c65d
tests: added queue, nat tests
- Added queue, snat, dnat, redirect, tproxy and masquerade tests.
- Return errors if verdict parameters are not formatted as expected.
2023-07-11 00:57:15 +02:00

202 lines
4.8 KiB
Go

package exprs
import (
"strconv"
"strings"
"github.com/evilsocket/opensnitch/daemon/log"
"github.com/google/nftables/expr"
"golang.org/x/sys/unix"
)
// NewExprVerdict constructs a new verdict to apply on connections.
func NewExprVerdict(verdict, parms string) *[]expr.Any {
switch strings.ToLower(verdict) {
case VERDICT_ACCEPT:
return NewExprAccept()
case VERDICT_DROP:
return &[]expr.Any{&expr.Verdict{
Kind: expr.VerdictDrop,
}}
// FIXME: this verdict is not added to nftables
case VERDICT_STOP:
return &[]expr.Any{&expr.Verdict{
Kind: expr.VerdictStop,
}}
case VERDICT_REJECT:
reject := NewExprReject(parms)
return &[]expr.Any{reject}
case VERDICT_RETURN:
return &[]expr.Any{&expr.Verdict{
Kind: expr.VerdictReturn,
}}
case VERDICT_JUMP:
return &[]expr.Any{
&expr.Verdict{
Kind: expr.VerdictKind(unix.NFT_JUMP),
Chain: parms,
},
}
case VERDICT_QUEUE:
queueNum := 0
var err error
p := strings.Split(parms, " ")
if len(p) == 0 {
log.Warning("invalid Queue expr parameters")
return nil
}
// TODO: allow to configure this flag
if p[0] == NFT_QUEUE_NUM {
queueNum, err = strconv.Atoi(p[len(p)-1])
if err != nil {
log.Warning("invalid Queue num: %s", err)
return nil
}
}
return &[]expr.Any{
&expr.Queue{
Num: uint16(queueNum),
Flag: expr.QueueFlagBypass,
}}
case VERDICT_SNAT:
snat := NewExprSNAT()
snat.Random, snat.FullyRandom, snat.Persistent = NewExprNATFlags(parms)
snatExpr := &[]expr.Any{snat}
regAddr, regProto, natParms, err := NewExprNAT(parms, VERDICT_SNAT)
if err != nil {
log.Warning("error adding snat verdict: %s", err)
return nil
}
if regAddr {
snat.RegAddrMin = 1
}
if regProto {
snat.RegProtoMin = 2
}
*snatExpr = append(*natParms, *snatExpr...)
return snatExpr
case VERDICT_DNAT:
dnat := NewExprDNAT()
dnat.Random, dnat.FullyRandom, dnat.Persistent = NewExprNATFlags(parms)
dnatExpr := &[]expr.Any{dnat}
regAddr, regProto, natParms, err := NewExprNAT(parms, VERDICT_DNAT)
if err != nil {
log.Warning("error adding dnat verdict: %s", err)
return nil
}
if regAddr {
dnat.RegAddrMin = 1
}
if regProto {
dnat.RegProtoMin = 2
}
*dnatExpr = append(*natParms, *dnatExpr...)
return dnatExpr
case VERDICT_MASQUERADE:
m := &expr.Masq{}
m.Random, m.FullyRandom, m.Persistent = NewExprNATFlags(parms)
masqExpr := &[]expr.Any{m}
if parms == "" {
return masqExpr
}
// if any of the flag is set to true, toPorts must be false
toPorts := !(m.Random == true || m.FullyRandom == true || m.Persistent == true)
masqExpr = NewExprMasquerade(toPorts, m.Random, m.FullyRandom, m.Persistent)
_, _, natParms, err := NewExprNAT(parms, VERDICT_MASQUERADE)
if err != nil {
log.Warning("error adding masquerade verdict: %s", err)
}
*masqExpr = append(*natParms, *masqExpr...)
return masqExpr
case VERDICT_REDIRECT:
_, _, rewriteParms, err := NewExprNAT(parms, VERDICT_REDIRECT)
if err != nil {
log.Warning("error adding redirect verdict: %s", err)
return nil
}
redirExpr := NewExprRedirect()
*redirExpr = append(*rewriteParms, *redirExpr...)
return redirExpr
case VERDICT_TPROXY:
_, _, rewriteParms, err := NewExprNAT(parms, VERDICT_TPROXY)
if err != nil {
log.Warning("error adding tproxy verdict: %s", err)
return nil
}
tproxyExpr := &[]expr.Any{}
*tproxyExpr = append(*tproxyExpr, *rewriteParms...)
tVerdict := NewExprTproxy()
*tproxyExpr = append(*tproxyExpr, *tVerdict...)
*tproxyExpr = append(*tproxyExpr, *NewExprAccept()...)
return tproxyExpr
}
// target can be empty, "ct set mark" or "log" for example
return &[]expr.Any{}
}
// NewExprAccept creates the accept verdict.
func NewExprAccept() *[]expr.Any {
return &[]expr.Any{&expr.Verdict{
Kind: expr.VerdictAccept,
}}
}
// NewExprReject creates new Reject expression
// icmpx, to reject the IPv4 and IPv6 traffic, icmp for ipv4, icmpv6 for ...
// Ex.: "Target": "reject", "TargetParameters": "with tcp reset"
// https://wiki.nftables.org/wiki-nftables/index.php/Rejecting_traffic
func NewExprReject(parms string) *expr.Reject {
reject := &expr.Reject{}
reject.Code = unix.NFT_REJECT_ICMP_UNREACH
reject.Type = unix.NFT_REJECT_ICMP_UNREACH
parmList := strings.Split(parms, " ")
length := len(parmList)
if length <= 1 {
return reject
}
what := parmList[1]
how := parmList[length-1]
switch what {
case NFT_PROTO_TCP:
reject.Type = unix.NFT_REJECT_TCP_RST
reject.Code = unix.NFT_REJECT_TCP_RST
case NFT_PROTO_ICMP:
reject.Type = unix.NFT_REJECT_ICMP_UNREACH
reject.Code = GetICMPRejectCode(how)
return reject
case NFT_PROTO_ICMPX:
// icmp and icmpv6
reject.Type = unix.NFT_REJECT_ICMPX_UNREACH
reject.Code = GetICMPxRejectCode(how)
return reject
case NFT_PROTO_ICMPv6:
reject.Type = 1
reject.Code = GetICMPv6RejectCode(how)
default:
}
return reject
}