ABYSS C2 — Framework d'exploitation de DVR HiSilicon

⚠️ USAGE UNIQUEMENT ÉDUCATIF / DE DÉMONSTRATION

Ce logiciel est fourni exclusivement à des fins éducatives et de recherche en sécurité autorisée. Il est conçu pour démontrer les vulnérabilités IoT courantes et les techniques de post-exploitation dans un environnement contrôlé et autorisé.

Vous NE DEVEZ PAS utiliser ce logiciel sur :

• Tout système ou appareil dont vous n'êtes pas propriétaire
• Tout système ou appareil pour lequel vous n'avez pas d'autorisation écrite explicite de test
• Toute infrastructure de production sans approbation préalable

Le créateur décline toute responsabilité en cas d'utilisation abusive, de dommage ou d'activité illégale avec ce logiciel. En utilisant ce logiciel, vous reconnaissez être seul responsable du respect de toutes les lois et réglementations applicables dans votre juridiction. L'accès non autorisé à des systèmes informatiques est illégal en vertu de lois telles que le Computer Fraud and Abuse Act (CFAA) et des statuts similaires dans le monde entier.

Ce projet existe pour démontrer :

• Comment fonctionne la CVE-2020-25078 (divulgation d'informations sur DVR HiSilicon)
• Les faiblesses de sécurité des appareils IoT et pourquoi les mises à jour du firmware sont importantes
• Les techniques de post-exploitation afin que les défenseurs comprennent les TTP des attaquants
• L'importance de la segmentation réseau et de l'hygiène des identifiants

Si vous ne le possédez pas, n'y touchez pas.

Vue d'ensemble

ABYSS C2 est un framework de commande & contrôle complet construit en Python/Flask avec un panneau web sombre en temps réel. Il démontre la chaîne d'attaque complète contre les appareils IoT (notamment les DVR et caméras IP basés sur HiSilicon affectés par CVE-2020-25078) — de la reconnaissance et l'acquisition de cibles à l'exploitation, la post-exploitation, la persistance, le mouvement latéral et l'exfiltration de données.

CVE-2020-25078 est une vulnérabilité de traversée de chemin / divulgation d'informations dans les appareils DVR/NVR basés sur HiSilicon Hi3516/Hi3518/Hi3519. Des attaquants non authentifiés peuvent accéder aux fichiers de configuration (/mnt/mtd/Config/Account*) contenant des identifiants administrateur en clair via une traversée de répertoire dans le serveur HTTP.

Fonctionnalités

• Tableau de bord web en temps réel — Interface mono-page sombre avec mises à jour en direct via WebSocket, 8 onglets opérationnels, terminal intégré
• Acquisition de cibles — Récupération d'appareils vulnérables via les API Shodan, FOFA, ZoomEye, plus scraping gratuit (Censys, Onyphe, Shodan free facet, InternetDB)
• Scanner de vulnérabilités — Scanner TCP/HTTP multi-threadé avec support CIDR, empreinte digitale DVR, extraction d'identifiants
• Post-exploitation — Shell telnet interactif, exécution de commandes en masse sur tous les appareils possédés, téléchargement de fichiers
• Scan de vulnérabilités web — Détection de CVE (Log4Shell, Spring4Shell, Confluence, Ghostcat, Struts2, Jenkins, GitLab, Exchange, F5 BIG-IP, Citrix, MOVEit, Ivanti, vCenter, PHPUnit, GeoServer, Solr, WordPress) et tests de classes de bugs (SQLi, LFI, SSRF, XXE, Injection de commandes, attaques JWT, Détournement de sous-domaine, Contrebande HTTP, GraphQL, CORS)
• Exploitation réseau — SMB/EternalBlue, RDP/BlueKeep, VNC, FTP, SNMP, Redis, MongoDB, Elasticsearch, CouchDB, MySQL/MSSQL/PostgreSQL, Memcached, IPMI, Mirai-IoT
• Attaques d'identifiants — Force brute multi-protocole (Telnet, SSH, FTP, HTTP Basic, WordPress, SMB, Redis, MySQL, MongoDB, VNC), pulvérisation d'identifiants, coffre d'identifiants
• Reconnaissance — Recherche/import ASN, reconnaissance DNS complète (A/AAAA/MX/NS/TXT/SOA + sous-domaine par force brute + AXFR), empreinte digitale JARM TLS, détection WAF, géolocalisation IP, scan de ports multi-préréglages
• Persistance — Injection de clé publique SSH, backdoors cron, persistance init.d/systemd, déploiement automatisé complet
• Shells inversés — Générateur de payload (bash, python, perl, php, nc, ruby, node, lua, etc.), écouteur multi-sessions avec interaction
• Pivotement — Exécution de chaîne multi-sauts, relais TCP, proxy SOCKS5 via hôtes compromis, scan automatique des réseaux locaux pour pivoter
• Orchestration de botnet — Étiquetage/groupement de bots, commandes de diffusion, vérifications de santé, déploiement de payloads
• Intel & Notifications — Notifications via webhook Telegram/Discord, intégration AbuseIPDB, capture d'écran de caméra
• Planificateur — Tâches récurrentes automatisées (scans, reconnaissance, vérifications de santé)

Architecture```

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

### Schéma de la base de données

La base de données SQLite (`cameras.db`, créée automatiquement lors du premier lancement) contient 11 tables :

| Table | Objectif |
|-------|---------|
| `cameras` | Appareils compromis — IP, identifiants, modèle, firmware, numéro de série, statut |
| `command_log` | Traçabilité complète de chaque commande exécutée et de sa sortie |
| `scan_results` | Historique des scans — quelles IP ont été scannées et si elles étaient vulnérables |
| `web_vulns` | Vulnérabilités web découvertes (CVE, sévérité, preuve) |
| `network_vulns` | Vulnérabilités de services réseau découvertes |
| `shells` | Sessions de reverse shell actives |
| `dns_records` | Résultats de reconnaissance DNS |
| `cred_vault` | Identifiants récoltés organisés par service |
| `asn_targets` | Préfixes ASN et plages IP importées |
| `web_targets` | Cibles web avec métadonnées (statut, serveur, CMS, JARM, WAF) |
| `scan_jobs` | Suivi des tâches — type de scan, cible, durée, nombre de résultats |
| `scan_log` | Journal d'activité au niveau des modules pour l'audit |

---

## Installation

### Prérequis

- Python 3.10 ou plus récent
- pip
- Git (optionnel)

### Étape 1 — Cloner ou télécharger```bash
git clone https://github.com/YOUR_USERNAME/abyss-c2.git
cd abyss-c2

Étape 2 — Créer un environnement virtuel (recommandé)```bash

python -m venv venv

Windows

venv\Scripts\activate

Linux / macOS

source venv/bin/activate

### Étape 3 — Installer les dépendances```bash
pip install -r requirements.txt

Étape 4 — (Facultatif) Télécharger la liste de mots

Les modules de force brute attendent une liste de mots rockyou.txt dans la racine du projet. En raison des limites de taille de fichier de GitHub (100 Mo), elle n'est PAS incluse dans ce dépôt.```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

Si vous n'avez pas besoin de force brute, les autres modules fonctionnent sans dictionnaire.

### Étape 5 — Lancement```bash
python server.py

Ouvrez http://localhost:5000 dans votre navigateur.

La base de données se crée automatiquement au premier lancement — aucune configuration nécessaire.

Guide d'utilisation

Le tableau de bord

Lorsque vous ouvrez le panneau pour la première fois, vous verrez :

• Barre de statistiques — Compteurs en direct : Scannés, Vulnérables, Compromis, En ligne
• 8 onglets — Appareils, Recon, Web CVEs, Réseau, Persistance, Shell inversés, Botnet, Paramètres
• Terminal intégré — Shell interactif vers n'importe quel appareil sélectionné
• Panneau latéral — Contrôles de scan, informations cible, commande de masse, pivot/upload/brute toolkit

Onglet 1 — Appareils (Opérations principales)

C'est votre centre de commandement. Vous pouvez y effectuer les actions suivantes :

Récupérer des cibles depuis des moteurs de recherche :

• Sélectionnez la source : Shodan, FOFA, ZoomEye ou FREE (scraping — aucune clé API nécessaire)
• Saisissez la clé API si vous utilisez Shodan/FOFA/ZoomEye
• Requête personnalisée ou laissez vide pour les requêtes DVR/caméra par défaut
• Cliquez sur FETCH & SCAN — les cibles sont automatiquement scannées à leur arrivée

Scan manuel :

• Saisissez une plage CIDR (ex : 192.168.1.0/24)
• Ou une seule IP et un port
• Définissez le nombre de threads (50 par défaut)
• Cliquez sur SCAN

Une fois les appareils compromis (apparaissent dans le tableau) :

• Cliquez sur une ligne pour la sélectionner — les détails apparaissent dans le panneau latéral
• Le terminal en bas s'active pour cet appareil
• Utilisez les boutons de commande rapide (CPU, UNAME, PS, IFCFG, NETSTAT, CREDS, PASSWD, LS)
• Tapez des commandes personnalisées dans le terminal et appuyez sur Entrée

Opérations de masse :

• Commande de masse — exécute la même commande sur TOUS les appareils possédés simultanément
• Scan pivot — utilise un appareil compromis pour scanner son réseau local à la recherche d'autres cibles
• Upload de fichier — télécharge un fichier vers l'appareil distant via un encodage base64
• Brute — force brute des identifiants Telnet sur l'appareil sélectionné

Mode scan Web (basculer avec le bouton WEB) :

• Saisissez une URL ou une IP pour un scan de vulnérabilités Web complet
• Détection CMS, fichiers de configuration exposés, paramètres d'injection SQL
• FETCH & SCAN récupère les cibles Web depuis Shodan gratuit et les scanne

Onglet 2 — Recon

Six modules de reconnaissance :

Onglet 3 — Web CVEs

Scanner CVE — Vérifie plus de 20 CVEs connues : 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), et les vulnérabilités des plugins WordPress.

Scanner de classes de bugs — Teste pour : Blind SQL Injection, Command Injection, Local File Inclusion, Server-Side Request Forgery, XML External Entity, attaques JWT, Subdomain Takeover, HTTP Request Smuggling, introspection GraphQL, mauvaise configuration CORS.

Force brute Web — Quatre modes :

• Force brute de formulaire (détecte automatiquement les formulaires de connexion et leurs paramètres)
• Force brute WordPress xmlrpc
• Force brute HTTP Basic Auth
• Credential stuffing (utilise des identifiants déjà récoltés)

Les résultats apparaissent dans le tableau Vulnérabilités découvertes ci-dessous.

Onglet 4 — Réseau

Scanner d'exploitation réseau — Vérifie les services réseau courants pour les vulnérabilités connues : SMB (EternalBlue, SMBGhost), RDP (BlueKeep), VNC (bypass d'authentification), FTP (accès anonyme), SNMP (communautés par défaut), Redis (sans authentification), MongoDB (sans authentification), Elasticsearch (sans authentification), CouchDB (sans authentification), MySQL/MSSQL/PostgreSQL (identifiants par défaut), Memcached (sans authentification), IPMI (bypass d'authentification), identifiants par défaut Mirai-IoT.

Credential Spray — Pulvérisation d'identifiants récoltés ou personnalisés sur plusieurs services : Telnet, SSH, FTP, HTTP Basic, WordPress, SMB, Redis, MySQL, MongoDB, VNC, ou TOUS en même temps.

Les résultats remplissent le tableau Vulnérabilités réseau et le Coffre d'identifiants.

Onglet 5 — Persistance

Trois actions de déploiement pour les hôtes compromis :

• Injection de clé SSH — Ajoute votre clé publique dans /root/.ssh/authorized_keys (ou plusieurs chemins)
• Backdoor Cron — Installe une tâche cron qui rappelle votre serveur C2
• Déploiement complet — Toutes les techniques combinées : clé SSH + cron + persistance init.d/systemd

Chaîne de pivot — Exécute des commandes à travers plusieurs hôtes intermédiaires :``` hop1 → hop2 → hop3 → command

**SOCKS Pivot** — Démarrer un proxy SOCKS5 local qui route le trafic à travers un appareil compromis, permettant d’utiliser proxychains ou tout outil compatible SOCKS pour atteindre le réseau interne.

### Onglet 6 — Reverse Shells

- **Générateur de Payload** — Choisir le type de shell (bash, python, perl, php, nc, ruby, node, lua, etc.), définir LHOST/LPORT, cliquer sur GÉNÉRER — le payload apparaît, cliquer pour copier
- **Listener** — Démarrer un listener sur n’importe quel port, gère automatiquement plusieurs connexions simultanées
- **Sessions Actives** — Cliquer sur une session pour interagir, taper des commandes et cliquer sur ENVOYER
- **Tous les Shells** affiche tous les callbacks de reverse shell reçus, avec leur statut

### Onglet 7 — Botnet

Pour gérer de grands groupes d’appareils compromis :

- **Commande Fan-Out** — Exécuter une commande sur tous les bots (optionnellement filtrée par tag)
- **Health Check** — Pinger tous les bots et rapporter leur statut en ligne/hors ligne
- **Taguer un Bot** — Assigner des tags aux bots pour les regrouper (ex. `eu`, `cameras`, `high-value`)
- **Déployer un Payload** — Pousser un payload vers tous les bots d’un groupe de tags
- **Résumé des Bots** — Affiche le nombre total, le nombre en ligne, et la répartition par tag

### Onglet 8 — Paramètres

- **Telegram/Discord** — Configurer les webhooks de notification pour les événements (nouveau compromis, scan terminé, etc.)
- **AbuseIPDB** — Vérifier la réputation d’une IP
- **Capture d’écran** — Récupérer une capture d’écran HTTP depuis l’interface web d’une caméra
- **Planificateur** — Mettre en place des tâches récurrentes (ex. health check toutes les 3600 secondes)
- **Journal des Scans** — Piste d’audit complète de toutes les opérations des modules, filtrable par type de module

---

## Référence API

L’API REST complète est disponible à `http://localhost:5000/api/`. Points d’accès clés :

| Point d’accès | Méthode | Description |
|----------|--------|-------------|
| `/api/cameras` | GET | Lister tous les appareils compromis |
| `/api/cameras/<ip>` | GET | Obtenir les détails d’un appareil |
| `/api/stats` | GET | Statistiques du tableau de bord |
| `/api/scan/start` | POST | Démarrer le scanner (CIDRs, cibles, threads) |
| `/api/scan/stop` | POST | Arrêter le scanner |
| `/api/scan/status` | GET | État d’exécution du scanner + statistiques |
| `/api/exploit/check` | POST | Vérifier une IP unique pour CVE-2020-25078 |
| `/api/fetch_targets` | POST | Récupérer depuis Shodan/FOFA/ZoomEye/Free |
| `/api/web_scan` | POST | Scan complet de vulnérabilités web |
| `/api/web_cves/scan` | POST | Scan CVE contre une cible |
| `/api/web_bugs/scan` | POST | Scan de classes de bugs contre une cible |
| `/api/web_brute` | POST | Brute force web |
| `/api/network/scan` | POST | Scan d’exploitation réseau |
| `/api/cred_spray` | POST | Credential spraying |
| `/api/portscan` | POST | Scan de ports TCP |
| `/api/recon/asn` | POST | Import/recherche/consultation ASN |
| `/api/recon/dns` | POST | Reconnaissance DNS |
| `/api/recon/jarm` | POST | Empreinte JARM |
| `/api/recon/waf` | POST | Détection WAF |
| `/api/recon/geoip` | POST | Recherche GeoIP |
| `/api/persistence/deploy` | POST | Déployer la persistance (ssh_key/cron/full) |
| `/api/revshell/generate` | POST | Générer un payload de reverse shell |
| `/api/revshell/listen` | POST | Démarrer un listener de reverse shell |
| `/api/revshell/stop` | POST | Arrêter le listener |
| `/api/botnet/bots` | GET | Liste des bots + résumé par groupe |
| `/api/botnet/fanout` | POST | Exécuter une commande sur tous les bots |
| `/api/botnet/health` | POST | Vérification de santé des bots |
| `/api/botnet/deploy` | POST | Déployer un payload sur les bots |
| `/api/socks/start` | POST | Démarrer le proxy SOCKS5 |
| `/api/socks/stop` | POST | Arrêter le proxy SOCKS5 |
| `/api/intel/config` | GET/POST | Obtenir/définir la configuration des notifications |
| `/api/intel/screenshot` | POST | Récupérer une capture d’écran de caméra |
| `/api/intel/notify` | POST | Envoyer une notification de test |
| `/api/scheduler/jobs` | GET | Lister les tâches planifiées |
| `/api/scheduler/add` | POST | Ajouter une tâche planifiée |
| `/api/scheduler/remove` | POST | Supprimer une tâche planifiée |
| `/api/credentials` | GET | Coffre d’identifiants |
| `/api/web_vulns` | GET | Liste des vulnérabilités web |
| `/api/network_vulns` | GET | Liste des vulnérabilités réseau |
| `/api/shells` | GET | Toutes les sessions reverse shell |
| `/api/scan_log` | GET | Journal d’audit avec filtres module/cible |
| `/api/scan_jobs` | GET | Historique des jobs de scan |

Événements WebSocket (SocketIO) :
- `scanner_event` — Progression du scan en temps réel (alive, vulnerable, owned, status)
- `stats_update` — Changement des statistiques du tableau de bord
- `cameras_list` — Rafraîchissement de la table des caméras
- `new_camera` — Nouvel appareil compromis
- `command_result` — Sortie de commande Telnet
- `mass_result` / `mass_result_item` — Résultats de commande de masse
- `brute_event` — Progression du brute force
- `web_cve_event` / `web_cves_done` — Progression du scan CVE
- `web_bug_event` / `web_bugs_done` — Progression du scan de bugs
- `network_event` / `network_done` — Progression du scan réseau
- `spray_event` / `spray_done` — Progression du credential spraying
- `portscan_event` / `portscan_done` — Progression du scan de ports
- `persistence_result` — Résultat du déploiement de la persistance
- `revshell_event` — Données/connexions reverse shell
- `botnet_event` / `botnet_fanout_done` — Opérations du botnet

---

## Détails Techniques

### Chaîne d’Exploitation CVE-2020-25078

1. **Vérification alive** — Connexion TCP au port 80
2. **Empreinte HTTP** — Vérifier la réponse pour 15 signatures DVR connues (`AppName="Hipcam"`, `hi3516`, `WEB SERVICE`, etc.)
3. **Path traversal** — Tenter 37 chemins vulnérables connus (`/../../../../../../../../../mnt/mtd/Config/Account1`, etc.)
4. **Extraction d’identifiants** — Analyser la réponse avec 14 motifs regex couvrant les formats INI, XML, JSON, URL-encodé, binaire, base64, délimité par deux-points et spécifiques aux DVR
5. **Filtrage des faux positifs** — Suppression agressive des faux positifs (balises HTML, en-têtes HTTP, mots courants)
6. **Fallback par défaut** — Si l’appareil est vulnérable mais sans identifiants extraits, essayer 22 paires d’identifiants par défaut connues

### Architecture du Scanner

- Pool de threads avec nombre de workers configurable (50 par défaut)
- Distribution des cibles basée sur une file d’attente
- Émission d’événements SocketIO en temps réel vers l’interface
- Statistiques thread-safe avec verrous mutex
- Expansion de plage CIDR avec exclusion réseau/broadcast
- Scan multi-ports (80, 8080, 443, 8443, 554, 8000, 81, 88, 8888, 37777)

---

## Avertissement

**CE LOGICIEL EST FOURNI UNIQUEMENT À DES FINS ÉDUCATIVES ET DE DÉMONSTRATION.**

Ce projet est destiné à être utilisé exclusivement dans le cadre de tests de sécurité autorisés, d’environnements éducatifs, ou sur des systèmes vous appartenant. Les techniques présentées ici sont bien connues dans l’industrie de la cybersécurité et sont documentées pour aider les défenseurs à comprendre les méthodologies d’attaque.

**En utilisant ce logiciel, vous acceptez que :**

1. Vous ne l’utiliserez que sur des systèmes vous appartenant ou pour lesquels vous avez une autorisation écrite explicite de test
2. Vous êtes responsable du respect de toutes les lois locales, nationales et internationales applicables
3. Le(s) créateur(s) et contributeur(s) de ce projet déclinent **toute responsabilité** pour tout :
   - Usage non autorisé ou illégal de ce logiciel
   - Dommage causé par l’utilisation ou la mauvaise utilisation de ce logiciel
   - Conséquence juridique résultant de l’utilisation de ce logiciel
4. Ce logiciel n’offre aucune garantie, expresse ou implicite

**Si vous n’êtes pas sûr que votre usage soit légal ou autorisé, N’UTILISEZ PAS ce logiciel.**

L’existence de ce projet ne constitue pas une incitation à des activités illégales. Il existe parce que comprendre les techniques offensives est essentiel pour construire des défenses efficaces.

---

## Licence

Ce projet est fourni en l’état à des fins éducatives. Aucune garantie. Aucune responsabilité. Utilisez-le à vos propres risques.

---

*N’oubliez pas : la recherche en sécurité existe pour rendre les systèmes plus sûrs, pas pour les casser. Utilisez ces connaissances pour défendre, non pour attaquer.*