https://wiki.nftables.org/wiki-nftables/index.php/Quick_reference-nftables_in_10_minutes#Counter
210 lines
6.5 KiB
Go
210 lines
6.5 KiB
Go
package nftables
|
|
|
|
import (
|
|
"github.com/evilsocket/opensnitch/daemon/firewall/config"
|
|
"github.com/evilsocket/opensnitch/daemon/firewall/nftables/exprs"
|
|
"github.com/evilsocket/opensnitch/daemon/log"
|
|
"github.com/google/nftables"
|
|
"github.com/google/nftables/expr"
|
|
)
|
|
|
|
// nftables rules are composed of expressions, for example:
|
|
// tcp dport 443 ip daddr 192.168.1.1
|
|
// \-----------/ \------------------/
|
|
// with these format:
|
|
// keyword1<SPACE>keyword2<SPACE>value...
|
|
//
|
|
// here we parse the expression, and based on keyword1, we build the rule with the given options.
|
|
//
|
|
// If the rule has multiple values (tcp dport 80,443,8080), no spaces are allowed,
|
|
// and the separator is a ",", instead of the format { 80, 443, 8080 }
|
|
//
|
|
// In order to debug invalid expressions, or how to build new ones, use the following command:
|
|
// # nft --debug netlink add rule filter output mark set 1
|
|
// ip filter output
|
|
// [ immediate reg 1 0x00000001 ]
|
|
// [ meta set mark with reg 1 ]
|
|
//
|
|
// Debugging added rules:
|
|
// nft --debug netlink list ruleset
|
|
//
|
|
// https://wiki.archlinux.org/title/Nftables#Expressions
|
|
// https://wiki.nftables.org/wiki-nftables/index.php/Building_rules_through_expressions
|
|
func (n *Nft) parseExpression(table, chain, family string, expression *config.Expressions) *[]expr.Any {
|
|
var exprList []expr.Any
|
|
cmpOp := exprs.NewOperator(expression.Statement.Op)
|
|
|
|
switch expression.Statement.Name {
|
|
|
|
case exprs.NFT_CT:
|
|
exprCt := n.buildConntrackRule(expression.Statement.Values, &cmpOp)
|
|
if exprCt == nil {
|
|
log.Warning("%s Ct statement error", logTag)
|
|
return nil
|
|
}
|
|
exprList = append(exprList, *exprCt...)
|
|
|
|
case exprs.NFT_META:
|
|
metaExpr, err := exprs.NewExprMeta(expression.Statement.Values, &cmpOp)
|
|
if err != nil {
|
|
log.Warning("%s meta statement error: %s", logTag, err)
|
|
return nil
|
|
}
|
|
|
|
for _, exprValue := range expression.Statement.Values {
|
|
switch exprValue.Key {
|
|
case exprs.NFT_META_L4PROTO:
|
|
l4rule, err := n.buildL4ProtoRule(table, family, exprValue.Value, &cmpOp)
|
|
if err != nil {
|
|
log.Warning("%s meta.l4proto statement error: %s", logTag, err)
|
|
return nil
|
|
}
|
|
*metaExpr = append(*metaExpr, *l4rule...)
|
|
case exprs.NFT_DPORT, exprs.NFT_SPORT:
|
|
exprPDir, err := exprs.NewExprPortDirection(exprValue.Key)
|
|
if err != nil {
|
|
log.Warning("%s ports statement error: %s", logTag, err)
|
|
return nil
|
|
}
|
|
*metaExpr = append(*metaExpr, []expr.Any{exprPDir}...)
|
|
portsRule, err := n.buildPortsRule(table, family, exprValue.Value, &cmpOp)
|
|
if err != nil {
|
|
log.Warning("%s meta.l4proto.ports statement error: %s", logTag, err)
|
|
return nil
|
|
}
|
|
*metaExpr = append(*metaExpr, *portsRule...)
|
|
}
|
|
}
|
|
return metaExpr
|
|
|
|
case exprs.NFT_ETHER:
|
|
etherExpr, err := exprs.NewExprEther(expression.Statement.Values)
|
|
if err != nil {
|
|
log.Warning("%s ether statement error: %s", logTag, err)
|
|
return nil
|
|
}
|
|
return etherExpr
|
|
|
|
// TODO: support iif, oif
|
|
case exprs.NFT_IIFNAME, exprs.NFT_OIFNAME:
|
|
isOut := expression.Statement.Name == exprs.NFT_OIFNAME
|
|
iface := expression.Statement.Values[0].Key
|
|
if iface == "" {
|
|
log.Warning("%s network interface statement error: %s", logTag, expression.Statement.Name)
|
|
return nil
|
|
}
|
|
exprList = append(exprList, *exprs.NewExprIface(iface, isOut, cmpOp)...)
|
|
|
|
case exprs.NFT_FAMILY_IP, exprs.NFT_FAMILY_IP6:
|
|
exprIP, err := exprs.NewExprIP(family, expression.Statement.Values, cmpOp)
|
|
if err != nil {
|
|
log.Warning("%s addr statement error: %s", logTag, err)
|
|
return nil
|
|
}
|
|
exprList = append(exprList, *exprIP...)
|
|
|
|
case exprs.NFT_PROTO_ICMP, exprs.NFT_PROTO_ICMPv6:
|
|
exprICMP := n.buildICMPRule(table, family, expression.Statement.Name, expression.Statement.Values)
|
|
if exprICMP == nil {
|
|
log.Warning("%s icmp statement error", logTag)
|
|
return nil
|
|
}
|
|
exprList = append(exprList, *exprICMP...)
|
|
|
|
case exprs.NFT_LOG:
|
|
exprLog, err := exprs.NewExprLog(expression.Statement)
|
|
if err != nil {
|
|
log.Warning("%s log statement error", logTag)
|
|
return nil
|
|
}
|
|
exprList = append(exprList, *exprLog...)
|
|
|
|
case exprs.NFT_LIMIT:
|
|
exprLimit, err := exprs.NewExprLimit(expression.Statement)
|
|
if err != nil {
|
|
log.Warning("%s %s", logTag, err)
|
|
return nil
|
|
}
|
|
exprList = append(exprList, *exprLimit...)
|
|
|
|
case exprs.NFT_PROTO_UDP, exprs.NFT_PROTO_TCP, exprs.NFT_PROTO_UDPLITE, exprs.NFT_PROTO_SCTP, exprs.NFT_PROTO_DCCP:
|
|
exprProto, err := exprs.NewExprProtocol(expression.Statement.Name)
|
|
if err != nil {
|
|
log.Warning("%s proto statement error: %s", logTag, err)
|
|
return nil
|
|
}
|
|
exprList = append(exprList, *exprProto...)
|
|
|
|
for _, exprValue := range expression.Statement.Values {
|
|
|
|
switch exprValue.Key {
|
|
case exprs.NFT_DPORT, exprs.NFT_SPORT:
|
|
exprPDir, err := exprs.NewExprPortDirection(exprValue.Key)
|
|
if err != nil {
|
|
log.Warning("%s ports statement error: %s", logTag, err)
|
|
return nil
|
|
}
|
|
exprList = append(exprList, []expr.Any{exprPDir}...)
|
|
portsRule, err := n.buildPortsRule(table, family, exprValue.Value, &cmpOp)
|
|
if err != nil {
|
|
log.Warning("%s proto.ports statement error: %s", logTag, err)
|
|
return nil
|
|
}
|
|
exprList = append(exprList, *portsRule...)
|
|
}
|
|
|
|
}
|
|
|
|
case exprs.NFT_QUOTA:
|
|
exprQuota, err := exprs.NewQuota(expression.Statement.Values)
|
|
if err != nil {
|
|
log.Warning("%s quota statement error: %s", logTag, err)
|
|
return nil
|
|
}
|
|
|
|
exprList = append(exprList, *exprQuota...)
|
|
|
|
case exprs.NFT_NOTRACK:
|
|
exprList = append(exprList, *exprs.NewNoTrack()...)
|
|
|
|
case exprs.NFT_COUNTER:
|
|
tbl := n.GetTable(table, family)
|
|
if tbl == nil {
|
|
log.Warning("%s Error getting table counter: %s, %s, %s", logTag, table, chain, family)
|
|
return nil
|
|
}
|
|
defaultCounterName := "opensnitch"
|
|
counterObj := &nftables.CounterObj{
|
|
Table: tbl,
|
|
Name: defaultCounterName,
|
|
Bytes: 0,
|
|
Packets: 0,
|
|
}
|
|
for _, counterOption := range expression.Statement.Values {
|
|
switch counterOption.Key {
|
|
case exprs.NFT_COUNTER_NAME:
|
|
defaultCounterName = counterOption.Value
|
|
counterObj.Name = defaultCounterName
|
|
case exprs.NFT_COUNTER_BYTES:
|
|
// TODO: allow to set initial bytes/packets?
|
|
counterObj.Bytes = 1
|
|
case exprs.NFT_COUNTER_PACKETS:
|
|
counterObj.Packets = 1
|
|
}
|
|
}
|
|
cntObj := n.Conn.AddObj(counterObj)
|
|
if cntObj == nil {
|
|
log.Warning("Error adding counter %s", defaultCounterName)
|
|
return nil
|
|
}
|
|
if !n.Commit() {
|
|
log.Warning("Error creating counter %s", defaultCounterName)
|
|
return nil
|
|
}
|
|
log.Debug("%s counter %s created (%s, %s, %s)", logTag, defaultCounterName, table, chain, family)
|
|
|
|
exprList = append(exprList, *exprs.NewExprCounter(defaultCounterName)...)
|
|
}
|
|
|
|
return &exprList
|
|
}
|