Analyseur réseau

Résumé

Dans le cadre du cours de "Services Réseaux" suivi en première année de Master en informatique, j'ai développé un programme en C permettant d'analyser le trafic réseau provenant d'une interface réseau ou d'un fichier PCAP. Ce programme lit et interprète les données des paquets sur les couches 2, 3 et 4 du modèle OSI, ainsi que les données applicatives.

Lien vers le projet : Analyseur réseau sur GitLab

Détails du projet

Le programme offre une analyse configurable, avec trois niveaux de détail disponibles : un résumé par paquet, une vue par protocole ou une analyse détaillée. Cela permet de s'adapter aux besoins de l'utilisateur.

Lors de l'exécution, les étapes principales sont :

1. Lecture de l'entête Ethernet pour identifier le protocole réseau.
2. Analyse des champs réseau, y compris la vérification du checksum.
3. Décodage des couches transport et applicative, si supportées.

Protocoles supportés

Le programme prend en charge :

Couche applicative : BOOTP, DHCP, DNS, FTP, HTTP, IMAP, POP, SMTP
Couche transport : SCTP, TCP, UDP
Couche réseau : ARP, ICMP (IPv4 et IPv6), IP (versions 4 et 6)
Couche liaison : Ethernet

Note : Seules certaines versions sans chiffrement sont prises en charge.

Bombernyan

Introduction

Lors de ma troisième année de licence en informatique à l'Université de Strasbourg, j'ai dirigé un projet de quatre mois en tant que chef de projet d'une équipe de 10 personnes. L'objectif était de développer un jeu 3D multijoueur en temps réel. Nous avons choisi de créer une version revisitée de Bomberman avec des chats, intitulée Bombernyan. Note : Bien que le code source soit disponible sur GitLab, ni le jeu ni le site web associé ne sont actuellement en service.

Présentation du jeu

Le projet a abouti à la création d'une arène où un maximum de 4 joueurs peuvent s'affronter en temps limité. Une fois le temps imparti écoulé, la zone de jeu commence à se réduire jusqu'à ce qu'il ne reste qu'un vainqueur. Par défaut, les bombes ont un rayon d'explosion de 3 blocs, mais des bonus permettent de modifier cette valeur. Voici quelques exemples de bonus :

1. C4 : Une bombe qui doit être activée manuellement avant d'exploser.
2. Bouclier : Protège le joueur contre le prochain coup reçu.
3. Bonus classiques : Augmentation de la portée ou du nombre de bombes.

Aspects techniques

Le projet a été réalisé à l'aide du moteur de jeu Godot. Tous les modèles 3D et designs ont été créés par l'équipe, puis intégrés dans le jeu pour offrir une esthétique unique. Plusieurs points techniques méritent d'être soulignés :

1. Gestion des scores et des parties : Une API dédiée stocke les informations sur les joueurs et les parties, incluant un système de score ELO. Un site web permettait de consulter des données telles que le nombre de parties jouées, l'ELO d'un joueur ou encore les détails des parties.

2. Réseau : Nous avons adopté une architecture à base de snapshots. Les clients envoient leurs actions au serveur tout en les appliquant localement pour assurer une expérience fluide. Le serveur vérifie les actions reçues, les applique à sa version du jeu et renvoie un instantané synchronisé toutes les 50ms. Cela permet au client de corriger les erreurs de prédiction, garantissant une cohérence avec la version du serveur.

Rôle de chef de projet

En tant que chef de projet, j'avais une double responsabilité : veiller à ce que l'équipe respecte les délais tout en satisfaisant les exigences du commanditaire (notre professeur). Cela impliquait :

- Organiser des réunions régulières avec l'équipe et le commanditaire.
- Rédiger des comptes-rendus, des rapports d'activités, et suivre l'avancement via des issues Git.
- Assurer une communication claire et efficace pour aligner le produit final sur les attentes.

Ce rôle m'a permis de développer des compétences en gestion d'équipe, en planification et en communication, tout en garantissant la qualité du produit livré.

Brick Breaker

Récapitulatif

Dans le cadre du cours de "Programmation avancée" suivi lors de ma première année de Master SIRIS, nous avons développé un brick breaker en C++. Ce projet devait inclure au minimum 4 bonus/malus, ainsi que des briques de formes variées (carré, triangle et hexagone). Il a été réalisé en collaboration avec un camarade. Lien vers le projet : Brick Breaker sur GitLab

Le projet en détail

Nous avons intégré l'univers de Minecraft à notre projet, en y ajoutant des textures, des musiques et des sons inspirés du célèbre jeu. Les joueurs disposent de plusieurs options de personnalisation pour leurs parties :

- Choix de la grille de jeu parmi une dizaine de grilles préenregistrées.
- Réglage de la vitesse de la balle pour ajuster la difficulté (plus rapide = plus difficile).
- Possibilité de créer et importer ses propres grilles grâce à un système de fichiers texte.

La sélection de la grille peut s'effectuer de deux façons : soit en définissant la grille au lancement du jeu, soit via le menu principal après avoir démarré une partie (si aucune grille n'a été choisie au préalable).

Calcul des collisions

Le système de collision repose sur des calculs de trigonométrie. Chaque obstacle est initialement considéré comme un rectangle minimal englobant sa forme. Cela permet d'utiliser une fonction standard pour détecter une collision entre deux rectangles. En cas de collision, des calculs trigonométriques précis déterminent si les objets se touchent réellement ou s'ils ne font que se frôler.

Bonus et malus

Les bonus et malus disponibles en jeu incluent :

1. Resize up : Agrandit la plateforme.
2. Resize down : Rétrécit la plateforme.
3. Shield : Ajoute temporairement un bouclier sous la plateforme.
4. Multiball : Rend le jeu plus dynamique en ajoutant plusieurs balles.

Compilateur CMat

Récapitulatif

Dans le cadre de la matière "Compilation" suivie lors de ma première année de Master en informatique à l'Université de Strasbourg, nous avons développé, en équipe de quatre personnes, un compilateur pour un langage fictif nommé CMat. CMat est une version simplifiée du langage C, avec une prise en charge spécifique des matrices. Lien vers le projet : Compilateur CMat sur GitLab

Le projet en détail

Le compilateur est constitué de quatre étapes principales qui s'enchaînent lors du traitement du code écrit en CMat :

Analyse lexicale (lex)
Analyse syntaxique (yacc)
Génération de code intermédiaire
Traduction en assembleur

Analyse lexicale

Cette étape vérifie si les mots du code source sont valides dans le langage CMat. Par exemple, "if" ou "45" sont des mots valides, contrairement à "foreach" (non supporté) ou "coucou". L'analyse lexicale identifie également les types des mots : nombre (entier ou flottant), chaîne de caractères, ou identifiant. Elle repose sur un fichier .lex associé à un fichier C.

Analyse syntaxique

L'analyse syntaxique détermine si une suite de mots (instruction) a un sens dans le langage CMat. Par exemple, "int b = 42;" est une instruction valide, alors que "42 b +" ne l'est pas. Cette étape s'appuie sur un fichier Yacc pour détecter les schémas d'instructions tels que les additions, les boucles ou les impressions, ce qui permet de générer du code intermédiaire.

Génération de code intermédiaire

Après l'analyse syntaxique, les instructions CMat sont traduites en un code intermédiaire composé d'instructions simples sous la forme (opération, x, y, z). Par exemple :

a = 2 + 3; devient (OP_PLUS, 2, 3, a)
print("coucou") devient (OP_PRINT, NULL, NULL, "coucou")
Les instructions complexes, comme c = b + 42 * a;, sont décomposées en plusieurs instructions : (OP_MULT, 42, a, temp), puis (OP_PLUS, b, temp, c).

Cette étape est implémentée en C directement dans le fichier Yacc.

Traduction en assembleur

Enfin, le code intermédiaire est traduit en assembleur RISC-V pour pouvoir être exécuté.

Mon rôle dans le projet

Dans ce projet, j'ai réalisé l'intégralité de la génération de code intermédiaire. J'ai également modifié l'analyseur lexical et l'analyseur syntaxique pour intégrer progressivement les nouvelles fonctionnalités de CMat. Nous avons adopté une approche incrémentale, en débutant par une version très simplifiée du langage afin de bien comprendre les fondamentaux de la compilation.

Code CMat

        int main(){
            
            int bonbons = 2;
        
            for(int i = 0; i < 42; i++) {
                bonbons = bonbons + i - 2;
            }
            
            return 0;
        }

Code assembleur

                        .data
        int0:   .word 0
        int1:   .word 0
        temp_int0:      .word 0
        temp_int1:      .word 0
        string0:        .asciz "J'ai des bonbons : "
        new_line:       .asciz "\n"
        line_tab:       .asciz "\t"
                        .text
        main:
                # ----- line 1 -----
                li t0, 2
                sw t0, int0, t6
                # ----- line 2 -----
                li t0, 0
                sw t0, int1, t6
                # ----- line 3 -----
        cond2:
                # ----- line 4 -----
                lw t0, int1
                li t1, 42
                blt t0, t1, cond6
                # ----- line 5 -----
                j cond10
                # ----- line 6 -----
        cond4:
                # ----- line 7 -----
                lw t0, int1
                li t1, 1
                add t2, t0, t1
                sw t2, int1, t6
                # ----- line 8 -----
                j cond2
                # ----- line 9 -----
        cond6:
                # ----- line 10 -----
                lw t0, int0
                lw t1, int1
                add t2, t0, t1
                sw t2, temp_int0, t6
                # ----- line 11 -----
                lw t0, temp_int0
                li t1, 2
                sub t2, t0, t1
                sw t2, temp_int1, t6
                # ----- line 12 -----
                lw t0, temp_int1
                sw t0, int0, t6
                # ----- line 13 -----
                j cond4
                # ----- line 14 -----
        cond10:
                # ----- line 15 -----
                li a0, 0
                li a7, 93
                ecall

Visualiseur d'OPTIC

Récapitulatif

Dans le cadre de la matière Travaux d'Études et de Recherches suivie lors de ma première année de Master SIRIS, j'ai travaillé sur l'implémentation d'une méthode de visualisation de la technique de re-routage rapide OPTIC. L'objectif était de fournir un outil simple pour comprendre le fonctionnement d'OPTIC et ses avantages par rapport à ses concurrents. Pour plus d'informations, vous pouvez consulter la publication liée : Publication OPTIC.
Lien vers le projet : Visualiseur d'OPTIC sur GitLab.

Le projet en détail

L'outil développé permet de comparer OPTIC avec deux autres technologies :

BGP vanilla, soit la version de base de BGP sans mécanisme de re-routage rapide.
PIC (Prefix Independent Convergence), une technologie précalculant un unique chemin de secours à l'avance.

L'outil présente simultanément deux graphes, un pour chaque technologie, avec une synchronisation des topologies. Cela permet de visualiser les événements et leurs effets en temps réel sur les deux technologies. Lorsqu'un événement se produit, un sous-menu permet à l'utilisateur de naviguer parmi les différentes étapes de convergence, en commençant par la convergence IGP, suivie de celle de BGP.

Interactions utilisateur

L'utilisateur peut déclencher différents types d'événements :

Couper ou réactiver un lien
Couper ou réactiver un nœud
Modifier la relation avec un système autonome (AS) : c2p (client-to-provider), p2p (peer-to-peer), ou p2c (provider-to-client)

Note importante : il n'est pas possible de cumuler plusieurs événements simultanément. Chaque événement doit être complètement traité avant d'en initier un autre.

Représentation du plan de contrôle et du plan de données

Les structures du plan de contrôle et du plan de données, souvent complexes à comprendre, sont représentées graphiquement pour en expliciter le fonctionnement (graphe affiché en bas de l'interface). Bien que difficile à résumer en quelques phrases, cette représentation permet de visualiser le tri des passerelles selon les caractéristiques classiques du processus de décision BGP.