maj, ajout des sections Utilisation et détails de concepts
This commit is contained in:
amokadem
parent
bfba1cc65f
commit
8e237c9cf2
212
HowtoScapy.md
212
HowtoScapy.md
|
|
@ -20,7 +20,7 @@ En effet Scapy est avant tout une librairie Python offrant aux utilisateur une i
|
|||
Scapy est un programme permettant d’accéder au plein potentiel de votre carte réseau, pour se faire, l'outil se sert du mode **promiscuous** des interfaces et réintroduit intégralement une stack TCP/IP sur laquelle le programme 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 la carte réseau est entièrement utilisable.
|
||||
Pour exemple, nous pouvons grâce à cela librement modifier l’adresse MAC source de nos paquets et les envoyer directement sur le réseau sans avoir à spécifier au kernel de ne pas réécrire le champs.
|
||||
|
||||
D'autre part cette structure nous permets également de définir entièrement un environnement réseau spécifique; en effet, Scapy nous offre la possibilité de créer/renommer/ajouter des interfaces réseau, créer une table routage dédiée idépendante de celle du système "hôte", la gestion de certificats d'encryption et bien d'autres à travers l'objet ```conf```.
|
||||
D'autre part cette structure nous permets également de définir entièrement un environnement réseau spécifique; en effet, 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```.
|
||||
|
||||
|
||||
Par ailleurs Scapy utilise 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']...```.
|
||||
|
|
@ -28,27 +28,211 @@ Par ailleurs Scapy utilise les nivaux du modèle OSI afin de structurer les couc
|
|||
|
||||
### Structures et Modèle OSI
|
||||
|
||||
|
||||
#### Couches
|
||||
|
||||
#### Protocoles
|
||||
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 controle total.
|
||||
Le principale impacte de cette structure en couche sur l'utilisation de scapy, est en réalité étalé sur deux aspects:
|
||||
|
||||
#### Encapsulation
|
||||
* Dans un premier temps cela permet de structurer notre objet et de compartimenter les données celon le modèle OSI, ce qui as pour but d'en augmenter la lisibilité et la facilité d'utilisation.
|
||||
|
||||
### Integration Python
|
||||
* Dans un secont 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.
|
||||
|
||||
**Scapy offre donc deux types de fonction inerragissant avec le réseau :**
|
||||
|
||||
* 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)
|
||||
|
||||
### Debian
|
||||
|
||||
Installation sous Debian :
|
||||
|
||||
~~~
|
||||
# apt install python3-scapy
|
||||
~~~
|
||||
|
||||
Puis vérifier que Scapy est bien installé :
|
||||
|
||||
~~~
|
||||
# scapy
|
||||
~~~
|
||||
|
||||
Vérification de la version (2.4.4 à ce jour) :
|
||||
|
||||
~~~{.python}
|
||||
>>> conf.version
|
||||
'2.4.4'
|
||||
~~~
|
||||
|
||||
## Installation
|
||||
|
||||
## Utilisation
|
||||
|
||||
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...
|
||||
|
||||
~~~{.python}
|
||||
>>> conf
|
||||
[...]
|
||||
iface = 'enp0s31f6'
|
||||
promisc = True
|
||||
route = Network Netmask Gateway Iface Output IP Metric 0.0.0.0 0.0.0.0 ...
|
||||
bufsize = 65536
|
||||
[...]
|
||||
~~~
|
||||
|
||||
La modification d'un champs de configuration se fait naturellement, à la manière d'une allocation de variable traditionnelle :
|
||||
|
||||
~~~{.python}
|
||||
>>> 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.
|
||||
|
||||
### Intégration Python
|
||||
|
||||
Scapy est avant tout un module python, il est donc facilement possible d'integrer les fonctionnalités de Scapy à ses scripts python :
|
||||
|
||||
~~~{.python}
|
||||
from scapy.all import *
|
||||
from scapy.utils import *
|
||||
|
||||
[...]
|
||||
~~~
|
||||
|
||||
Après quoi, il vous sera possible de facilement créer des scripts :
|
||||
|
||||
~~~{.python}
|
||||
# Exemple 3way handshake :
|
||||
#--------------------------
|
||||
from scapy.all import *
|
||||
|
||||
port=RandNum(1024,65535)
|
||||
# création du packet SYN
|
||||
SYN=ip/TCP(sport=port, dport=80, flags="S", seq=42)
|
||||
# SYN,ACK
|
||||
SYNACK=sr1(SYN)
|
||||
# ACK
|
||||
ACK=ip/TCP(sport=SYNACK.dport, dport=80, flags="A", seq=SYNACK.ack, ack=SYNACK.seq + 1) / get
|
||||
# envoi de la reqête GET
|
||||
reply,error=sr(ACK)
|
||||
|
||||
print reply.show()
|
||||
|
||||
~~~
|
||||
|
||||
### Création de paquets
|
||||
|
||||
La bibliothèque de Scapy mets en place plusieurs methodes et surchages 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 :
|
||||
|
||||
~~~{.python}
|
||||
>>> x = IP()
|
||||
>>> x.show()
|
||||
###[ IP ]###
|
||||
version= 4
|
||||
ihl= None
|
||||
tos= 0x0
|
||||
len= None
|
||||
id= 1
|
||||
flags=
|
||||
frag= 0
|
||||
ttl= 64
|
||||
proto= hopopt
|
||||
chksum= None
|
||||
src= 127.0.0.1
|
||||
dst= 127.0.0.1
|
||||
\options\
|
||||
~~~
|
||||
|
||||
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 :
|
||||
|
||||
~~~{.python}
|
||||
>>> x["IP"].dst = "9.9.9.9"
|
||||
~~~
|
||||
|
||||
Construisons maintenant les autres "layers" entourant celui-ci :
|
||||
|
||||
~~~{.python}
|
||||
>>> y = x / TCP() # OU
|
||||
>>> y = IP() / TCP()
|
||||
>>> y.show()
|
||||
###[ IP ]###
|
||||
version= 4
|
||||
ihl= None
|
||||
tos= 0x0
|
||||
len= None
|
||||
id= 1
|
||||
flags=
|
||||
frag= 0
|
||||
ttl= 64
|
||||
proto= tcp
|
||||
chksum= None
|
||||
src= 127.0.0.1
|
||||
dst= 127.0.0.1
|
||||
\options\
|
||||
###[ TCP ]###
|
||||
sport= ftp_data
|
||||
dport= http
|
||||
seq= 0
|
||||
ack= 0
|
||||
dataofs= None
|
||||
reserved= 0
|
||||
flags= S
|
||||
window= 8192
|
||||
chksum= None
|
||||
urgptr= 0
|
||||
options= []
|
||||
|
||||
~~~
|
||||
|
||||
Ici l'opérateur ```/``` est l'opérateur **d'encapsulation**, nous permettant de visualiser la structure du paquet et de la manipuler.
|
||||
L'inverse se fait au travers de la fonction ```del()```, versatile, qui permet de supprimet un layer, et des champs.
|
||||
|
||||
~~~{.python}
|
||||
#Suppression d'un layer
|
||||
>>> del(y["TCP"])
|
||||
>>> y.show()
|
||||
###[ IP ]###
|
||||
version= 4
|
||||
ihl= None
|
||||
[...]
|
||||
~~~
|
||||
|
||||
~~~{.python}
|
||||
#Suppression du contenu (reset) d'un champs
|
||||
>>> y = IP(src="10.1.1.1",dst="9.9.9.9")
|
||||
>>> y.summary()
|
||||
'10.1.1.1 > 9.9.9.9 hopopt'
|
||||
>>> del(y.src)
|
||||
>>> y.summary()
|
||||
'192.X.X.X > 9.9.9.9 hopopt' # Récupération de l'addresse IP par défaut, celle de la stack du systeme.
|
||||
~~~
|
||||
|
||||
#### Génération de collections de paquets
|
||||
|
||||
#### Modification de paquets
|
||||
|
||||
##### Spoofing à la volée
|
||||
|
||||
### Ecoute du réseau
|
||||
### Écoute du réseau
|
||||
|
||||
#### Sauvegarde de communication écoutées
|
||||
|
||||
|
|
@ -58,15 +242,15 @@ Par ailleurs Scapy utilise les nivaux du modèle OSI afin de structurer les couc
|
|||
|
||||
##### Lecture de fichier PCAP
|
||||
|
||||
##### Annalyse de contenu
|
||||
##### Analyse de contenu
|
||||
|
||||
### Emissions sur les réseau
|
||||
### Émissions sur les réseau
|
||||
|
||||
#### A partir de fichiers PCAP
|
||||
|
||||
#### A partir de collections générées
|
||||
|
||||
#### Emission et reception de réponses
|
||||
#### Émission et réception de réponses
|
||||
|
||||
## Exemples d'utilisation basique
|
||||
|
||||
|
|
@ -82,13 +266,13 @@ Par ailleurs Scapy utilise les nivaux du modèle OSI afin de structurer les couc
|
|||
|
||||
### Création de paquets/collections
|
||||
|
||||
### Emission de paquets/collections
|
||||
### Émission de paquets/collections
|
||||
|
||||
### Emission et écoute de réponse
|
||||
### Émission et écoute de réponse
|
||||
|
||||
### Ecoute sur le réseau
|
||||
### Écoute sur le réseau
|
||||
|
||||
#### Filtres d'ecoute
|
||||
#### Filtres d’écoute
|
||||
|
||||
#### Filtre par IP
|
||||
|
||||
|
|
@ -96,7 +280,7 @@ Par ailleurs Scapy utilise les nivaux du modèle OSI afin de structurer les couc
|
|||
|
||||
#### Filtre par protocole
|
||||
|
||||
### Ecriture PCAP
|
||||
### Écriture PCAP
|
||||
|
||||
### Lecture PCAP
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue