Skip to content
Back to search

LazyOwn

LazyOwn RedTeam/APT Framework is the first RedTeam Framework with an AI-powered C&C, featuring rootkits to conceal campaigns, undetectable malleable implants compatible with Windows/Linux/Mac OSX, and self-configuring backdoors. With its Web interface and powerful Console Client, it is the best combination for your Autonomous RedTeam/APT campaigns.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/grisuno/LazyOwn with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/grisuno/LazyOwn'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/grisuno--lazyown/badge.svg)](/listings/grisuno--lazyown)

HTML

<a href="/listings/grisuno--lazyown"><img src="/api/listings/grisuno--lazyown/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

curl -fsSL https://raw.githubusercontent.com/grisuno/LazyOwn/main/bootstrap.sh -o /tmp/bootstrap.sh \
  && bash /tmp/bootstrap.sh

| Try in 60 seconds (no install) | Golden path (every engagement) | One-command auto-pwn | |---|---|---| | `docker run -it ghcr.io/grisuno/lazyown:latest` | `ping > lazynmap > auto_populate > facts_show > recommend_next` | `engage 10.10.11.5` |

More demos

| First 7 commands | Recon loop | |---|---| | ![first steps](assets/demo/first-steps.gif) | ![recon loop](assets/demo/recon-loop.gif) |

| C2 from CLI | Issue commands to beacons | |---|---| | ![C2 CLI](assets/demo/c2-cli.gif) | ![issue to C2](assets/demo/issue-c2.gif) |

Full walkthrough: [`QUICKSTART.md`](QUICKSTART.md) (5 min) · 80/20 guide: [`ESSENTIALS.md`](ESSENTIALS.md) · HTB end-to-end: [`docs/examples/htb-lame-walkthrough.md`](docs/examples/htb-lame-walkthrough.md) · Honest comparison: [`COMPARISON.md`](COMPARISON.md)

Doc

Automated by [readmenator](https://grisuno.github.io/LazyOwn/readmenator-maps/index.html) (pip install readminator)

[https://grisuno.github.io/LazyOwn](https://grisuno.github.io/LazyOwn)

Why LazyOwn vs Sliver / Havoc / Mythic / Caldera / Metasploit

| Capability | LazyOwn | Sliver | Havoc | Mythic | Caldera | Metasploit | |---|:-:|:-:|:-:|:-:|:-:|:-:| | Linux BOF support | yes | no | no | no | no | no | | YARA + Nuclei marketplace built-in | yes | no | no | no | no | no | | MCP server for AI agents (153 tools) | yes | no | no | no | no | no | | LLM operator + multi-agent hive | yes | no | no | no | no | no | | Multi-operator C2 + phishing engine | yes | partial | partial | partial | partial | partial |

Full table: [`COMPARISON.md`](COMPARISON.md). Found an error? Open an issue, we fix it.

 ██▓    ▄▄▄      ▒███████▒▓██   ██▓ ▒█████   █     █░███▄    █
▓██▒   ▒████▄    ▒ ▒ ▒ ▄▀░ ▒██  ██▒▒██▒  ██▒▓█░ █ ░█░██ ▀█   █
▒██░   ▒██  ▀█▄  ░ ▒ ▄▀▒░   ▒██ ██░▒██░  ██▒▒█░ █ ░█▓██  ▀█ ██▒
▒██░   ░██▄▄▄▄██   ▄▀▒   ░  ░ ▐██▓░▒██   ██░░█░ █ ░█▓██▒  ▐▌██▒
░██████▒▓█   ▓██▒▒███████▒  ░ ██▒▓░░ ████▓▒░░░██▒██▓▒██░   ▓██░
░ ▒░▓  ░▒▒   ▓▒█░░▒▒ ▓░▒░▒   ██▒▒▒ ░ ▒░▒░▒░ ░ ▓░▒ ▒ ░ ▒░   ▒ ▒
░ ░ ▒  ░ ▒   ▒▒ ░░░▒ ▒ ░ ▒ ▓██ ░▒░   ░ ▒ ▒░   ▒ ░ ░ ░ ░░   ░ ▒░
  ░ ░    ░   ▒   ░ ░ ░ ░ ░ ▒ ▒ ░░  ░ ░ ░ ▒    ░   ░    ░   ░ ░
    ░  ░     ░  ░  ░ ░     ░ ░         ░ ░      ░            ░
                 ░         ░ ░

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.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 550 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # LazyOwn RedTeam Framework with AI agents, Linux BOF beacon, YARA+Nuclei marketplace
  2. <img width="862" height="862" alt="image" src="https://github.com/user-attachments/assets/6157c084-c743-4042-bd91-f8d2cc6a194c" />
  3. [![stars](https://img.shields.io/github/stars/grisuno/LazyOwn?style=social)](https://github.com/grisuno/LazyOwn/stargazers)
  4. [![release](https://img.shields.io/github/v/release/grisuno/LazyOwn?include_prereleases&logo=github)](https://github.com/grisuno/LazyOwn/releases)
  5. [![docker](https://img.shields.io/badge/docker-ghcr.io%2Fgrisuno%2Flazyown-blue?logo=docker)](https://github.com/grisuno/LazyOwn/pkgs/container/lazyown)
  6. [![ci](https://github.com/grisuno/LazyOwn/actions/workflows/ci.yml/badge.svg)](https://github.com/grisuno/LazyOwn/actions/workflows/ci.yml)
  7. [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
  8. [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/grisuno/LazyOwn)
  9. > **872 CLI commands. Multi-operator C2. 153 MCP tools for AI agents. The First OSS C2 with Linux native c BOF support + built-in YARA/Nuclei marketplaces.**
  10. ## Install in one command
  11. ```bash
  12. curl -fsSL https://raw.githubusercontent.com/grisuno/LazyOwn/main/bootstrap.sh -o /tmp/bootstrap.sh \
  13. && bash /tmp/bootstrap.sh
  14. ```
  15. | Try in 60 seconds (no install) | Golden path (every engagement) | One-command auto-pwn |
  16. |---|---|---|
  17. | `docker run -it ghcr.io/grisuno/lazyown:latest` | `ping > lazynmap > auto_populate > facts_show > recommend_next` | `auto_loop --target 10.10.11.5` |
  18. <img width="1505" height="868" alt="image" src="https://github.com/user-attachments/assets/a39570b5-8062-4448-a83e-b1609cc60f82" />
  19. ![golden path demo](assets/demo/golden-path.gif)
  20. ![C2 collab demo](assets/demo/c2-collab.gif)
  21. ![MCP AI demo](assets/demo/mcp-ai.gif)
  22. ### More demos
  23. | First 7 commands | Recon loop |
  24. |---|---|
  25. | ![first steps](assets/demo/first-steps.gif) | ![recon loop](assets/demo/recon-loop.gif) |
  26. | C2 from CLI | Issue commands to beacons |
  27. |---|---|
  28. | ![C2 CLI](assets/demo/c2-cli.gif) | ![issue to C2](assets/demo/issue-c2.gif) |
  29. First victory in 5 minutes: [`TUTORIAL_5_MINUTES.md`](TUTORIAL_5_MINUTES.md) · Full walkthrough: [`QUICKSTART.md`](QUICKSTART.md) (5 min) · 80/20 guide: [`ESSENTIALS.md`](ESSENTIALS.md) · HTB end-to-end: [`docs/examples/htb-lame-walkthrough.md`](docs/examples/htb-lame-walkthrough.md) · Honest comparison: [`COMPARISON.md`](COMPARISON.md)
  30. ### Doc
  31. Automated by [readmenator](https://grisuno.github.io/LazyOwn/readmenator-maps/index.html) (pip install readminator)
  32. [https://grisuno.github.io/LazyOwn](https://grisuno.github.io/LazyOwn)
  33. <img width="1913" height="963" alt="image" src="https://github.com/user-attachments/assets/798fd75b-db6c-4443-a7bd-ed79788280ce" />
  34. ### Why LazyOwn vs Sliver / Havoc / Mythic / Caldera / Metasploit
  35. | Capability | LazyOwn | Sliver | Havoc | Mythic | Caldera | Metasploit |
  36. |---|:-:|:-:|:-:|:-:|:-:|:-:|
  37. | Linux BOF support | yes | no | no | no | no | no |
  38. | YARA + Nuclei marketplace built-in | yes | no | no | no | no | no |
  39. | MCP server for AI agents (153 tools) | yes | no | no | no | no | no |
  40. | LLM operator + multi-agent hive | yes | no | no | no | no | no |
  41. | Multi-operator C2 + phishing engine | yes | partial | partial | partial | partial | partial |
  42. Full table: [`COMPARISON.md`](COMPARISON.md). Found an error? Open an issue, we fix it.
  43. ```sh
  44. ██▓ ▄▄▄ ▒███████▒▓██ ██▓ ▒█████ █ █░███▄ █
  45. ▓██▒ ▒████▄ ▒ ▒ ▒ ▄▀░ ▒██ ██▒▒██▒ ██▒▓█░ █ ░█░██ ▀█ █
  46. ▒██░ ▒██ ▀█▄ ░ ▒ ▄▀▒░ ▒██ ██░▒██░ ██▒▒█░ █ ░█▓██ ▀█ ██▒
  47. ▒██░ ░██▄▄▄▄██ ▄▀▒ ░ ░ ▐██▓░▒██ ██░░█░ █ ░█▓██▒ ▐▌██▒
  48. ░██████▒▓█ ▓██▒▒███████▒ ░ ██▒▓░░ ████▓▒░░░██▒██▓▒██░ ▓██░
  49. ░ ▒░▓ ░▒▒ ▓▒█░░▒▒ ▓░▒░▒ ██▒▒▒ ░ ▒░▒░▒░ ░ ▓░▒ ▒ ░ ▒░ ▒ ▒
  50. ░ ░ ▒ ░ ▒ ▒▒ ░░░▒ ▒ ░ ▒ ▓██ ░▒░ ░ ▒ ▒░ ▒ ░ ░ ░ ░░ ░ ▒░
  51. ░ ░ ░ ▒ ░ ░ ░ ░ ░ ▒ ▒ ░░ ░ ░ ░ ▒ ░ ░ ░ ░ ░
  52. ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░
  53. ░ ░ ░
  54. ```
  55. [![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/Y8Y2Z73AV)
  56. LazyOwn comes with ABSOLUTELY NO WARRANTY. This is free software, and you are welcome to redistribute it under the terms of the GNU Affero General Public License v3.
  57. See the LICENSE file for details about using this software.
  58. # LazyOwn RedTeam Framework v 0.5.0
  59. LazyOwn is a professional red team framework and Command & Control (C2) platform built for penetration testers, red teams, and security researchers. It delivers 872 CLI commands, 130 aliases, 153 MCP tools for AI agents, a multi-operator web C2 dashboard, and 137 YAML/Lua plugin integrations covering the full kill chain across Linux, Windows, macOS, and BSD.
  60. **New in this release:** integrated marketplace with YARA rules + Nuclei templates, `auto_loop` autonomous exploitation, `hunt` command for threat-informed recon, post-command tips engine, automatic session data encryption, gamified ELO/badges, and 7 new APT playbooks. Plus: `retry` resume of interrupted chains/loops (with a guarded `--sudo` mode), `chain_distill` to turn one loop trace into a reusable chain YAML, typed verb manifests for the planner, and every installed lazyaddon surfacing as a toggleable `addon:*` verb.
  61. **Autonomous contracts update:** the loop is now administered by
  62. `config/orchestrator.yaml` profiles (`default`, `stealth`, `lab`, `gym`),
  63. chains support conditions, timeouts, retries, capture and sink tags, and
  64. every exploit, emulation step, chain result and finding fans out through
  65. one outcome bus. Metasploitable 2 ships with 45 indexed vectors, one
  66. exploit and one chain each, including SQLi, XSS, CSRF, LFI/RFI, upload and
  67. command injection. Lazyaddons opt in to git fast-forward updates with
  68. `update: true`; every shipped addon is opted in.
  69. I also integrated autonomous-operation contracts into the existing
  70. flows (safety gate and planner frontier inside the daemon loop,
  71. provider failover, evidence vault, db-backed finding retests).
  72. I verify them through the usual verbs. Full contract:
  73. `specs/autonomous_ops.md`.
  74. ## Quickstart in three commands
  75. New here? This is the whole on-ramp. Full walkthrough: [`QUICKSTART.md`](QUICKSTART.md).
  76. Fastest path (one-liner: clones into `~/LazyOwn`, installs, then asks whether
  77. to start a normal `./run` session or the full `fast_run_as_r00t.sh` stack):
  78. ```bash
  79. curl -fsSL https://raw.githubusercontent.com/grisuno/LazyOwn/main/bootstrap.sh -o /tmp/bootstrap.sh \
  80. && bash /tmp/bootstrap.sh
  81. ```
  82. (One-command alternative: `curl -fsSL https://raw.githubusercontent.com/grisuno/LazyOwn/main/bootstrap.sh | bash`.)
  83. If `~/LazyOwn` already exists, the installer asks whether to update in place, do a clean reinstall (backing up `payload.json` to `/tmp` first), use another directory, or abort.
  84. Or step by step:
  85. ```bash
  86. git clone https://github.com/grisuno/LazyOwn.git && cd LazyOwn
  87. bash install.sh # virtualenv + pinned dependencies + C2 certificates
  88. ./run # launches the shell; first run offers the setup wizard
  89. ```
  90. The default install is light; add `--with-ml` for the heavy torch/CUDA stack, `--with-ollama` for the local LLM runtime, `--with-tools` for the common external binaries (forward them through the one-liner with `bash -s -- <flags>`). Dependencies are pinned in `requirements.txt` (cross-platform core) and `requirements-ml.txt` (optional ML); `pyproject.toml` is the single source of truth.
  91. ### Docker
  92. For isolated, reproducible engagements, see [`lazyown-docker/README.md`](lazyown-docker/README.md).
  93. ```bash
  94. cd lazyown-docker
  95. ./mkdocker.sh build
  96. ./mkdocker.sh run --vpn 1
  97. ```
  98. ### Autonomous loop and chains
  99. The generic golden path no lab, no containers, one authorized target:
  100. ```bash
  101. lazy_loop --target 10.10.10.5 --rounds 6 "gain initial access"
  102. apt_chain apt_generic 10.10.10.5 # auto-discovered fallback chain runs itself on failure
  103. apt_chain apt_generic 10.10.10.5 --dry-run # plan check only
  104. # multi-target: one loop per line of scope.txt, max 3 in flight:
  105. auto_loop --targets-from-file scope.txt --max-concurrent 3 "gain initial access"
  106. ```
  107. `apt_chain` is self-recovering by schema: steps accept
  108. `pre_check` (skip the step early when a cheap predictor fails), steps
  109. accept `parallel: true` (independent scans run concurrently), and
  110. chains accept `fallback: <chain>` (a failed chain re-runs its fallback
  111. with the same run id, reported as `fallback_used`). Repeated failures
  112. can hand the objective to the model: `apt_chain ... --replan`.
  113. Contract: [`docs/autonomous-loop.md`](docs/autonomous-loop.md).
  114. The loop reads `config/orchestrator.yaml`; explicit flags still win.
  115. ```bash
  116. lazy_loop --profile gym --target 172.17.0.2 "root the gym"
  117. apt_chain gym_metasploitable_ms2_distcc_exec 172.17.0.2
  118. apt_chain gym_metasploitable_ms2_distcc_exec 172.17.0.2 --dry-run
  119. # something failed mid-chain? resume only what did not finish:
  120. retry status
  121. retry chain gym_metasploitable_ms2_distcc_exec --var target=172.17.0.2
  122. retry chain gym_metasploitable_ms2_distcc_exec --sudo # guarded: prints a warning, waits for YES
  123. # distill a finished loop trace into a reusable chain:
  124. chain_distill t0001 --write
  125. # choose what the loop may run (837 shell verbs + every lazyaddon):
  126. verb list addon
  127. verb on addon:adcs_attacks
  128. gym_ms2 list
  129. gym_ms2 validate
  130. lazy_addon update --all --dry-run
  131. ```
  132. `lab start metasploitable` prints the container IP and the `assign rhost`
  133. line, starts Apache when the image boots without it, and applies the gym
  134. migrations automatically (`modules/metasploitable_migrations.py`): core
  135. daemons, telnet/rlogin/rsh access from the docker subnet, anonymous FTP,
  136. an open X display, the Shellshock CGI, the mutillidae database (setup +
  137. mirror into `metasploit`) and the canonical DVWA DOM XSS page. Three
  138. vectors need extra cheerleading inside a container, and migrations fix
  139. them too: a Python DNS responder stands in for `bind9` (Docker strips the
  140. `capset` it wants), a userspace `rpc.mountd` stands in for the kernel
  141. NFS server, and `/root/.rhosts` trusts the loopback for `rsh`. All 45
  142. shipped vectors yield a shell on the lab. Setup guide:
  143. [`docs/gym-setup.md`](docs/gym-setup.md).
  144. The outcome bus updates the world model, kill-chain, intel graph, attack
  145. graph, C2 banners/CVEs/notes, objectives and session report from one
  146. event. Contracts: [`docs/autonomous-loop.md`](docs/autonomous-loop.md),
  147. [`docs/outcome-bus.md`](docs/outcome-bus.md),
  148. [`docs/emulation-runner.md`](docs/emulation-runner.md),
  149. [`docs/metasploitable-gym.md`](docs/metasploitable-gym.md).
  150. Then, inside the `(LazyOwn) >` shell:
  151. ```text
  152. doctor # preflight: verifies Python, venv, packages, certs, SecLists, tools
  153. wizard # guided config (auto-detects lhost, walks 8 steps incl. LLM provider)
  154. ping # confirm the target is up and detect its OS
  155. lazynmap # full port + service scan
  156. ```
  157. If `doctor` reports a blocking failure (red), fix it before going further it
  158. tells you the exact `pip install` / `apt install` command for whatever is
  159. missing. Warnings (yellow) are optional features you can ignore for now.
  160. ## Autonomous loop
  161. LazyOwn ships a native autonomous loop: one command drives a full
  162. engagement round by round (scope, enrichment, planning, workers, guard,
  163. traffic, findings, retest, compaction, intel fusion, report), with every
  164. step persisted and auditable under `sessions/lazy/`.
  165. ```text
  166. auto_loop --target 10.10.10.5 --rounds 6 --workers 2 "gain initial access"
  167. lazy_loop --view # resume/observe with the live worker monitor
  168. lazy_view t0001 # attach the monitor from another terminal
  169. lazy_orchestrator # admin console: stages, verbs, playbooks, gyms, chains, profiles, LLM chain, guard
  170. ```
  171. Highlights:
  172. - configurable pipeline: enable/disable each stage and manage the auto
  173. verb registry (`lazy_orchestrator` Pipeline and Verbs tabs, with a
  174. searchable command picker when adding verbs);
  175. - playbook administration: list, preview, create, edit and delete
  176. `playbooks/*.yaml` from the `lazy_orchestrator` Playbooks tab;
  177. - gym administration: YAML definitions under `gyms/`, persistent runs in
  178. the world model, and a `lazy_orchestrator` Gyms tab to start/stop them;
  179. - transparent execution: every step is narrated live, with heartbeats, a
  180. stall watchdog and thread-stack dumps when nothing moves;
  181. - safe teardown: `Ctrl+C`, `qa`, `exit`, EOF and `atexit` kill children,
  182. close shell sessions, pause tasks and leave everything resumable;
  183. - intel fusion: each round merges logs into the world model, findings
  184. lifecycle and objectives via `lazy_bridge.sync_all`.
  185. Full documentation: [`docs/autonomous-loop.md`](docs/autonomous-loop.md).
  186. # Core Architecture
  187. LazyOwn is built around a modular, command-driven architecture that provides flexibility and extensibility for security testing workflows.
  188. # LazyOwn Skills MCP Integration
  189. Connect AI agents to the framework via the Model Context Protocol (MCP). The MCP server
  190. (`skills/lazyown_mcp.py`) exposes 153 tools covering the full engagement lifecycle.
  191. ```bash
  192. bash scripts/setup_hermes_mcp.sh # register the MCP server
  193. ```
  194. Then restart your agent or run `/reload-mcp`. Full tool playbook: [`skills/lazyown.md`](skills/lazyown.md).
  195. Agent setup details (Claude Code, Hermes, OpenCode, env vars, tool groups): [`docs/mcp-setup.md`](docs/mcp-setup.md).
  196. ## Key Features
  197. 1. **872 Attack Commands**: Full kill-chain coverage across Linux, Windows, macOS, and BSD recon, enum, exploit, privesc, lateral movement, credential access, C2, exfiltration, and reporting.
  198. 2. **Interactive cmd2 CLI**: Fuzzy autocomplete, neon-box configurable prompt, command palette (`Ctrl+K`), inline reactive hints after every command, and a Textual TUI dashboard.
  199. 3. **Integrated Marketplace**: `yara_marketplace` (10 built-in rules: ransomware, C2, webshells, obfuscation, privesc), `nuclei_marketplace` (500+ templates), `marketplace` for community plugins/addons all browsable via curses TUI.
  200. 4. **auto_pwn & hunt**: Autonomous exploitation chaining and threat-informed recon `auto_pwn` walks kill-chain phases automatically, `hunt` executes targeted discovery based on known TTPs.
  201. 5. **Unified Post-Command Tips Engine**: Smart suggestions (kill-chain hints, protips, curiosity, autosuggest) with ELO rating, badges (First Blood, Arsenal Master, Kill Chain Master), and VRI rewards gamified operator experience.
  202. 6. **Automatic Session Crypto**: `auto_crypto` encrypts sensitive session files on exit and decrypts on startup (PBKDF2HMAC + Fernet), transparent to the operator.
  203. 7. **AI-Native Architecture**: MoE (Mixture of Experts) router, RL training, SWAN orchestrator, Hive Mind multi-agent system, ACI (Autonomous Campaign Intelligence) planner the first C2 that plans, executes, and learns autonomously.
  204. 8. **Multi-Stage Obfuscated Go Implants**: Two-stage XOR-encoded beacon delivery with C stubs, AES-256 encrypted C2 channels, VM/sandbox/debugger evasion, polymorphism, and LOLBAS-based stagers. Tested on Kernel 6.12 and Windows 10.0.20348.
  205. 9. **Linux BOF (Beacon Object Files)**: First open-source C2 framework with BOF support for Linux via ELF `dlopen` runtime. Source-compatible `datap` API with Windows BOF contract. Direct syscalls and `io_uring` support.
  206. 10. **Decoy Blue Team Trap**: Flask decoy website records video/audio and captures images of unauthorized visitors (blue team operators probing the C2), stored in `sessions/captured_images`.
  207. 11. **Bloodhound Attack Surface**: Upload Bloodhound ZIP data to render interactive attack surface graphs with filtering and search, augmented by `lazynmap` discovery data.
  208. 12. **AI-Powered Phishing Engine**: Groq/DeepSeek AI-generated email templates with dynamic URL generation, tracking pixels, URL shortening, and test endpoint creation.
  209. ---
  210. 3. **Decoy**: if the ip addres not match with 127.0.0.1 or lhost flask will show a decoy website this decoy site will record a video with audio and take pictures from the intruder (sessions/captured_images) like a small versión of storm breaker to know who is the blueteam operator
  211. ![image](https://github.com/user-attachments/assets/17f36120-3a17-4ee3-9358-8f4f6caa07bf)
  212. 4. **Adversary Simulation**: Advanced capabilities for generating red team operation sessions, ensuring meticulous and effective simulations.
  213. ![adversay emulator](https://github.com/user-attachments/assets/dc6e3ca2-c70d-46c5-9240-488bbea409ce)
  214. 5. **Task Scheduling**: Utilize the `cron` command to schedule and automate tasks, enabling persistent threat simulations.
  215. 6. **Real-Time Results**: Obtain immediate feedback and results from security assessments, ensuring timely and accurate insights.
  216. 7. **RAT and Botnet Capabilities**: Includes features for remote access and control, allowing for the management of botnets and persistent threats.
  217. 8. **C2 Framework IA Powered**: Acts as a command and control (C2) framework, enabling covert communication and control over compromised systems. and many IA bots to improve your opsec, Developed in Flask, providing a user-friendly interface for seamless interaction. Now with network discovery capabilities, allowing us to see the attack surface on our client map clearly and intuitively with filters and a search panel. New functionalities are coming soon.
  218. ![image](https://github.com/user-attachments/assets/f0b61d32-a67d-4036-809e-1d6f5e872057)
  219. ![vulnbot](https://github.com/user-attachments/assets/86ae6384-f61b-41be-8b87-222399bf2b77)
  220. - **C2 LazyAddon Creator**: Guided `/addons` pages in the C2 dashboard to author `lazyaddons/*.yaml` integrations without touching YAML by hand. One form exposes every addon option (name, description, author, version, enabled, target OS, trigger services, category, module type, install type, parameters, tool block, C2 extras, environment variables) with tooltips, placeholders, and per-field help. Placeholder chips (`{rhost}`, `{url}`, declared params, and every payload.json key) are drag-and-drop into command boxes. Server-side validation rejects unsafe names, path traversal, unknown placeholders, and malformed URLs before the file is written; writes are atomic and secure (temp file created with restrictive permissions via `mkstemp` + `fchmod`, flushed and fsynced, then promoted with `os.replace`). The list and YAML preview pages complete the lifecycle. Every mutating route is CSRF-protected. Contract: `lazyc2/addon_creator.py` + `lazyc2/blueprints/addons.py`, covered by `tests/test_addon_creator.py` and the `tests/run_mutation_addon_creator.py` mutation gate.
  221. 9. **Obfuscated and Malleable GO Implants**: The command with the payload comes obfuscated by default. Instead of directly downloading the beacon, it downloads a stub created in C to download the beacon, which is XOR-encoded with a key. It is then decoded in memory and executed in a temporary path with a unique name to evade detection, using svchost in Windows and lazyservice in Linux. This performs a two-stage implant, which has been tested on Kernel 6.12 and Windows [Version 10.0.20348.3807]. Additionally, an alternative Windows stub using LOLBAS PS1 and Csharp has been added, along with a version of ebird3 in LOLBAS that uses the same technologies. The Go beacon is a multi-platform, highly obfuscated implant tailored for advanced red teaming operations. It features polymorphism, operates in a configurable stealth mode, and secures communications with AES-256 encrypted channels. The beacon blends into environments by simulating legitimate network traffic and evades detection by identifying virtual machines, sandboxes, containers, and debuggers, dynamically adjusting its behavior. With a minimal footprint, it supports robust network discovery through ping-based host enumeration and port scanning of configured targets. The implant excels at exfiltrating sensitive data, including private keys, AWS credentials, browser credentials, and system logs. It offers dynamic TCP proxying for traffic redirection, privilege escalation attempts, and system log cleaning. Persistence is achieved across Windows, Linux, and macOS via scheduled tasks, systemd, crontab, and LaunchAgents. Additional capabilities include adversary emulation (MITRE ATT&CK), file timestamp obfuscation, and directory compression for exfiltration. Built with Go vet for code health, the implant integrates seamlessly with Dockerized environments and AWS Firecracker microVMs, making it a cornerstone of modern red team infrastructure, Built with Go vet for code integrity, the implant leverages Cloudflare for traffic obfuscation, routing communications through secure, high-performance redirectors to conceal C2 infrastructure. The Go binary is hardened with Garble obfuscation, thwarting reverse engineering and signature-based detection. On Windows, the implant employs extension camouflage to masquerade as benign files (e.g., `.pdfx`) and embeds custom icons via `rsrc` for convincing social engineering.
  222. ![image](https://github.com/user-attachments/assets/4e114c5c-d28d-4570-9e02-6868bb838dd2)
  223. ## **Available beacon commands**:
  224. - **stealth_off** stop being stealthy, Disables stealth mode, allowing normal operations.
  225. - **stealth_on** enter ninja mode, Enables stealth mode, minimizing activity to avoid detection.
  226. - **download:** download:[filename] Downloads a file from the C2 to the compromised host.
  227. - **upload:** [filename]: Uploads a file from the compromised host to the C2.
  228. - **rev:** Establishes a reverse shell to the C2 using the configured port.
  229. - **exfil:** Exfiltrates sensitive data (e.g., SSH keys, AWS credentials, command histories).
  230. - **download_exec:** download_exec:[url]: Downloads and executes a binary from a URL (Linux only, stored in /dev/shm).
  231. - **obfuscate:** [filename]: Obfuscates file timestamps to hinder forensic analysis.
  232. - **cleanlogs:** Clears system logs (e.g., /var/log/syslog on Linux, event logs on Windows).
  233. - **discover:** Performs network discovery, identifying live hosts via ping.
  234. - **adversary:**[id_atomic]: Executes an adversary emulation test (MITRE ATT&CK) using downloaded atomic redteam framework scripts.
  235. - **softenum:** Enumerates useful software on the host (e.g., docker, nc, python).
  236. - **netconfig:** Captures and exfiltrates network configuration (e.g., ipconfig on Windows, ifconfig on Linux).
  237. - **escalatelin:** Attempts privilege escalation on Linux (e.g., via sudo -n or SUID binaries).
  238. - **proxy:**[listenip]:[listenport]:[targetip]:[targetport] Starts a TCP proxy redirecting traffic from listenAddr to targetAddr.
  239. - **stop_proxy:**[listenaddr] Stops a TCP proxy on the specified address.
  240. - **portscan:** Scans ports on discovered hosts and the configured rhost.
  241. - **compressdir:**[directory]: Compresses a directory into a .tar.gz file and exfiltrates it.
  242. - **sandbox:** Get info about the system if it's a sandbox or not.
  243. - **isvm:** Get info about the system if it's a virtual machine or not.
  244. - **debug:** Get info about the system if the target is debugged or not.
  245. - **persist:** Try to persist mechanism in the target system.
  246. ---
  247. ## Command Capabilities
  248. LazyOwn provides 872 commands across 13 kill-chain phases, available from both CLI and web C2 dashboard:
  249. | Phase | Highlight Commands |
  250. |-------|-------------------|
  251. | Recon | `lazynmap`, `ping`, `whatweb`, `gobuster`, `ffuf`, `dig`, `dnsenum`, `finalrecon` |
  252. | Enum | `enum4linux`, `cme`, `bloodhound`, `nuclei`, `kerbrute`, `ldapdomaindump` |
  253. | Exploit | `auto_pwn`, `hunt`, `ss` (searchsploit), `venom`, `lazymsfvenom`, `searchhash` |
  254. | Post-Exploit | `linpeas`, `winpeas`, `blacksandbeacon`, `mimikatzpy`, `disableav` |
  255. | Persistence | `persist`, `backdoor`, `cron`, `schtask`, `createwebshell` |
  256. | PrivEsc | `getcap`, `sudo`, `adcs_check`, `privesc_predictor` |
  257. | Cred Access | `secretsdump`, `evil`, `getnpusers`, `hashcat`, `john`, `spraykatz` |
  258. | Lateral | `psexec`, `wmiexec`, `ssh_cmd`, `chisel`, `ligolo`, `bloodhound` |
  259. | Exfil | `exfil`, `upload_gofile`, `encrypt`/`decrypt`, `compressdir` |
  260. | C2 | `lazyc2`, `blacksandbeacon`, `createrevshell`, `listener_go` |
  261. | Reporting | `report`, `lazyreport`, `campaign_sitrep`, `timeline`, `dashboard` |
  262. | AI/Agents | `auto_loop`, `recommend_next`, `playbook_generate`, `playbook_run`, `orchestrate` |
  263. | Marketplace | `yara_marketplace`, `nuclei_marketplace`, `marketplace`, `lab` |
  264. Core management: `assign`, `show`, `doctor`, `wizard`, `scope`, `collab_join`, `config_banner`, `palette`, `fz`.
  265. See [`COMMANDS.md`](COMMANDS.md) for the full 872-command reference and [`ESSENTIALS.md`](ESSENTIALS.md) for the 18 commands that cover 80% of engagements.
  266. ## Go deeper
  267. | Guide | Contents |
  268. |-------|----------|
  269. | [`docs/collaboration.md`](docs/collaboration.md) | Multi-operator C2: SSE stream, publish, target locks |
  270. | [`docs/autonomous-loop.md`](docs/autonomous-loop.md) | Autonomous loop: pipeline stages, auto verbs, observability, audit, teardown, retry/resume, chain distillation, verb catalog |
  271. | [`docs/command_chain.md`](docs/command_chain.md) | `prev`/`next`: what runs before and after a verb |
  272. | [`docs/metasploitable-gym.md`](docs/metasploitable-gym.md) | Gym: 45 indexed MS2 vectors, migrations, verified matrix |
  273. | [`docs/lazymode.md`](docs/lazymode.md) | lazymode (code mode): the `lazy` SDK facade, hybrid Python/Lua runners, the two MCP tools, and the per-vector exploit playbooks |
  274. | [`docs/lab-gym-toolkit.md`](docs/lab-gym-toolkit.md) | AD Docker gym, self-healing WinBox gym, gym auto-chain, lab scope guard, lazycreds KB, lazyoob canary, web playbook, kerninc addon |
  275. | [`docs/browser-sync.md`](docs/browser-sync.md) | Real browser session into the proxy: cookie extension, receiver, identity injection, Match and Replace rules |
  276. | [`docs/mcp-setup.md`](docs/mcp-setup.md) | MCP setup per agent, env vars, 153 tool groups |
  277. | [`docs/cli-ux.md`](docs/cli-ux.md) | Audit mode, fuzzy autocomplete, prompt themes, palette, dashboard |
  278. | [`docs/ai-architecture.md`](docs/ai-architecture.md) | MoE router, RL trainer, SWAN, Hive Mind, detection oracle |
  279. | [`docs/operator-safeguards.md`](docs/operator-safeguards.md) | Scope guard, reproducible installs |
  280. | [`docs/profiles.md`](docs/profiles.md) | Install profiles: `full` vs `light` (`LAZYOWN_PROFILE`) |
  281. | [`docs/lua-plugins.md`](docs/lua-plugins.md) | Write Lua plugins for the shell |
  282. | [`docs/lazyaddons-yaml.md`](docs/lazyaddons-yaml.md) | Author YAML tool integrations |
  283. | [`docs/telegram-bot.md`](docs/telegram-bot.md) | Telegram Hermes C2 bot setup |
  284. | [`docs/beacons-linux-bof.md`](docs/beacons-linux-bof.md) | Linux BOF beacon: build, deliver, port from Windows |
  285. | [`docs/related-projects.md`](docs/related-projects.md) | Related beacons, C2s, and tooling |
  286. ## Full references (auto-generated, standalone)
  287. - [`COMMANDS.md`](COMMANDS.md) full 872-command reference
  288. - [`UTILS.md`](UTILS.md) helper-function reference for `utils.py`
  289. - [`CHANGELOG.md`](CHANGELOG.md) release history
  290. ## Media
  291. - YouTube, podcast, and DeepWiki links live with the launch kit: [`docs/launch_kit/POSTS.md`](docs/launch_kit/POSTS.md)
  292. ## License
  293. LazyOwn is free software under the GNU General Public License v3 see [`LICENSE`](LICENSE). Comes with ABSOLUTELY NO WARRANTY.
  294. ## Acknowledgments
  295. 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
  296. ### Thanks to pwntomate
  297. 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>
  298. ### Thanks to Sicat
  299. 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/>
  300. ### Thanks to josefcohernandez
  301. 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`.
  302. ### Thanks to EQSTLab (via yym8538)
  303. 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.
  304. ### KitPloit.com
  305. We, the people who dedicate time to LazyOwn, are flattered by that excellent review on [Kitploit](https://x.com/KitPloit/status/2105568661779907031). Thank you so much, it helps us reach a wider community.
  306. - [https://kitploit.com/es/tools/github/grisuno/lazyown](https://kitploit.com/es/tools/github/grisuno/lazyown)
  307. - [https://kitploit.com/en/tools/github/grisuno/blacksandbeacon](https://kitploit.com/en/tools/github/grisuno/blacksandbeacon)
  308. - [kitploit.com/en/tools/github/grisuno/cve-2022-22077](kitploit.com/en/tools/github/grisuno/cve-2022-22077)
  309. ### Spook.news
  310. Thank you so much, Spooky News members! It's an honor to be recommended by you. Thank you so much!
  311. [https://spook.news/members/stipko_news_pv.php?id=65519](https://spook.news/members/stipko_news_pv.php?id=65519)
  312. ### Vulners.com
  313. Thank you so much, Vulners! All publicity is good publicity, and we will strive to improve.
  314. [https://vulners.com/kitploit/KITPLOIT:TOOLS-GITHUB-GRISUNO-LAZYOWN](https://vulners.com/kitploit/KITPLOIT:TOOLS-GITHUB-GRISUNO-LAZYOWN)
  315. ### Bharat Kayth
  316. We love your post bro :D Thank you so much.
  317. [https://www.linkedin.com/posts/splog_lazyown-is-a-comprehensive-red-team-framework-share-7445191628039974912-viWM/](https://www.linkedin.com/posts/splog_lazyown-is-a-comprehensive-red-team-framework-share-7445191628039974912-viWM/)
  318. ### cmd2
  319. Thanks to cmd2 for making this tool possible through their great work, and we love being recommended as a good example of tools made with cmd2, we are honored.
  320. [https://pypi.org/project/cmd2/](https://pypi.org/project/cmd2/)
  321. ## ZONE.CI 全球网
  322. Many thanks to [ZONE.CI](https://zone.ci/secarticles/wx/587776.html) for their review, but they failed to check some repositories before confirming that we're missing capabilities announced in the readme. They're not in the repo, but they load as lazy add-ons ;) [blacksandbeacon](https://github.com/grisuno/blacksandbeacon) event [kiploit](https://kitploit.com/en/tools/github/grisuno/blacksandbeacon) known [win beacon](https://github.com/grisuno/beacon)
  323. CN-Sec was wrong to say that these techniques "were not implemented." Hacktricks ([https://hacktricks.wiki/en/linux-hardening/post-exploitation/linux-fileless-execution.html](https://hacktricks.wiki/en/linux-hardening/post-exploitation/linux-fileless-execution.html)
  324. ), one of the most respected sources in offensive security, includes LazyOwn as an official reference for:
  325. - Fileless post-exploitation techniques in Linux
  326. - Linux BOF implementation with .so/dlopen
  327. - Memory staging (runtime decoding/decompression)
  328. - Deleted-file execution
  329. [https://zone.ci/secarticles/wx/587776.html](https://zone.ci/secarticles/wx/587776.html?utm_source=lazyown_redteam)
  330. ## mcpharbor.app
  331. Many thanks to mcpharbor.app for adding the lazyown mcp to their list of tools; we are honored to be featured on their website.
  332. [https://mcpharbor.app/tools/grisuno-lazyown/](https://mcpharbor.app/tools/grisuno-lazyown/?utm_source=lazyown_redteam)
  333. ## Verified Skill
  334. We are proud that our humble skill has been verified in verified skills, it gives us a lot of encouragement to continue developing this lovely community.
  335. [https://verified-skill.com/skills/grisuno/lazyown/lazyown?utm_source=lazyown_redteam](https://verified-skill.com/skills/grisuno/lazyown/lazyown?utm_source=lazyown_redteam)
  336. ## CN-Sec
  337. Some echoes of Zone.ci, in any case we appreciate their words, they were not in vain and we have not only mitigated a large part of what was mentioned, if not all, and we will continue to improve day by day.
  338. [https://cn-sec.com/archives/5401000.html](https://cn-sec.com/archives/5401000.html)
  339. ## Awesome bof
  340. Thank you so much for your work compiling bofs, it's incredible! We are proud to be indexed in your magnificent list
  341. [https://chryzsh.github.io/awesome-bof/site/](https://chryzsh.github.io/awesome-bof/site/)
  342. ## LibHunt
  343. Great comparison! We love that the community does these benchmarks so that at the end of the day each operator can choose the best option. Thank you very much, LibHunt.
  344. [https://www.libhunt.com/compare-LazyOwn-vs-tor-rootkit](https://www.libhunt.com/compare-LazyOwn-vs-tor-rootkit)
  345. ## Hacktricks
  346. Honestly, the team is speechless, and I think I speak for everyone when I say that when I started, I was reading everything on Hacktricks, and now being on one of their pages fills us with love. Thank you so much, Hacktricks, for your amazing work!
  347. [https://hacktricks.wiki/en/linux-hardening/post-exploitation/linux-fileless-execution.html](https://hacktricks.wiki/en/linux-hardening/post-exploitation/linux-fileless-execution.html)
  348. ## Star History
  349. <a href="https://www.star-history.com/#grisuno/LazyOwn&Date">
  350. <picture>
  351. <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=grisuno/LazyOwn&type=Date&theme=dark" />
  352. <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=grisuno/LazyOwn&type=Date" />
  353. <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=grisuno/LazyOwn&type=Date" />
  354. </picture>
  355. </a>
  356. <!-- readmenator-kb-link -->
  357. ## Knowledge Base
  358. This project has been analyzed by [ReadMenator](https://github.com/grisuno/ReadMenator),
  359. a zero-token polyglot static analysis tool. Regenerate with
  360. `pip install readmenator && readmenator . --rebuild`. Analysis outputs:
  361. - **[KNOWLEDGE_BASE.md](./KNOWLEDGE_BASE.md)** -- Full architecture reference with all
  362. classes, functions, imports, dependency graphs, UML class diagrams, security
  363. audit findings, community analysis, taint paths, hotspots, cycles, and more.
  364. - **[readmenator-agent/](./readmenator-agent/)** -- Agent-friendly, grep-optimized index.
  365. - `INDEX.md` -- Quick reference: what each file does
  366. - `SYMBOLS.md` -- Every symbol with file:line
  367. - `ARCHITECTURE.md` -- Internal dependency pairs + external imports
  368. - `API.md` -- Public function contracts
  369. - `GOTCHAS.md` -- Change warnings (blast radius, cycles, hotspots)
  370. - `SECURITY.md` -- Findings by severity with fix hints
  371. - `MEMORY.md` -- Rules, workflow, style, deliverables, session log
  372. - `MANIFEST.json` -- Freshness (git_commit + source_fingerprint) + read order
  373. - `KB_<subsystem>.md` -- Per-subsystem context
  374. - `recipes/*.md` -- Grounded task guides (add-function, fix-cycle, ...)
  375. - **[readmenator-wiki/](./readmenator-wiki/)** -- Navigable wiki (start here for the big picture).
  376. - `index.md` -- Entry point: overview, reading order, god nodes, connections
  377. - `community_*.md` -- One synthesis page per code community
  378. - `connections.json` -- Typed bridges between communities
  379. - `queries.md` -- Suggested questions + answer log
  380. - `REPORT.md` -- Honest audit: coverage, confidence, limits
  381. - **[readmenator-graphrag/](./readmenator-graphrag/)** -- Zero-token GraphRAG index.
  382. - `index.json` + `REPORTS.md` -- Query with `readmenator . ask "<question>"`
  383. - **[readmenator-apidocs/](./readmenator-apidocs/)** -- API reference (Sphinx/Doxygen style).
  384. - `index.md` + `modules/*.md` -- Signatures, parameters, returns, raises, examples, call graphs
  385. - `architecture.md` -- Tiered architecture + execution flows (control flow, call tree, sequence)
  386. - `classes.md`, `genindex.md`, `COVERAGE.md` -- Hierarchy, A-Z index, doc coverage + warnings
  387. - `index.html` + `api/` -- Offline searchable browser and machine-readable model (`api/index.json`, `api/modules/*.jsonl` one entity per line)
  388. - **[readmenator-maps/](./readmenator-maps/)** -- Interactive gallery (`index.html`).
  389. - 5 system maps: architecture, workflow, sequence, dataflow, lifecycle
  390. - `graph-force.html` -- Force-graph explorer (2D/3D, reach, paths, lenses)
  391. - `graph-bundle.html` -- Edge bundle explorer (circle + sphere)
  392. - `components.html` -- Component diagrams
  393. - **[docs/](./docs/)** -- Static site (GitHub Pages ready).
  394. - Gallery copy + `llms.txt` (agent entry point) + `md/` docs + video
  395. - **[readmenator-diagrams/](./readmenator-diagrams/)** -- Component diagrams.
  396. - `analysis.json` + `graph LR` markdown + per-component pages + `index.html`
  397. - **[readmenator-rules/](./readmenator-rules/)** -- Suggested Semgrep rules (`*.yml`),
  398. `yara_rules.yar` (YARA-lite) + `exclusions.yaml` (false-positive blocklist)
  399. - **[readmenator.mp4](./readmenator.mp4)** -- Cinematic synthwave overview video
  400. - **[.cursorrules](./.cursorrules)** -- Generated AI assistant rules
  401. - **[readmenator_audit.sarif](./readmenator_audit.sarif)** -- SARIF v2.1.0 audit (when security scan is on)
  402. Cache (`.readmenator_cache/`), packaged agent skills (`.claude/skills/`), and the
  403. GitHub wiki mirror are also produced on `run`/`--rebuild`.
  404. AI agents: Read `readmenator-wiki/index.md` first for the big picture, then `readmenator-agent/INDEX.md` for grep-friendly lookup.
  405. Developers: Read `KNOWLEDGE_BASE.md` for full architecture reference, open `readmenator-maps/index.html` for the visual gallery.
  406. <!-- /readmenator-kb-link -->
  407. <!-- deploynator-footer -->
  408. ---
  409. Deployed with [deploynator](https://github.com/grisuno/deploynator)
  410. <!-- /deploynator-footer -->

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.