man nftables traduction japonaise

Traduction japonaise du manuel affiché par `` man nftables ''.

Nom

Outil de gestion du framework nft-Nftables pour le filtrage et la classification des paquets

Aperçu

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

La description

nft est un outil de ligne de commande utilisé par le noyau Linux du framework nftables pour définir, gérer et inspecter les règles de filtrage et de classification des paquets. Le sous-système du noyau Linux est connu sous le nom de nf_tables, où nf '' signifie Netfilter ''.

option

Exécutez nft --help pour voir un résumé complet des options.

• -h, -help Afficher les messages d'aide et toutes les options.
• -v, -version Montrez la version.
• -n, -numeric Affichez les données numériquement. Une fois spécifiée (comportement par défaut), la conversion de nom d'adresse en symbole est ignorée. Spécifiez deux fois pour afficher le service Internet (numéro de port) numériquement. Spécifiez trois fois pour afficher le protocole et l'UID / GID numériquement.
• -N, -reversedns Convertissez l'adresse IP en nom. Les recherches DNS nécessitent généralement du trafic réseau.
• -s, -stateless Omet les informations d'état pour les règles et les objets avec état.
• -c, -check Vérifiez la validité de la commande sans appliquer réellement les modifications.
• -a, -handle Affiche la poignée de l'objet dans la sortie.
• -e, -echo Affichez des notifications similaires aux moniteurs nft lors de l'insertion d'éléments dans un ensemble de règles à l'aide des commandes d'ajout, d'insertion et de remplacement.
• -I, -includepath directory Ajoute le répertoire spécifié dans le répertoire d'arguments à la liste des répertoires dans lesquels rechercher les fichiers d'inclusion. Cette option peut être spécifiée plusieurs fois.
• -f、-file filename Lisez l'entrée à partir du nom du fichier. Si le nom du fichier est - '', lire à partir de l'entrée standard. Le script nft doit commencer par #! / Usr / sbin / nft -f ''.
• -i, -interactive Lit l'entrée de la CLI readline interactive. Vous pouvez quitter avec quit ou utiliser le marqueur EOF. Le marqueur EOF est généralement CTRL-D.

Format de fichier d'entrée

Convention de langue

L'entrée est analysée ligne par ligne. Si le dernier caractère sur une ligne (immédiatement avant le caractère de saut de ligne) est une barre oblique inverse ( \ '') sans guillemets, la ligne suivante est traitée comme une continuation. Plusieurs commandes sur la même ligne peuvent être séparées à l'aide d'un point-virgule (; '').

Le symbole dièse (`` # '') démarre le commentaire. Tous les caractères suivants sur la même ligne sont ignorés.

Les identificateurs commencent par un caractère alphabétique (az, AZ), avec zéro ou plusieurs caractères alphanumériques (az, AZ, 0-9), une barre oblique (/), une barre oblique inverse (\ '') et un trait de soulignement ( Il est suivi des caractères _ '') et des points (. ''). Les identificateurs qui utilisent des caractères différents ou sont en conflit avec des mots-clés doivent être placés entre guillemets ( " ).

Lire le fichier

Vous pouvez utiliser l'instruction include pour lire d'autres fichiers. Le répertoire dans lequel rechercher les fichiers d'inclusion peut être spécifié à l'aide de l'option -I / --includepath ''. Pour remplacer ce comportement, préfixez le chemin avec. / '' Pour forcer les fichiers dans le répertoire de travail actuel (c'est-à-dire les chemins relatifs) à être inclus, ou utilisez le chemin absolu `` / ''. Spécifie l'emplacement du fichier représenté.

Si -I / --includepath n'est pas spécifié, nft utilisera le répertoire par défaut spécifié lors de la compilation. Ce répertoire par défaut peut être obtenu avec l'option -h / --help.

L'instruction include prend en charge les symboles génériques habituels du shell (* '',? '', []). Si un symbole générique est utilisé dans l'instruction include, aucune erreur ne se produira même s'il n'y a pas de correspondance pour l'instruction include. Cela vous permet de spécifier un répertoire d'inclusion potentiellement vide, tel que ʻinclude / etc / firewall / rules / * `. Les correspondances génériques sont lues par ordre alphabétique. Les fichiers commençant par un point (``. '') Ne correspondent pas dans l'instruction d'inclusion.

Symbole variable

Définition de l'expression variable

$variable

Les symboles de variable peuvent être définis à l'aide de l'instruction `` define ''. Les références de variable sont des expressions qui peuvent être utilisées pour initialiser d'autres variables. La portée de la définition est le bloc actuel et tous les blocs qu'il contient.

Exemple d'utilisation de variables

define int_if1 = eth0
define int_if2 = eth1
define int_ifs = { $int_if1, $int_if2 }

filter input iif $int_ifs accept

Famille d'adresses

La famille d'adresses détermine le type de paquet traité. Pour chaque famille d'adresses, le noyau contient des hooks qui représentent des étapes spécifiques du processus de traitement des paquets. Ces hooks appellent nftables si les règles du hook existent.

• ip: famille d'adresses IPv4.
• ip6: famille d'adresses IPv6.
• inet: famille d'adresses Internet (IPv4 / IPv6).
• arp: famille d'adresses ARP. Traitez les paquets ARP IPv4.
• bridge: famille d'adresses de pont. Gère les paquets qui transitent par le périphérique de pont.
• netdev: famille d'adresses Netdev. Traitez les paquets depuis l'entrée.

Tous les identificateurs incluent une famille d'adresses car tous les objets nftables résident dans un espace de noms spécifique à une famille d'adresses. Si vous spécifiez un identifiant sans famille d'adresses, la famille ip est utilisée par défaut.

Famille d'adresses IPV4 / IPV6 / INET

La famille d'adresses IPv4 / IPv6 / Inet gère IPv4, IPv6 ou les deux types de paquets. Ils contiennent cinq hooks à différentes étapes de traitement des paquets de la pile réseau.

Crochet de famille d'adresses IPv4 / IPv6 / Inet

Famille d'adresses ARP

La famille d'adresses ARP gère les paquets ARP envoyés et reçus par le système. Ceci est généralement utilisé pour modifier les paquets ARP pour le clustering.

Crochet de famille d'adresses ARP

Famille d'adresses de pont

La famille d'adresses de pont gère les paquets Ethernet qui transitent par le périphérique de pont.

La liste des hooks pris en charge est la même que celle de la famille d'adresses IPv4 / IPv6 / Inet ci-dessus.

Famille d'adresses NETDEV

La famille d'adresses Netdev gère les paquets en entrée.

Crochet de la famille d'adresses Netdev

Ensemble de règles

{list | flush} ruleset [family]
export [ruleset] format

Le mot-clé ruleset est utilisé pour identifier l'ensemble complet des tables, chaînes, etc. actuellement situées dans le noyau. Les commandes d'ensemble de règles suivantes existent.

• list: affiche l'ensemble de règles dans un format lisible par l'homme.
• flush: vide l'ensemble de règles. Notez que contrairement à iptables, cela supprime toutes les tables et tout ce qu'elles contiennent, laissant un ensemble de règles pratiquement vide. Le filtrage des paquets ne se produit plus, le noyau accepte donc tous les paquets valides qu'il reçoit.
• export: affiche l'ensemble de règles dans un format lisible par machine. Les paramètres de format requis sont soit xml '', soit json ''.

Il est possible de limiter la liste et de vider uniquement des familles d'adresses spécifiques. Voir Famille d'adresses (#Address Family) ci-dessus pour une liste des noms de famille valides.

Notez que, contrairement aux attentes, la production produite par l'exportation ne peut pas être analysée par `` nft -f ''. Au lieu de cela, la sortie de la commande list sert cet objectif.

table

{add | create} table [family] table [ { flags flags } ]
{delete | list | flush} table [family] table
delete table [family] handle handle

Les tables sont des conteneurs pour les chaînes, les ensembles et les objets avec état. Ils sont identifiés par leur famille d'adresse et leur nom. La famille d'adresses doit être une parmi ip, ip6, inet, arp, bridge, netdev. La famille d'adresses inet est une famille factice utilisée pour créer des tables hybrides IPv4 / IPv6. Vous pouvez utiliser le mot-clé méta-expression nfproto pour tester le contexte de la famille (IPv4 ou IPv6) dans lequel le paquet est traité. Si aucune famille d'adresses n'est spécifiée, ip est utilisé par défaut. La seule différence entre add et create est que create renvoie une erreur, tandis que add ne renvoie pas d'erreur si la table spécifiée existe déjà.

Drapeau de table

Exemple d'ajout, de modification ou de suppression d'une table

#Lancez nft en mode interactif
nft --interactive

#Créez une nouvelle table.
create table inet mytable

#Ajouter une nouvelle chaîne de base:Obtenir le paquet d'entrée
add chain inet mytable myin { type filter hook input priority 0; }

#Ajouter un seul compteur à la chaîne
add rule inet mytable myin counter

#Désactiver temporairement la table(Les règles ne sont pas évaluées)
add table inet mytable { flags dormant; }

#Réactiver le tableau:
add table inet mytable

• add: Ajoute une nouvelle table pour la famille spécifiée avec le nom spécifié.
• delete: supprime la table spécifiée.
• list: répertorie toutes les chaînes et règles de la table spécifiée.
• flush: Vide toutes les chaînes et règles de la table spécifiée.

chaîne

{add | create} chain [family] table chain [ { type type hook hook [device device] priority priority ; [policy policy ;] } ]
{delete | list | flush} chain [family] table chain
delete chain [family] table handle handle
rename chain [family] table chain newname

Une chaîne est un conteneur de règles. Il existe deux types de chaînes, les chaînes de base et les chaînes régulières. La chaîne de base est le point d'entrée des paquets de la pile réseau. Les chaînes régulières peuvent être utilisées comme cibles de saut et sont utilisées pour une meilleure formation des règles.

• add: ajoute une nouvelle chaîne à la table spécifiée. Si un hook et une valeur de priorité sont spécifiés, la chaîne sera créée en tant que chaîne de base et accrochée à la pile réseau.
• Similaire à la commande create: add, mais renvoie une erreur si la chaîne existe déjà.
• delete: supprime la chaîne spécifiée. N'incluez pas de règles dans la chaîne et ne l'utilisez pas comme cible de saut.
• renommer: Renomme la chaîne spécifiée.
• list: répertorie toutes les règles de la chaîne spécifiée.
• flush: Vide toutes les règles de la chaîne spécifiée.

Pour la chaîne de base, les paramètres type, hook et priorité sont requis.

Types de chaînes pris en charge

Hormis le cas particulier ci-dessus (par exemple, le type nat ne prend pas en charge les hooks avant, ou le type de route ne prend en charge que les hooks de sortie), il existe deux autres bizarreries notables.

• La famille netdev ne prend en charge qu'une seule combinaison: le type de filtre et le hook d'entrée. La chaîne de base de cette famille existe pour chaque interface de réception, les paramètres de périphérique doivent donc également être présents.

• La famille arp est une chaîne de type filtre qui ne prend en charge que les hooks d'entrée et de sortie.

Le paramètre `` priority '' accepte une valeur entière signée qui spécifie l'ordre dans lequel les chaînes avec la même valeur de hook sont traversées. L'ordre est croissant. Autrement dit, les valeurs de faible priorité ont priorité sur les valeurs élevées.

La chaîne de base vous permet également de définir des stratégies de chaîne. La politique définit ce qui arrive aux paquets qui ne sont pas explicitement acceptés ou rejetés par les règles prédéfinies. Les valeurs de politique prises en charge sont «accept» (par défaut) ou «drop».

règle

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

La règle est ajoutée à la chaîne de la table spécifiée. Si aucune famille n'est spécifiée, la famille ip sera utilisée. Une règle se compose de deux types de composants selon un ensemble de règles grammaticales. Expressions et déclarations.

Les commandes add et insert prennent en charge les spécificateurs de position arbitraires. Il s'agit d'un descripteur ou d'un index (à partir de zéro) d'une règle existante. En interne, l'emplacement de la règle est toujours identifié par le handle, et la conversion à partir de l'index se fait dans l'espace utilisateur. Si des changements simultanés de jeu de règles se produisent après la conversion, cela a deux implications potentielles. Si une règle est insérée ou supprimée avant la règle référencée, l'index de règle valide peut changer. Si la règle référencée est supprimée, la commande sera rejetée par le noyau, comme si un handle non valide était spécifié.

• add: Ajoute une nouvelle règle décrite dans la liste des instructions. Sauf si un handle est spécifié, la règle sera ajoutée à la chaîne spécifiée. Si un handle est spécifié, la règle sera ajoutée à la règle spécifiée par le handle. Les autres positions de nom sont obsolètes. Veuillez ne pas l'utiliser à l'avenir.
• insert: similaire à la commande add, mais la règle est ajoutée au début de la chaîne ou avant la règle avec le handle spécifié.
• replace: similaire à la commande add, mais remplace la règle spécifiée.
• delete: supprime la règle spécifiée.

Exemple d'ajout d'une règle à la chaîne d'entrée de la table ip

# 'ip filter'Devrait
nft add rule filter output ip daddr 192.168.0.0/24 accept
#Même commande, un peu plus de détails
nft add rule ip filter output ip daddr 192.168.0.0/24 accept

Exemple de suppression d'une règle de la table inet

nft -a list ruleset

table inet filter {
  chain input {
    type filter hook input priority 0; policy accept;
    ct state established,related accept # handle 4
    ip saddr 10.1.1.1 tcp dport ssh accept # handle 5
    ...

#Supprimer la règle de poignée 5.
nft delete rule inet filter input handle 5

ensemble

nftables fournit deux types de concepts d'ensemble. Les ensembles anonymes sont des ensembles qui n'ont pas de nom spécifique. Les membres de l'ensemble sont placés entre accolades et les éléments sont séparés par des virgules lors de la création de règles qui utilisent l'ensemble. Lorsque la règle est supprimée, l'ensemble l'est aussi. Vous ne pouvez pas les mettre à jour. Autrement dit, une fois qu'un ensemble anonyme est déclaré, il ne peut être mis à jour que si les règles qui utilisent l'ensemble anonyme sont supprimées ou modifiées.

Un exemple d'acceptation d'un sous-réseau et d'un port spécifiques à l'aide d'un ensemble anonyme

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

Les ensembles nommés sont le premier ensemble qui doit être défini avant de pouvoir être référencés dans une règle. Contrairement aux ensembles anonymes, les éléments peuvent être ajoutés ou supprimés des ensembles nommés à tout moment. L'ensemble est référencé par la règle avec le nom de l'ensemble précédé de `` @ ''.

Un exemple d'acceptation d'une adresse et d'un port à l'aide d'un ensemble nommé

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

Les ensembles ʻallowed_hosts`` et ʻallowed_ports`` doivent être créés en premier.

La section suivante détaille la syntaxe de l'ensemble nft.

add set [family] table set { type type ; [flags flags ;] [timeout timeout ;] [gc-interval gc-interval ;] [elements = { element[,...] } ;] [size size ;] [policy policy ;] [auto-merge auto-merge ;] }
{delete | list | flush} set [family] table set
delete set [family] table handle handle
{add | delete} element [family] table set { element[,...] }

Un ensemble est un conteneur d'éléments d'un type de données défini par l'utilisateur qui est identifié de manière unique par un nom défini par l'utilisateur et attaché à une table.

• add: ajoute un nouvel ensemble à la table spécifiée.
• delete: supprime l'ensemble spécifié.
• list: affiche les éléments de l'ensemble spécifié.
• flush: Vide tous les éléments de l'ensemble spécifié.
• add element Une liste d'éléments séparés par des virgules à ajouter à l'ensemble spécifié.
• delete element Une liste d'éléments séparés par des virgules à supprimer de l'ensemble spécifié.

Définir les spécifications

carte

add map [family] table map { type type [flags flags ;] [elements = { element[,...] };] [size size ;] [policy policy ;] }
{delete | list | flush} map [family] table map
{add | delete} element [family] table map { elements = { element[,...] } ; }

Les cartes stockent des données basées sur une clé spécifique utilisée comme entrée, sont identifiées de manière unique par un nom défini par l'utilisateur et sont attachées à une table.

• add: ajoute une nouvelle carte à la table spécifiée.
• supprimer: supprime la carte spécifiée.
• list: affiche les éléments de la carte spécifiée.
• flush: Vide tous les éléments de la carte spécifiée.
• add element Une liste d'éléments séparés par des virgules à ajouter à la carte spécifiée.
• delete element Une liste de clés d'élément séparées par des virgules à supprimer de la carte spécifiée.

Spécifications de la carte

Tableau de flux

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

Les tableaux de flux peuvent être utilisés pour accélérer le transfert de paquets dans le logiciel. Les entrées de la table de flux sont représentées par un tuple composé d'une interface d'entrée, des adresses source et de destination, des ports source et de destination; protocole de couche 3/4. Chaque entrée met en cache l'interface de destination et l'adresse de la passerelle, met à jour l'adresse de la couche de liaison de destination et transmet le paquet. Les champs ttl et hoplimit sont également réduits. La table de flux fournit donc un chemin alternatif qui permet au paquet de contourner le chemin de transmission traditionnel. La table de flux se trouve sur le crochet d'entrée devant le crochet de pré-acheminement. Flux de la chaîne avant Vous pouvez utiliser l'expression de déchargement pour sélectionner le flux à décharger. Les tableaux de flux sont identifiés par leur famille d'adresses et leur nom. La famille d'adresses doit être ip, ip6 ou inet. La famille d'adresses inet est une famille factice utilisée pour créer des tables hybrides IPv4 / IPv6. Si aucune famille d'adresses n'est spécifiée, ip est utilisé par défaut.

• add: ajoute une nouvelle table de flux pour la famille spécifiée avec le nom spécifié.
• delete: supprime la table de flux spécifiée.
• list: répertorie tous les tableaux de flux.

Objet avec état

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

Les objets avec état sont attachés à la table et identifiés par un nom unique. Ils regroupent les informations avec état de la règle et le mot-clé nom de type '' est utilisé pour y faire référence dans la règle. Exemple: nom du compteur ''.

• add: ajoute un nouvel objet avec état à la table spécifiée.
• delete: supprime l'objet spécifié.
• list: affiche les informations avec état détenues par l'objet.
• reset: répertorie et réinitialise les objets avec état.

CT

ct helper helper { type type protocol protocol ; [l3proto family ;] }

ct helper est utilisé pour définir un assistant de suivi de connexion qui peut être utilisé en combinaison avec l'instruction ct helper set ''. le type et le protocole sont requis. l3proto`` est dérivé de la famille de tables par défaut. Autrement dit, si le noyau le prend en charge, le noyau essaiera de charger les backends d'assistance IPv4 et IPv6 dans la table inet.

spécifications de l'assistant conntrack

Définition et affectation de l'assistance FTP

Contrairement à iptables, les affectations d'assistance doivent être effectuées, par exemple, avec la priorité de hook par défaut 0 une fois la recherche conntrack terminée.

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

compteur

counter [packets bytes]

Spécifications du compteur

quota

quota [over | until] [used]

Spécifications de quota

formule

L'expression représente la valeur d'une constante telle qu'une adresse réseau ou un numéro de port, ou les données collectées à partir du paquet lors de l'évaluation de l'ensemble de règles. Vous pouvez combiner des expressions à l'aide d'expressions binaires, logiques, relationnelles et autres pour former des expressions complexes ou relationnelles (correspondance). Ils sont également utilisés comme arguments pour certains types d'opérations, comme le NAT et le marquage de paquets.

Chaque expression a un type de données, qui détermine la taille, l'analyse, la représentation et la compatibilité de type de la valeur symbolique avec d'autres expressions.

Commande DESCRIBE

describe expression

La commande `` décrire '' affiche des informations sur le type d'expression et son type de données.

$ 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

Type de données

Le type de données détermine la taille, l'analyse, la représentation et la compatibilité du type d'expression des valeurs symboliques. Il existe plusieurs types de données globales, et certains types d'expression définissent des types de données supplémentaires spécifiques à ce type d'expression. La plupart des types de données sont de taille fixe, mais certains sont de taille dynamique. (Exemple: type de chaîne)

Les types peuvent être dérivés de types d'ordre inférieur. Le type d'adresse IPv4 est dérivé du type entier. Autrement dit, vous pouvez également spécifier l'adresse IPv4 sous forme de valeur entière.

Dans certains contextes (définitions d'ensemble et de mappage), vous devez spécifier explicitement le type de données. Chaque type a un nom utilisé pour cela.

Type entier

Le type entier est utilisé pour les nombres. Vous pouvez le spécifier en décimal, hexadécimal ou octal. Le type entier n'est pas de taille fixe, sa taille est déterminée par l'expression utilisée.

Type de masque de bits

Le type de masque de bits (masque de bits) est utilisé pour le masque de bits.

Type de chaîne

Le type chaîne est utilisé pour les chaînes. La chaîne commence par un caractère alphabétique (a-zA-Z), suivi de zéro ou plusieurs caractères alphanumériques ou caractères et symboles (/, -, _, .. ) Suit. De plus, tout ce qui est entre guillemets (") est reconnu comme une chaîne.

Spécification du type de chaîne de caractères

#Nom de l'interface
filter input iifname eth0

#Nom d'interface étrange
filter input iifname "(eth0)"

Type d'adresse de couche de liaison

Le type d'adresse de couche liaison est utilisé pour les adresses de couche liaison. Les adresses de couche liaison sont spécifiées sous la forme d'un groupe de nombres variables hexadécimaux à deux chiffres séparés par deux points (:).

Adressage de la couche de liaison

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

Type d'adresse IPV4

Le type d'adresse IPv4 est utilisé pour les adresses IPv4. L'adresse peut être spécifiée sous forme de nom décimal, hexadécimal pointillé, octogone pointillé, décimal, hexadécimal, octal ou d'hôte. Les noms d'hôte sont résolus à l'aide d'un résolveur système standard.

Spécification d'adresse IPv4

#Notation décimale par points
filter output ip daddr 127.0.0.1

#nom d'hôte
filter output ip daddr localhost

Type d'adresse IPV6

Le type d'adresse IPv6 est utilisé pour les adresses IPv6. L'adresse est spécifiée sous la forme d'un nom d'hôte ou d'un demi-mot hexadécimal séparé par deux-points. Les adresses peuvent être placées entre crochets (`` [] '') pour les distinguer des numéros de port.

Spécifier une adresse IPv6

#Adresse de bouclage omise
filter output ip6 daddr ::1

#Spécification d'une adresse IPv6 à l'aide de la notation entre crochets
# []Aucun numéro de port(22)Est analysé dans le cadre de l'adresse ipv6.
ip6 nat prerouting tcp dport 2222 dnat to [1ce::d0]:22

Type booléen

Les types booléens sont des types d'assistance de syntaxe dans l'espace utilisateur. C'est le côté droit de l'expression relationnelle (généralement implicite) et il est utilisé pour changer l'expression du côté gauche en une vérification de valeur booléenne (généralement «existe»).

Les mots-clés suivants sont automatiquement résolus en un type booléen avec la valeur spécifiée.

Spécifications booléennes

La formule suivante prend en charge les comparaisons booléennes.

#Correspondre si l'itinéraire existe
filter input fib daddr . iif oif exists

#Correspond uniquement aux paquets non fragmentés de trafic IPv6
filter input exthdr frag missing

#Correspondance si l'option d'horodatage TCP est présente
filter input tcp option timestamp exists

Type ICMP

Le type ICMP est utilisé pour spécifier facilement le champ type dans l'en-tête ICMP.

Vous pouvez utiliser les mots-clés suivants lors de la spécification du type ICMP:

Spécification du type ICMP

#Match ping paquet
filter output icmp type { echo-request, echo-reply }

Type de code ICMP

Le type de code ICMP est utilisé pour spécifier facilement le champ de code dans l'en-tête ICMP.

Vous pouvez utiliser les mots-clés suivants lors de la spécification du code ICMP:

Type ICMPV6

Le type de type ICMPv6 est utilisé pour spécifier facilement le champ de type dans l'en-tête ICMPv6.

Vous pouvez utiliser les mots-clés suivants lors de la spécification du type ICMPv6:

Spécification du type ICMPv6

#Faire correspondre le paquet ping ICMPv6
filter output icmpv6 type { echo-request, echo-reply }

Type de code ICMPV6

Le type de code ICMPv6 est utilisé pour spécifier facilement les champs de code dans l'en-tête ICMPv6.

Vous pouvez utiliser les mots-clés suivants lors de la spécification du code ICMPv6:

Type de code ICMPVX

L'abstraction de type de code ICMPvX est un ensemble de valeurs dupliquées entre les types de code ICMP et ICMPv6 utilisés dans la famille inet.

Vous pouvez utiliser les mots-clés suivants lors de la spécification du code ICMPvX:

Type de Conntrack

Ceci est un aperçu des types utilisés dans les expressions et instructions ct.

Vous pouvez utiliser des mots clés par commodité pour chacun des types ci-dessus.

conntrack state(ct_state)

conntrack direction(ct_dir)

conntrack status(ct_status)

conntrack event bits(ct_event)

Les mots-clés qui peuvent être spécifiés pour le type d'étiquette conntrack (ct_label) sont lus à partir de / etc / connlabel.conf au moment de l'exécution.

Expression linéaire

L'expression de niveau le plus bas est une expression linéaire qui représente une charge utile de paquet, des métadonnées ou des données constantes ou uniques d'un module avec état.

Expression méta

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 | secpath}

Une méta expression est les métadonnées associées à un paquet.

Il existe deux types de méta-expressions: les méta-expressions non modifiées et les méta-expressions modifiées. Une méta expression qualifiée nécessite le mot clé meta '' avant le metakey. Les méta-expressions non qualifiées vous permettent de spécifier la méta-expression directement ou en tant que méta-expression qualifiée. meta l4proto '' aide à faire correspondre les protocoles de transport spécifiques qui font partie des paquets IPv4 ou IPv6. Il ignore également les en-têtes d'extension IPv6 présents dans les paquets IPv6.

Type d'expression méta

Type spécifique de méta expression

Exemple d'utilisation de méta expression

#Méta-expression modifiée
filter output meta oif eth0

#Méta-expression non qualifiée
filter output oif eth0

#Pack qui était la cible du traitement ipsec
raw prerouting meta secpath exists accept

Formule FIB (Forwarding Information Base)

fib {saddr | daddr | {mark | iif | oif}} {oif | oifname | type}

L'expression fib interroge fib (base d'informations de transfert) pour obtenir des informations telles que l'index d'interface de sortie utilisé par une adresse particulière. L'entrée est un tuple d'éléments utilisés comme entrée dans la fonction de recherche fib.

type spécifique à l'expression fib

Exemple d'utilisation de formule FIB

#Déposer des paquets sans chemin inverse
filter prerouting fib saddr . iif oif missing drop

#Déposer les paquets vers des adresses qui ne sont pas configurées sur l'interface
filter prerouting fib daddr . iif type != { local, broadcast, multicast } drop

#spécifique'blackhole'Effectuer une recherche sur la table( 0xdead,Nécessite des règles IP appropriées)
filter prerouting meta mark set 0xdead fib daddr . mark type vmap { blackhole : drop, prohibit : jump prohibited, unreachable : drop }

Formule de routage

rt {classid | nexthop}

Une expression de routage fait référence aux données de routage associées à un paquet.

Type d'expression de routage

Type spécifique d'expression de routage

Exemple d'utilisation d'une expression de routage

#Expression RT indépendante de la famille IP
filter output rt classid 10

#Expression rt dépendante de la famille IP
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

Expression de la charge utile

L'expression de charge utile fait référence aux données de la charge utile du paquet.

Expression d'en-tête Ethernet

ether [Ethernet header field]

Type d'expression d'en-tête Ethernet

Expression d'en-tête VLAN

vlan [VLAN header field]

Expression d'en-tête ARP

arp [ARP header field]

Expression d'en-tête IPV4

ip [IPv4 header field]

Expression d'en-tête ICMP

icmp [ICMP header field]

Expression d'en-tête IPV6

ip6 [IPv6 header field]

Cette expression fait référence au champ d'en-tête ipv6. Notez que lorsque vous utilisez «ip6 nexthdr», la valeur se réfère uniquement à l'en-tête suivant. Autrement dit, «ip6 nexthdr tcp» ne correspondra que si le paquet ipv6 ne contient pas d'en-tête d'extension. Il ne sera pas mis en correspondance s'il contient des paquets fragmentés ou des en-têtes d'extension de routage. Utilisez `` meta l4proto '' si vous souhaitez faire correspondre l'en-tête de transport réel et ignorer plutôt l'en-tête d'extension supplémentaire.

Correspondre si le premier en-tête d'extension pointe vers un fragment

ip6 nexthdr ipv6-frag counter

Expression d'en-tête ICMPV6

icmpv6 [ICMPv6 header field]

Expression d'en-tête TCP

tcp [TCP header field]

Expression d'en-tête UDP

udp [UDP header field]

Expression d'en-tête UDP simple

udplite [UDP-Lite header field]

Expression d'en-tête SCTP

sctp [SCTP header field]

Expression d'en-tête DCCP

dccp [DCCP header field]

Expression d'en-tête d'authentification

ah [AH header field]

Expression d'en-tête de charge utile de sécurité chiffrée

esp [ESP header field]

Expression d'en-tête IPCOMP

comp [IPComp header field]

Expression de la charge utile RAW

@ [base,offset,length]

L'expression de charge utile brute vous indique de charger les bits de longueur commençant par offsetbits. Le bit 0 pointe vers le premier bit. Dans le langage de programmation C, cela correspond au bit le plus significatif, ou 0x80 '' pour les octets. Ils sont utiles pour faire correspondre les en-têtes qui n'ont pas encore d'expression de modèle lisible par l'homme. Notez que nft n'ajoute pas de dépendances d'expression de charge utile brute. Par exemple, pour faire correspondre le champ de protocole de l'en-tête de transport au protocole numéro 5, vous devez exclure manuellement les paquets avec des en-têtes de transport différents. Par exemple, utilisez meta l4proto 5 '' avant l'expression Raw.

Base de protocole de charge utile prise en charge

python

#Port de destination qui correspond à la fois à UDP et à TCP
inet filter input meta l4proto {tcp, udp} @th,16,16 { dns, http }

#Si l'adresse de protocole cible correspond à l'adresse spécifiée
#réécrire l'adresse matérielle cible du paquet arp.
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

Expression d'en-tête étendue

Les expressions d'en-tête étendues font référence aux données d'en-têtes de protocole de taille variable, telles que les en-têtes étendus IPv6 et les options TCP.

nftables prend actuellement en charge la correspondance (recherche) de certains en-têtes d'extension ipv6 ou options TCP.

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 | noop | maxseg | window | sack-permitted | sack | sack0 | sack1 | sack2 | sack3 | timestamp} tcp_option_field

La syntaxe suivante n'est valide que pour les expressions relationnelles qui ont un type booléen sur le côté droit et vérifient uniquement l'existence de l'en-tête.

exthdr {hbh | frag | rt | dst | mh}
tcp option {eol | noop | maxseg | window | sack-permitted | sack | sack0 | sack1 | sack2 | sack3 | timestamp}

En-tête d'extension IPv6

Option TCP

#Rechercher les options TCP
filter input tcp option sack-permitted kind 1 counter

#Rechercher IPv6 exthdr
ip6 filter input frag more-fragments 1 counter

Expression CONNTRACK

L'expression conntrack fait référence aux métadonnées de l'entrée de suivi de connexion associée au paquet.

Il existe trois types d'expressions conntrack. Certaines expressions conntrack nécessitent une direction de flux avant la touche conntrack, tandis que d'autres sont indépendantes de la direction et doivent être utilisées directement. Les mots clés packets, bytes et ```avgpkt`` peuvent être utilisés avec ou sans orientation. Si vous omettez la direction, la somme de la direction d'origine et de la direction de réponse est renvoyée. La même chose s'applique aux zones. Si une direction est spécifiée, les zones correspondent uniquement si l'ID de zone est associé à la direction spécifiée.

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

Une description des types spécifiques à conntrack ci-dessus peut être trouvée dans la sous-section TYPES DE CONNTRACK ci-dessus.

déclaration

La déclaration représente l'action à entreprendre. Vous pouvez modifier le flux de contrôle (retour, passer à une autre chaîne, accepter ou supprimer des paquets) et effectuer des actions telles que la journalisation et le rejet de paquets.

Il existe deux types de déclarations. L'instruction end termine sans condition l'évaluation de la règle actuelle. Les instructions sans fin ne terminent que conditionnellement ou ne terminent jamais l'évaluation de la règle actuelle. Autrement dit, ils sont passifs en termes d'évaluation des règles. La règle peut contenir n'importe quel nombre d'instructions sans fin, mais une seule instruction de fin peut être utilisée comme instruction finale.

Déclaration de jugement

La déclaration de décision modifie le flux de contrôle de l'ensemble de règles et émet une décision de politique pour le paquet.

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

• accepter: termine l'évaluation du jeu de règles et accepte le paquet.
• drop: Termine l'évaluation du jeu de règles et supprime le paquet.
• queue: Termine l'évaluation du jeu de règles et met les paquets en file d'attente dans l'espace utilisateur.
• continue: Continuez à évaluer l'ensemble de règles avec les règles suivantes. RÉPARE-MOI.
• return: Retour de la chaîne actuelle et continuer l'évaluation avec la règle suivante dans la dernière chaîne. Lorsqu'il est émis dans la chaîne de base, il équivaut à accepter.
• jump chain: Continuez l'évaluation avec la première règle de la chaîne. La position actuelle du jeu de règles est poussée dans la pile d'appels, et lorsque la nouvelle chaîne est entièrement évaluée et qu'un verdict de retour est émis, l'évaluation se poursuit là.
• goto chain: Similaire à sauter '', mais la position actuelle n'est pas poussée dans la pile d'appels. Autrement dit, après avoir évalué une nouvelle chaîne, elle continuera avec la dernière chaîne, et non avec la chaîne contenant l'instruction goto ''.

#Paquets de eth0 et réseau interne de_Processus avec LAN.
filter input iif eth0 ip saddr 192.168.0.0/24 jump from_lan

#Supprimez tous les paquets de la chaîne, eth0 avec des adresses sources différentes.
filter input iif eth0 drop

Énoncé de la charge de travail

L'instruction de charge utile modifie le contenu du paquet. Par exemple, il peut être utilisé pour définir le champ d'en-tête ip DSCP (differv) ou l'étiquette de flux ipv6.

Acheminez certains paquets au lieu de faire un pont.

# tcp:http 192.160.0.0/Redirection de 16 vers votre machine locale et routage au lieu de pontage
# 00:11:22:33:44:On suppose que 55 est l'adresse MAC locale.
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

#Définition des champs d'en-tête DSCP IPv4
ip forward ip dscp set 42

Instruction d'en-tête étendue

L'instruction d'en-tête étendue modifie le contenu des paquets d'en-têtes de taille variable. Cela peut maintenant être utilisé pour modifier la taille de segment maximale TCP d'un paquet, similaire à TCPMSS.

#Changer tcp mss
tcp flags syn tcp option maxseg size set 1360

#Définissez la taille en fonction des informations sur l'itinéraire
tcp flags syn tcp option maxseg size set rt mtu

Instruction de journal

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

L'instruction log active la journalisation des paquets correspondants. Lorsque cette instruction est utilisée à partir d'une règle, le noyau Linux imprime des informations sur tous les paquets correspondants, y compris les champs d'en-tête, via le journal du noyau (qui peut être lu par dmesg (1) ou syslog). Si un numéro de groupe est spécifié, le noyau Linux passe le paquet au nfnetlink_log '' et multidiffuse le paquet via la socket netlink '' vers le groupe de multidiffusion spécifié. Un ou plusieurs processus de l'espace utilisateur peuvent être enregistrés dans un groupe et recevoir des paquets. Voir la documentation `` libnetfilter_queue '' pour plus d'informations. Puisqu'il s'agit d'une instruction sans fin, l'évaluation de la règle se poursuivra après la journalisation du paquet.

Options des instructions de journal

Indicateur de journal

Exemple d'utilisation de l'instruction de journal

#Enregistrez l'UID qui a généré le paquet et les options IP
ip filter output log flags skuid flags ip options

#Consigner les numéros de séquence TCP et les options TCP à partir des paquets TCP
ip filter output log flags tcp sequence,options

#Activer tous les indicateurs de journal pris en charge
ip6 filter output log flags all

Déclaration de rejet

reject [ with {icmp | icmpv6 | icmpx} type {icmp_code | icmpv6_code | icmpx_code} ]
reject [ with tcp reset ]

L'instruction rejeter '' est utilisée pour renvoyer un paquet d'erreur en réponse à un paquet correspondant. Sinon, c'est la même chose que drop '', c'est donc une instruction de fin qui termine le parcours de règle. Cette instruction n'est valide que pour les chaînes d'entrée, les chaînes avant, les chaînes de sortie et les chaînes définies par l'utilisateur qui sont appelées uniquement à partir de ces chaînes.

Les différentes variables de refus ICMP sont destinées à être utilisées avec différentes familles de tables.

Consultez la section Types de données (# Types de données) ci-dessus pour une description des types et une liste des mots clés pris en charge. Généralement, la valeur de refus par défaut est `` port-inaccessible ''.

Notez que dans la famille de ponts, les instructions `` rejeter '' ne sont autorisées que dans les chaînes de base qui s'accrochent à l'entrée ou au pré-routage.

Déclaration de contestation

L'instruction counter définit le nombre de hits dans un paquet ainsi que le nombre d'octets.

counter [ packets number bytes number ]

Instruction CONNTRACK

Vous pouvez utiliser l'instruction conntrack pour définir la marque conntrack et l'étiquette conntrack.

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

L'instruction ct '' définit les métadonnées associées à la connexion. L'ID de zone doit être attribué avant qu'une recherche de conntrack puisse être effectuée. C'est-à-dire que cela devrait être fait avec le pré-routage et la sortie (si les paquets générés localement doivent être placés dans des zones séparées) et la priorité de hook est -300 ''.

Type d'instruction Conntrack

#Enregistrer le paquet nfmark dans conntrack
ct mark set meta mark

#Configurer des zones mappées via l'interface
table inet raw {
  chain prerouting {
    type filter hook prerouting priority -300;
    ct zone set iif map { "eth1" : 1, "veth1" : 2 }
  }
  chain output {
    type filter hook output priority -300;
    ct zone set oif map { "eth1" : 1, "veth1" : 2 }
  }
}

#Limiter les événements signalés par ctnetlink
ct event set new,related,destroy

Déclaration Meta

L'instruction meta '' définit la valeur de la méta expression. Les méta-champs existants sont priority '', mark '', pkttype '', `` nftrace ''.

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

L'instruction meta définit les métadonnées associées au paquet.

Type de méta-déclaration

Déclaration de restriction

limit rate [over] packet_number / {second | minute | hour | day} [burst packet_number packets]
limit rate [over] byte_number {bytes | kbytes | mbytes} / {second | minute | hour | day | week} [burst byte_number bytes]

L'instruction `` limit '' correspond à un taux limité à l'aide du filtre de compartiment de jetons. Les règles qui utilisent cette instruction correspondent jusqu'à ce que cette limite soit atteinte. Vous pouvez l'utiliser en combinaison avec une instruction de journal pour limiter la journalisation. Le mot-clé optionnel «over» correspond au-delà du taux spécifié.

Déclaration NAT

snat to address [:port] [persistent, random, fully-random]
snat to address - address [:port - port] [persistent, random, fully-random]
dnat to address [:port] [persistent, random, fully-random]
dnat to address [:port - port] [persistent, random, fully-random]
masquerade to [:port] [persistent, random, fully-random]
masquerade to [:port - port] [persistent, random, fully-random]
redirect to [:port] [persistent, random, fully-random]
redirect to [:port - port] [persistent, random, fully-random]

L'instruction nat n'est valide qu'à partir du type de chaîne nat.

Les instructions snat '' et masquerade '' indiquent que l'adresse source du paquet doit être modifiée. snat n'est valide que pour les chaînes de post-acheminement et d'entrée, mais la mascarade n'est valable que pour les post-routages. Les instructions dnat et redirect ne sont valides que dans les chaînes de pré-routage et de sortie et indiquent que l'adresse de destination du paquet doit être modifiée. Vous pouvez également utiliser des chaînes sans base appelées à partir de chaînes de base de type chaîne nat. Tous les futurs paquets sur cette connexion seront abandonnés et l'évaluation des règles sera abandonnée.

L'instruction masquerade '' est une forme spéciale de snat '' et utilise toujours l'adresse IP de l'interface d'envoi de destination. Ceci est particulièrement utile pour les passerelles avec des adresses IP dynamiques (publiques).

L'instruction redirect '' est une forme spéciale de dnat '' qui traduit toujours l'adresse de destination en l'adresse de l'hôte local. Ceci est utile si vous souhaitez uniquement modifier le port de destination du trafic entrant sur différentes interfaces.

Notez que chaque instruction nat doit avoir à la fois des chaînes de base de pré-routage et de post-routage. Sinon, les paquets sur la route de retour ne seront pas reconnus par netfilter et la conversion inverse ne se produira pas.

Valeur de l'instruction NAT

Indicateur de déclaration NAT

Utilisation des déclarations NAT

#Un tableau adapté à tous les autres exemples/Créer un paramètre de chaîne
add table nat
add chain nat prerouting { type nat hook prerouting priority 0; }
add chain nat postrouting { type nat hook postrouting priority 100; }

#Adresse 1 l'adresse source de tous les paquets envoyés via eth0.2.3.Convertir en 4
add rule nat postrouting oif eth0 snat to 1.2.3.4

#Adresse de destination 192 pour tout le trafic entrant via eth0.168.1.Rediriger vers 120
add rule nat prerouting iif eth0 dnat to 192.168.1.120

#Traduire l'adresse source de tous les paquets envoyés via eth0 en n'importe quoi
#Les paquets générés localement sont utilisés comme source pour atteindre la même destination
add rule nat postrouting oif eth0 masquerade

#Trafic TCP entrant direct sur le port 22 vers le port 2222
add rule nat prerouting tcp dport 22 redirect to :2222

Instruction de déchargement de flux

L'instruction de déchargement de flux vous permet de sélectionner un flux qui accélère le transfert via un contournement de pile réseau de couche 3. Vous devez spécifier le nom de la table de flux pour décharger ce flux.

flow offload @flowtable

Instruction de file d'attente

Cette instruction utilise le gestionnaire nfnetlink_queue '' pour transmettre le paquet à l'espace utilisateur. Le paquet est placé dans une file d'attente identifiée par un numéro de file d'attente de 16 bits. L'espace utilisateur peut inspecter et modifier les paquets selon les besoins. L'espace utilisateur doit alors supprimer ou réinjecter le paquet à partir du noyau. Voir la documentation libnetfilter_queue '' pour plus d'informations.

queue [num queue_number] [bypass]
queue [num queue_number_from - queue_number_to] [bypass,fanout]

Valeur de l'instruction de file d'attente

Indicateur de déclaration de file d'attente

Instruction DUP

L'instruction dup est utilisée pour dupliquer un paquet et envoyer une copie vers une autre destination.

dup to device
dup to address device device

Valeur de la déclaration Dup

Exemple d'utilisation de l'instruction dup

#Adresse IP 10 avec eth0.2.3.Envoyer à 4 machines
ip filter forward dup to 10.2.3.4 device "eth0"

#Copier l'image brute vers une autre interface
netdetv ingress dup to "eth0"
dup to "eth0"

#Mapper vers la passerelle Combiner avec dst addr
dup to ip daddr map { 192.168.7.1 : "eth0", 192.168.7.2 : "eth1" }

Déclaration FWD

L'instruction fwd est utilisée pour rediriger les paquets bruts vers une autre interface. Il ne peut être utilisé qu'avec le crochet d'entrée de la famille netdev. Similaire à une instruction dup, sauf qu'aucune copie n'est effectuée.

fwd to device

déclaration set

L'instruction set '' est utilisée pour ajouter ou mettre à jour dynamiquement des éléments dans l'ensemble à partir du chemin du paquet. set setname`` doit déjà exister dans la table spécifiée. En outre, les ensembles qui sont mis à jour dynamiquement à partir du jeu de règles nftables doivent spécifier à la fois une taille maximale de l'ensemble (pour éviter de manquer de mémoire) et un délai (pour éviter un nombre illimité d'entrées dans l'ensemble). .. L'instruction set crée, par exemple, une liste noire dynamique.

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

Exemple de liste noire simple

#famille"ip"Table"filter"Déclarez l'ensemble lié à. Le délai et la taille sont nécessaires pour ajouter des éléments à partir du chemin du paquet.
nft add set ip filter blackhole "{type ipv4_addr; flags timeout; size 65536;}"

#Ajoutez l'interface interne à la liste blanche.
nft add rule ip filter input meta iifname "internal" accept

#Supprimez les paquets des adresses IP de la liste noire.
nft add rule ip filter input ip saddr @blackhole counter drop

#S'il y a plus de 10 demandes de connexion TCP par seconde, mettez sur liste noire l'adresse IP source.
#L'entrée expire après 1 minute. Après cela, si l'état restreint continue, l'entrée peut être ajoutée à nouveau.
nft add rule ip filter input tcp flags syn tcp dport ssh meter flood size 128000 {ip saddr timeout 10s limit rate over 10 / second} add @blackhole {ip saddr timeout 1m} drop

#Vérifiez l'état du compteur de limite de débit.
nft list meter ip filter flood

#Inspectez le contenu du trou noir:
nft list set ip filter blackhole

#Ajouter manuellement les deux adresses à l'ensemble:
nft add element filter blackhole { 10.2.3.4, 10.23.1.42 }

Commandes supplémentaires

Voici quelques-unes des commandes supplémentaires incluses dans nft.

moniteur

Vous pouvez utiliser la commande `` monitor '' pour écouter les événements Netlink générés par le sous-système nf_tables en relation avec la création et la suppression d'objets. Lorsqu'un événement se produit, nft imprime l'événement surveillé sur la sortie standard au format XML, JSON ou nft natif.

Pour filtrer les événements liés aux objets concrets, utilisez les mots-clés tables, chaînes, sets, rules, ```elements, ruleset`` Utiliser.

Utilisez les mots-clés nouveau '' ou détruire '' pour filtrer les événements liés à une action spécifique.

Appuyez sur `` ^ C '' pour terminer l'opération de surveillance.

#Écoute tous les événements et génère un rapport au format natif nft
% nft monitor

#Écoute la table ajoutée et génère un rapport au format XML
% nft monitor new tables xml

#Écoute les règles supprimées et génère un rapport au format JSON
% nft monitor destroy rules json

#Attendre les chaînes nouvelles et détruites au format nft natif
% nft monitor chains

#Écoute les événements d'ensemble de règles tels que les tables, les chaînes, les règles, les ensembles, les compteurs, les quotas au format nft natif
% nft monitor ruleset

Rapport d'erreur

Lorsqu'une erreur est détectée, nft '' indique la ligne contenant l'erreur, indique l'emplacement de la partie erronée dans le flux d'entrée et utilise le carryt ( ^ '') pour marquer la partie erronée. Je vais le télécharger. Si l'erreur est due à une combinaison de deux expressions ou instructions, la partie imposant la contrainte violante est marquée d'un tilder (`` ~ '').

Pour les erreurs renvoyées par le noyau, nft ne peut pas détecter quelle partie de l'entrée est à l'origine de l'erreur et la commande entière est marquée.

Erreur due à une expression incorrecte

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

Erreur causée par une combinaison incorrecte de deux expressions

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

Erreur renvoyée par le noyau

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

Statut de résiliation

En cas de succès, nft quittera avec le statut 0. Si une erreur non spécifiée se produit, il sort avec l'état 1, l'état 2 est l'état 3 s'il s'agit d'une erreur d'allocation de mémoire et le socket Netlink ne peut pas être ouvert.

Article connexe

• iptables(8)
• ip6tables(8)
• arptables(8)
• ebtables(8)
• ip(8)
• tc(8)

Il existe un wiki officiel sur https://wiki.nftables.org.