ABYSS C2 — Framework di Exploit per DVR HiSilicon

⚠️ SOLO A SCOPO EDUCATIVO / DIMOSTRATIVO

Questo software è fornito esclusivamente per scopi educativi e di ricerca sulla sicurezza autorizzata. È progettato per dimostrare vulnerabilità IoT comuni e tecniche di post-exploitation in un ambiente controllato e autorizzato.

NON devi utilizzare questo software su:

• Qualsiasi sistema o dispositivo che non possiedi
• Qualsiasi sistema o dispositivo per cui non hai esplicita autorizzazione scritta a testare
• Qualsiasi infrastruttura di produzione senza previa approvazione

Il creatore NON si assume alcuna responsabilità per qualsiasi uso improprio, danno o attività illegale condotta con questo software. Utilizzando questo software, riconosci di essere l'unico responsabile di garantire la conformità a tutte le leggi e i regolamenti applicabili nella tua giurisdizione. L'accesso non autorizzato a sistemi informatici è illegale ai sensi di leggi come il Computer Fraud and Abuse Act (CFAA) e normative simili in tutto il mondo.

Questo progetto esiste per dimostrare:

• Come funziona CVE-2020-25078 (divulgazione di informazioni del DVR HiSilicon)
• Le debolezze di sicurezza dei dispositivi IoT e perché gli aggiornamenti del firmware sono importanti
• Le tecniche di post-exploitation così che i difensori comprendano le TTP degli attaccanti
• L'importanza della segmentazione di rete e dell'igiene delle credenziali

Se non lo possiedi, non toccarlo.

Panoramica

ABYSS C2 è un framework Command & Control full-stack costruito in Python/Flask con un pannello web a tema scuro in tempo reale. Dimostra l'intera catena di attacco contro i dispositivi IoT (in particolare DVR e telecamere IP basati su HiSilicon affetti da CVE-2020-25078) — dalla ricognizione e acquisizione dei target fino allo sfruttamento, post-exploitation, persistenza, movimento laterale ed esfiltrazione dei dati.

La CVE-2020-25078 è una vulnerabilità di path traversal / divulgazione di informazioni nei dispositivi DVR/NVR basati su HiSilicon Hi3516/Hi3518/Hi3519. Attaccanti non autenticati possono accedere ai file di configurazione (/mnt/mtd/Config/Account*) contenenti credenziali admin in chiaro tramite directory traversal nel server HTTP.

Caratteristiche

• Pannello Web in Tempo Reale — Interfaccia a pagina singola a tema scuro con aggiornamenti live WebSocket, 8 schede operative, terminale integrato
• Acquisizione Target — Recupera dispositivi vulnerabili tramite API Shodan, FOFA, ZoomEye, più scraping gratuito (Censys, Onyphe, Shodan free facet, InternetDB)
• Scanner di Vulnerabilità — Scanner TCP/HTTP multi-thread con supporto CIDR, fingerprinting DVR, estrazione credenziali
• Post-Exploitation — Shell telnet interattiva, esecuzione di comandi di massa su tutti i dispositivi posseduti, upload di file
• Scansione Vulnerabilità Web — Rilevamento CVE (Log4Shell, Spring4Shell, Confluence, Ghostcat, Struts2, Jenkins, GitLab, Exchange, F5 BIG-IP, Citrix, MOVEit, Ivanti, vCenter, PHPUnit, GeoServer, Solr, WordPress) e test di classi di bug (SQLi, LFI, SSRF, XXE, Command Injection, attacchi JWT, Subdomain Takeover, HTTP Smuggling, GraphQL, CORS)
• Sfruttamento di Rete — SMB/EternalBlue, RDP/BlueKeep, VNC, FTP, SNMP, Redis, MongoDB, Elasticsearch, CouchDB, MySQL/MSSQL/PostgreSQL, Memcached, IPMI, Mirai-IoT
• Attacchi alle Credenziali — Forza bruta multi-protocollo (Telnet, SSH, FTP, HTTP Basic, WordPress, SMB, Redis, MySQL, MongoDB, VNC), credential spraying, vault delle credenziali
• Ricognizione — Ricerca/importazione ASN, ricognizione DNS completa (A/AAAA/MX/NS/TXT/SOA + brute force dei sottodomini + AXFR), fingerprinting TLS JARM, rilevamento WAF, lookup GeoIP, scansione delle porte multi-preset
• Persistenza — Iniezione di chiavi pubbliche SSH, backdoor cron, persistenza init.d/systemd, distribuzione automatica completa
• Reverse Shell — Generatore di payload (bash, python, perl, php, nc, ruby, node, lua, ecc.), listener multi-sessione con interazione
• Pivoting — Esecuzione di catene multi-hop, relay TCP, proxy SOCKS5 tramite host compromessi, scansione pivot automatica delle reti locali
• Orchestrazione Botnet — Tag/raggruppamento bot, comandi fan-out, health check, distribuzione payload
• Intel e Notifiche — Notifiche webhook Telegram/Discord, integrazione AbuseIPDB, cattura screenshot delle telecamere
• Scheduler — Attività ricorrenti automatizzate (scansioni, ricognizione, health check)

Architettura```

panel/ ├── server.py # Flask + SocketIO C2 web panel (~1200 lines, 50+ API routes) ├── database.py # SQLite ORM — 11 tables (cameras, vulns, creds, shells, DNS, ASN, etc.) ├── scanner.py # Multi-threaded TCP/HTTP vulnerability scanner ├── exploit.py # CVE-2020-25078 exploit — 37 vulnerable paths, 14 credential parsers ├── telnet_client.py # Raw telnet command execution against owned devices ├── brute.py # Multi-threaded brute force engine ├── web_exploit.py # Full website vulnerability scanner (CMS detection, exposed files, SQLi) ├── web_cves.py # CVE scanner — Log4Shell, Spring4Shell, Confluence, Ghostcat, etc. ├── web_bugs.py # Bug class scanner — SQLi, LFI, SSRF, XXE, CmdI, JWT, etc. ├── web_brute.py # Web brute force — forms, WordPress xmlrpc, Basic Auth, cred stuffing ├── network_exploit.py # Network service exploit scanner — SMB, RDP, VNC, databases, etc. ├── cred_spray.py # Multi-service credential spraying ├── recon_asn.py # ASN import, organization search, IP-to-ASN lookup ├── recon_dns.py # DNS recon — all record types, subdomain brute, zone transfer ├── recon_jarm.py # JARM TLS server fingerprinting ├── recon_waf.py # WAF detection and identification ├── recon_geoip.py # GeoIP lookup and bulk IP geolocation ├── portscan.py # TCP port scanner with banner grabbing, SYN option, multiple presets ├── persistence.py # SSH key injection, cron backdoors, full deployment ├── reverse_shell.py # Payload generator + multi-session listener ├── pivot_chain.py # Multi-hop command execution and TCP relay ├── socks_pivot.py # SOCKS5 proxy through compromised hosts ├── botnet.py # Bot grouping, fan-out commands, health checks, payload deployment ├── intel.py # Telegram/Discord webhooks, AbuseIPDB, screenshot capture ├── scheduler.py # APScheduler-based job scheduling ├── proxy_rotation.py # Proxy list rotation for stealth ├── stealth.py # Traffic obfuscation utilities ├── inject_key.py # SSH key injection variants ├── inject_ssh.py # SSH-based injection ├── launch.py # Simple launcher wrapper ├── auto_exploit.py # Automated exploitation routines ├── templates/ │ └── index.html # Dark-themed SPA — 8 tabs, real-time updates, terminal └── requirements.txt # Python dependencies

### Schema del Database

Il database SQLite (`cameras.db`, creato automaticamente al primo avvio) contiene 11 tabelle:

| Tabella | Scopo |
|---------|-------|
| `cameras` | Dispositivi compromessi — IP, credenziali, modello, firmware, seriale, stato |
| `command_log` | Traccia di audit completa di ogni comando eseguito e del relativo output |
| `scan_results` | Storico delle scansioni — quali IP sono stati scansionati e se erano vulnerabili |
| `web_vulns` | Vulnerabilità web scoperte (CVE, gravità, evidenze) |
| `network_vulns` | Vulnerabilità dei servizi di rete scoperte |
| `shells` | Sessioni di reverse shell attive |
| `dns_records` | Risultati della ricognizione DNS |
| `cred_vault` | Credenziali raccolte organizzate per servizio |
| `asn_targets` | Prefissi ASN e intervalli IP importati |
| `web_targets` | Target web con metadati (stato, server, CMS, JARM, WAF) |
| `scan_jobs` | Tracciamento dei job — tipo di scansione, target, durata, conteggio risultati |
| `scan_log` | Registro attività a livello di modulo per l'auditing |

---

## Installazione

### Prerequisiti

- Python 3.10 o successivo
- pip
- Git (opzionale)

### Passo 1 — Clona o scarica```bash
git clone https://github.com/YOUR_USERNAME/abyss-c2.git
cd abyss-c2

Passaggio 2 — Creare un ambiente virtuale (consigliato)```bash

python -m venv venv

Windows

venv\Scripts\activate

Linux / macOS

source venv/bin/activate

### Passaggio 3 — Installa le dipendenze```bash
pip install -r requirements.txt

Passaggio 4 — (Facoltativo) Scaricare la wordlist

I moduli di brute force si aspettano una wordlist rockyou.txt nella directory principale del progetto. A causa dei limiti di dimensione dei file di GitHub (100MB), NON è inclusa in questo repository.```bash

On Kali Linux, rockyou.txt is typically at:

cp /usr/share/wordlists/rockyou.txt.gz . gunzip rockyou.txt.gz

Or download from SecLists:

https://github.com/danielmiessler/SecLists/blob/master/Passwords/Leaked-Databases/rockyou.txt.tar.gz

Se non ti serve il brute forcing, gli altri moduli funzionano senza una wordlist.

### Passaggio 5 — Avvio```bash
python server.py

Apri http://localhost:5000 nel browser.

Il database viene creato automaticamente al primo avvio — nessuna configurazione necessaria.

Guida all'uso

La Dashboard

Quando apri il pannello per la prima volta, vedrai:

• Barra delle statistiche — Contatori in tempo reale: Scansionati, Vulnerabili, Compromessi, Online
• 8 pannelli a schede — Dispositivi, Recon, CVE Web, Rete, Persistenza, Reverse Shell, Botnet, Impostazioni
• Terminale integrato — Shell interattiva per qualsiasi dispositivo selezionato
• Pannello laterale — Controlli di scansione, info sul target, comando di massa, toolkit pivot/upload/brute

Scheda 1 — Dispositivi (Operazioni principali)

Questa è la tua centrale di comando. Qui puoi:

Recuperare target dai motori di ricerca:

• Seleziona la fonte: Shodan, FOFA, ZoomEye o FREE (scraping — nessuna API key richiesta)
• Inserisci la API key se usi Shodan/FOFA/ZoomEye
• Query personalizzata o lascia vuoto per le query predefinite su DVR/fotocamere
• Clicca su FETCH & SCAN — i target vengono scansionati automaticamente all'arrivo

Scansione manuale:

• Inserisci una rete CIDR (es. 192.168.1.0/24)
• Oppure un singolo IP e porta
• Imposta il numero di thread (predefinito 50)
• Clicca su SCAN

Una volta che i dispositivi sono compromessi (appaiono nella tabella):

• Clicca su qualsiasi riga per selezionarla — i dettagli appaiono nel pannello laterale
• Il terminale in basso si attiva per quel dispositivo
• Usa i pulsanti dei comandi rapidi (CPU, UNAME, PS, IFCFG, NETSTAT, CREDS, PASSWD, LS)
• Digita comandi personalizzati nel terminale e premi Invio

Operazioni di massa:

• Mass Command — esegui lo stesso comando su TUTTI i dispositivi compromessi contemporaneamente
• Pivot Scan — usa un dispositivo compromesso per scansionare la sua rete locale alla ricerca di altri target
• Upload File — carica un file sul dispositivo remoto tramite codifica base64
• Brute — forza bruta sulle credenziali telnet del dispositivo selezionato

Modalità scansione web (attivabile con il pulsante WEB):

• Inserisci un URL o IP per una scansione completa delle vulnerabilità web
• Rilevamento CMS, file di configurazione esposti, parametri di SQL injection
• FETCH & SCAN recupera i target web da Shodan free e li scansiona

Scheda 2 — Recon

Sei moduli di ricognizione:

Scheda 3 — CVE Web

CVE Scanner — Verifica la presenza di oltre 20 CVE note: Log4Shell (CVE-2021-44228), Spring4Shell (CVE-2022-22965), Confluence (CVE-2022-26134), Ghostcat (CVE-2020-1938), Struts2 (CVE-2017-5638), Jenkins (CVE-2018-1000861), GitLab (CVE-2021-22205), Exchange ProxyShell/ProxyLogon, F5 BIG-IP (CVE-2022-1388), Citrix (CVE-2019-19781), MOVEit (CVE-2023-34362), Ivanti (CVE-2024-21887), vCenter (CVE-2021-21972), PHPUnit (CVE-2017-9841), GeoServer (CVE-2024-36401), Apache Solr (CVE-2019-17558) e vulnerabilità dei plugin WordPress.

Bug Class Scanner — Verifica: Blind SQL Injection, Command Injection, Local File Inclusion, Server-Side Request Forgery, XML External Entity, attacchi JWT, Subdomain Takeover, HTTP Request Smuggling, introspezione GraphQL, configurazione errata CORS.

Web Brute Force — Quattro modalità:

• Brute su form (rileva automaticamente i form di login e i parametri)
• Brute su WordPress xmlrpc
• Brute su HTTP Basic Auth
• Credential stuffing (usa credenziali precedentemente raccolte)

I risultati appaiono nella tabella Discovered Vulnerabilities in basso.

Scheda 4 — Rete

Network Exploit Scanner — Controlla i servizi di rete comuni per vulnerabilità note: SMB (EternalBlue, SMBGhost), RDP (BlueKeep), VNC (auth bypass), FTP (accesso anonimo), SNMP (community predefinite), Redis (senza auth), MongoDB (senza auth), Elasticsearch (senza auth), CouchDB (senza auth), MySQL/MSSQL/PostgreSQL (credenziali predefinite), Memcached (senza auth), IPMI (auth bypass), predefiniti Mirai-IoT.

Credential Spray — Distribuisci credenziali raccolte o personalizzate su più servizi: Telnet, SSH, FTP, HTTP Basic, WordPress, SMB, Redis, MySQL, MongoDB, VNC o TUTTI contemporaneamente.

I risultati popolano la tabella Network Vulnerabilities e il Credential Vault.

Scheda 5 — Persistenza

Tre azioni di deployment per gli host compromessi:

• Iniezione chiave SSH — Aggiunge la tua chiave pubblica a /root/.ssh/authorized_keys (o a più percorsi)
• Backdoor Cron — Installa un job cron che richiama il tuo server C2
• Deploy completo — Tutte le tecniche combinate: chiave SSH + cron + persistenza init.d/systemd

Pivot Chain — Esegui comandi attraverso più host intermedi:``` hop1 → hop2 → hop3 → command

**SOCKS Pivot** — Avvia un proxy SOCKS5 locale che instrada il traffico attraverso un dispositivo compromesso, consentendoti di usare proxychains o qualsiasi strumento compatibile con SOCKS per raggiungere la rete interna.

### Scheda 6 — Reverse Shell

- **Payload Generator** — Seleziona il tipo di shell (bash, python, perl, php, nc, ruby, node, lua, ecc.), imposta LHOST/LPORT, clicca su GENERATE — il payload appare, clicca per copiarlo
- **Listener** — Avvia un listener su qualsiasi porta, gestisce automaticamente più connessioni simultanee
- **Active Sessions** — Clicca su una sessione per interagire, digita i comandi e clicca su SEND
- La tabella **All Shells** mostra ogni callback di reverse shell ricevuta, con stato

### Scheda 7 — Botnet

Per la gestione di grandi gruppi di dispositivi compromessi:

- **Fan-Out Command** — Esegue un comando su tutti i bot (opzionalmente filtrati per tag)
- **Health Check** — Esegue il ping di tutti i bot e riporta lo stato online/offline
- **Tag Bot** — Assegna tag ai bot per raggrupparli (ad es. `eu`, `cameras`, `high-value`)
- **Deploy Payload** — Invia un payload a tutti i bot in un gruppo di tag
- **Bot Summary** — Mostra il conteggio totale, il numero di online e la ripartizione per tag

### Scheda 8 — Impostazioni

- **Telegram/Discord** — Configura le notifiche webhook per gli eventi (nuova compromissione, scansione completata, ecc.)
- **AbuseIPDB** — Controlla la reputazione degli IP
- **Screenshot** — Acquisisci uno screenshot HTTP dall'interfaccia web di una telecamera
- **Scheduler** — Configura attività ricorrenti (ad es., health check ogni 3600 secondi)
- **Scan Log** — Registro completo di tutte le operazioni dei moduli, filtrabile per tipo di modulo

---

## Riferimento API

La REST API completa è disponibile all'indirizzo `http://localhost:5000/api/`. Endpoint principali:

| Endpoint | Method | Description |
|----------|--------|-------------|
| `/api/cameras` | GET | Elenca tutti i dispositivi compromessi |
| `/api/cameras/<ip>` | GET | Ottieni i dettagli del dispositivo |
| `/api/stats` | GET | Statistiche della dashboard |
| `/api/scan/start` | POST | Avvia lo scanner (CIDR, target, thread) |
| `/api/scan/stop` | POST | Ferma lo scanner |
| `/api/scan/status` | GET | Stato dello scanner in esecuzione + statistiche |
| `/api/exploit/check` | POST | Controlla un singolo IP per CVE-2020-25078 |
| `/api/fetch_targets` | POST | Recupera da Shodan/FOFA/ZoomEye/Free |
| `/api/web_scan` | POST | Scansione completa delle vulnerabilità del sito web |
| `/api/web_cves/scan` | POST | Scansione CVE sul target |
| `/api/web_bugs/scan` | POST | Scansione delle classi di bug sul target |
| `/api/web_brute` | POST | Forza bruta web |
| `/api/network/scan` | POST | Scansione exploit di rete |
| `/api/cred_spray` | POST | Spraying di credenziali |
| `/api/portscan` | POST | Scansione delle porte TCP |
| `/api/recon/asn` | POST | Importazione/ricerca/consultazione ASN |
| `/api/recon/dns` | POST | Ricognizione DNS |
| `/api/recon/jarm` | POST | Impronta JARM |
| `/api/recon/waf` | POST | Rilevamento WAF |
| `/api/recon/geoip` | POST | Ricerca GeoIP |
| `/api/persistence/deploy` | POST | Distribuisci persistenza (ssh_key/cron/full) |
| `/api/revshell/generate` | POST | Genera payload reverse shell |
| `/api/revshell/listen` | POST | Avvia listener reverse shell |
| `/api/revshell/stop` | POST | Ferma il listener |
| `/api/botnet/bots` | GET | Elenco bot + riepilogo gruppi |
| `/api/botnet/fanout` | POST | Esegui comando su tutti i bot |
| `/api/botnet/health` | POST | Health check dei bot |
| `/api/botnet/deploy` | POST | Distribuisci payload ai bot |
| `/api/socks/start` | POST | Avvia proxy SOCKS5 |
| `/api/socks/stop` | POST | Ferma proxy SOCKS5 |
| `/api/intel/config` | GET/POST | Legge/imposta la configurazione delle notifiche |
| `/api/intel/screenshot` | POST | Cattura screenshot della telecamera |
| `/api/intel/notify` | POST | Invia notifica di test |
| `/api/scheduler/jobs` | GET | Elenca i job pianificati |
| `/api/scheduler/add` | POST | Aggiungi job pianificato |
| `/api/scheduler/remove` | POST | Rimuovi job pianificato |
| `/api/credentials` | GET | Archivio credenziali |
| `/api/web_vulns` | GET | Elenco vulnerabilità web |
| `/api/network_vulns` | GET | Elenco vulnerabilità di rete |
| `/api/shells` | GET | Tutte le sessioni reverse shell |
| `/api/scan_log` | GET | Registro di audit con filtri per modulo/target |
| `/api/scan_jobs` | GET | Cronologia dei job di scansione |

Eventi WebSocket (SocketIO):
- `scanner_event` — Avanzamento della scansione in tempo reale (alive, vulnerable, owned, status)
- `stats_update` — Modifica delle statistiche della dashboard
- `cameras_list` — Aggiornamento della tabella delle telecamere
- `new_camera` — Nuovo dispositivo compromesso
- `command_result` — Output dei comandi Telnet
- `mass_result` / `mass_result_item` — Risultati dei comandi di massa
- `brute_event` — Avanzamento della forza bruta
- `web_cve_event` / `web_cves_done` — Avanzamento della scansione CVE
- `web_bug_event` / `web_bugs_done` — Avanzamento della scansione dei bug
- `network_event` / `network_done` — Avanzamento della scansione di rete
- `spray_event` / `spray_done` — Avanzamento dello spraying di credenziali
- `portscan_event` / `portscan_done` — Avanzamento della scansione delle porte
- `persistence_result` — Risultato della distribuzione della persistenza
- `revshell_event` — Dati/connessioni della reverse shell
- `botnet_event` / `botnet_fanout_done` — Operazioni botnet

---

## Dettagli Tecnici

### Catena di Exploit CVE-2020-25078

1. **Controllo di attività** — Connessione TCP alla porta 80
2. **Impronta HTTP** — Controlla la risposta per 15 firme DVR note (`AppName="Hipcam"`, `hi3516`, `WEB SERVICE`, ecc.)
3. **Path traversal** — Prova 37 percorsi vulnerabili noti (`/../../../../../../../../../mnt/mtd/Config/Account1`, ecc.)
4. **Estrazione delle credenziali** — Analizza la risposta con 14 pattern regex che coprono formati INI, XML, JSON, URL-encoded, binari, base64, delimitati da due punti e specifici DVR
5. **Filtro dei dati spuri** — Rimozione aggressiva dei falsi positivi (tag HTML, header HTTP, parole comuni)
6. **Fallback predefinito** — Se il dispositivo è vulnerabile ma non vengono estratte credenziali, prova 22 coppie di credenziali predefinite note

### Architettura dello Scanner

- Pool di thread con numero di worker configurabile (predefinito 50)
- Distribuzione dei target basata su coda
- Emissione di eventi SocketIO in tempo reale verso l'interfaccia utente
- Statistiche thread-safe con blocchi mutex
- Espansione degli intervalli CIDR con esclusione di rete/broadcast
- Scansione multi-porta (80, 8080, 443, 8443, 554, 8000, 81, 88, 8888, 37777)

---

## Dichiarazione di non responsabilità

**QUESTO SOFTWARE È FORNITO SOLO PER SCOPI EDUCATIVI E DIMOSTRATIVI.**

Questo progetto è pensato per essere utilizzato esclusivamente in test di sicurezza autorizzati, ambienti educativi o su sistemi di tua proprietà. Le tecniche qui dimostrate sono note nel settore della cybersecurity e sono documentate per aiutare i difensori a comprendere le metodologie di attacco.

**Utilizzando questo software, accetti che:**

1. Lo utilizzerai solo su sistemi di tua proprietà o per i quali hai ricevuto esplicita autorizzazione scritta a testarli
2. Sei responsabile della conformità a tutte le leggi locali, statali, nazionali e internazionali applicabili
3. I creatori e i contributori di questo progetto non si assumono **alcuna responsabilità** per:
   - Uso non autorizzato o illegale di questo software
   - Danni causati dall'uso o dall'abuso di questo software
   - Conseguenze legali derivanti dall'uso di questo software
4. Questo software non fornisce alcuna garanzia, esplicita o implicita

**Se non sei sicuro che il tuo caso d'uso sia legale o autorizzato, NON utilizzare questo software.**

L'esistenza di questo progetto non costituisce un incoraggiamento a intraprendere attività illegali. Esiste perché comprendere le tecniche offensive è essenziale per costruire difese efficaci.

---

## Licenza

Questo progetto è fornito così com'è per scopi educativi. Nessuna garanzia. Nessuna responsabilità. Utilizzo a proprio rischio.

---

*Ricorda: la ricerca sulla sicurezza esiste per rendere i sistemi più sicuri, non per romperli. Usa questa conoscenza per difendere, non per attaccare.*