[Scapy](https://github.com/secdev/scapy) est un programme et une librairie de manipulation de paquets écrite en Python. L'outil permet de forger, décoder des paquets reçus, émettre des paquets et capturer un segment de communication (format [PCAP](https://www.endace.com/learn/what-is-a-pcap-file)) ainsi que des procédures de prototypage de paquets simplifiées et naturelles grâce à l’auto-complétion intelligente mise à disposition.
Scapy se sert du mode **promiscuous** des interfaces et réintroduit intégralement une stack TCP/IP sur laquelle il possède les pleins pouvoirs. Cela simplifie notamment la traversée du niveau 2 (Modèle OSI) dans la stack TCP/IP noyau. L'interface étant configurée en **promiscuous** le kernel est alors supplanté par Scapy et le matériel à disposition.
Cette structure nous permets de définir entièrement un environnement réseau spécifique. Scapy nous offre la possibilité de créer/renommer/ajouter des interfaces réseau, créer une table routage dédiée dépendante de celle du système "hôte", la gestion de certificats d'encryption et bien d'autres à travers l'objet ```conf```.
L'outil se base sur les nivaux du modèle OSI afin de structurer les couches composant les objets descripteurs de paquets. Ainsi un objet de type PKT dans Scapy se compose généralement de plusieurs couches en fonction des choix de l'utilisateur et peut être vu comme un dictionnaire bidimensionnel : ```PKT['IP']['TCP']...```.
Les couches mises en place par Scapy dans sa représentation des paquets sont celles modélisées par le modèle OSI, en effet, chaque interaction avec la librairie ou l'outil cible un couche particulières afin de pouvoir donner à l'utilisateur un contrôle total.
* Dans un premier temps cela permet de structurer notre objet et de compartimenter les données selon le modèle OSI, ce qui as pour but d'en augmenter la lisibilité et la facilité d'utilisation.
* Dans un second temps, et en conséquence du choix précédemment exposé de mise en place d'une stack TCP/IP séparée, cela signifie que la couche Ethernet est un peu spéciale.
* Les fonctions de **niveau 3** et plus, utilisant la **stack TCP/IP du système par défaut** (ex : ```sr()```,```send()```).
* Les fonctions de **niveau 2** spécifiant l'utilisation de la **stack de Scapy** (```srp()```,```sendp()```).
## Installation
Scapy est suporté par *nix, macOS et Windows, mais seules les procédures sous Linux seront documentées ici. Pour plus d'information concernant les procédures d'installation propre à d'autres plateformes, se réferer à la [documentation officielle](https://scapy.readthedocs.io/en/latest/installation.html#installing-scapy-v2-x)
L'utilisation principale de Scapy se fait au travers de l’interpréteur python directement, et l'outil nécessitant l'accès au mode **promiscuous**, il requiert donc les droits root au lancement :
~~~
# scapy
~~~
Une fois scapy lancé, l’interpréteur python est alors le nouvel environnement de travail.
### Configuration
Dans l'interpréteur, toute la configuration de Scapy se fait via l'objet ```conf``` mis à disposition. Les champs qui le composent permettent de moduler le comportement de l'outil en fonction de vos attentes.
Nous pouvons retrouver dans ce dictionnaire les champs concernant la stack TCP/IP propre à Scapy, notamment la table de routage, les interfaces, la taille de buffer etc...
>>> conf.iface = 'vio0' # renommage de l'interface en vio0
~~~
Python étant la base sur laquelle se construit Scapy, nous pouvons facilement en déduire que la connaissance de quelques bases de python sont intéressantes.
La bibliothèque de Scapy mets en place plusieurs méthodes et surcharges d’opérateurs nous permettant de *construire* un paquet "de bas en haut" suivant le modèle OSI.
En parallèle plusieurs classes dérivant du type ```PKT``` sont mises à disposition afin de représenter les protocoles et le processus d'encapsulation visuellement lors de la construction du paquet.
Pour clarifier, attribuons à une variable x, le contenu d'un paquet au niveau 3 pour le protocole IP :
Dans le paquet que nous venons de créer, ```x``` est un objet ```layer``` de niveau trois appartenant à la spécialisation IP et contenant tous les champs destinés à ce niveau.
Chaque champs est accessible de la même façon que l'on accéderait à un champs de dictionnaire traditionnel :