logo do pwneye

pwneye é uma ferramenta de segurança ofensiva focada e portátil para trabalhar com câmeras IP que expõem serviços ONVIF e RTSP, visando dar a pesquisadores de segurança e hackers uma maneira fácil de lidar com descoberta, testes de autenticação, coleta de metadados, validação de fluxo, gravação e ações de acompanhamento a partir de um único fluxo de trabalho via CLI.

Algumas das capacidades atualmente suportadas incluem:

Descoberta ONVIF em rede local via WS-Discovery
Autenticação ONVIF e bruteforce multithread com credenciais únicas ou arquivos de usuário/senha
Enumeração ONVIF pós-autenticação de informações do dispositivo, usuários configurados, configuração de rede, perfis de mídia e URIs de fluxo RTSP
Reinicialização da câmera, restauração de fábrica e acesso a shell interativo via ONVIF
Movimento PTZ ONVIF tanto pela CLI quanto pelo visualizador dedicado
Suporte a desfiguração e restauração de fluxo via ONVIF
Detecção de porta RTSP e identificação de fornecedor baseada em banner
Bruteforce RTSP ciente do fornecedor com mais de 450 perfis integrados de credenciais/cadeias de conexão de fornecedores, além de suporte a fornecedor manual e cadeia de conexão manual
Bruteforce RTSP multithread com saída de progresso em tempo real
Tratamento multicanal RTSP com detecção automática, enumeração guiada e seleção interativa de canal
Cliente de pré-visualização ao vivo dedicado com zoom e troca rápida de canal para alvos do tipo DVR/NVR
Validação de fluxo RTSP, pré-visualização ao vivo via ffplay, gravação via ffmpeg e captura de instantâneos
Cache por alvo de descobertas bem-sucedidas de ONVIF e RTSP em ~/.pwneye

Demonstração

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

Instalação e Atualizações

pipx

Instale pwneye como um comando CLI de todo o sistema a partir do GitHub:```bash pipx install git+https://github.com/Hackerest/pwneye.git pwneye --help

Desinstale-o:```bash
pipx uninstall pwneye

Mais tarde, atualize-o a partir da mesma fonte do 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

Atualize-o mais tarde a partir da mesma fonte do GitHub:```bash cd pwneye git pull source .venv/bin/activate pip install -r requirements.txt

### Dependências Externas

As seguintes ferramentas são esperadas em `PATH`, dependendo do modo que você usar:
- `ffplay`
- `ffprobe`
- `ffmpeg` para gravação

| Plataforma | Comando de instalação |
| --- | --- |
| 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` |

## Primeiros Passos

Use estes como os pontos de entrada mais rápidos para a ferramenta. O objetivo aqui não é documentar todas as opções, mas mostrar as formas mais úteis de começar a trabalhar com uma câmera, dependendo do que você já sabe.

Comece pelo fluxo de trabalho completo padrão quando você tem um único alvo e quer que o `pwneye` faça o trabalho de seleção de protocolo por você:```bash
pwneye -t 192.168.1.135

Comece pela descoberta ONVIF quando você estiver na mesma rede local e quiser identificar dispositivos, fornecedores e pistas de stream antes de tocar no RTSP:```bash pwneye --discover

Comece diretamente pelo RTSP quando o ONVIF for irrelevante, indisponível ou quando você já souber o que deseja testar:```bash
pwneye -t 192.168.1.135 --skip-onvif

Comece por credenciais conhecidas ou suspeitas quando quiser reduzir ruído e validar o acesso rapidamente:```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

Comece a partir de um caminho conhecido ou de um modelo de caminho quando você já tiver uma pista de stream e quiser controle rígido sobre as solicitações 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'

Comece a coleta de evidências assim que um fluxo funcional for encontrado:```bash pwneye -t 192.168.1.135 --snapshot pwneye -t 192.168.1.135 --record

Sinalizadores úteis a ter em conta:
- `--vendor VENDOR`: reduz os pedidos RTSP quando a família do dispositivo já é conhecida
- `-cn, --connection-string PATH`: tenta um caminho RTSP conhecido ou um ficheiro contendo caminhos candidatos
- `--multi-channel`: prefere caminhos RTSP baseados em canais quando suspeitas de um alvo do tipo DVR/NVR
- `--threads N`: controla a concorrência para força bruta ONVIF e RTSP
- `--skip-onvif` / `--skip-rtsp`: foca-te apenas num protocolo
- `--no-cache`: não lê nem escreve na cache
- `--fresh`: ignora leituras da cache, mas continua a escrever novas descobertas

## ONVIF

ONVIF é o lado de gestão e controlo do mundo das câmaras. Na prática, é útil para descoberta, autenticação, extração de metadados, enumeração de perfis de media, obtenção de URIs de fluxo e ações no dispositivo, como reiniciar.

No `pwneye`, o ONVIF é normalmente o protocolo que fornece o contexto pós-autenticação mais rico, o caminho mais limpo para compreender o que uma câmara expõe e, quando a conta autenticada tem privilégios suficientes, acesso a ações administrativas reais no dispositivo.

### O Que o ONVIF Te Oferece

Quando uma câmara expõe ONVIF, o `pwneye` pode usá-lo para:

- descobrir câmaras na rede local via WS-Discovery
- testar a autenticação ONVIF usando credenciais fixas ou ficheiros
- extrair metadados do fabricante e do dispositivo
- obter URIs de fluxo RTSP expostos pelo dispositivo
- enumerar contexto útil pós-autenticação antes de abordar o RTSP de forma mais agressiva
- solicitar um reinício autenticado com `--reboot`
- solicitar uma reposição de fábrica autenticada com `--reset`
- mover uma câmara com capacidade PTZ a partir da CLI ou do visualizador dedicado
- abrir uma shell interativa autenticada com `--shell`
- desfigurar o fluxo via ONVIF com `--deface`
- restaurar o último perfil de desfiguração guardado com `--undeface`

### Enumerar a Rede Local

Usa WS-Discovery para identificar dispositivos com capacidade ONVIF na rede 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)

O ciclo de descoberta continua a sondar a cada poucos segundos, imprime apenas os dispositivos recém-descobertos e pode ser interrompido com CTRL-C.

Também pode forçar a descoberta através de uma interface de rede específica:```bash pwneye --discover en0 pwneye --discover eth0

Quando nenhuma interface é especificada, o `pwneye` escolhe automaticamente a interface de saída padrão e informa qual sub-rede de destino está usando para o WS-Discovery.

### Força bruta de credenciais

Execute a força bruta somente ONVIF com um nome de usuário fixo e um arquivo de senhas:```
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

Opções úteis:

--skip-onvif: ignora a detecção e enumeração ONVIF
-oP, --onvif-port PORT: testa uma porta ONVIF específica
-ou, --onvif-username USER: nome de usuário ONVIF ou arquivo com um nome de usuário por linha
-op, --onvif-password PASS: senha ONVIF ou arquivo com uma senha por linha

Se -ou e -op não forem especificados, o pwneye usa automaticamente seus nomes de usuário e senhas ONVIF comuns integrados.

O pwneye armazena em cache as credenciais ONVIF bem-sucedidas por alvo em ~/.pwneye/cache e as reutiliza em execuções futuras, a menos que você use --fresh ou --no-cache.

Reiniciando uma Câmera

Se a autenticação ONVIF for bem-sucedida, você pode solicitar uma reinicialização diretamente:``` 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 `--reboot` é utilizado, a sondagem RTSP é ignorada.

### Repor uma Câmara

Se a autenticação ONVIF for bem-sucedida, também pode solicitar uma reposição de fábrica diretamente:```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.

Aviso: esta operação pode ser irreversível e pode apagar a configuração atual do dispositivo, credenciais e configurações de rede. Use --reset somente quando você entender completamente o impacto e estiver explicitamente autorizado a executá-la.

Assim como com --reboot, quando --reset é usado, a sondagem RTSP é ignorada.

Movendo a Câmera

Se o alvo expõe controles PTZ por meio de ONVIF, o pwneye pode mover a câmera tanto pelo terminal quanto pelo visualizador ao vivo dedicado.

Pela CLI, use --move com direction,duration. A flag pode ser repetida, e os movimentos solicitados são executados em sequência enquanto a sondagem RTSP é ignorada:```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

Direções aceitas são:

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

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

Dentro do visualizador dedicado, se o PTZ for suportado, a visualização focada também permite mover a câmera interativamente com W, A, S e D. Isso é útil quando você já tem um stream funcionando e deseja um feedback visual direto enquanto ajusta o dispositivo.

Desfigurando um Stream

Se a autenticação ONVIF for bem-sucedida, o pwneye também pode tentar desfigurar o stream diretamente:```bash pwneye -t 192.168.1.135 --deface "THIS CAMERA IS EXPOSED"

O que o `--deface` faz, em resumo:

- primeiro, verifica se o alvo suporta escurecimento de stream por meio do ONVIF Imaging
- também verifica se o alvo expõe camadas de texto ONVIF reutilizáveis
- se ambos estiverem disponíveis, o `pwneye` realiza um deface completo
- se apenas um lado estiver disponível, o `pwneye` avisa o usuário e oferece um deface parcial
- antes de alterar qualquer coisa, o `pwneye` salva um perfil de restauração para o alvo em `~/.pwneye/cache`

A implementação é intencionalmente conservadora e amigável ao fornecedor:

- para a etapa de escurecimento, o `pwneye` reduz controles de imagem suportados, como brilho, contraste e saturação, em vez de depender de truques específicos do fornecedor
- para a etapa de texto, o `pwneye` reutiliza camadas de texto ONVIF graváveis existentes, em vez de criar ou excluir novas entradas OSD
- isso torna o recurso mais compatível entre diferentes famílias de câmeras, mesmo que o resultado visual final ainda dependa do firmware

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

Placeholder de desfiguração

Removendo a desfiguração de um stream

Se uma execução anterior de --deface salvou um perfil de restauração para o alvo, o pwneye pode usá-lo para restaurar o estado ONVIF original:```bash pwneye -t 192.168.1.135 --undeface

O que o `--undeface` faz, em resumo:

- procura um perfil de restauração de deface previamente salvo na entrada de cache do alvo
- se nenhum perfil existir, ele para imediatamente com um erro
- se um perfil existir, ele tenta restaurar as configurações originais de Imaging e as camadas de texto graváveis originais
- como acontece com o `--deface`, o resultado final pode ser total ou parcial, dependendo do que o alvo permite através do ONVIF

O perfil de restauração não é excluído após um `--undeface` bem-sucedido. Ele permanece no cache até que um futuro `--deface` o sobrescreva com um perfil mais recente.

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

Obtendo um shell

Se a autenticação ONVIF for bem-sucedida, o pwneye também pode colocá-lo diretamente em um shell ONVIF interativo. Isso é útil quando você deseja inspecionar serviços, chamar métodos manualmente, explorar capacidades ou testar operações específicas do alvo sem sair do fluxo de trabalho atual.

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

O RTSP é o lado de streaming do mundo das câmeras. É o protocolo que normalmente fornece o caminho de vídeo ao vivo, mas também é o mais fragmentado: os fornecedores usam caminhos diferentes, convenções de canais, peculiaridades de autenticação e formatos de banner distintos.

No `pwneye`, o tratamento de RTSP é construído em torno da descoberta de portas, captura de banners, seleção de caminhos ciente do fornecedor, orquestração de bruteforce, validação de stream, pré-visualização e gravação.

### O Que o RTSP Oferece

O RTSP é a parte do fluxo de trabalho que confirma se você realmente consegue acessar um stream. No `pwneye`, isso significa:

- detetar RTSP em portas comuns ou especificadas pelo utilizador
- capturar banners e tentar identificar o fornecedor automaticamente
- fazer bruteforce de credenciais contra caminhos cientes do fornecedor ou fornecidos pelo utilizador
- validar streams funcionais antes de os abrir
- gravar streams ou capturar instantâneos como evidência
- enumerar múltiplos canais quando o alvo se comporta como um DVR ou NVR

### Identificar o Fornecedor

O `pwneye` tentará identificar o fornecedor de RTSP automaticamente através da captura de banners RTSP antes de recorrer a uma enumeração de caminhos mais ampla.

Se a identificação automática baseada em banners falhar e você já souber o fornecedor a partir de análises anteriores, pode passá-lo diretamente para reduzir significativamente o número de pedidos:```bash
pwneye -t 192.168.1.135 --vendor tenda

Pode também obter apenas o banner RTSP e sair:``` 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

Opções úteis:
- `--skip-rtsp`: ignorar a detecção e o bruteforce de RTSP
- `-P, --rtsp-port PORT`: testar uma porta RTSP específica
- `--vendor VENDOR`: forçar um fabricante da base de dados de RTSP
- `--list-vendors`: listar os fabricantes suportados pela base de conhecimento de RTSP e sair
- `--protocol tcp|udp`: escolher o transporte RTSP, o padrão é `tcp`
- `--timeout SECONDS`: timeout de RTSP, o padrão é `10`

### Bruteforce de RTSP

Bruteforce de RTSP com credenciais fixas:```bash
pwneye -t 192.168.1.135 --username admin --password admin

Rotacionar apenas nomes de usuário com uma senha fixa:```bash pwneye -t 192.168.1.135 --password 'SuperSecretPass' --vendor hikvision --threads 10

Experimente uma única string de conexão RTSP fornecida pelo usuário:```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"

Carregar strings de conexão candidatas a partir do arquivo:```bash pwneye -t 192.168.1.135 --skip-onvif -cn paths.txt

Combine um caminho manual com credenciais fixas:```bash
pwneye -t 192.168.1.135 --skip-onvif -u admin -p admin -cn "/live/ch00_0"

Prefira caminhos multicanal quando o alvo for provavelmente um DVR/NVR:```bash pwneye -t 192.168.1.135 --skip-onvif --multi-channel

Opções úteis:
- `-u, --username USER`: nome de utilizador RTSP ou ficheiro com um nome de utilizador por linha
- `-p, --password PASS`: palavra-passe RTSP ou ficheiro com uma palavra-passe por linha
- `-cn, --connection-string PATH`: string de ligação RTSP ou ficheiro com uma string de ligação por linha
- `--multi-channel`: preferir strings de ligação RTSP multicanal quando disponíveis
- `--threads N`: número de threads concorrentes usados pelo motor de bruteforce

Se `-u` e `-p` não forem especificados, o `pwneye` recorre automaticamente aos seus nomes de utilizador e palavras-passe RTSP comuns incorporados.

O `pwneye` armazena em cache credenciais RTSP bem-sucedidas e metadados de stream validados por alvo em `~/.pwneye/cache`.

Comportamento da cache:
- predefinido: reutilizar descobertas válidas em cache antes de executar um bruteforce novo
- `--fresh`: ignorar resultados em cache, mas ainda atualizar a cache com novas descobertas
- `--no-cache`: desativar tanto leituras como escritas na cache

### Streams Multicanal

Algumas câmaras, DVRs e NVRs expõem múltiplos canais RTSP lógicos em vez de um único caminho estático. Exemplos típicos incluem modelos como:```text
rtsp://IP:554/?chID=1&streamType=main&linkType=tcp
rtsp://IP:554/cam/realmonitor?channel=1&subtype=0

pwneye pode detetar isto automaticamente ao sondar RTSP, inclusive através do conhecimento RTSP baseado no fornecedor, mas também pode orientar o processo explicitamente:

--multi-channel diz ao pwneye para preferir caminhos RTSP baseados em canais a partir da base de conhecimento
--connection-string permite fornecer o seu próprio modelo de canal, incluindo espaços reservados como {channel}
a mesma lógica de modelo também funciona quando as strings de ligação vêm de um ficheiro
assim que vários canais são encontrados, o pwneye pode abrir um único feed ou um visualizador dedicado de múltiplos canais numa única janela

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

Amostra de saída:```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 escolheres Open all discovered channels, o pwneye lança um cliente dedicado de múltiplos canais que mantém todos os streams descobertos dentro de uma única janela. Cada feed é mostrado no mosaico como uma pré-visualização ao vivo, e clicar num mosaico promove esse canal para uma vista focada maior, com uma ação simples de Back para regressar à grelha.

pwneye dedicated multi-channel client demo

Por predefinição, a pré-visualização RTSP ao vivo usa o cliente dedicado do pwneye. Se preferires o fluxo de trabalho clássico com o leitor do sistema, podes adicionar --legacy para abrir o stream validado com o ffplay.

Quando o cliente dedicado está aberto, também podes acionar Snapshot e Record diretamente a partir da vista focada, sem sair da GUI. Isto é útil quando queres inspecionar um feed primeiro e só depois decidir guardar uma imagem estática ou começar a gravar evidências.

Streaming, Gravação e Snapshots

Abre um stream validado com pré-visualização ao vivo:```bash pwneye -t 192.168.1.135 --vendor tenda

Grave um stream RTSP validado com pré-visualização:```bash
pwneye -t 192.168.1.135 --record
pwneye -t 192.168.1.135 --record living-room.mp4

Capture a snapshot instead of a full recording:```bash pwneye -t 192.168.1.135 --snapshot pwneye -t 192.168.1.135 --snapshot living-room.jpg

Gravar sem abrir a janela de pré-visualização:```
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 de gravação:

--record [OUTPUT.mp4]: grava o stream RTSP validado; se omitido, um arquivo com timestamp é criado em ~/.pwneye/recordings
--snapshot [OUTPUT.jpg]: salva um quadro estático do stream RTSP validado; se omitido, um arquivo com timestamp é criado em ~/.pwneye/snapshots
--no-video: pula a pré-visualização ao vivo e a decodificação
o visualizador dedicado também expõe as ações Snapshot e Record diretamente na visualização focada
gravações padrão são armazenadas em ~/.pwneye/recordings/<target>/
snapshots padrão são armazenados em ~/.pwneye/snapshots/<target>/

Dicas e Truques

Se pwneye fosse um videogame, estas são provavelmente as dicas que você veria na tela de carregamento:

Uma interface web forte não significa uma câmera segura: Uma câmera com uma interface web bem protegida não está necessariamente bem protegida como um todo. É comum encontrar um bloqueio web sólido enquanto o RTSP permanece sem autenticação ou aceita tentativas efetivamente ilimitadas.
Use a descoberta quando puder: Se --discover funcionar na rede local, use-o primeiro. Informações do fornecedor, metadados do dispositivo e descobertas em cache podem tornar o trabalho RTSP posterior muito mais silencioso e confiável.
ONVIF primeiro pode ser a jogada mais inteligente: ONVIF e RTSP frequentemente compartilham as mesmas credenciais. Se o ONVIF estiver exposto, geralmente é mais inteligente fazer bruteforce nesse lado primeiro com --skip-rtsp em vez de martelar o RTSP diretamente e tornar o stream instável. Quando pwneye encontra credenciais ONVIF válidas, ele tenta reutilizá-las no RTSP automaticamente.
Fornecedores conhecidos reduzem ruído: Se você já conhece o fornecedor, passe --vendor explicitamente. Isso reduz requisições e pode ajudar a manter alvos frágeis estáveis.
Caminhos conhecidos superam adivinhação às cegas: Se você já conhece ou suspeita do caminho, use --connection-string em vez de enumeração RTSP ampla. Isso dá a você um controle mais rígido sobre o conjunto de requisições e torna as falhas mais fáceis de interpretar.
Um gravador pode expor mais de um feed: Se um alvo parece ser um DVR/NVR, tente --multi-channel ou um template de canal manual antes de assumir que ele expõe apenas um único stream.
Reinicialização pode ser uma etapa de recuperação: Se você tem credenciais RTSP válidas mas ainda não consegue abrir o vídeo, o stream pode simplesmente estar instável após sondagens repetidas. Se você também tiver acesso ONVIF, uma etapa de recuperação direta mas frequentemente eficaz é .

Agradecimentos

Agradecimento especial a @kaburagisec por onvif-python, a biblioteca ONVIF usada pelo pwneye. Ela tornou o lado ONVIF deste projeto dramaticamente mais fácil e confiável.

Obrigado a Darix Deros por ajudar durante os testes e por compartilhar várias sugestões úteis que melhoraram partes da ferramenta, incluindo o fluxo de trabalho de descoberta ONVIF.

Segurança

Use pwneye apenas contra ativos que você possui ou para os quais está explicitamente autorizado a avaliar.

Esta ferramenta pode enumerar serviços, testar autenticação, abrir streams, gravar vídeo, interagir com recursos administrativos ONVIF e, com privilégios suficientes, reinicializar, redefinir, desfigurar ou alterar de outra forma o comportamento de um dispositivo alvo.

Mesmo quando seu objetivo é apenas a coleta de evidências, sondagens RTSP repetidas podem tornar câmeras frágeis instáveis, e ações ONVIF podem ter impacto operacional imediato.

Licença

Este projeto é distribuído sob a Licença GNU GPL3. Consulte LICENSE.md.

Mais Populares

pwneye