[Précédent : Redirection de Trafic ("Forwarding" de Ports)] [Index] [Suivant : Options de Fonctionnement]

PF : Raccourcis pour la Création de Jeux de Règles

Table des Matières

Introduction
Utiliser les Macros
Utiliser les Listes
Grammaire de PF

Introduction

PF offre plusieurs moyens pour simplifier un jeu de règles. Quelques bons exemples sont les macros et les listes. De plus, le langage d'écriture des jeux de règles, ou grammaire, offre aussi quelques raccourcis pour rendre un jeu de règles plus simple. En règle générale, plus un jeu de règles est facile plus il est facile de le comprendre et le maintenir.

Utiliser les Macros

Les macros sont utiles car elles fournissent une alternative au codage en dur des adresses, des numéros de ports, des noms d'interfaces, etc... dans un jeu de règles. Est-ce que l'adresse IP d'un serveur a été modifiée ? Pas de problème, il suffit de mettre à jour la macro; nul besoin de retoucher les règles de filtrage que vous avez mis du temps et de l'énergie à construire selon vos besoins.

Une convention usuelle dans l'écriture des jeux de règles PF est de définir une macro pour chaque interface réseau. Si une carte réseau doit être remplacée par une autre carte qui utilise un pilote différent (en changeant une 3Com par une Intel par exemple), la macro est mise à jour et les règles de filtrage fonctionneront comme avant. Un autre bénéfice est le déploiement du même jeu de règles sur plusieurs machines. Certaines de ces machines peuvent avoir des cartes réseau différentes. L'utilisation de macros pour définir les cartes réseau permet d'installer les jeux de règles avec un minimum d'édition. L'utilisation de macros pour définir des informations dans un jeu de règles sujet à changements, telles que les numéros de ports, les adresses IP et les noms d'interfaces est une pratique recommandée.

# définition de macros pour chaque interface réseau IntIF = "dc0" ExtIF = "fxp0" DmzIF = "fxp1"

Une autre convention usuelle est d'utiliser les macros pour définir des adresses IP et les blocs réseau. Ceci aura pour effet de réduire de manière significative les opérations de maintenance d'un jeu de règles lorsque les adresses IP y figurant changent.

# définition de nos réseaux IntNet = "192.168.0.0/24" ExtAdd = "24.65.13.4" DmzNet = "10.0.0.0/24"

Si le réseau interne doit être étendu ou modifié, il suffit de mettre à jour la macro :

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

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

Utiliser les Listes

Prenons comme exemple quelques bonnes règles à inclure dans vos jeux de règles pour gérer les adresses RFC 1918 qui ne doivent pas être routées sur Internet et qui d'habitude sont utilisées dans un but malicieux :

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

Simplifions maintenant les règles ci-dessus :

block in quick on tl0 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 tl0 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 six lignes : on est passé de huit lignes à deux. On peut encore simplifier en utilisant des macros en conjonction d'une liste :

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

Notez que les macros et les listes simplifient le fichier pf.conf mais que les lignes sont en réalité interprétées par pfctl(8) en plusieurs lignes. Ainsi l'exemple précédent est interprété comme suit :

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

Comme vous pouvez le voir, la simplification des règles figurant dans le fichier pf.conf est une facilité offerte à l'auteur et à la personne chargée de la maintenance de ce fichier. Ce n'est pas une simplification réelle des règles traitées par pf(4).

Les macros peuvent être utilisées n'importe où dans le fichier de règles PF et pas seulement pour définir des adresses et des ports :

pre = "pass in quick on ep0 inet proto tcp from " post = "to any port { 80, 6667 } keep state" # classe de David $pre 21.14.24.80 $post # logement de Nick $pre 24.2.74.79 $post $pre 24.2.74.178 $post

Les macros précédentes sont interprétées comme suit :

pass in quick on ep0 inet proto tcp from 21.14.24.80 to any \ port = 80 keep state pass in quick on ep0 inet proto tcp from 21.14.24.80 to any \ port = 6667 keep state pass in quick on ep0 inet proto tcp from 24.2.74.79 to any \ port = 80 keep state pass in quick on ep0 inet proto tcp from 24.2.74.79 to any \ port = 6667 keep state pass in quick on ep0 inet proto tcp from 24.2.74.178 to any \ port = 80 keep state pass in quick on ep0 inet proto tcp from 24.2.74.178 to any \ port = 6667 keep state

Grammaire de PF

La grammaire de PF est assez flexible ce qui permet une grande flexibilité dans les jeux de règles. PF est capable de supposer certains mots-clés ce qui veut dire qu'ils n'ont pas besoin d'être explicitement inclus dans une règle, et l'ordonnancement des mots-clés est relâché de telle façon à ce qu'il ne soit pas nécessaire de mémoriser une syntaxe stricte.

Élimination de mots-clé

Pour définir une politique de blocage par défaut, deux règles sont utilisés :

block in all block out all

Ceci peut être réduit à :

block all

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

De manière similaire, les clauses "from any to any" et "all" peuvent ne pas figurer dans une règle. Par exemple :

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

peut être simplifiée de la manière suivante :

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

La première règle bloque tous les paquets en entrée de n'importe où vers n'importe où sur l'interface rl0, et la deuxième règle laisse passer le trafic TCP sur rl0 à destination du port 22.

Simplification des Règles avec `return`

Un jeu de règles utilisé pour bloquer des paquets et répondre avec un TCP RST ou un ICMP Unreachable peut être écrit comme suit :

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

Il peut être largement simplifié comme suit :

block return

Quand PF voit le mot-clé return, il "sait" ce qu'il faut envoyer comme réponse (ou ne pas en envoyer du tout), selon le protocole du paquet bloqué.

Ordonnancement de Mots-clés

L'ordre selon lequel les mots-clés sont spécifiés est flexible dans la plupart des cas. Par exemple, une règle écrite comme suit :

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

Peut aussi être écrite de cette façon :

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

Des variations similaires fonctionneront aussi.