aisec traduit une intention en langage naturel en commande d'outil de
sécurité (nmap, tshark, dig, ...), la vérifie, la contrôle, l'exécute et
analyse le résultat.
Avant :
nmap -p 22,80,8080 -sV target.comAvec aisec :
nmapAI "analyse les ports 22, 80, 8080 sur target.com et détecte les versions"L'outil construit la commande, la lance, puis te renvoie un résumé et des constats (ports sensibles, services à risque, ...).
Niveau 1 — l'IA pilote l'outil. Tu décris l'intention en français ; l'IA choisit l'outil, les drapeaux et les paramètres, puis lit la sortie.
Niveau 2 — l'humain pilote l'IA. Rien ne s'exécute sans passer par une
politique de contrôle. Chaque commande proposée est classée par risque et
reçoit une décision : allow, confirm ou deny. C'est ce qui empêche l'IA
de partir en roue libre.
Intention ("enumere les serveurs de noms de example.com")
|
v
+-------------- NIVEAU 1 : l'IA pilote ---------------+
| GENERALISTE (objectif compose, ex: "scanne X puis |
| casse le WPA") -- decompose --> questionne --> |
| synthetise |
| | |
| v |
| ROUTEUR --> EXPERT (classe Parrot) --> OUTIL |
| IA dediee + dig/host/whois |
+---------------------------+----------------------------+
v
+-------------- NIVEAU 2 : l'humain pilote ------------+
| POLITIQUE DE CONTROLE |
| risque de l'outil + mots-cles sensibles |
| plafond de risque, cibles max, liste blanche/noire |
| cibles privees |
| | |
| allow --> execute |
| confirm --> demande a l'humain --> execute / annule |
| deny --> refuse, point. |
+---------------------------+----------------------------+
v
Execution (argv, jamais de shell) --> Analyse
- Les experts sont des IA specialisees : une par classe (dns, wireless, webapp, ...), chacune maitrise ses outils et son prompt systeme.
- Le generaliste est l'IA chef d'orchestre (
aisec/core/generalist.py) : il recoit un objectif libre, le decompose en etapes, questionne les experts pertinents (qui executent leur commande), puis synthetise une reponse unique. Il a sa place reservee :generalist_modeldans la config permet de brancher une IA generaliste entrainee, comme[expert_models]pour les experts.
# Le generaliste decompose, interroge les experts et synthetise
generalistAI "analyse les ports 22,80,8080 de 10.0.0.5 puis casse le wpa de capture.cap"
# ...ou questionne un specialiste precis
aisec consult wireless "casse le wpa de capture.cap"On construit un expert à la fois (comme la taxonomie de Parrot : Information Gathering, Web, Password Attacks, Sniffing, Forensics, ...), on le teste, puis on ajoute le suivant. Le generaliste route vers tous les experts.
Chaque expert peut être branché sur sa propre IA entraînée
([expert_models] dans la config), ou partager le LLM global ; le generaliste a
son propre modèle (generalist_model).
Le moteur de contrôle (aisec/core/control.py) attribue à chaque commande un
niveau de risque et une décision :
| Risque | Outils typiques | Décision par défaut |
|---|---|---|
low |
dig, host, whois, tshark | exécute directement |
medium |
nmap (scan réseau) | demande confirmation |
high |
— | demande confirmation |
critical |
— | demande confirmation |
Le risque d'un outil est déclaré dans le plugin (risk = "low"), et monte
d'un cran si la commande contient un argument sensible (AXFR, --script,
brute, exploit, spoof, ...).
La politique borne aussi le comportement de l'IA :
- plafond de risque auto-approuvé — au-delà, confirmation obligatoire ;
- nombre maximal de cibles par commande (défaut : 16) ;
- liste blanche / liste noire d'outils ;
- refus des cibles privées/internes (optionnel).
# Risque low : part tout seul
aisec dns "MX example.com"
# Risque medium : aisec demande confirmation avant de lancer nmap
aisec nmap "scan des ports 22,80 sur 10.0.0.1"
# $ nmap -p 22,80 10.0.0.1 [risk: medium]
# - risque medium > plafond auto-approuve low
# Executer cette commande ? [y/N]
# On peut auto-approuver explicitement
aisec nmap "scan des ports 22,80 sur 10.0.0.1" --yes
# Ou relever le plafond pour la session
aisec nmap "scan des ports 22,80 sur 10.0.0.1" --auto-approve-risk medium
# Refus net : sortie 3 si l'humain annuleEn mode non interactif (pas de TTY, ex. dans un script), une commande qui exige une confirmation est annulée (jamais exécutée silencieusement).
Retenir la syntaxe exacte de chaque outil est pénible. Ici tu décris ce que tu
veux, aisec s'occupe des drapeaux, de la validation, du contrôle et de la
lecture du résultat. Chaque nouvel outil est un plugin, chaque nouvelle
classe un expert : on étend la suite sans toucher au cœur.
pip install -e ".[dev]" # depuis le dépôt
# ou, pour l'affichage enrichi :
pip install -e ".[dev,ui]"Les binaires des outils doivent être présents :
sudo apt-get install -y nmap bind9-dnsutils whois tsharkPar défaut aisec utilise Ollama (100 % local, aucune donnée ne sort) :
# install Ollama: https://ollama.com
ollama pull llama3.1Si Ollama n'est pas disponible, aisec bascule automatiquement sur un mode
heuristique (sans LLM) : il sait quand même construire les commandes
courantes et analyser les sorties.
Tu peux choisir le backend à chaque appel :
aisec dns "..." --provider ollama # local (défaut)
aisec dns "..." --provider none # heuristique seule
aisec dns "..." --provider openai --model gpt-4o-mini # API (données envoyées)Copie aisec.example.toml vers ./aisec.toml (par projet) ou
~/.config/aisec/config.toml (global). Variables d'environnement AISEC_*
possibles (AISEC_PROVIDER, AISEC_MODEL, AISEC_API_KEY, ...).
provider = "ollama"
model = "llama3.1"
# --- Niveau 2 : politique de contrôle ---
auto_approve_risk = "low" # low | medium | high | critical
max_targets = 16
deny_private_targets = false
assume_yes = false
# --- IA dédiée par expert ---
[expert_models]
dns = "aisec-dns:latest"
web = "aisec-web:latest"
# --- IA généraliste (chef d'orchestre) ---
# Modèle dédié optionnel ; laisser vide pour utiliser le modèle global.
generalist_model = "aisec-generalist:latest"# IA généraliste : décompose l'objectif, questionne les experts, synthétise
generalistAI "analyse les ports 22,80,8080 de 10.0.0.5 puis casse le wpa de capture.cap"
# Questionner un expert précis (IA spécialiste)
aisec consult wireless "casse le wpa de capture.cap"
# Demande libre : le routeur choisit l'expert
aisec ask "je veux les enregistrements MX de example.com"
# Expert DNS (IA dédiée à la classe DNS)
dnsAI "qui possede example.com"
aisec dns "résolution inverse de 8.8.8.8"
aisec dns "tente un transfert de zone sur example.com"
# Experts par classe (reconnaissance, vulnerabilites, web, mots de passe, sniffing)
infoAI "découverte des hôtes sur 192.168.1.0/24"
infoAI "détecte le waf devant https://example.com"
vulnerabilityAI "audite le tls de example.com:443"
aisec vulnerability "audite le routeur cisco 10.0.0.1"
aisec vulnerability "enumere les extensions sip de 10.0.0.1"
aisec vulnerability "fuzz le binaire ./parser avec afl"
webappAI "brute force les répertoires de https://example.com avec gobuster"
passwordsAI "identifie le hash 5f4dcc3b5aa765d61d8327deb882cf99"
sniffingAI "capture le trafic http sur eth0 pendant 100 paquets"
# Expert Web Application Analysis (classe 03 : empreinte, bruteforce, scanners, CMS, proxies)
webappAI "scanne le wordpress http://cible"
aisec webapp "identifie les technologies de example.com"
aisec webapp "bruteforce les répertoires de http://cible"
aisec webapp "teste les failles xss sur http://cible"
# Expert forensique (analyse en lecture seule)
forensicsAI "analyse le firmware firmware.bin avec binwalk"
forensicsAI "analyse suspect.pdf avec pdfid"
forensicsAI "liste les processus de dump.mem avec volatility3"
forensicsAI "recupere les fichiers de disk.img avec foremost"
# Expert reverse engineering (analyse statique en lecture seule)
reverseAI "liste les imports de malware.dll"
reverseAI "identifie sample.exe avec detect-it-easy"
reverseAI "desassemble la fonction main de sample.exe avec radare2"
reverseAI "decompile app.apk avec jadx"
# Expert wireless (tests Wi-Fi, Bluetooth, RFID/NFC)
wirelessAI "capture les reseaux wifi sur wlan0mon"
wirelessAI "casse le wpa de capture.cap avec rockyou.txt"
wirelessAI "attaque le wps du bssid AA:BB:CC:DD:EE:FF sur wlan0mon"
wirelessAI "scanne les peripheriques bluetooth"
# Expert automotive (bus CAN)
automotiveAI "capture les trames can sur can0"
automotiveAI "envoie la trame 123#DEADBEEF sur can0"
# Expert AI tools (orchestration MCP, agents de codage, entrainement)
aiAI "lance le serveur mcpwn sur le port 1337"
aiAI "entraine un modele unsloth sur dataset.jsonl"
# Expert maintien d'acces (C2, backdoors, tunnels, evasion)
maintainingAI "cartographie active directory de corp.local avec bloodhound"
maintainingAI "ecoute sur le port 4444 avec pwncat"
maintainingAI "ouvre un tunnel iodine vers tunnel.example.com"
maintainingAI "lance nmap via proxychains sur 10.0.0.5"
maintainingAI "injecte un shellcode dans app.exe avec shellter"
# Expert systeme/utilitaires (services, dev, radio, navigation)
miscAI "arrete le service nginx"
miscAI "efface ce fichier de facon irreversible"
miscAI "nettoie les metadonnees de photo.jpg"
miscAI "cree une cle usb windows avec woeusb-ng"
miscAI "monte le volume chiffre /dev/sdb1 avec sirikali"
# nmap / tshark (outils directs)
nmapAI "découverte des hôtes vivants sur 192.168.1.0/24"
tsharkAI "lis capture.pcap et affiche les requêtes dns"
# Catalogue (445 outils Parrot) : recherche + installés
aisec tools --search dns
aisec tools --installed
# Lister les experts (classes)
aisec experts
# Ne rien exécuter, juste voir la commande (et son risque)
aisec --dry-run dns "MX example.com"
# Sortie JSON (pour scripter)
aisec --json dns "qui possede example.com"| Option | Effet |
|---|---|
--provider {ollama,openai,groq,none} |
backend LLM |
--model NAME |
modèle à utiliser |
--dry-run |
affiche sans exécuter |
--json |
sortie machine |
--report FICHIER |
écrit un rapport d'audit (.json, .md ou .html) |
--routing {heuristic,llm} |
sélection d'expert : mots-clés (défaut) ou LLM |
--yes |
auto-approuve les confirmations |
--auto-approve-risk LEVEL |
plafond de risque pour la session |
aisec sait enchaîner plusieurs demandes et produire un rapport d'audit.
Au-dessus des experts, la commande generalist traite un objectif composé.
Elle le découpe en étapes, questionne chaque expert concerné (chacun exécute
sa commande avec les mêmes garde-fous), puis synthétise le tout :
generalistAI "analyse les ports 22,80,8080 de 10.0.0.5 puis casse le wpa de capture.cap"Sans LLM, la décomposition est heuristique (connecteurs ;, puis,
ensuite, ...) et la synthèse concatène les réponses : déterministe et
testable. Avec un provider, le généraliste choisit lui-même les experts et
rédige la synthèse. Le rapport d'audit agrège toutes les consultations
(--report audit.html).
Pour ne questionner qu'un seul expert, consult :
aisec consult wireless "casse le wpa de capture.cap"Par défaut le routeur est heuristique (mots-clés, déterministe). Avec un provider actif, on peut demander au LLM de choisir la classe :
aisec ask --routing llm "trouve les failles du portail web"
# le LLM choisit l'expert (webapp), puis l'outil ; repli heuristique si échecLa commande report exécute plusieurs demandes (séparées par ;) et écrit un
rapport consolidé :
aisec report -o audit.html \
"analyse les ports 22, 80, 8080 de la cible 10.0.0.1 ; \
audite le tls de example.com ; \
brute force les répertoires de https://example.com"Formats : .html (autonome, CSS inline), .md, .json. Le rapport contient
les constats triés par sévérité, la commande, le risque et la sortie de chaque
exécution.
Une seule demande peut aussi produire un rapport avec --report :
aisec nmap --report scan.md "scan des ports 22,80 sur 10.0.0.1"Au-dessus du niveau 2, chaque classe peut durcir sa politique : les classes
offensives (exploitation, post-exploit, wireless, passwords) exigent
toujours une confirmation, même pour un outil de risque faible. La politique
combinée est la plus stricte des deux (on ne relâche jamais une borne globale).
Surchargeable dans [expert_policies] :
[expert_policies]
exploitation = { max_auto_risk = "low", require_confirmation = true }[expert_models] branche un modèle par classe (une IA entraînée par domaine) ;
l'orchestrateur l'applique automatiquement à l'expert sélectionné. Le
généraliste a son propre modèle (generalist_model), réservé de la même façon.
[expert_models]
dns = "aisec-dns:latest"
generalist_model = "aisec-generalist:latest"Guide complet : docs/AI_TRAINING.md. En bref :
# 1. générer les jeux d'entraînement depuis le code (experts + outils + generaliste)
python scripts/build_dataset.py --out datasets
# 2. adapter un modèle local par classe et un pour le generaliste (Ollama, sans GPU)
python scripts/build_dataset.py --modelfiles --out datasets --base-model llama3.1
ollama create aisec-info -f datasets/Modelfile.info
ollama create aisec-generalist -f datasets/Modelfile.generalist
# 3. évaluer l'exactitude JSON d'un modèle
python scripts/build_dataset.py --eval datasets/expert_routing.val.jsonl --provider ollamaLe savoir est déjà dans le code (system_prompt, examples de chaque
outil) : le script réutilise les prompts de production, donc un modèle adapté
colle au comportement réel. Ajouter des examples est le levier n°1.
aisec génère des commandes : il les vérifie avant exécution, puis les
contrôle.
- Jamais de
shell=True: les commandes sont lancées avec une liste d'arguments. - Le binaire est verrouillé (une commande
nmapne peut pas devenirrm). - Les métacaractères shell (
;,|,$, backticks, ...) sont rejetés. - Les CIDR trop larges (ex :
/0) et les cibles non routables sont bloqués. - Les cibles privées/internes génèrent un avertissement (ou un refus).
- Politique de risque :
allow/confirm/denyavant chaque exécution. --dry-run(oudry_run = true) n'exécute rien.
aisec/
catalog/ catalogue d'outils (445 outils Parrot) + recherche/installés
core/ moteur: config, safety, control, policies (niveau 3),
executor, intent, analyzer, engine, orchestrator, generalist,
registry
experts/ experts par classe: base.py (socle) + dns, info, vulnerability,
webapp, passwords, sniffing, exploitation, forensics, reverse,
post_exploit, reporting, wireless, ai, automotive, maintaining,
misc
providers/ backends LLM: ollama (local), openai-compatible (API)
report.py rapport d'audit: agregation + export JSON / Markdown / HTML
tools/ plugins: nmap, tshark, dig, host, whois, masscan, arp-scan,
sslscan, wafw00f, dnsrecon, bettercap, passwords (13 outils),
exploitation (18 outils) + spec.py (base déclarative)
+ vuln_scan/cisco/stress/fuzz/voip (classe 02 : 46 outils)
+ web_crawl/web_vuln/web_misc + webapp (classe 03 : 38 outils)
+ outils forensiques (classe 11 : fls, mmls, icat, foremost,
scalpel, binwalk, bulk_extractor, pdfid, pdf-parser, yara,
volatility3, regripper, reglookup, galleta, vinetto, hashdeep,
ssdeep, rkhunter, chkrootkit, extundelete, dc3dd, ddrescue)
+ outils reverse (classe 07 : rabin2, radare2, rahash2, rasm2,
radiff2, rizin, rz-hash, rz-find, gdb, bddisasm, die, apktool,
dex2jar, jadx, androguard, baksmali, smali)
+ post_exploit (classe 08 : 15 outils) + reporting (classe 12 :
4 outils)
+ outils wireless (classe 06 : airmon-ng, airodump-ng,
aireplay-ng, aircrack-ng, reaver, wifite, mdk4, pixiewps, bully,
cowpatty, asleap, bluesnarfer, blueranger, hcitool, mfoc, mfcuk,
nfc-list)
+ outils automotive (classe 13 : candump, cansend, cangen,
canconfig, canconvert, isotpdump)
+ outils IA (classe 14 : hexstrike-ai, mcpwn, opencode, pi-dev,
unsloth)
+ outils maintien d'acces (classe 10 : bloodhound, dnscat2,
villain, starkiller, convoc2, windows-binaries, powershell-empire,
pwncat, cryptcat, sbd, sliver, weevely, webacoo, laudanum,
nishang, webshells, htshells, iodine, dns2tcp, godoh, miredo,
proxychains, proxychains4, proxytunnel, ptunnel, pwnat, socat,
stunnel4, udptunnel, shellter, veil-evasion, hyperion, exe2hexbat)
+ misc (classe 15 : services systeme apache2/nginx/mariadb/
postgresql/openssh/metasploit/gvm, arduino, powershell,
chirp, nyx, firefox, coreutils, gpa, keepassxc, mat2,
sirikali, zulucrypt-gui, zulumount-gui, woeusb-ng)
cli.py CLI unifiée + commandes `report`, `generalist`, `consult` +
alias (generalistAI, nmapAI, tsharkAI, dnsAI,
infoAI, vulnerabilityAI, webappAI, passwordsAI, sniffingAI,
exploitationAI, forensicsAI, reverseAI, postExploitAI,
reportingAI, wirelessAI, aiAI, automotiveAI, maintainingAI,
miscAI)
Flux : objectif → generaliste (decomposition + synthese) → routeur → expert → outil → params → argv → garde-fous → politique (niveaux 2+3) → exécution → analyse → rapport.
- Créer
aisec/tools/mon_outil.pyavec une classe héritant deTool(build_argv,parse_intent,analyze), un tupleparameterset unrisk(low/medium/high/critical). - L'enregistrer via
register(MonOutil()). - L'importer dans
aisec/core/registry.py::_load_builtins. - (Optionnel) Ajouter un alias dans
pyproject.toml [project.scripts].
- Créer
aisec/experts/ma_classe.pyavec unExpert(...):system_prompt,tool_names,keywords(routage),routing_rules(outil + mots-clés). - Le
register(...)dansaisec/experts/__init__.py.
C'est tout : le routeur, la CLI (aisec ma_classe "...") et le rendu suivent.
pytest -qCouverture : moteur, garde-fous, catalogue Parrot, routage d'expert, construction d'argv DNS, politique de contrôle (niveau 2), politiques par classe (niveau 3), orchestrateur, rapports, et générateur de jeux d'entraînement.