Les listes d'accès sont une matière importante et basique du CCNA.
Ici, il s'agit seulement d'appliquer des filtres sur les interfaces
afin de bloquer du trafic qui les traverse. Toutefois, leur principe
s'applique à d'autres circonstances qui dépassent notre étude ...
1. Définition
Une liste d'accès est un ensemble d'instructions basées sur des protocoles de couche 3 et de couches supérieures pour filtrer le trafic. L'étude exige seulement que nous les appliquions à partir des interfaces.
Les ACLs font partie des fonctionnalités de type "firewall" des IOS Cisco. On se contentera d'étudier les ACLs standard et étendue désignées par un numéro ou nom.
Notons que l'on trouvera aussi des ACLs réflexives, basées sur le temps
et Context-based access control (CBAC). Ces dernières ne sont pas
abordées par le CCNA. Elles font parties du cours sécurité.
2. Types de protocoles
Les types de protocoles que nous allons pouvoir configurer dans les instructions de filtrage sont :
*le port source
* l'adresse IP source
* une partie de l'adresse source
* le port de destination
* l'adresse IP de destination
* une partie de l'adresse de destination
3. Utilité
Une liste d'accès va servir :
* A supprimer des paquets pour des raisons de sécurité (pour du trafic de données ou des accès VTY)
* A supprimer des paquets pour des raisons de sécurité (pour du trafic de données ou des accès VTY)
* A filtrer des mises à jour de routage
* A filtrer des paquets en fonction de leur priorité (QoS)
* A définir du trafic intéressant pour des configurations spécifiques (NAT, ISDN, etc.)
4. Logique
Une liste d'accès,
comportant une suite d'instructions de filtrage, va être appliquée sur
une interface du routeur, pour le trafic entrant ou pour le trafic
sortant. Il va falloir appliquer une logique sur les interfaces en
sortie ou en entrée :
5. Caractéristiques
* Les paquets peuvent être filtrés en entrée (quand ils entrent sur une interface) avant la décision de routage
* Les paquets peuvent être filtrés en sortie (avant de quitter une interface) après la décision de routage.
* Le mot clef IOS est "deny" pour signifier que les paquets doivent être filtrés ; précisément les paquets seront refusés selon les critères définis.
* Le mot clef IOS est "permit" pour signifier que les paquets ne doivent pas être filtrés ; précisément les paquets seront permis selon les critères définis.
* La logique de filtrage est configurée dans les listes d'accès.
* Une instruction implicite rejette tout le trafic à la fin de chaque liste d'accès
6. Traitement
Le traitement d'une liste d'accès se déroule en deux étapes :
1. Recherche de correspondance (examen de chaque paquet)
2. Action (deny ou permit)
Ensuite ,
3. Si pas de correspondance, instruction suivante
4. Si aucune correspondance, l'instruction implicite est appliquée
1. Recherche de correspondance (examen de chaque paquet)
2. Action (deny ou permit)
Ensuite ,
3. Si pas de correspondance, instruction suivante
4. Si aucune correspondance, l'instruction implicite est appliquée
7. Différence entre liste d'accès standard et liste d'accès étendue
* Une liste d'accès standard examinera seulement l'adresse IP source.
* Une liste d'accès étendue pourra examiner les adresses IP et les ports aussi bien source que destination, ainsi que type de protocole (IP, ICMP, TCP, UDP).
* Par ailleurs, il sera possible de vérifier une partie des adresses avec un masque générique (wildcard mask).
8. Désignation d'une liste d'accès
On donnera soit un numéro ou un nom à une liste d'accès (un ensemble d'instructions de filtrage) à appliquer sur une interface en entrée ou en sortie.
Si on utilise un numéro on aura le choix dans une plage de nombres en fonction du protocole de couche 3 :
Si on utilise un numéro on aura le choix dans une plage de nombres en fonction du protocole de couche 3 :
| Protocole | Plage |
| IP | 1 - 99 et 1300 - 1999 |
| IP étendu | 100 - 199 et 2000 - 2699 |
| Apple Talk | 600 - 699 |
| IPX | 800 - 899 |
| IPX étendu | 900 - 999 |
| Protocole IPX Service Advertising | 1000 - 1099 |
Si on utilise un nom, il faudra désigner le type de liste : standard ou étendue.
9. Le masque générique (Wildcard Mask)
Il ne faut pas confondre un masque générique (wilcard mask) avec un masque de réseau.
Un masque générique est un masque de filtrage. Quand un bit aura une valeur de 0 dans le masque, il y aura vérification de ce bit sur l'adresse IP de référence. Lorsque le bit aura une valeur de 1, il n'en y aura pas.
Un masque de réseau est un masque de division ou de regroupement. Une addition booléenne d'une adresse IP et d'un masque de réseau est utilisée pour distinguer la partie réseau de la partie hôte.
En binaire, alors qu'un masque de réseau est nécessairement une suite homogène de 1 et puis de 0, un masque générique peut être une suite quelconque de 1 et de 0 en fonction du filtrage que l'on veut opérer sur des adresses IP.
Un masque générique est un masque de filtrage. Quand un bit aura une valeur de 0 dans le masque, il y aura vérification de ce bit sur l'adresse IP de référence. Lorsque le bit aura une valeur de 1, il n'en y aura pas.
Un masque de réseau est un masque de division ou de regroupement. Une addition booléenne d'une adresse IP et d'un masque de réseau est utilisée pour distinguer la partie réseau de la partie hôte.
En binaire, alors qu'un masque de réseau est nécessairement une suite homogène de 1 et puis de 0, un masque générique peut être une suite quelconque de 1 et de 0 en fonction du filtrage que l'on veut opérer sur des adresses IP.
Considérons l'exemple suivant :
| Adresse de référence : | 10.1.1.0 |
| Masque générique : | 0.0.0.255 |
| Adresse de référence (binaire) : | 00001010. 00000001. 00000001.00000000 |
| Masque générique (binaire) : | 00000000. 00000000. 00000000.11111111 |
En se basant sur le masque en binaire, on peut remarquer que les
trois premiers octets de l'adresse de référence doivent correspondre. La
valeur du dernier octet n'a pas d'importance. Autrement dit, avec ce
masque, toutes les adresses de 10.1.1.0 jusque 10.1.1.255 seront
vérifiées.
Voici quelques exemples classiques de masque générique sur n'importe quelle adresse IP :
| Masque générique | Version binaire | Description |
| 0.0.0.0 | 00000000.00000000.00000000.00000000 | Tous les bits seront examinés |
| 0.0.0.255 | 00000000.00000000.00000000.11111111 | Les 24 premiers bits seront examinés |
| 0.0.255.255 | 00000000.00000000.11111111.11111111 | Les 16 premiers bits seront examinés |
| 0.255.255.255 | 00000000.11111111.11111111.11111111 | Les 8 premiers bits seront examinés |
| 255.255.255.255 | 11111111.11111111.11111111.11111111 | L'adresse ne sera pas examinée. Tous les bits correspondent d'emblée. |
| 0.0.15.255 | 00000000.00000000.00001111.11111111 | Les 20 premiers bits seront examinés |
| 0.0.3.255 | 00000000.00000000.00000011.11111111 | Les 22 premiers bits seront examinés |
| 32.48.0.255 | 00100000.00110000.00000000.11111111 | Tous les bits seront examinés sauf le 3ème, le 11ème, le 12ème et les 8 derniers |
* Le mot "any" remplace le 0.0.0.0 255.255.255.255, autrement dit toute adresse IP
* Le mot "host" remplace le masque 0.0.0.0, par exemple, 10.1.1.1 0.0.0.0 peut être remplacé par "host 10.1.1.1"
Concrètement, on pourra
généraliser de la manière suivante. Le masque générique à utiliser est
l'inverse du masque de réseau pour un réseau à filtrer. Par exemple,
pour filter sur 192.168.1.0/24 (255.255.255.0), on prendra un masque générique 0.0.0.255. Autre exemple aussi, pour filter sur 192.168.1.0/27 (255.255.255.224), on prendra un masque générique 0.0.0.31.
10. Règles d'application
Placer les listes d'accès
aussi près de que possible de la source des paquets (au niveau de
l'interface) s'il s'agit d'une ACL étendue. Par contre, s'il s'agit
d'une ACL standard, il faut la placer au plus proche de la destination
(puisque c'est ce qu'elle ne vérifie pas).* Placer en tête de liste les règles (les instructions) qui font l'objet d'une correspondance la plus précise et les plus générales à la fin.
* Suivre ces deux recommandations tout en respectant les restrictions d'accès qui ont été identifiées.
11. Syntaxe des commandes
La mise en œuvre d'une ACL se déroule en deux étapes :
- Création de la liste, en plaçant les instructions les unes après les autres suivies d'un retour chariot.
- Application sur une interface en entrée ou en sortie
11.1. Liste d'accès standard
Router(config)#access-list numéro-liste-accès {deny|permit} adresse-source [masque-source] [log]
11.2. Liste d'accès étendue
Router(config)#access-list numéro-liste-accès {deny|permit} protocole adresse-source masque-source [opérateur port] adresse-destination masque-destination [opérateur port] [log]
Où :
"opérateur" peut prendre les valeurs suivantes :
"opérateur" peut prendre les valeurs suivantes :
- lt (less than)
- gt (greater than)
- eq (equal)
- neq (not equal)
- range (inclusive range).
Où le paramètre "port" peut prendre une valeur nominative ou numéraire :
de 0 à 65535 ou, par exemple, http, telnet, ftp, etc.
de 0 à 65535 ou, par exemple, http, telnet, ftp, etc.
11.3. Liste d'accès nommée
Router(config)#ip access-list standard nom
Router(config-ext-nacl)#permit|deny …
Router(config-ext-nacl)#permit|deny …
Router(config)#ip access-list extended nom
Router(config-ext-nacl)#permit|deny …
Router(config-ext-nacl)#permit|deny …
11.4. Activation d'une liste d'accès sur une interface
Router(config-if)#ip access-group {numéro-liste-accès|nom [in | out]}
11.5. Diagnostic
Router#show ip interface [type numéro]
Router#show access-lists [numéro-liste-accès|nom-liste-accès]
Router#show ip access-list [numéro-liste-accès|nom-liste-accès]
On pourra "logguer" le comportement d'une ACL en ajoutant le terme log à la fin d'une directive. Un show logging donnera le résultat.
12. Optimisation du masque générique
Chaque paquet sera vérifié par chaque entrée d'une ACL. Il y aura autant de vérification qu'il y a de paquets et d'entrées. Des listes d'accès
trop longues peuvent engager beaucoup de ressources. Il s'agira de les
optimiser. Aussi, on peut également élaborer des critères de
vérifications assez fins. En voici des exemples.
12.1. Summarization d'ACL
Considérons ces huit réseaux à filtrer :
192.168.32.0/24
192.168.33.0/24
192.168.34.0/24
192.168.35.0/24
192.168.36.0/24
192.168.37.0/24
192.168.38.0/24
192.168.39.0/24
Les deux premiers octets sont identiques. Ils devront être vérifiés. Le masque générique commencera par 0.0.
Le troisième octet varie. Il peut être écrit comme dans le tableau
suivant conformément à la position de chaque bit par rapport à sa
valeur :
| Décimale | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
| 32 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 |
| 33 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 1 |
| 34 | 0 | 0 | 1 | 0 | 0 | 0 | 1 | 0 |
| 35 | 0 | 0 | 1 | 0 | 0 | 0 | 1 | 1 |
| 36 | 0 | 0 | 1 | 0 | 0 | 1 | 0 | 0 |
| 37 | 0 | 0 | 1 | 0 | 0 | 1 | 0 | 1 |
| 38 | 0 | 0 | 1 | 0 | 0 | 1 | 1 | 0 |
| 39 | 0 | 0 | 1 | 0 | 0 | 1 | 1 | 1 |
| M | M | M | M | M | D | D | D |
On remarque aisément que les cinq premiers bits correspondent
exactement (M) alors que les trois derniers changent. Le masque
générique sur cet octet sera donc : 7 (00000111)
Dans le cas présenté, le dernier octet ne doit pas être vérifié. Le masque générique sera : 0.0.7.255
Notons que cet ensemble d'adresses peut être résumé avec le masque de
super-réseau : "192.168.32.0/21" ou "192.168.32.0 255.255.248.0". Dans ce cas commun dans lequel il faudra vérifier ce groupe d'adresse IP, le masque générique sera l'inverse du masque réseau : en soustrayant 255.255.248.0 de 255.255.255.255, on obtient 0.0.7.255
12.2. Filtrage fin
Quelle méthode a été employée pour découvrir les bits qui doivent
être filtrés sur une adresse IP ? On a désigné les bits qui ne
varient pas d'une adresse à une autre et nous les avons marqué avec un
masque générique à la valeur 0 en binaire. Par exemple, pour filtrer sur
un octet uniquement les adresses paires :
| Décimale | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 2 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
| 4 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 |
| 6 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 0 |
| 8 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 |
| 10 | 0 | 0 | 0 | 0 | 1 | 0 | 1 | 0 |
| x pairs | ? | ? | ? | ? | ? | ? | ? | 0 |
| D | D | D | D | D | D | D | M |
On constate que le point commun entre toutes ces adresses ne concerne
que le dernier bit de l'octet. C'est donc ce dernier qu'il faudra
vérifier par rapport à une adresse de référence. Concrètement, en
binaire, on aura un masque sur l'octet de "11111110", "254" en décimale avec comme octet de référence binaire "00000000", "0" en décimale. Avec la directive "192.168.1.0/0.0.0.254", on filtrera toutes les adresses paires du réseau 192.168.1.0/24. C'est comme si on disait, vérifie :
* que le premier octet soit toujours égal à 192 en décimale,
* que le second octet soit toujours égal à 168 en décimale,
* que le troisième octet soit toujours égal à 1 en décimale,
* que le dernier bit du quatrième octet soit toujours égal à zéro en binaire, soit que sa valeur décimale soit paire.
