OBSD4* : wiki

Version de traduction basée sur la 6.4 officielle (v1.58 : 29/10/2018)


PF - Les Ancres

Introduction

En plus du jeu de règle principal, PF peut aussi évaluer des sous-ensembles de règles. Puisque les sous-ensembles de règles peuvent être manipulés à la volée en utilisant pfctl(8), ils fournissent une manière convenable d’altérer dynamiquement un jeu de règle actif. Là où une table est utilisée pour capturer dynamiquement une liste d'adresses, un sous-ensemble de règles est utilisé pour capturer un ensemble dynamique de règles. Un sous-ensemble est attaché au jeu de règles principal en utilisant anchor.

Les ancres peuvent être imbriquées ce qui permet aux sous-ensembles d'être chaînés ensemble. Les règles d'ancres seront évaluées relativement à l'ancre depuis laquelle elles sont chargées. Par exemple, les règles d'ancres dans le jeu de règles principal créeront des points d'attaches d'ancre avec le jeu de règles principal en tant que parents, et les règles d'ancres chargées depuis des fichiers seront chargées par la directive load anchor, créeront des points d'ancres avec l'ancre pour parents.

Les ancres

Une ancre est une collection de règles, de tables et d'autres ancres qui ont été assignées par un nom. Quand PF rencontre une règle anchor dans le jeu de règles principal, il évalue les règles contenues dans ce point d'ancrage, tout comme il évalue les règles du jeu de règles principal. Le processus continuera alors dans le jeu de règles principal à moins qu'un paquet correspond à une règle de filtrage qui utilise l'option quick ; dans un tel cas, la correspondance sera considérée terminée et fera échouée l'évaluation des règles dans les deux ensembles que sont l'ancre et le jeu de règles principal.

Par exemple :

  block on     egress
  pass  out on egress
  
  anchor goodguys

Ce jeu de règle définit une politique de refus par défaut sur l'interface egress pour le trafic entrant et sortant, qui est alors suivi d'état en sortie, et une règle d'ancre est créée, nommée goodguys. Les ancres peuvent être remplies de règles par trois méthodes :

  • en utilisant la règle load
  • en utilisant pfctl(8)
  • en spécifiant les règles à l’intérieur du jeu de règles principal

La règle load oblige pfctl à remplir l'ancre spécifiée par la lecture de règles depuis un fichier texte. La règle load doit être placée après la règle anchor.

Par exemple :

  anchor goodguys
  load anchor goodguys from "/etc/anchor-goodguys-ssh"

Pour ajouter des règles à une ancre en utilisant pfctl, la commande type suivante peut être utilisée :

  # echo "pass in proto tcp from 192.0.2.3 to any port 22" | pfctl -a goodguys -f -

Les règles peuvent être aussi sauvées (et chargées depuis) depuis un fichier texte. Par exemple, vous pouvez ajouter les deux lignes suivantes au fichier /etc/anchor-goodguys-www :

  pass in proto tcp from 192.0.2.3 to any port 80
  pass in proto tcp from 192.0.2.4 to any port { 80 443 }

Puis appliquez-les, avec :

  # pfctl -a goodguys -f /etc/anchor-goodguys-www

Pour charger les règles directement depuis le jeu de règles principal, délimitez les règles d'ancre entre crochets :

  anchor "goodguys" {
      pass in proto tcp from 192.168.2.3 to port 22
  }

Des ancres inline peuvent aussi contenir d'autres ancres.

  allow = "{ 192.0.2.3 192.0.2.4 }"
  
  anchor "goodguys" {
    anchor {
         pass in proto tcp from 192.0.2.3 to port 80
    }
    pass in proto tcp from $allow to port 22
  }

Avec les ancres inline, le nom d'ancre devient optionnel. Notez comment l'ancre imbriquée dans l'exemple ci-dessus n'a pas de nom. La macro $allow est créée en-dehors de l'ancre (dans le jeu de règles principal) et est alors utilisée dans l'ancre.

Les règles peuvent être chargées dans une ancre en utilisant la même syntaxe et les mêmes options que les règles chargées depuis le jeu de règles principal. À la réserve près, à moins que vous utilisiez des ancres inline, toutes les macros qui sont utilisées doivent aussi être définies dans l'ancre elle-même ; les macros qui sont définies dans le jeu de règles parent ne sont pas visibles depuis l'ancre.

Puisque les ancres peuvent être imbriquées, il est possible de spécifier que toutes les ancres enfants d'une ancre spécifiée soient évaluées :

  anchor "spam/*"

Cette syntaxe oblige chaque règle à l'intérieur de chaque ancre attachée à l'ancre spam à être évaluée. Les ancres enfants seront évaluées dans l'ordre alphabétique mais ne le seront pas de manières récursives. Les ancres sont toujours évaluées relativement à l'ancre dans lesquelles elles sont définies.

Chaque ancre, aussi bien que le jeu de règles principal, existe séparément des autres ensembles de règles. Les opérations faites sur un jeu de règles, tel que nettoyer des règles, n'affectent aucunes des autres. De plus, supprimer un point d'ancre depuis le jeu de règles principal ne détruit pas l'ancre ou les ancres enfants qui sont attachées à cette ancre. Une ancre n'est pas détruite jusqu'à ce qu'elle soit purgée de toutes les règles utilisant pfctl(8) et qu'il n'y ait pas d'ancres enfants à l'intérieur de celle-ci.

Options d'ancres

Optionnellement, les règles anchor peuvent spécifier des interfaces, des protocoles, des adresses sources et de destinations, des étiquettes, en utilisant la même syntaxe que les autres règles. Quand une telle information est donnée, les règles anchor sont seulement traitées si les paquets correspondent aux règles anchor.

Par exemple :

  block          on egress
  pass       out on egress
  anchor ssh in  on egress proto tcp to port 22

Les règles dans l'ancre ssh sont seulement évaluées pour les paquets TCP à destination du port 22 qui arrivent sur l'interface egress. Les règles sont alors ajoutées à l'ancre, telles quelles :

  # echo "pass in from 192.0.2.10 to any" | pfctl -a ssh -f -

Ainsi, même au-travers d'une règle de filtrage qui ne spécifie aucune interface, protocole ou port, l'hôte 192.0.2.10 sera le seul autorisé à se connecter en utilisant SSH grâce à la définition de la règle anchor.

La même syntaxe peut être appliquée aux ancres inline.

  allow = "{ 192.0.2.3 192.0.2.4 }"
  anchor "goodguys" in proto tcp {
     anchor proto tcp to port 80 {
        pass from 192.0.2.3
     }
     anchor proto tcp to port 22 {
        pass from $allow
     }
  }

Manipuler les ancres

La manipulation des ancres est assurée via pfctl(8). Il peut être utilisé pour ajouter et supprimer des règles depuis une ancre sans recharger le jeu de règles principal.

Pour lister toutes les règles de l'ancre nommée ssh :

# pfctl -a ssh -s rules

Pour purger toutes les règles depuis la même ancre :

# pfctl -a ssh -F rules

Pour avoir une pleine liste des commandes, veuillez lire pfctl(8).


Cette page est la traduction officieuse de la page “Anchors de la FAQ officielle d'OpenBSD.
En cas de doute, merci de vous y référer !

Si vous voulez participer à l'effort de traduction, merci de lire ce topic.