Client / serveur de contrôle à distance (projet pédagogique)

Cadre pédagogique. Ce projet a été réalisé en environnement de laboratoire isolé, à des fins d'apprentissage défensif. L'objectif est de comprendre le fonctionnement d'un outil de contrôle à distance pour mieux le détecter et s'en protéger. Aucun déploiement hors de ce cadre n'est envisagé.

Fiche à compléter. Structure prête ; complétez avec les détails de votre implémentation. Le code de l'agent n'est volontairement pas publié.

Objectif pédagogique#

Comprendre en le construisant le fonctionnement d'un canal de commande et de contrôle (C2) : établissement de session, chiffrement des échanges, gestion de plusieurs agents simultanés. Cette compréhension sert directement le travail défensif au SOC — on détecte mieux ce qu'on a soi-même démonté.

Compétences mises en œuvre#

• Programmation réseau bas niveau avec les sockets Python.
• Concurrence : un serveur gérant plusieurs clients par threads.
• Cryptographie appliquée : chiffrement symétrique du canal.
• Conception de protocole applicatif simple (encadrement des messages, sérialisation).

Architecture#

┌────────────┐        canal chiffré         ┌────────────┐
│   Agent    │ ───────────────────────────▶ │            │
├────────────┤                              │  Serveur   │
│   Agent    │ ───────────────────────────▶ │  (C2)      │
├────────────┤                              │  threadé   │
│   Agent    │ ───────────────────────────▶ │            │
└────────────┘                              └────────────┘
                                                  │
                                                  ▼
                                           console opérateur

Points techniques#

Serveur multi-clients#

Le serveur écoute sur un socket, et délègue chaque connexion acceptée à un thread dédié, ce qui permet de suivre plusieurs agents en parallèle.

import socket
import threading

def handle_client(conn: socket.socket, addr) -> None:
    with conn:
        # négociation de session puis boucle de traitement chiffrée
        ...

def serve(host: str, port: int) -> None:
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as srv:
        srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        srv.bind((host, port))
        srv.listen()
        while True:
            conn, addr = srv.accept()
            threading.Thread(target=handle_client, args=(conn, addr), daemon=True).start()

Chiffrement du canal#

Les échanges sont chiffrés pour que le trafic ne soit pas lisible en clair sur le réseau, avec une clé négociée à l'établissement de session.

Encadrement des messages#

Comme TCP est un flux continu, chaque message est précédé de sa longueur, afin que le récepteur sache où s'arrête un message et où commence le suivant.

L'angle défensif — le vrai enseignement#

Avoir construit l'outil éclaire directement sa détection côté SOC :

Limites et éthique#

• Projet cantonné à un réseau de laboratoire, sans cible réelle.
• Code de l'agent non diffusé publiquement.
• Finalité strictement pédagogique et défensive.

Ce que j'en retire#

• [À compléter] — par exemple : la difficulté de fiabiliser l'encadrement des

  messages, ou ce que l'exercice a changé dans votre lecture des alertes réseau au SOC.