Analyse du Trafic Réseau avec Wireshark

Analyse du Trafic Réseau avec Wireshark

Table of Contents

Vue d’Ensemble

Un projet complet d’analyste SOC pour analyser le trafic réseau afin de détecter les menaces de sécurité et comprendre les modèles d’attaque en utilisant Wireshark.

Objectifs d’Apprentissage

  • Maîtriser Wireshark pour la forensique réseau
  • Identifier les modèles de trafic réseau malveillant
  • Analyser les protocoles chiffrés et non chiffrés
  • Détecter l’exfiltration de données et les communications commande et contrôle
  • Documenter les incidents de sécurité basés sur le réseau

Structure du Projet

network-traffic-analysis/
├── sample-captures/
│   ├── legitimate-traffic.pcap
│   ├── malware-c2.pcap
│   ├── data-exfiltration.pcap
│   └── ddos-attack.pcap
├── analysis-scripts/
│   ├── pcap-parser.py
│   ├── flow-analyzer.py
│   └── threat-detector.py
├── filters/
│   ├── common-filters.txt
│   ├── threat-specific-filters.txt
│   └── custom-filters.txt
├── documentation/
│   ├── wireshark-guide.md
│   ├── protocol-reference.md
│   └── analysis-checklist.md
├── reports/
│   └── traffic-analysis-template.md
└── README.md

Outils Requis

  • Wireshark 4.x
  • TShark (version ligne de commande)
  • Python 3.8+ avec Scapy/PyShark
  • NetworkMiner (Optionnel)
  • Zeek/Bro (Optionnel)

Scénarios d’Analyse

Scénario 1: Communications C2 Malware

  • Identifier les modèles de balisage (beaconing)
  • Détecter le tunneling DNS
  • Analyser les communications HTTP/HTTPS
  • Identifier l’exfiltration de données encodées

Scénario 2: Détection d’Exfiltration de Données

  • Surveiller les transferts de données inhabituels
  • Identifier les téléchargements de fichiers volumineux
  • Détecter les pics de trafic chiffré
  • Analyser les transferts FTP/SMTP

Scénario 3: Mouvement Latéral

  • Détecter le scan du réseau interne
  • Identifier les tentatives d’exploitation SMB/RPC
  • Surveiller les protocoles d’authentification
  • Suivre le trafic d’escalade de privilèges

Scénario 4: Analyse d’Attaque DDoS

  • Identifier les vecteurs d’attaque (SYN, UDP, HTTP)
  • Analyser les modèles et sources d’attaque
  • Calculer le volume de trafic et l’impact
  • Recommander des stratégies d’atténuation

Filtres Wireshark Essentiels

Analyse Générale du Trafic

# Afficher uniquement le trafic HTTP
http

# Afficher uniquement le trafic DNS
dns

# Afficher le trafic vers/depuis une IP spécifique
ip.addr == 192.168.1.100

# Afficher le trafic sur un port spécifique
tcp.port == 443

# Exclure le trafic du réseau local
not ip.addr == 192.168.0.0/16

Filtres Orientés Sécurité

# Balisage potentiel de malware (intervalles réguliers)
frame.time_delta > 300 and frame.time_delta < 400

# User agents suspects
http.user_agent contains "curl"

# Transferts de fichiers volumineux
http.content_length > 1000000

# Trafic PowerShell
tcp.port == 5985 or tcp.port == 5986

# Connexions RDP
tcp.port == 3389

# Connexions SSH
tcp.port == 22

Analyse du Trafic Chiffré

# Trafic TLS/SSL
ssl

# Problèmes de certificat
ssl.alert_message

# Échecs de handshake
ssl.handshake.type == 0

Exemples de Scripts d’Analyse

Analyseur PCAP avec Scapy

from scapy.all import *
import pandas as pd
from collections import Counter

def analyze_pcap(pcap_file):
    """
    Analyser un fichier PCAP pour les événements de sécurité
    """
    packets = rdpcap(pcap_file)
    
    analysis = {
        'total_packets': len(packets),
        'protocols': Counter(),
        'top_sources': Counter(),
        'top_destinations': Counter(),
        'top_ports': Counter(),
        'suspicious_patterns': []
    }
    
    for packet in packets:
        # Analyse de protocole
        if IP in packet:
            analysis['protocols'][packet[IP].proto] += 1
            analysis['top_sources'][packet[IP].src] += 1
            analysis['top_destinations'][packet[IP].dst] += 1
        
        # Analyse des ports
        if TCP in packet:
            analysis['top_ports'][packet[TCP].dport] += 1
        elif UDP in packet:
            analysis['top_ports'][packet[UDP].dport] += 1
    
    return analysis

def detect_beaconing(packets, time_threshold=60):
    """
    Détecter les modèles potentiels de balisage C2
    """
    connections = {}
    
    for packet in packets:
        if IP in packet and TCP in packet:
            key = f"{packet[IP].src}:{packet[TCP].sport}-{packet[IP].dst}:{packet[TCP].dport}"
            
            if key not in connections:
                connections[key] = []
            
            connections[key].append(packet.time)
    
    beacons = []
    for conn, timestamps in connections.items():
        if len(timestamps) >= 3:
            intervals = []
            for i in range(1, len(timestamps)):
                intervals.append(timestamps[i] - timestamps[i-1])
            
            # Vérifier les intervalles réguliers
            avg_interval = sum(intervals) / len(intervals)
            variance = sum((x - avg_interval) ** 2 for x in intervals) / len(intervals)
            
            if variance < time_threshold:  # Faible variance indique un modèle régulier
                beacons.append({
                    'connection': conn,
                    'avg_interval': avg_interval,
                    'packet_count': len(timestamps)
                })
    
    return beacons

Analyse de Flux

import pyshark
import socket

def analyze_flows(pcap_file):
    """
    Analyser les flux réseau pour les anomalies
    """
    cap = pyshark.FileCapture(pcap_file)
    
    flows = {}
    for packet in cap:
        try:
            if hasattr(packet, 'ip') and hasattr(packet, 'tcp'):
                src_ip = packet.ip.src
                dst_ip = packet.ip.dst
                src_port = packet.tcp.srcport
                dst_port = packet.tcp.dstport
                
                flow_key = f"{src_ip}:{src_port}-{dst_ip}:{dst_port}"
                
                if flow_key not in flows:
                    flows[flow_key] = {
                        'packet_count': 0,
                        'bytes_total': 0,
                        'start_time': float(packet.sniff_timestamp),
                        'end_time': float(packet.sniff_timestamp),
                        'flags': set()
                    }
                
                flows[flow_key]['packet_count'] += 1
                flows[flow_key]['end_time'] = float(packet.sniff_timestamp)
                
                if hasattr(packet, 'tcp'):
                    flows[flow_key]['flags'].add(packet.tcp.flags)
                
                # Calculer les octets (simplifié)
                flows[flow_key]['bytes_total'] += int(packet.length)
        
        except AttributeError:
            continue
    
    return flows

def detect_anomalous_flows(flows):
    """
    Identifier les flux réseau suspects
    """
    anomalies = []
    
    for flow_key, flow_data in flows.items():
        # Connexions de longue durée
        duration = flow_data['end_time'] - flow_data['start_time']
        if duration > 3600:  # Plus d'une heure
            anomalies.append({
                'flow': flow_key,
                'type': 'long_connection',
                'duration': duration,
                'details': flow_data
            })
        
        # Transferts d'octets élevés
        if flow_data['bytes_total'] > 100000000:  # Plus de 100MB
            anomalies.append({
                'flow': flow_key,
                'type': 'large_transfer',
                'bytes': flow_data['bytes_total'],
                'details': flow_data
            })
        
        # Paquets fréquents de petite taille (balisage potentiel)
        if flow_data['packet_count'] > 1000 and flow_data['bytes_total'] < 10000:
            anomalies.append({
                'flow': flow_key,
                'type': 'frequent_small_packets',
                'packet_count': flow_data['packet_count'],
                'details': flow_data
            })
    
    return anomalies

Flux de Travail d’Analyse

1. Tri Initial

  • Aperçu basique du trafic (protocoles, volume)
  • Établissement de la chronologie
  • Identifier les conversations clés
  • Signaler les protocoles/ports suspects

2. Analyse Approfondie

  • Extraire les transferts de fichiers
  • Analyser les requêtes HTTP/HTTPS
  • Décoder les protocoles chiffrés si possible
  • Identifier les méthodes d’encodage des données

3. Chasse aux Menaces

  • Rechercher les modèles malveillants connus
  • Identifier les indicateurs d’attaque zero-day
  • Corréler avec les renseignements sur les menaces
  • Construire la chronologie de l’attaque

4. Documentation

  • Créer des cartes visuelles du trafic
  • Documenter toutes les conclusions
  • Fournir l’extraction des IOC
  • Recommander des règles de détection

Modèles d’Attaque Courants

Détection de Tunneling DNS

# Rechercher les requêtes DNS longues
dns.qry.name contains "很长" or dns.flags.rcode == 3

# Volume élevé de requêtes DNS vers un seul domaine
dns and frame.time_delta < 0.1

PowerShell Remoting

# Trafic WinRM
tcp.port == 5985 or tcp.port == 5986

# PowerShell Web Access
http.request.uri contains "/powershell"

Exfiltration de Données

# Grandes requêtes HTTP POST
http.request.method == POST and http.content_length > 1000000

# Téléchargements FTP
ftp and ftp.request.command == "STOR"

Exemples de Conclusions d’Analyse

Détection de Balisage C2

Résultats de l'Analyse des Flux:
- Connexion: 192.168.1.50:54321-185.14.28.100:443
- Intervalle moyen: 301 secondes (5 minutes)
- Nombre de paquets: 47 connexions
- Modèle: Balise HTTPS régulière avec données POST
- Évaluation: Communication C2 de haute confiance

Exfiltration de Données

Anomalie Détectée:
- Flux: 10.0.0.15:5555-203.0.113.10:21
- Taille du transfert: 250MB
- Durée: 2 minutes
- Protocole: FTP
- Fichiers: customer_data_2026.zip
- Évaluation: Exfiltration de données potentielle

Résultats Attendus

  1. Rapports d’analyse de trafic complets
  2. IOC et artefacts extraits
  3. Visualisations du trafic réseau
  4. Signatures/règles de détection
  5. Documentation en article de blog

Idées d’Extension

  • Pipeline de détection automatisé des menaces
  • Intégration avec Suricata/Snort
  • Tableau de bord de surveillance du trafic en temps réel
  • Apprentissage automatique pour la détection d’anomalies

Ressources

Notes de Sécurité

  • Travailler dans un environnement réseau isolé
  • Assainir les données sensibles avant le partage
  • Suivre les directives légales et éthiques
  • Utiliser des données légitimes pour la pratique
Tags :
Share :
comments powered by Disqus

Related Posts

Laboratoire d'Analyse d'E-mails de Phishing

Laboratoire d'Analyse d'E-mails de Phishing

Vue d’Ensemble Un projet complet d’analyste SOC pour analyser les e-mails de phishing et développer les compétences de réponse aux incidents.

Read More
Configuration d'un Bac à Sable pour l'Analyse de Malware

Configuration d'un Bac à Sable pour l'Analyse de Malware

Vue d’Ensemble Construire un environnement sécurisé d’analyse de malware pour les analystes SOC afin d’analyser safely les échantillons malveillants et extraire les renseignements sur les menaces.

Read More
Projets Analyste SOC

Projets Analyste SOC

Bienvenue dans une collection complète de projets pratiques d’analyste SOC conçus pour développer des compétences pratiques en cybersécurité.

Read More