OBSD4* : wiki

Version de traduction basée sur la 6.2 officielle


PF - Raccourcis pour créer des jeux de règles

Introduction

PF offre beaucoup de manières par lesquelles une règle peut être simplifiée. Quelques bons exemples sont l'usage de macros et listes. En outre, le langage des jeux de règles, ou la grammaire, offre aussi quelques raccourcis pour la création de jeu de règles simples. En règle générale, plus le jeu de règles est simple, plus il est facile de le comprendre et le maintenir.

Utiliser des macros

Les macros sont pratiques parce qu'elles fournissent une alternative aux adresses codées en dur, aux numéros de ports, aux noms d'interfaces, etc… dans un jeu de règles. Est-ce qu'un serveur à changer d'adresse IP ? Pas de problème, mettez à jour juste la macro ; pas besoin de se demander à-propos des règles de filtrage sur lesquelles vous avez passé du temps et de l'énergie à les perfectionner pour vos besoins.

Une convention commune dans les jeux de règles PF est de définir une macro pour chaque interface réseau. Si jamais une carte réseau a besoin d'être remplacée par une qui utilise un pilote logiciel différent, la macro peut être mise à jour, et le jeu de règles fonctionnera comme avant. Un autre bénéfice est lors de l'installation de jeu de règles similaire sur de multiples machines. Certaines machines ont des cartes réseaux différentes, et utiliser des macros pour définir les interfaces réseaux permet d'installer des jeux de règles avec à un minimum d'édition. Utiliser les macros pour définir l'information dans un jeu de règles susceptible de changer, tels que des numéros de ports, des adresses IP, et des noms d'interfaces est une pratique recommandée.

  # définir une macro pour chaque interface réseaux
  IntIF = "dc0"
  ExtIF = "fxp0"
  DmzIF = "fxp1"

Une autre convention commune est l'usage de macros pour définir des adresses IP ou des blocs réseaux. Cela peut grandement réduire la maintenance d'un jeu de règles quand des adresses IP changent.

  # définir nos réseaux
  IntNet = "192.168.0.0/24"
  ExtAdd = "192.0.2.4"
  DmzNet = "10.0.0.0/24"

Si le réseau interne a été étendu, ou a été renuméroté dans un bloc IP différent, la macro peut être mise-à-jour :

  IntNet = "{ 192.168.0.0/24, 192.168.1.0/24 }"

Une fois le jeu de règles rechargé, chaque chose fonctionnera comme avant.

Utiliser les listes

Examinons un bon ensemble de règles, à avoir dans votre jeu de règles, qui gèrent les adresses définies dans la RFC 1918, qui ne devraient pas être sur Internet, et qui si elles y sont, posent habituellement problème :

  block in  quick on egress inet from 127.0.0.0/8 to any
  block in  quick on egress inet from 192.168.0.0/16 to any
  block in  quick on egress inet from 172.16.0.0/12 to any
  block in  quick on egress inet from 10.0.0.0/8 to any
  block out quick on egress inet from any to 127.0.0.0/8
  block out quick on egress inet from any to 192.168.0.0/16
  block out quick on egress inet from any to 172.16.0.0/12
  block out quick on egress inet from any to 10.0.0.0/8

Maintenant, regardons la simplification suivante :

  block in quick  on egress inet from { 127.0.0.0/8, 192.168.0.0/16, \
     172.16.0.0/12, 10.0.0.0/8 } to any
  block out quick on egress inet from any to { 127.0.0.0/8, \
     192.168.0.0/16, 172.16.0.0/12, 10.0.0.0/8 }

Le jeu de règles a été réduit de huit lignes à deux. Les choses deviennent encore plus intéressantes quand les macros sont utilisées conjointement avec une liste :

  NoRouteIPs = "{ 127.0.0.0/8, 192.168.0.0/16, 172.16.0.0/12, 10.0.0.0/8 }"
  
  block in  quick on egress from $NoRouteIPs to any
  block out quick on egress from any to $NoRouteIPs

Notez que les macros et les listes simplifient le fichier pf.conf, mais que les lignes sont actuellement développées par pfctl(8) dans de multiples règles. Ainsi, l'exemple ci-dessus fonctionne comme le jeu de règles étendu suivant :

  block in  quick on egress inet from 127.0.0.0/8 to any
  block in  quick on egress inet from 192.168.0.0/16 to any
  block in  quick on egress inet from 172.16.0.0/12 to any
  block in  quick on egress inet from 10.0.0.0/8 to any
  block out quick on egress inet from any to 10.0.0.0/8
  block out quick on egress inet from any to 172.16.0.0/12
  block out quick on egress inet from any to 192.168.0.0/16
  block out quick on egress inet from any to 127.0.0.0/8

Comme vous le voyez, l’expansion de PF est purement une commodité pour celui qui écrit et maintient le fichier pf.conf, mais pas une simplification réelle des règles traitées par pf(4).

Les macros peuvent être utilisées pour définir plus que juste des adresses et des ports ; elles peuvent être utilisées partout dans le fichier de règles de PF :

  pre  = "pass in quick on ep0 inet proto tcp from "
  post = "to any port { 80, 6667 }"
  
  $pre 198.51.100.80 $post
  $pre 203.0.113.79  $post
  $pre 203.0.113.178 $post

Qui une fois développées :

  pass in quick on ep0 inet proto tcp from 198.51.100.80 to any port = 80
  pass in quick on ep0 inet proto tcp from 198.51.100.80 to any port = 6667
  pass in quick on ep0 inet proto tcp from 203.0.113.79  to any port = 80
  pass in quick on ep0 inet proto tcp from 203.0.113.79  to any port = 6667
  pass in quick on ep0 inet proto tcp from 203.0.113.178 to any port = 80
  pass in quick on ep0 inet proto tcp from 203.0.113.178 to any port = 6667

Grammaire de PF

La grammaire de PF est assez flexible, ce qui, à son tour, permet une plus grande flexibilité dans un jeu de règles. PF est capable de déduire certains mots-clés ce qui signifie qu'ils n'ont pas à être explicites dans une règle, et que l'ordre des mots-clés n'est pas nécessaire au point de mémoriser une syntaxe stricte.

Élimination des mots-clés

Pour définir une politique “deny default” (rejet par défaut), deux règles sont utilisées :

  block in  all
  block out all

Cela peut maintenant être réduit à :

  block

Quand aucune direction n'est spécifiée, PF supposera que la règle s'applique aux paquets traversant dans les deux directions.

De la même manière, les clauses “from any to any” et “all”, peuvent être exclues d'une règle, par exemple :

  block in on rl0 all
  pass  in quick log on rl0 proto tcp from any to any port 22

qui peut être simplifiée, comme :

  block in on rl0
  pass  in quick log on rl0 proto tcp to port 22

La première règle bloque tous les paquets entrants de partout et vers partout sur l'interface réseau rl0, et la seconde règle passe le trafic TCP dans rl0 sur le port 22.

La simplification ''return''

Un jeu de règles utilisé pour bloquer les paquets et répondre avec un TCP RST ou une réponse ICMP Unreachable peut prendre la forme suivante :

  block in all
  block return-rst  in proto tcp all
  block return-icmp in proto udp all
  block out all
  block return-rst  out proto tcp all
  block return-icmp out proto udp all

Ce qui peut être simplifié par :

  block return

Quand PF voit le mot-clé return, il est assez intelligent pour envoyer la réponse correcte, ou pas de réponse du tout, selon le protocole du paquet qui doit être bloqué.

L'ordre des mots-clés

L'ordre des mots-clés spécifiés est flexible dans la plupart des cas. Par exemple, une règle écrite telle que :

  pass in log quick on rl0 proto tcp to port 22 flags S/SA queue ssh label ssh

peut aussi être écrite, telle que :

  pass in quick log on rl0 proto tcp to port 22 queue ssh label ssh flags S/SA

D'autres variations similaires peuvent aussi fonctionner.


Cette page est la traduction officieuse de la page “Shortcuts for creating rulesets 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.