System Grab Bag

Name

Synopsis

nft [ -nNscaeSupyjt ] [ -I directory ] [ -f filename | -i | cmd ...]
nft -h
nft -v

Description

Options

General options:

-h, --help Show help message and all options.

-v, --version Show version.

-V Show long version information, including compile-time configuration.

Ruleset input handling options that specify to how to load rulesets:

-f, --file filename Read input from filename. If filename is -, read from stdin.

-D, --define name=value Define a variable. You can only combine this option with -f.

-i, --interactive Read input from an interactive readline CLI. You can use quit to exit, or use the EOF marker, normally this is CTRL-D.

-I, --includepath directory Add the directory directory to the list of directories to be searched for included files. This option may be specified multiple times.

-c, --check Check commands validity without actually applying the changes.

-o, --optimize Optimize your ruleset. You can combine this option with -c to inspect the proposed optimizations.

Ruleset list output formatting that modify the output of the list ruleset command:

-a, --handle Show object handles in output.

-s, --stateless Omit stateful information of rules and stateful objects.

-t, --terse Omit contents of sets from output.

-S, --service Translate ports to service names as defined by /etc/services.

-N, --reversedns Translate IP address to names via reverse DNS lookup. This may slow down your listing since it generates network traffic.

-u, --guid Translate numeric UID/GID to names as defined by /etc/passwd and /etc/group.

-n, --numeric Print fully numerical output.

-y, --numeric-priority Display base chain priority numerically.

-p, --numeric-protocol Display layer 4 protocol numerically.

-T, --numeric-time Show time, day and hour values in numeric format.

Command output formatting:

-e, --echo When inserting items into the ruleset using add, insert or replace commands, print notifications just like nft monitor.

-j, --json Format output in JSON. See libnftables-json(5) for a schema description.

-d, --debug level Enable debugging output. The debug level can be any of scanner, parser, eval, netlink, mnl, proto-ctx, segtree, all. You can combine more than one by separating by the , symbol, for example -d eval,mnl.

Input File Formats

Lexical Conventions

Include Files

include filename

Symbolic Variables

define variable = expr
undefine variable
redefine variable = expr
$variable

Using symbolic variables.

define int_if1 = eth0
define int_if2 = eth1
define int_ifs = { $int_if1, $int_if2 }
redefine int_if2 = wlan0
undefine int_if2

filter input iif $int_ifs accept

Address Families

Ipv4/Ipv6/Inet Address Families

Arp Address Family

Bridge Address Family

Netdev Address Family

Ruleset

{list | flush} ruleset [family]

Tables

{add | create} table [family] table [ {comment comment ;} { flags \*(Aqflags ; }]
{delete | list | flush} table [family] table
list tables [family]
delete table [family] handle handle

Add, change, delete a table.

# start nft in interactive mode
nft --interactive

# create a new table.
create table inet mytable

# add a new base chain: get input packets
add chain inet mytable myin { type filter hook input priority filter; }

# add a single counter to the chain
add rule inet mytable myin counter

# disable the table temporarily -- rules are not evaluated anymore
add table inet mytable { flags dormant; }

# make table active again:
add table inet mytable

Chains

{add | create} chain [family] table chain [{ type type hook hook [device device] priority priority ; [policy policy ;] [comment comment ;] }]
{delete | list | flush} chain [\*(Aqfamily] table chain
list chains [family]
delete chain [family] table handle handle
rename chain [family] table chain newname

The netdev family supports merely two combinations, namely filter type with ingress hook and filter type with egress hook. Base chains in this family also require the device parameter to be present since they exist per interface only. \h'-04'\(bu\h'+03'\c

The arp family supports only the input and output hooks, both in chains of type filter. \h'-04'\(bu\h'+03'\c

The inet family also supports the ingress hook (since Linux kernel 5.10), to filter IPv4 and IPv6 packet at the same location as the netdev ingress hook. This inet hook allows you to share sets and maps between the usual prerouting, input, forward, output, postrouting and this ingress hook. The priority parameter accepts a signed integer value or a standard priority name which specifies the order in which chains with the same hook value are traversed. The ordering is ascending, i.e. lower priority values have precedence over higher ones. Standard priority values can be replaced with easily memorizable names. Not all names make sense in every family with every hook (see the compatibility matrices below) but their numerical value can still be used for prioritizing chains. These names and values are defined and made available based on what priorities are used by xtables when registering their default chains. Most of the families use the same values, but bridge uses different ones from the others. See the following tables that describe the values and compatibility. Table\ \&6.\ \&Standard priority names, family and hook compatibility matrix

Rules

{add | insert} rule [family] table chain [handle handle | index index] statement ... [comment comment]
replace rule [family] table chain handle handle statement ... [comment comment]
delete rule [family] table chain handle handle

add a rule to ip table output chain.

nft add rule filter output ip daddr 192.168.0.0/24 accept # \*(Aqip filter\*(Aq is assumed
# same command, slightly more verbose
nft add rule ip filter output ip daddr 192.168.0.0/24 accept

delete rule from inet table.

# nft -a list ruleset
table inet filter {
        chain input {
                type filter hook input priority filter; policy accept;
                ct state established,related accept # handle 4
                ip saddr 10.1.1.1 tcp dport ssh accept # handle 5
          ...
# delete the rule with handle 5
nft delete rule inet filter input handle 5

Sets

Using anonymous sets to accept particular subnets and ports.

nft add rule filter input ip saddr { 10.0.0.0/8, 192.168.0.0/16 } tcp dport { 22, 443 } accept

Using named sets to accept addresses and ports.

nft add rule filter input ip saddr @allowed_hosts tcp dport @allowed_ports accept

add set [family] table set { type type | typeof expression ; [flags flags ;] [timeout timeout ;] [gc-interval gc-interval ;] [elements = { element[, ...] } ;] [size size ;] [comment comment ;] [policy \*(Aqpolicy ;] [auto-merge ;] }
{delete | list | flush} set [family] table set
list sets [family]
delete set [family] table handle handle
{add | delete} element [family] table set { element[, ...] }

Maps

add map [family] table map { type type | typeof expression [flags flags ;] [elements = { element[, ...] } ;] [size size ;] [comment comment ;] [policy \*(Aqpolicy ;] }
{delete | list | flush} map [family] table map
list maps [family]

Elements

{add | create | delete | get } element [family] table set { ELEMENT[, ...] }

ELEMENT := key_expression OPTIONS [: value_expression]
OPTIONS := [timeout TIMESPEC] [expires TIMESPEC] [comment string]
TIMESPEC := [numd][numh][numm][num[s]]

Flowtables

{add | create} flowtable [family] table flowtable { hook hook priority priority ; devices = { device[, ...] } ; }
list flowtables [family]
{delete | list} flowtable [family] table flowtable
delete flowtable [family] table handle handle

Listing

list { secmarks | synproxys | flow tables | meters | hooks } [family]
list { secmarks | synproxys | flow tables | meters | hooks } table [family] table
list ct { timeout | expectation | helper | helpers } table [family] table

Stateful Objects

{add | delete | list | reset} type [family] table object
delete type [family] table handle handle
list counters [family]
list quotas [family]
list limits [family]

Ct Helper

add ct helper [family] table name { type type protocol protocol ; [l3proto family ;] }
delete ct helper [family] table name
list ct helpers

defining and assigning ftp helper.

Unlike iptables, helper assignment needs to be performed after the conntrack
lookup has completed, for example with the default 0 hook priority.

table inet myhelpers {
  ct helper ftp-standard {
     type "ftp" protocol tcp
  }
  chain prerouting {
      type filter hook prerouting priority filter;
      tcp dport 21 ct helper set "ftp-standard"
  }
}

Ct Timeout

add ct timeout  [family] table name { protocol protocol ; policy = { state: value [, ...] } ; [l3proto family ;] }
delete ct timeout [family] table name
list ct timeouts

defining and assigning ct timeout policy.

table ip filter {
        ct timeout customtimeout {
                protocol tcp;
                l3proto ip
                policy = { established: 120, close: 20 }
        }

        chain output {
                type filter hook output priority filter; policy accept;
                ct timeout set "customtimeout"
        }
}

testing the updated timeout policy.

% conntrack -E

It should display:

[UPDATE] tcp      6 120 ESTABLISHED src=172.16.19.128 dst=172.16.19.1
sport=22 dport=41360 [UNREPLIED] src=172.16.19.1 dst=172.16.19.128
sport=41360 dport=22

Ct Expectation

add ct expectation  [family] table name { protocol protocol ; dport dport ; timeout timeout ; size size ; [*l3proto family ;] }
delete ct expectation  [family] table name
list ct expectations

defining and assigning ct expectation policy.

table ip filter {
        ct expectation expect {
                protocol udp
                dport 9876
                timeout 2m
                size 8
                l3proto ip
        }

        chain input {
                type filter hook input priority filter; policy accept;
                ct expectation set "expect"
        }
}

Counter

add counter [family] table name [{ [ packets packets bytes bytes ; ] [ comment comment ; }]
delete counter [family] table name
list counters

Using named counters.

nft add counter filter http
nft add rule filter input tcp dport 80 counter name \e"http\e"

Using named counters with maps.

nft add counter filter http
nft add counter filter https
nft add rule filter input counter name tcp dport map { 80 : \e"http\e", 443 : \e"https\e" }

Quota

add quota [family] table name { [over|until] bytes BYTE_UNIT [ used bytes BYTE_UNIT ] ; [ comment comment ; ] }
BYTE_UNIT := bytes | kbytes | mbytes
delete quota [family] table name
list quotas

Using named quotas.

nft add quota filter user123 { over 20 mbytes }
nft add rule filter input ip saddr 192.168.10.123 quota name \e"user123\e"

Using named quotas with maps.

nft add quota filter user123 { over 20 mbytes }
nft add quota filter user124 { over 20 mbytes }
nft add rule filter input quota name ip saddr map { 192.168.10.123 : \e"user123\e", 192.168.10.124 : \e"user124\e" }

Expressions

Describe Command

describe expression | data type

The describe command.

$ nft describe tcp flags
payload expression, datatype tcp_flag (TCP flag) (basetype bitmask, integer), 8 bits

predefined symbolic constants:
fin                           0x01
syn                           0x02
rst                           0x04
psh                           0x08
ack                           0x10
urg                           0x20
ecn                           0x40
cwr                           0x80

Data Types

$ nft describe ct_state
datatype ct_state (conntrack state) (basetype bitmask, integer), 32 bits

pre-defined symbolic constants (in hexadecimal):
invalid                         0x00000001
new ...

Integer Type

Bitmask Type

String Type

String specification.

# Interface name
filter input iifname eth0

# Weird interface name
filter input iifname "(eth0)"

Link Layer Address Type

Link layer address specification.

# Ethernet destination MAC address
filter input ether daddr 20:c9:d0:43:12:d9

Ipv4 Address Type

IPv4 address specification.

# dotted decimal notation
filter output ip daddr 127.0.0.1

# host name
filter output ip daddr localhost

Ipv6 Address Type

IPv6 address specification.

# abbreviated loopback address
filter output ip6 daddr ::1

IPv6 address specification with bracket notation.

# without [] the port number (22) would be parsed as part of the
# ipv6 address
ip6 nat prerouting tcp dport 2222 dnat to [1ce::d0]:22

Boolean Type

Boolean specification.

# match if route exists
filter input fib daddr . iif oif exists

# match only non-fragmented packets in IPv6 traffic
filter input exthdr frag missing

# match if TCP timestamp option is present
filter input tcp option timestamp exists

Icmp Type Type

ICMP Type specification.

# match ping packets
filter output icmp type { echo-request, echo-reply }

Icmp Code Type

Icmpv6 Type Type

ICMPv6 Type specification.

# match ICMPv6 ping packets
filter output icmpv6 type { echo-request, echo-reply }

Icmpv6 Code Type

Icmpvx Code Type

Conntrack Types

Dccp Pkttype Type

Primary Expressions

Meta Expressions

meta {length | nfproto | l4proto | protocol | priority}
[meta] {mark | iif | iifname | iiftype | oif | oifname | oiftype | skuid | skgid | nftrace | rtclassid | ibrname | obrname | pkttype | cpu | iifgroup | oifgroup | cgroup | random | ipsec | iifkind | oifkind | time | hour | day }

filter input meta iif "foo"

Using meta expressions.

# qualified meta expression
filter output meta oif eth0
filter forward meta iifkind { "tun", "veth" }

# unqualified meta expression
filter output oif eth0

# incoming packet was subject to ipsec processing
raw prerouting meta ipsec exists accept

Socket Expression

socket {transparent | mark | wildcard}
socket cgroupv2 level NUM

Using socket expression.

# Mark packets that correspond to a transparent socket. "socket wildcard 0"
# means that zero-bound listener sockets are NOT matched (which is usually
# exactly what you want).
table inet x {
    chain y {
        type filter hook prerouting priority mangle; policy accept;
        socket transparent 1 socket wildcard 0 mark set 0x00000001 accept
    }
}

# Trace packets that corresponds to a socket with a mark value of 15
table inet x {
    chain y {
        type filter hook prerouting priority mangle; policy accept;
        socket mark 0x0000000f nftrace set 1
    }
}

# Set packet mark to socket mark
table inet x {
    chain y {
        type filter hook prerouting priority mangle; policy accept;
        tcp dport 8080 mark set socket mark
    }
}

# Count packets for cgroupv2 "user.slice" at level 1
table inet x {
    chain y {
        type filter hook input priority filter; policy accept;
        socket cgroupv2 level 1 "user.slice" counter
    }
}

Osf Expression

osf [ttl {loose | skip}] {name | version}

Available ttl values.

If no TTL attribute is passed, make a true IP header and fingerprint TTL true comparison. This generally works for LANs.

* loose: Check if the IP header\*(Aqs TTL is less than the fingerprint one. Works for globally-routable addresses.
* skip: Do not compare the TTL at all.

Using osf expression.

# Accept packets that match the "Linux" OS genre signature without comparing TTL.
table inet x {
    chain y {
        type filter hook input priority filter; policy accept;
        osf ttl skip name "Linux"
    }
}

Fib Expressions

fib {saddr | daddr | mark | iif | oif} [. ...] {oif | oifname | type}

Using fib expressions.

# drop packets without a reverse path
filter prerouting fib saddr . iif oif missing drop

In this example, \*(Aqsaddr . iif\*(Aq looks up routing information based on the source address and the input interface.
oif picks the output interface index from the routing information.
If no route was found for the source address/input interface combination, the output interface index is zero.
In case the input interface is specified as part of the input key, the output interface index is always the same as the input interface index or zero.
If only \*(Aqsaddr oif\*(Aq is given, then oif can be any interface index or zero.

# drop packets to address not configured on incoming interface
filter prerouting fib daddr . iif type != { local, broadcast, multicast } drop

# perform lookup in a specific \*(Aqblackhole\*(Aq table (0xdead, needs ip appropriate ip rule)
filter prerouting meta mark set 0xdead fib daddr . mark type vmap { blackhole : drop, prohibit : jump prohibited, unreachable : drop }

Routing Expressions

rt [ip | ip6] {classid | nexthop | mtu | ipsec}

Using routing expressions.

# IP family independent rt expression
filter output rt classid 10

# IP family dependent rt expressions
ip filter output rt nexthop 192.168.0.1
ip6 filter output rt nexthop fd00::1
inet filter output rt ip nexthop 192.168.0.1
inet filter output rt ip6 nexthop fd00::1

# outgoing packet will be encapsulated/encrypted by ipsec
filter output rt ipsec exists

Ipsec Expressions

ipsec {in | out} [ spnum NUM ]  {reqid | spi}
ipsec {in | out} [ spnum NUM ]  {ip | ip6} {saddr | daddr}

Numgen Expression

numgen {inc | random} mod NUM [ offset NUM ]

Using numgen expression.

# round-robin between 192.168.10.100 and 192.168.20.200:
add rule nat prerouting dnat to numgen inc mod 2 map \e
        { 0 : 192.168.10.100, 1 : 192.168.20.200 }

# probability-based with odd bias using intervals:
add rule nat prerouting dnat to numgen random mod 10 map \e
        { 0-2 : 192.168.10.100, 3-9 : 192.168.20.200 }

Hash Expressions

jhash {ip saddr | ip6 daddr | tcp dport | udp sport | ether saddr} [. ...] mod NUM [ seed NUM ] [ offset NUM ]
symhash mod NUM [ offset NUM ]

Using hash expressions.

# load balance based on source ip between 2 ip addresses:
add rule nat prerouting dnat to jhash ip saddr mod 2 map \e
        { 0 : 192.168.10.100, 1 : 192.168.20.200 }

# symmetric load balancing between 2 ip addresses:
add rule nat prerouting dnat to symhash mod 2 map \e
        { 0 : 192.168.10.100, 1 : 192.168.20.200 }

Payload Expressions

Ethernet Header Expression

ether {daddr | saddr | type}

Vlan Header Expression

vlan {id | dei | pcp | type}

Arp Header Expression

arp {htype | ptype | hlen | plen | operation | saddr { ip | ether } | daddr { ip | ether }

Ipv4 Header Expression

ip {version | hdrlength | dscp | ecn | length | id | frag-off | ttl | protocol | checksum | saddr | daddr }

Icmp Header Expression

icmp {type | code | checksum | id | sequence | gateway | mtu}

Igmp Header Expression

igmp {type | mrt | checksum | group}

Ipv6 Header Expression

ip6 {version | dscp | ecn | flowlabel | length | nexthdr | hoplimit | saddr | daddr}

Using ip6 header expressions.

# matching if first extension header indicates a fragment
ip6 nexthdr ipv6-frag

Icmpv6 Header Expression

icmpv6 {type | code | checksum | parameter-problem | packet-too-big | id | sequence | max-delay}

Tcp Header Expression

tcp {sport | dport | sequence | ackseq | doff | reserved | flags | window | checksum | urgptr}

Udp Header Expression

udp {sport | dport | length | checksum}

Udp-Lite Header Expression

udplite {sport | dport | checksum}

Sctp Header Expression

sctp {sport | dport | vtag | checksum}
sctp chunk CHUNK [ FIELD ]

CHUNK := data | init | init-ack | sack | heartbeat |
           heartbeat-ack | abort | shutdown | shutdown-ack | error |
           cookie-echo | cookie-ack | ecne | cwr | shutdown-complete
           | asconf-ack | forward-tsn | asconf

FIELD := COMMON_FIELD | DATA_FIELD | INIT_FIELD | INIT_ACK_FIELD |
           SACK_FIELD | SHUTDOWN_FIELD | ECNE_FIELD | CWR_FIELD |
           ASCONF_ACK_FIELD | FORWARD_TSN_FIELD | ASCONF_FIELD

COMMON_FIELD := type | flags | length
DATA_FIELD := tsn | stream | ssn | ppid
INIT_FIELD := init-tag | a-rwnd | num-outbound-streams |
                num-inbound-streams | initial-tsn
INIT_ACK_FIELD := INIT_FIELD
SACK_FIELD := cum-tsn-ack | a-rwnd | num-gap-ack-blocks |
                num-dup-tsns
SHUTDOWN_FIELD := cum-tsn-ack
ECNE_FIELD := lowest-tsn
CWR_FIELD := lowest-tsn
ASCONF_ACK_FIELD := seqno
FORWARD_TSN_FIELD := new-cum-tsn
ASCONF_FIELD := seqno

Dccp Header Expression

dccp {sport | dport | type}

Authentication Header Expression

ah {nexthdr | hdrlength | reserved | spi | sequence}

Encrypted Security Payload Header Expression

esp {spi | sequence}

Ipcomp Header Expression

Raw Payload Expression

@base,offset,length

Matching destination port of both UDP and TCP.

inet filter input meta l4proto {tcp, udp} @th,16,16 { 53, 80 }

inet filter input meta l4proto {tcp, udp} th dport { 53, 80 }

Rewrite arp packet target hardware address if target protocol address matches a given address.

input meta iifname enp2s0 arp ptype 0x0800 arp htype 1 arp hlen 6 arp plen 4 @nh,192,32 0xc0a88f10 @nh,144,48 set 0x112233445566 accept

Extension Header Expressions

hbh {nexthdr | hdrlength}
frag {nexthdr | frag-off | more-fragments | id}
rt {nexthdr | hdrlength | type | seg-left}
dst {nexthdr | hdrlength}
mh {nexthdr | hdrlength | checksum | type}
srh {flags | tag | sid | seg-left}
tcp option {eol | nop | maxseg | window | sack-perm | sack | sack0 | sack1 | sack2 | sack3 | timestamp} tcp_option_field
ip option { lsrr | ra | rr | ssrr } ip_option_field

exthdr {hbh | frag | rt | dst | mh}
tcp option {eol | nop | maxseg | window | sack-perm | sack | sack0 | sack1 | sack2 | sack3 | timestamp}
ip option { lsrr | ra | rr | ssrr }

tcp option

tcp option @number,offset,length

finding TCP options.

filter input tcp option sack-perm exists counter

matching TCP options.

filter input tcp option maxseg size lt 536

matching IPv6 exthdr.

ip6 filter input frag more-fragments 1 counter

finding IP option.

filter input ip option lsrr exists counter

Conntrack Expressions

ct {state | direction | status | mark | expiration | helper | label | count | id}
ct [original | reply] {l3proto | protocol | bytes | packets | avgpkt | zone}
ct {original | reply} {proto-src | proto-dst}
ct {original | reply} {ip | ip6} {saddr | daddr}

restrict the number of parallel connections to a server.

nft add set filter ssh_flood \*(Aq{ type ipv4_addr; flags dynamic; }\*(Aq
nft add rule filter input tcp dport 22 add @ssh_flood \*(Aq{ ip saddr ct count over 2 }\*(Aq reject

Statements

Verdict Statement

{accept | drop | queue | continue | return}
{jump | goto} chain

Using verdict statements.

# process packets from eth0 and the internal network in from_lan
# chain, drop all packets from eth0 with different source addresses.

filter input iif eth0 ip saddr 192.168.0.0/24 jump from_lan
filter input iif eth0 drop

Payload Statement

payload_expression set value

route some packets instead of bridging.

# redirect tcp:http from 192.160.0.0/16 to local machine for routing instead of bridging
# assumes 00:11:22:33:44:55 is local MAC address.
bridge input meta iif eth0 ip saddr 192.168.0.0/16 tcp dport 80 meta pkttype set unicast ether daddr set 00:11:22:33:44:55

Set IPv4 DSCP header field.

ip forward ip dscp set 42

Extension Header Statement

extension_header_expression set value

change tcp mss.

tcp flags syn tcp option maxseg size set 1360
# set a size based on route information:
tcp flags syn tcp option maxseg size set rt mtu

remove tcp option.

tcp flags syn reset tcp option sack-perm

Log Statement

log [prefix quoted_string] [level syslog-level] [flags log-flags]
log group nflog_group [prefix quoted_string] [queue-threshold value] [snaplen size]
log level audit

Using log statement.

# log the UID which generated the packet and ip options
ip filter output log flags skuid flags ip options

# log the tcp sequence numbers and tcp options from the TCP packet
ip filter output log flags tcp sequence,options

# enable all supported log flags
ip6 filter output log flags all

Reject Statement

reject [ with REJECT_WITH ]

REJECT_WITH := icmp icmp_code |
                 icmpv6 icmpv6_code |
                 icmpx icmpx_code |
                 tcp reset

Counter Statement

counter packets number bytes number
counter { packets number | bytes number }

Conntrack Statement

ct {mark | event | label | zone} set value

save packet nfmark in conntrack.

ct mark set meta mark

set zone mapped via interface.

table inet raw {
  chain prerouting {
      type filter hook prerouting priority raw;
      ct zone set iif map { "eth1" : 1, "veth1" : 2 }
  }
  chain output {
      type filter hook output priority raw;
      ct zone set oif map { "eth1" : 1, "veth1" : 2 }
  }
}

restrict events reported by ctnetlink.

ct event set new,related,destroy

Notrack Statement

notrack

Meta Statement

meta {mark | priority | pkttype | nftrace} set value

Limit Statement

limit rate [over] packet_number / TIME_UNIT [burst packet_number packets]
limit rate [over] byte_number BYTE_UNIT / TIME_UNIT [burst byte_number BYTE_UNIT]

TIME_UNIT := second | minute | hour | day
BYTE_UNIT := bytes | kbytes | mbytes

Nat Statements

snat [[ip | ip6] to] ADDR_SPEC [:PORT_SPEC] [FLAGS]
dnat [[ip | ip6] to] ADDR_SPEC [:PORT_SPEC] [FLAGS]
masquerade [to :PORT_SPEC] [FLAGS]
redirect [to :PORT_SPEC] [FLAGS]

ADDR_SPEC := address | address - address
PORT_SPEC := port | port - port

FLAGS  := FLAG [, FLAGS]
FLAG  := persistent | random | fully-random

Using NAT statements.

# create a suitable table/chain setup for all further examples
add table nat
add chain nat prerouting { type nat hook prerouting priority dstnat; }
add chain nat postrouting { type nat hook postrouting priority srcnat; }

# translate source addresses of all packets leaving via eth0 to address 1.2.3.4
add rule nat postrouting oif eth0 snat to 1.2.3.4

# redirect all traffic entering via eth0 to destination address 192.168.1.120
add rule nat prerouting iif eth0 dnat to 192.168.1.120

# translate source addresses of all packets leaving via eth0 to whatever
# locally generated packets would use as source to reach the same destination
add rule nat postrouting oif eth0 masquerade

# redirect incoming TCP traffic for port 22 to port 2222
add rule nat prerouting tcp dport 22 redirect to :2222

# inet family:
# handle ip dnat:
add rule inet nat prerouting dnat ip to 10.0.2.99
# handle ip6 dnat:
add rule inet nat prerouting dnat ip6 to fe80::dead
# this masquerades both ipv4 and ipv6:
add rule inet nat postrouting meta oif ppp0 masquerade

Tproxy Statement

tproxy to address:port
tproxy to {address | :port}

tproxy {ip | ip6} to address[:port]
tproxy to :port

Example ruleset for tproxy statement.

table ip x {
    chain y {
        type filter hook prerouting priority mangle; policy accept;
        tcp dport ntp tproxy to 1.1.1.1
        udp dport ssh tproxy to :2222
    }
}
table ip6 x {
    chain y {
       type filter hook prerouting priority mangle; policy accept;
       tcp dport ntp tproxy to [dead::beef]
       udp dport ssh tproxy to :2222
    }
}
table inet x {
    chain y {
        type filter hook prerouting priority mangle; policy accept;
        tcp dport 321 tproxy to :ssh
        tcp dport 99 tproxy ip to 1.1.1.1:999
        udp dport 155 tproxy ip6 to [dead::beef]:smux
    }
}

Synproxy Statement

synproxy [mss mss_value] [wscale wscale_value] [SYNPROXY_FLAGS]

Example ruleset for synproxy statement.

Determine tcp options used by backend, from an external system

              tcpdump -pni eth0 -c 1 \*(Aqtcp[tcpflags] == (tcp-syn|tcp-ack)\*(Aq
                  port 80 &
              telnet 192.0.2.42 80
              18:57:24.693307 IP 192.0.2.42.80 > 192.0.2.43.48757:
                  Flags [S.], seq 360414582, ack 788841994, win 14480,
                  options [mss 1460,sackOK,
                  TS val 1409056151 ecr 9690221,
                  nop,wscale 9],
                  length 0

Switch tcp_loose mode off, so conntrack will mark out-of-flow packets as state INVALID.

              echo 0 > /proc/sys/net/netfilter/nf_conntrack_tcp_loose

Make SYN packets untracked.

        table ip x {
                chain y {
                        type filter hook prerouting priority raw; policy accept;
                        tcp flags syn notrack
                }
        }

Catch UNTRACKED (SYN  packets) and INVALID (3WHS ACK packets) states and send
them to SYNPROXY. This rule will respond to SYN packets with SYN+ACK
syncookies, create ESTABLISHED for valid client response (3WHS ACK packets) and
drop incorrect cookies. Flags combinations not expected during  3WHS will not
match and continue (e.g. SYN+FIN, SYN+ACK). Finally, drop invalid packets, this
will be out-of-flow packets that were not matched by SYNPROXY.

    table ip x {
            chain z {
                    type filter hook input priority filter; policy accept;
                    ct state invalid, untracked synproxy mss 1460 wscale 9 timestamp sack-perm
                    ct state invalid drop
            }
    }

Flow Statement

Queue Statement

queue [flags QUEUE_FLAGS] [to queue_number]
queue [flags QUEUE_FLAGS] [to queue_number_from - queue_number_to]
queue [flags QUEUE_FLAGS] [to QUEUE_EXPRESSION ]

QUEUE_FLAGS := QUEUE_FLAG [, QUEUE_FLAGS]
QUEUE_FLAG  := bypass | fanout
QUEUE_EXPRESSION := numgen | hash | symhash | MAP STATEMENT

Dup Statement

dup to device
dup to address device device

Using the dup statement.

# send to machine with ip address 10.2.3.4 on eth0
ip filter forward dup to 10.2.3.4 device "eth0"

# copy raw frame to another interface
netdev ingress dup to "eth0"
dup to "eth0"

# combine with map dst addr to gateways
dup to ip daddr map { 192.168.7.1 : "eth0", 192.168.7.2 : "eth1" }

Fwd Statement

Set Statement

{add | update} @setname { expression [timeout timeout] [comment string] }

Example for simple blacklist.

# declare a set, bound to table "filter", in family "ip".
# Timeout and size are mandatory because we will add elements from packet path.
# Entries will timeout after one minute, after which they might be
# re-added if limit condition persists.
nft add set ip filter blackhole \e
    "{ type ipv4_addr; flags dynamic; timeout 1m; size 65536; }"

# declare a set to store the limit per saddr.
# This must be separate from blackhole since the timeout is different
nft add set ip filter flood \e
    "{ type ipv4_addr; flags dynamic; timeout 10s; size 128000; }"

# whitelist internal interface.
nft add rule ip filter input meta iifname "internal" accept

# drop packets coming from blacklisted ip addresses.
nft add rule ip filter input ip saddr @blackhole counter drop

# add source ip addresses to the blacklist if more than 10 tcp connection
# requests occurred per second and ip address.
nft add rule ip filter input tcp flags syn tcp dport ssh \e
    add @flood { ip saddr limit rate over 10/second } \e
    add @blackhole { ip saddr } \e
    drop

# inspect state of the sets.
nft list set ip filter flood
nft list set ip filter blackhole

# manually add two addresses to the blackhole.
nft add element filter blackhole { 10.2.3.4, 10.23.1.42 }

Map Statement

expression map { MAP_ELEMENTS }

MAP_ELEMENTS := MAP_ELEMENT [, MAP_ELEMENTS]
MAP_ELEMENT  := key : value

Using the map statement.

# select DNAT target based on TCP dport:
# connections to port 80 are redirected to 192.168.1.100,
# connections to port 8888 are redirected to 192.168.1.101
nft add rule ip nat prerouting dnat tcp dport map { 80 : 192.168.1.100, 8888 : 192.168.1.101 }

# source address based SNAT:
# packets from net 192.168.1.0/24 will appear as originating from 10.0.0.1,
# packets from net 192.168.2.0/24 will appear as originating from 10.0.0.2
nft add rule ip nat postrouting snat to ip saddr map { 192.168.1.0/24 : 10.0.0.1, 192.168.2.0/24 : 10.0.0.2 }

Vmap Statement

expression vmap { VMAP_ELEMENTS }

VMAP_ELEMENTS := VMAP_ELEMENT [, VMAP_ELEMENTS]
VMAP_ELEMENT  := key : verdict

Using the vmap statement.

# jump to different chains depending on layer 4 protocol type:
nft add rule ip filter input ip protocol vmap { tcp : jump tcp-chain, udp : jump udp-chain , icmp : jump icmp-chain }

Additional Commands

Monitor

monitor [new | destroy] MONITOR_OBJECT
monitor trace

MONITOR_OBJECT := tables | chains | sets | rules | elements | ruleset

Listen to all events, report in native nft format.

% nft monitor

Listen to deleted rules, report in JSON format.

% nft -j monitor destroy rules

Listen to both new and destroyed chains, in native nft format.

% nft monitor chains

Listen to ruleset events such as table, chain, rule, set, counters and quotas, in native nft format.

% nft monitor ruleset

Trace incoming packets from host 10.0.0.1.

% nft add rule filter input ip saddr 10.0.0.1 meta nftrace set 1
% nft monitor trace

Error Reporting

Error caused by single incorrect expression.

<cmdline>:1:19-22: Error: Interface does not exist
filter output oif eth0
                  ^^^^

Error caused by invalid combination of two expressions.

<cmdline>:1:28-36: Error: Right hand side of relational expression (==) must be constant
filter output tcp dport == tcp dport
                        ~~ ^^^^^^^^^

Error returned by the kernel.

<cmdline>:0:0-23: Error: Could not process rule: Operation not permitted
filter output oif wlan0
^^^^^^^^^^^^^^^^^^^^^^^

Exit Status

See Also

libnftables(3), libnftables-json(5), iptables(8), ip6tables(8), arptables(8), ebtables(8), ip(8), tc(8)

Authors

Copyright