Développement d`un module de décodage logiciel

Développement d’un module de décodage
logiciel WIRESHARK pour le trafic radar au
format ASTERIX
DREVON Bertrand
ZONCO Vincent
IENAC 06 L
1
I. INTRODUCTION ............................................................................................................................................. 3
II. CONTEXTE ..................................................................................................................................................... 4
II.1. ASTERIX ...................................................................................................................................................... 4
II.1.1. Les catégories ..................................................................................................................................... 4
II.1.2. Le message.......................................................................................................................................... 4
II.1.2.1. Champ fixe.................................................................................................................................................... 5
II.1.2.2. Champ étendu ............................................................................................................................................... 5
II.1.2.3. Champ répétitif ............................................................................................................................................. 5
II.1.2.4. Message ........................................................................................................................................................ 5
II.1.2.5. Bloc............................................................................................................................................................... 6
II.1.2.6. Enregistrement .............................................................................................................................................. 6
II.1.2.7. Exemple ........................................................................................................................................................ 7
II.1.3. Exemple de décodage associé à la catégorie 1 sur de l’éthernet........................................................ 7
II.2. WIRESHARK ............................................................................................................................................... 11
III. LE CAHIER DES CHARGES .................................................................................................................... 12
III.1. LE BESOIN................................................................................................................................................ 12
III.2. LES CHOIX ................................................................................................................................................ 12
III.2.1. Asterix.............................................................................................................................................. 12
III.2.2. Wireshark ........................................................................................................................................ 12
III.2.3. Environnement de travail. ............................................................................................................... 14
III.3. LES TESTS ................................................................................................................................................. 14
IV. DEVELOPPEMENT - TESTS .................................................................................................................... 15
IV.1. LE PLUGIN WIRESHARK TYPE .................................................................................................................... 15
IV.2. LE PLUGIN ASTERIX .................................................................................................................................. 16
IV.2.1. Fonctions ......................................................................................................................................... 16
IV.2.2. Algorithme ....................................................................................................................................... 17
IV.2.2.1. Reconnaissance de la trame asterix ........................................................................................................... 17
IV.2.2.2. Décodage de la trame asterix..................................................................................................................... 18
IV.3. TESTS ....................................................................................................................................................... 19
V. PERSPECTIVES............................................................................................................................................ 20
VI. CONCLUSION ............................................................................................................................................. 21
VII. ANNEXE TECHNIQUE ............................................................................................................................ 22
VII.1. LA COMPILATION .................................................................................................................................... 22
VII.2. LE FICHIER DE SAP, SAC ET SIC ........................................................................................................... 22
VII.3. STRUCTURE ET ALGORITHME DU CODE ................................................................................................... 23
2
I. INTRODUCTION
Un service technique de la DGAC (aéroport de Toulouse) a demandé le
développement d'un module wireshark permettant la lecture de messages au format
ASTERIX.
Le protocole Astérix assure l’échange des données des capteurs de surveillance (radars
primaires, secondaires, … ) sur les réseaux de l’aviation civile. Il a été normalisé au niveau
européen par Eurocontrol.
Quant au logiciel Wireshark, il s’agit d’un analyseur de trafic réseau. Ce dernier
supporte de très nombreux protocoles. Etant un logiciel libre, on peut lui en ajouter de
nouveaux.
Dans ce document, nous commencerons par nous familiariser avec la norme Asterix et
le logiciel Wireshark. Nous poursuivrons par l’analyse du cahier des charges et les solutions
apportées pour y répondre. Enfin nous aborderons les perspectives d’évolution de notre
travail.
3
II. CONTEXTE
Nous présenterons dans cette section les messages ASTERIX et le logiciel
WIRESHARK. Le paragraphe sur Astérix a été inspiré de la documentation « Les protocoles
utilisés dans IRMA », fournie au début du projet.
II.1. ASTERIX
Le format ASTERIX est un format utilisé au sein de la DGAC pour la transmission des
données opérationnelles.
Ce format est aussi bien utilisé pour le CAUTRA (STR) que pour les radars primaires et
secondaires.
ASTERIX est une norme Eurocontrol. On va donc pouvoir émettre et recevoir vers des pays
étrangers.
La description exhaustive des messages ASTERIX est consultable à l’adresse suivante :
http://www.eurocontrol.int/asterix/public/subsite_homepage/homepage.html.
II.1.1. Les catégories
La catégorie définie le type de données qui vont suivre dans les enregistrements.
Les catégories vont de 0 à 255.
Catégorie 0 à 127
: Applications "standard" civile et militaire
-> Utilisé pour l'Air Traffic Control (ATC) et la météo
Catégorie 128 à 240 : Applications spéciales pour le domaine militaire
Catégorie 241 à 255 : Application non standard civile et militaire
recherche, test, expérimentation …
II.1.2. Le message
Les champs de chaque catégorie ASTERIX sont définis par une norme EUROCONTROL.
Ces champs sont de tailles fixes ou variables. Nous proposons à travers les graphiques suivant
de mieux comprendre la structure du message.
4
II.1.2.1. Champ fixe
n octets
Les champs fixes sont des multiples d’octets.
II.1.2.2. Champ étendu
k octets
1
i octets
1
j octets
0
La valeur du bit de poids faible de l’octet permet d’étendre ou non le champ. S’il vaut 1 le
champ est étendu à l’octet suivant, s’il vaut 0, le champ s’arrête.
II.1.2.3. Champ répétitif
Rep = N
j octets
Octets de répétition
j octets
N fois
Certains champs se répètent plusieurs fois, la valeur d’un octet nous informe alors sur le
nombre de fois où les champs apparaissent dans la trame.
II.1.2.4. Message
Bloc 1
Bloc n
Un message peut contenir plusieurs blocs de données.
5
II.1.2.5. Bloc
BLOC i
CAT
LONG
ENG 1
ENG i
Le champ cat (catégorie) indique sur un octet à quelle catégorie astérix appartiennent les
données du bloc. Il y aura par exemple une catégorie pour le STR, une pour les radars
aviation, une pour les radars météo, …
Le champ long (longueur) indique sur 2 octets la longueur (en nombre d'octets) du bloc.
II.1.2.6. Enregistrement
ENG i
FSPEC
Données1
Données n
Un enregistrement commence par un champ appelé FSPEC (un ou plusieurs octets) signifiant
Field SPECification.
Chaque bit de FSPEC indique la présence ou l'absence de la donnée du rang i pour la
catégorie en cours.
6
II.1.2.7. Exemple
Bloc n°1
CAT
LONG
FSPEC
(1,5,8)
Data1
Data5
Bloc n°2
FSPEC
(7,12)
Data8
Enregistrement n°1
Data7
Data12
CAT
LONG
FSPEC
Enregistrement n°2
Message ASTERIX
Le message asterix peut être composé de plusieurs blocs. Chaque bloc correspond à une
catégorie. La longueur est relative à la taille d’un bloc. Enfin dans chaque bloc nous pouvons
trouver plusieurs enregistrements. Les données des enregistrements sont détaillées dans les
champs FSPEC. Ainsi chaque bit à un du champ FSPEC annonce une donnée particulière
définie par la norme.
FSPEC, Field Special, est un champ étendu, c'est-à-dire que sa taille est variable.
II.1.3. Exemple de décodage associé à la catégorie 1 sur de
l’éthernet
La catégorie 1 collecte les informations issues des radars primaires et secondaires
FSPEC
Un octet extensible.
Octet 1:
8
IDEN
7
DESC
6
NUM
8
MCD
7
6
HPTU PLOT
5
4
POSU POSX
3
VIT
2
MODA
3
PIST
2
QUAL
1
EXT
Octet 2:
5
PUIS
4
DOPP
1
EXT
7
Data
Octet 3:
8
MOD2
7
QA
6
QC
5
Q2
4
WEC
3
SP
2
RFS
1
EXT
7
0
6
0
5
0
4
0
3
0
2
0
1
EXT
Octet 4 (jamais transmis):
8
0
Par nature même, le champ FSPEC est présent pour chaque plot pisté.
Par principe:
- chaque bit de chaque octet de FSPEC indique, lorsqu'il est positionné à 1, la présence du
champ correspondant dans le plot pisté courant. Certains bits sont fixés à la valeur 0; ils
correspondent à des champs prévus mais qui sont inutilisés dans le cadre de la présente
application radar secondaire monoimpulsion (champs réservés au radar primaire ou
optionnels).
On trouve, dans l'octet No 3, un bit SP et un bit RFS indicateurs de présence respectivement
d'un champ de données non standard et de champs organisés en séquence aléatoire (RFS =
Random field Séquence). Ces bits ne seront jamais positionnés dans le cadre de notre
application, mais leur utilisation est prévue par ASTERIX.
- un octet de FSPEC dont tous les bits sont à 0 (absence des champs correspondants), y
compris le bit d'extension, n'est pas transmis. C'est le cas de l'octet No 4 qui est prévu par
Eurocontrol mais qui ne sera jamais transmis ici.
8
Voici une capture de trame ethernet enregistrée à l'ENAC
FD FF FF FF 08 02 00 80 02 00 00 15 00 92 34 34 03 01 00 83 F7
84 08 05 A8 01 A8 70
21 BD 88 09 09 26 68 00 89 85 50 68 77
84 A8 00 21 68 BC B9 D4 08 1B A7 28 4D A0 45
C8 48 77 84 A8 01 7D 57 A9 B8 70 08 0E FE 0E 0A E8 05 78 48 77 84 A8 00 88 48 3E
BF 34 08 1F 2A B8 02 06 04 D8 48 77 84 A8 00 8B 4 E B7 BC CC 07 05 82 08 06 E 6 02
0C 48
77 84 A8 01 4F 4A FA BE 00 08 37 7B 00 04 C8 05 C8 48 77 84 A8 00 31 18 3A BC 50
01 E1 07 D0 0D 40 00 70 68 02 00 0C F4 08 05 02 C0 3D 81 AF 20 …
La première chose à faire est d'examiner le FSPEC.
Examen du FSPEC pour connaître les champs de données qui seront présents ou absent dans
les données utiles.
FSPEC = F7 84
F7
1111
84
0111
1000
0100
ext
IDEN
QUAL
DESC
PIST
DOPP
NUM
POSU
PUIS
POSX
PLOT
VIT
HPTU
MODA
MCD
Le Champ IDEN se décompose en deux sous champs très importants :
• Le SAC, Source Area Code qui définit l’origine géographique de l’émetteur,
• Le SIC, Source Identification Code (numéro du radar)
Ces deux champs particuliers seront utilisés dans la suite de notre exposé.
9
Nous allons maintenant détailler chaque champ de données utiles.
FD FF FF FF 08 02
00 80 02 00 00 15
00 92
34
34
@ MAC dest
@ MAC source
Long
Ethernet
SSAP
DSAP
03
01
00 83
F7 84
08 05
A8
cmde
CAT
longueur
FSPEC
SAC SIC
DESC
01 A8
70 21 BD 88
09 09 26 68
00 89
85 50
N° piste
POSU
VITESSE
Mode A
Mode C
68
77 84
Piste
FSPEC suivant
A8 00 21 68 BC B9 D4 08 1B A7 28 4D A0 45 C8 48 77 84 A8 01 7D 57 A9 B8 70 08 0E
FE 0E 0A E8 05 78 48 77 84 A8 00 88 48 …..
Champ
Données
SAC SIC 08 05
DESC A8
N° piste
POSU
Vitesse
01 A8
70 21 BD 88
09 09 26 68
Mode A
00 89
Mode C
Piste
85 50
68
commentaires
Monopulse Mont Ventoux
Piste,vraie,secondaire,TPR2,pas SPI,non
transpondeur fixe
Piste n° 424
Rho=224 Nm(7021), Théta=266°(BD88)
Vitesse=508Kts ou 0,14 Nm/s (0909)
cap=54 ° (2668)
Mode A valide, pas de garbling, mode A brut,
mode A= 1120
Mode C valide,pas de garbling, FL=340
Piste confirmée, radar sec, avion en manœuvre ,
TPR2, pas d'association plot/piste douteuse ,ce
n'est pas une piste fantôme
10
II.2. WIRESHARK
Wireshark est un logiciel permettant l'écoute et le décodage des trames circulant sur un
réseau. Il fonctionne aussi bien sur Windows que Linux.
(Source : site officiel de Wireshark : http://www.wireshark.org/docs/wsug_html/wsug_graphics/ws-main.png)
L’affichage se décompose en trois zones :
- zone du haut : affichage des trames reçues dans l’ordre chronologique,
- zone du milieu : décodage des informations, protocoles par protocoles,
- zone du bas : affichage de la trame en hexadécimale.
11
III. LE CAHIER DES CHARGES
III.1. LE BESOIN
La subdivision radar de l’aéroport de Toulouse Blagnac a exprimé le besoin de pouvoir
décoder des messages ASTERIX grâce à l’analyseur de protocole réseau WIRESHARK.
III.2. LES CHOIX
III.2.1. Asterix
Les catégories de message Astérix sont nombreuses (256), mais pas toutes intéressantes pour
l’aviation civile. Il est donc nécessaire de faire des choix préalables. Ainsi, nous avons décidé
d’implémenter le décodage des catégories 1 et 48. En effet, nous disposons d’enregistrements
de trames du réseau opérationnel sur lesquelles nous avons de la catégorie 1. Par ailleurs, la
catégorie 1 a évolué en catégorie 48. Ces deux catégories sont relatives aux radars primaires
et secondaires.
Notre programme s’adaptera à l’ajout de catégories supplémentaires.
Nous faisons l’hypothèse que les trames asterix sont encapsulées dans de l’éthernet
IEEE802.3. Hypothèse forte qui se fonde sur les exemples de trames et les documents mis à
notre disposition. Cette hypothèse n’est pas généralisable à l’ensemble des réseaux
transportant de l’ASTERIX. En effet, il peut être transporté sur de l’X25 par exemple. Dans
ce cas, nous serons aveugles aux messages asterix transportés.
III.2.2. Wireshark
Un décodeur de protocole est appelé dans wireshark un dissector, nous utiliserons cette
dénomination dans la suite du rapport. Ainsi, nous développerons un dissector ASTERIX.
Pour décoder un nouveau protocole, wireshark propose 2 options. La première est d’intégrer
directement notre dissector dans le logiciel. Cette méthode a l’inconvénient d’être lourde lors
de la compilation car c’est tout le logiciel qui sera recompilé lors des modifications sur notre
dissector. La deuxième est d’intégrer notre dissector en tant que plugin. Ainsi, seul notre
dissector sera compilé lors de nos modifications.
Nous avons choisi d’intégrer notre dissector en tant que plugin.
12
Wireshark analyse les paquets circulant sur le réseau et commence par analyser les protocoles
de plus bas niveau. Avec notre hypothèse, les paquets auront la structure suivante :
Adresse MAC
destinataire
Adresse MAC
source
long
SSAP
DSAP
Message ASTERIX
cmde
L’explication relative aux différents éléments a été donnée dans la partie sur ASTERIX.
Le premier protocole décodé sera l’éthernet (en gras).
Pour annoncer des protocoles de niveau supérieur, le champ SSAP est utilisé. Par exemple un
SSAP de 0x06 annonce de l’IP.
Pour ASTERIX, nous avons SSAP = DSAP et les valeurs sont normalisées au sein de la
DGAC. Cependant, les valeurs ne sont pas normalisées par une norme internationale. Une
valeur de SSAP ne conditionne pas que la suite du message soit spécifiquement de
l’ASTERIX.
Il est donc nécessaire d’avoir d’autres contrôles pour être sûr de décoder de l’ASTERIX.
Ainsi, dans un premier temps notre programme se basera sur les valeurs de SSAP et de
DSAP pour détecter le protocole Astérix. Puis il décodera des champs du protocole suivant.
Si c’est de l’asterix les champs lus (SAC et SIC) correspondront à des valeurs normées et
connues :
SAC : Source Area Code (0x08 pour la France)
SIC : Source Identification Code - numéro du radar source (0 à 255). Ce numéro est européen.
SSAP
DSAP
ethernet
cmde
cat
long
fspec
SAC
SIC
Message Asterix
Sinon, le protocole analysé n’est pas de l’asterix et la main est rendue au logiciel.
13
III.2.3. Environnement de travail.
Nous avons choisi de développer notre plugin sous Linux. En effet Wireshark fait partie de
la suite logiciel fournie de base avec les distributions les plus courantes de Linux.
III.3. LES TESTS
Pour tester la validité et la cohérence du dissector ASTERIX, nous créons des trames asterix
particulières grâce à un éditeur de code hexadécimal (Khexedit). La méthode est fastidieuse
mais porte ses fruits.
Capture d’écran de Khexedit.
14
IV. DEVELOPPEMENT - TESTS
Maintenant que les choix de conception ont été effectués, passons à la mise en œuvre.
Des renseignements supplémentaires sont apportés dans l’annexe techniques en vue de
développements ultérieurs.
IV.1. LE PLUGIN WIRESHARK TYPE
L’architecture d’un plugin wireshark est figée. Elle est décrite dans le manuel du
développeur wireshark qui explique dans les paragraphes 8 et 9 comment ajouter un plugin
(http://www.wireshark.org/docs/wsdg_html_chunked/). Ces explications sont reprises
partiellement dans les readme du logiciel.
Pour wireshark, un plugin est un répertoire qui contient au moins :
- Makefile.am
- Makefile.common
- Makefile.nmake
- moduleinfo.h
- moduleinfo.nmake
- packet-nom_du_plugin.c
- plugin.rc.in
(pour Unix/Linux)
(pour Windows)
(pour Windows)
(pour Windows)
Les fichiers Makefile sont des fichiers exécutables, ils permettent de compiler l’ensemble du
code grâce à une commande unique.
Les fichiers moduleinfo contiennent des informations sur la version du plugin.
Le fichier packet-nom_du_plugin.c contient le code permettant le découpage du message
asterix.
15
IV.2. LE PLUGIN ASTERIX
IV.2.1. Fonctions
Pour développer le plugin ˝asterix˝, nous avons comme le suggéraient les différents
tutoriaux repris un plugin existant.
Nous avons donc dans un premier temps, remplacé le nom du plugin copié par le nom de
notre plugin : ˝asterix˝. Cette étape concerne les fichiers autres que le « .c » (ie les ˝makefile˝,
les ˝moduleinfo˝ et le ˝plugin.rc.in˝).
Ensuite nous nous sommes attelés au « .c » qui contient le code du dissecteur Asterix et que
nous avons appelé : ˝packet-asterix.c˝.
Dans le « .c », la structure du code est elle aussi imposée. Pour coder un plugin, l’interface
wireshark propose 3 fonctions :
- proto_register_asterix( )
- proto_reg_handoff_asterix( )
- dissect_asterix( )
La fonction proto_register_asterix( ) enregistre le protocole asterix, son nom, différentes
variables et leurs propriétés d’affichage dans wireshark. C’est dans cette fonction que nous
déclarons la structure des champs du protocole asterix.
La fonction proto_reg_handoff_asterix( ) recueille les cas où le dissecteur astérix doit être
appelé. Par exemple après le protocole Ethernet 802.3 lorsque le SAP = 20.
La fonction dissect_asterix( ) contient la façon de découper la trame. Nous réalisons la lecture
des champs et leur attribuons le décodage qui leur correspond en fonction des variables
enregistrées dans la fonction proto_register_asterix.
16
IV.2.2. Algorithme
IV.2.2.1. Reconnaissance de la trame asterix
Trame ethernet
Filtre sur les champs
« DSAP = SSAP »
Plugin inactif
NON
Fichier SAP_SAC_SIC
SAP connu ?
OUI
Lecture de champs
particuliers, X et Y dans le
protocole encapsulé
NON
Plugin inactif
X = SAC
Y = SIC
Fichier SAP_SAC_SIC
OUI
Plugin actif
17
IV.2.2.2. Décodage de la trame asterix
Plugin
actif
L = Taille de la
trame asterix
Lecture de la
catégorie
NON
Catégorie
connue?
Message d’alerte
OUI
Appel de la fonction
associée
FIN
OUI
Fin de trame ?
NON
18
IV.3. TESTS
En ce qui concerne le système d’exploitation, nous avons développé et testé notre plugin
sous Linux. Mais il doit normalement aussi marcher sur Windows. Aucun test n’a encore été
effectué à ce jour. Selon les fichiers « readme » de wireshark, il suffirait de bien compléter les
« Makefile Windows » pour le portage.
De notre côté, nous avons veillé à utiliser seulement les fonctions standard du C et les
fonctions propres à Wireshark. Par exemple, nous n’avons pas utilisé d’appel système Linux.
A propos des tests, ils ont consisté en la vérification du bon décodage de chaque champ. On a
donc porté une attention particulière à la justesse de la traduction de l’hexadécimal vers le
décimal.
Notre plus grosse contrainte est de disposer de messages Asterix où :
- tous les champs sont présents
- il existe des blocs de catégories différentes.
Pour ce faire, nous avons modifié un fichier de données réseau enregistré grâce à wireshark.
Cette modification a été rendue possible en utilisant un éditeur hexadécimal.
Nous avons rejoué des exemples fournis dans la documentation et concernant la catégorie 1 et
48. Et nous avons également créé d’autres messages permettant de tester la validité de notre
algorithme de décodage (plusieurs enregistrements dans une catégorie, plusieurs blocs dans
une trame…).
Cette phase de test a permis de mettre en lumière de mauvaises traductions de champ et leurs
corrections.
19
V. PERSPECTIVES
Le module permet actuellement de décoder deux catégories asterix : 1 et 48. Il est
envisageable d'ajouter d'autres catégories pour répondre au besoin. Nous pensons notamment
aux catégories :
- 2 : messages de service (bon fonctionnement du radar,…),
- 34 : nouvelle version de la catégorie 2,
- 21 : ADS-B,
- 23 : CNS/ATM,
Par ailleurs, il existe différents niveaux de décodage pour les champs d'une catégorie. En
effet, la valeur de certain champ doit être lu bit à bit, chaque bit contenant une information
bien particulière alors que d’autres champs se lisent par octets.
Ainsi, nous n'avons pas jugé nécessaire de lire toutes les informations liées à un champ
particulier mais plutôt de repérer la présence du champ et de le nommer.
Là encore, l'expression de besoin permettra d'affiner le décodage des champs.
Enfin, programmer avec wireshark n'est pas trivial. Des fonctions ont été créées pour faciliter
la vie du programmeur et manipuler les flux réseaux. Cependant, la difficulté provient du
manque de documentation : il faut chercher, fureter dans les plugins et buildins existants.
Le code produit est donc perfectible et optimisable.
En particulier, la détection du protocole Astérix pourrait se faire en utilisant un dissector
heuristique. Wireshark teste suivant certains critères et de façon assez légère quel est le
protocole suivant dans le flux de données réseau. Le lecteur pourra se référer au fichier
wireshark/epan/packet.c pour avoir une liste de fonctions utilisant cette approche.
Une modification possible pour annoncer le protocole Astérix pourrait se faire au niveau du
protocole LLC en ajoutant des SAP connus (fichiers wireshark/epan/llcsap.h et
wireshark/epan/packet-llc.c). Mais cela demanderait une modification à l’extérieur de notre
plugin.
Enfin, notre module s'appuie sur une encapsulation Ethernet des messages Astérix. Un
développement supplémentaire permettrait le support de l'X25.
20
VI. CONCLUSION
La demande succincte de départ : produire un module de décodage des messages Astérix,
nous a demandé de faire des choix. Quid des catégories des messages Astérix, quid du
protocole encapsulant ?
Nos choix se sont fondés sur la documentation fournie, l'analyse technique du sujet et sur les
conseils de nos encadrants.
La première partie de notre projet a consisté en une analyse globale du problème. Il a fallu
s'imprégner du format des messages Astérix et comprendre l'architecture de Wireshark.
Dans un deuxième temps, nous avons installé et adapté notre outil de travail. Apprendre à
compiler wireshark et lui ajouter un plugin a été une route sinueuse.
Enfin, après avoir déterminé sur quels critères wireshark devait introduire Astérix, nous
sommes rentrés dans le code du module. Les tests de lecture de trame mis en oeuvre ont
permis de détecter des erreurs de programmation. Ces tests ont été essentiels dans le
développement de notre module.
Notre module détecte les catégories 1 et 48 en se basant sur l'analyse des champs DSAP, SAC
et SIC pour s'assurer que l'on décode bien de l’Astérix.
D'un point de vue personnel, ce projet nous a permis de rentrer dans le monde du logiciel
libre. Le plus difficile a été de préparer le poste de travail, c'est à dire de compiler Wireshark
et d'apprendre à ajouter un plugin. Nous regrettons aussi de ne pas avoir eu plus d’intéraction
avec le service technique demandeur du module.
21
VII. ANNEXE TECHNIQUE
Cette annexe présente différents points pratiques de notre travail. Dans un premier temps nous
évoquons la compilation de Wireshark. Puis nous enchaînons sur le fichier de code de notre
dissector et sur le fichier comportant les informations de SAP, SAC et SIC.
VII.1. LA COMPILATION
Après avoir téléchargé les fichiers wireshark, nous allons les compiler.
La compilation se passe en 3 commandes, à la racine du dossier wireshark :
autogen.sh, positionne les variables d'environnement.
./configure,
./make
Avant de se lancer dans la création de plugin, il est fortement conseiller de lire le fichier
wireshark/doc/README.plugins. En effet, il nous est expliqué comment ajouter un plugin
et comment le compiler.
Pour créer le plugin, nous ajoutons un dossier dans le répertoire wireshark/plugins. Il porte le
nom de notre protocole : asterix.
Dans ce dossier doivent figurer un certain nombre de fichiers. Ils sont explicités dans le
README.plugins. En particulier, le fichier packet-asterix.c correspond à la programmation
du « dissector » asterix.
Ensuite, pour que notre plugin puisse être compilé, il faut modifier quelques fichiers, en
particulier des MakeFile. Là encore, le fichier README.plugins est invoqué.
La compilation du plugin se fait à travers les lignes de commande suivantes :
./make,
./make install, commande très importante.
VII.2. LE FICHIER DE SAP, SAC ET SIC
Localisation du fichier : wireshark/plugins/asterix/liste_sap_sac_sic
La reconnaissance du protocole wireshark se fait grâce à l’analyse de champs bien particuliers
dans la trame. L’un est contenu dans la trame éthernet (IEEE802.3), il s’agit du SAP.
Dans un premier temps nous décidons que toutes les valeurs de SAP contenu dans le fichier
permettent de décoder une trame asterix. Cependant ces valeurs ne sont pas standardisées et
ne permettent pas spécifiquement d’annoncer de l’asterix.
D’autres champs de contrôles contenus dans le protocole encapsulé dans l’Ethernet doivent
être analysés. Nous lirons les champs où devraient se trouver les valeurs de SAC et SIC. Si les
valeurs sont cohérentes avec les valeurs contenues dans le fichier. Nous validons la présence
d’un message asterix et nous le décodons, sinon nous rendons la main à wireshark.
22
Ce fichier doit être modifié lors de mise à jour des paramètres SAP, SAC et SIC.
Les paramètres sont écrits en décimal de la façon suivante dans le fichier :
32 08 23
32 08 14
SAP
SAC
SIC
Les entiers sont séparés par des espaces. Il est indispensable d’avoir les 3 champs présents sur
une ligne.
VII.3. STRUCTURE ET ALGORITHME DU CODE
Le but de ce paragraphe est de présenter rapidement la structure et l’algorithme principal du
dissecteur Astérix. Il s’agit du code du fichier « packet-asterix.c ».
PLUGIN WIRESKARK
proto_reg_handoff_asterix( )
proto_register_asterix( )
dissect_asterix( )
FONCTIONS ˝MAISON˝
Et les fonctions :
Lire_bloc()
Lire_categorie()
Lire_enregistrement()
Lire_longueur()
Recuperer_sac_sic()
Lire_fspec()
Verifier_protocole_asterix()
etc
Structure du code du plugin Asterix.
23
Voici maintenant l’algorithme simplifié de quelques fonctions importantes :
Dissect_asterix( )
{
…
On récupère les couples (SAC,SIC) ;
WHILE ( on n’a pas fini de lire la trame )
{
SI ( il s’agit du protocole Asterix )
Lire le bloc ;
SINON …
}
…
}
Lire_bloc( )
{
…
WHILE ( on n’a pas fini de lire le bloc )
{
Lire les enregistrements ;
}
…
}
(à vérifier)
Lire_enregistrement( )
{
…
SWITCH( catégorie )
{
On déchiffre les champs de l’enregistrement ;
/* 1 enregistrement = 1 fspec et les champs correspondants */
}
…
}
24