- Added queue, snat, dnat, redirect, tproxy and masquerade tests. - Return errors if verdict parameters are not formatted as expected.
202 lines
4.8 KiB
Go
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
|
|
}
|