Projet RS Manager - Thomas BAERT

Contexte du projet

rs_manager est un système de "Command & Control" (C2) léger, développé pour explorer les mécanismes profonds de la programmation réseau. L'objectif était de sortir des frameworks web classiques pour construire une architecture client-serveur robuste "from scratch" utilisant des sockets bruts.

Contrairement aux solutions traditionnelles reposant sur des bases de données lourdes, ce projet opère entièrement en mémoire vive (RAM), privilégiant la volatilité, la discrétion et la performance immédiate pour l'administration d'un parc de machines.

Architecture Système

L'application repose sur une architecture asynchrone utilisant la bibliothèque standard asyncio de Python, permettant de gérer simultanément de multiples connexions sans blocage.

Diagramme de Séquence

Flux d'exécution d'une commande, de l'admin vers le bot.

sequenceDiagram participant Admin as Administrateur participant Server as Serveur participant Bot as Client participant Shell as Shell Note over Server: écoute sur port 12008 Bot->>Server: connexion TCP (reverse shell) activate Server Server-->>Bot: acquittement (session init) Note right of Server: session enregistrée en RAM Admin->>Server: list Server-->>Admin: table des sessions [id, ip, port] Admin->>Server: select 1 Server-->>Admin: session 1 sélectionnée Admin->>Server: exec whoami Note right of Server: encapsulation JSON: type=exec Server->>Bot: envoi paquet + EOM activate Bot Bot->>Shell: whoami -> stdin Shell-->>Bot: root (stdout) Bot->>Server: result: root deactivate Bot Server-->>Admin: affiche root deactivate Server

Architecture Logicielle

Diagramme de classes simplifié montrant le polymorphisme.

classDiagram
class Core {
    +start_server()
    +session_manager : Manager
}

class Manager {
    -sessions : List~Session~
    -commands : Dict
    +active_session : Session
    +broadcast(cmd)
    +exec(cmd)
    +select(id)
}

class Session {
    +reader : StreamReader
    +writer : StreamWriter
    +ip : str
    +port : int
    +send(msg)
    +recv()
}

class Request {
    +type : str
    +data : dict
    +send(session)
}

class Exec {
    +command : str
}

class Upload {
    +filename : str
    +content : bytes
}

Core --> Manager : possède
Manager o-- Session : gère
Manager ..> Request : instancie
Request <|-- Exec : hérite
Request <|-- Upload : hérite

Concepts Clés

Boucle d'événements : Gestion non-bloquante des I/O (asyncio) pour supporter de multiples connexions.
Console Admin : Interface CLI pour piloter les sessions et envoyer des commandes.
State-less (RAM) : Toutes les sessions et l'état sont maintenus en mémoire pour une empreinte minimale.

Serveur (C2)

Asyncio Server : Écoute et gestion d'un event loop pour multi-connections.
Gestion des sessions : Table en mémoire des sessions [id, ip, port].
Console Admin : Interface CLI pour sélectionner et piloter les sessions.

L'Agent (Client)

Reverse Shell : Connexion sortante vers le serveur pour contourner le NAT/Pare-feu.
Persistance de contexte : Un sous-processus shell maintenu en vie permet de garder l'état (ex: cd /tmp est mémorisé pour la commande suivante).
Discrétion : Empreinte minimale sur le système hôte.

Protocole de Communication

Sockets TCP Bruts : Pas de HTTP/HTTPS, communication bas niveau.
Encapsulation JSON : Structure des commandes (id, type, data) pour la flexibilité.
Délimiteurs : Utilisation de marqueurs EOM pour gérer la fragmentation TCP.

Fonctionnalités Clés

Administration Centralisée : Visualisation et sélection des "bots" connectés via une table de session dynamique.
Exécution de Commandes : Envoi de commandes shell arbitraires et récupération du flux standard (stdout/stderr) en temps réel.
Système de Fichiers : Upload et Download de fichiers binaire/texte via le canal TCP établi.
Polymorphisme : Architecture code orientée objet avec une classe abstraite Request dérivée en Exec, Upload, etc.

Défis Techniques & Apprentissages

Programmation Asynchrone

Core Architecture

Maîtrise de l'Event Loop Python et du modèle de "cooperative multitasking". Comprendre comment await suspend l'exécution pour laisser la main à d'autres clients connectés, permettant à un seul thread de gérer des dizaines de connexions.

Gestion des Sockets

Protocole

Implémentation d'un buffer de lecture robuste. Sur TCP, les données arrivent par flux (streams) et non par paquets discrets. Il a fallu gérer la concaténation et le découpage des messages via des délimiteurs propriétaires.

Interaction Système

Système

Utilisation avancée du module subprocess pour manipuler les pipes (stdin/stdout) d'un shell système de manière programmatique, simulant une véritable interaction utilisateur.