On a demandé à une IA d'attaquer un lab Active Directory, un simple honeypot l'a arrêtée

À l'ère de l'IA, détecter et bloquer une attaque sur un réseau le plus rapidement possible est devenu une nécessité. Mettre en place un honeypot est une solution particulièrement efficace pour ça, et l'exercice devient encore plus intéressant lorsque le blocage s'effectue automatiquement, sans intervention humaine. C'est ce que nous allons voir dans cet article : comment un agent IA autonome a mené une attaque sur un lab Active Directory vulnérable, et comment un honeypot couplé à un pare-feu a suffi à la stopper.

Le contexte

Les agents IA autonomes capables de piloter un terminal, d'exécuter des commandes et d'itérer sur leurs résultats sont de plus en plus performants. Des outils comme Claude Code, conçus au départ pour du développement logiciel, peuvent tout aussi bien être détournés pour orchestrer une séquence d'attaque : reconnaissance, énumération, exploitation, mouvement latéral.

Ça pose une question simple mais importante côté défense : une attaque pilotée par IA se comporte-t-elle différemment d'une attaque humaine, et est-ce qu'on peut la détecter et la bloquer plus facilement ?

Pour y répondre, une expérience a été montée autour de quatre briques :

1. GOAD (Game of Active Directory), un lab volontairement vulnérable qui reproduit un environnement Active Directory réaliste avec plusieurs failles enchaînables.
2. Claude Code, utilisé comme agent autonome pour mener l'attaque contre ce lab.
3. Trapster Community, un honeypot déployé sur le même réseau, couplé à un pare-feu OPNsense pour bloquer automatiquement toute IP détectée en train d'interagir avec lui.
4. Un script Python pour récupérer les logs de Trapster et ajouter les IP à bloquer dans OPNsense.

Configuration d'OPNsense

Une fois le lab prêt (GOAD en place, ainsi que la machine Trapster), l'étape suivante consiste à configurer OPNsense : créer un alias qui contiendra les IP bannies, ainsi que la règle de blocage associée.

L'idée est ensuite de développer un petit script qui récupère les alertes Trapster et ajoute automatiquement l'IP de l'attaquant dans cet alias.

Création de l'alias

Il suffit de créer un nouvel alias dans l'onglet Firewall > Alias, de lui donner un nom, de choisir le type Host(s), et de laisser le reste vide : le script se chargera de le remplir.

Création de la règle de blocage

Il faut ensuite se rendre dans Firewall > Rules > <interface concernée> et créer une nouvelle règle. L'action doit être configurée en Block (ou Reject), et la source doit correspondre à l'alias créé précédemment :

Il ne faut pas oublier de placer cette règle au-dessus des autres : sur OPNsense, c'est la première règle qui correspond au trafic qui s'applique.

Créer une clé API

Dernière étape : créer une clé API pour ajouter les IP malveillantes dans l'alias depuis le script. Rendez-vous dans System → Access → Users :

Configuration de Trapster

Pour Trapster, il suffit de partir d'un fichier de configuration standard adapté à l'Active Directory (SMB, LDAP, MSSQL, etc.). Il faut ensuite indiquer à Trapster d'écrire ses logs dans un fichier, afin de pouvoir les récupérer depuis le script :

"logger": {
  "output": "file",
  "format": "default",
  "kwargs": {
    "logfile": "/var/log/trapster-community.log",
    "mode": "a"
  }
}

Création du script

Pour relier le tout, il faut un petit script qui se contente de lire le fichier de logs Trapster configuré précédemment, de récupérer l'IP source de chaque alerte, puis de l'ajouter dans l'alias grâce à l'API d'OPNsense :

#!/usr/bin/env python3

import json
import time
import requests

url = "http://<ip_opnsense>/api/firewall/alias_util/add/trapster_blocklist"

def parse_alert(line):
    try:
        data = json.loads(line)
        return data.get("src_ip")
    except json.JSONDecodeError:
        return None

def tail_file(path):
    with open(path, "r") as file:
        file.seek(0, 2)
        while True:
            line = file.readline()
            if not line:
                time.sleep(1)
                continue
            yield line

def block_ip(ip):
    response = requests.post(
        url,
        json={"address": ip},
        auth=("<api_key>", "<secret>"),
        verify=False,  # certificat auto-signé du lab, à retirer en production
    )
    if response.status_code == 200:
        print(f"{ip} added to the ban list")
    else:
        print(response.json())

def main():
    logfile = "/var/log/trapster-community.log"
    for line in tail_file(logfile):
        ip = parse_alert(line)
        if ip:
            block_ip(ip)

if __name__ == "__main__":
    main()

Démonstration

Toutes les briques sont maintenant en place : reste à vérifier que l'ensemble fonctionne réellement. Première étape : déposer le script sur la machine qui héberge le honeypot, démarrer Trapster, puis lancer le script.

Il ne reste plus qu'à lancer Claude sur une mission de pentest contre le réseau GOAD. Il dispose pour cela d'un fichier CLAUDE.md définissant le contexte et le scope de la mission :

# Project Context

Educational pentesting lab: GOAD (Game of Active Directory), deployed locally
in an isolated environment for offensive and defensive security training.

## Authorized Scope

- Target network: [e.g., <network>/24]
- Strictly prohibited from going outside this network range

## Objective

Enumerate the Active Directory environment, identify attack paths,
obtain Domain Admin rights on the `sevenkingdoms` domain,
and document every step.

## Tools Available on This Machine

- nmap, NetExec (crackmapexec), Impacket (Python scripts)
- BloodHound / bloodhound-python / SharpHound
- All tools available in Exegol

## Expected Methodology

1. Network reconnaissance
2. AD enumeration (users, groups, ACLs, SPNs)
3. Credential hunting (Kerberoasting, AS-REP roasting, shares)
4. Lateral movement
5. Privilege escalation
6. Documentation of every step in a final report

## Operational Rules

- Document every executed command and its result in a
`logs/session.md` file
- Request confirmation before any destructive action (account
modification, DCSync, etc.)
- Never interact with IP addresses outside the defined scope

Une fois la mission lancée, Claude entame logiquement sa phase de reconnaissance : il balaie le réseau pour identifier les machines actives et les services exposés. C'est précisément ce type d'interaction que Trapster est censé intercepter : le mécanisme est détaillé dans notre article sur la détection des scans Nmap.

Et effectivement, lors de ce scan de services, une alerte est levée côté honeypot, et le script Python la récupère correctement, en extrayant l'IP source de la ligne de log :

Quelques instants plus tard, l'IP est immédiatement bloquée sur OPNsense : l'alias trapster_blocklist a bien été mis à jour via l'API, et la règle de blocage placée en haut de la liste s'applique désormais à cette adresse :

Conséquence directe : l'attaque se retrouve bloquée automatiquement, sans qu'aucune intervention manuelle n'ait été nécessaire entre la détection et la coupure du trafic. Claude perd l'accès au réseau cible en cours de mission, comme le montre la suite de la session :

Conclusion

Cet exemple met en lumière l'utilité d'un honeypot : simple à mettre en place, il suffit de le coupler à un firewall et à un script de quelques dizaines de lignes pour transformer une simple alerte en une riposte automatique. En quelques secondes, une attaque peut ainsi être stoppée net, sans qu'aucune intervention humaine ne soit nécessaire.