Skip to content
KitploitKITPLOIT
FerramentasExploitsBlog
Log in
Enviar
FerramentasExploitsBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

FeedsContatoPrivacidade© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
Ferramentas/GitHubGitHub/ullaakut/cameradar
Segurança IoTAtaques de SenhaColeta de InformaçõesSegurança de RedeTestes de Penetração
GitHubullaakut/cameradar

cameradar

Cameradar invade câmeras de videovigilância RTSP

Ver Repositório
5.2k628125há 5 diasRevisado pelo Kitploit
Compartilhar
## Cameradar

<p align="center">
    <a href="#license">
        <img src="https://img.shields.io/badge/license-MIT-blue.svg?style=flat" />
    </a>
    <a href="https://hub.docker.com/r/ullaakut/cameradar/">
        <img src="https://img.shields.io/docker/pulls/ullaakut/cameradar.svg?style=flat" />
    </a>
    <a href="https://github.com/Ullaakut/cameradar/actions">
        <img src="https://img.shields.io/github/actions/workflow/status/Ullaakut/cameradar/build.yaml" />
    </a>
    <a href='https://coveralls.io/github/Ullaakut/cameradar?branch=master'>
        <img src="https://coveralls.io/repos/github/Ullaakut/cameradar/badge.svg?branch=master" alt='Coverage Status' />
    </a>
    <a href="https://goreportcard.com/report/github.com/ullaakut/cameradar">
        <img src="https://goreportcard.com/badge/github.com/ullaakut/cameradar" />
    </a>
    <a href="https://github.com/ullaakut/cameradar/releases/latest">
        <img src="https://img.shields.io/github/release/Ullaakut/cameradar.svg?style=flat" />
    </a>
    <a href="https://pkg.go.dev/github.com/ullaakut/cameradar">
        <img src="https://godoc.org/github.com/ullaakut/cameradar?status.svg" />
    </a>
</p>

## Ferramenta de acesso a streams RTSP

O Cameradar verifica endpoints RTSP em alvos autorizados e usa ataques de dicionário para forçar credenciais e rotas.

### O que o Cameradar faz

- Detecta hosts RTSP abertos em alvos acessíveis.
- Detecta o modelo do dispositivo que transmite o feed RTSP.
- Tenta descobrir rotas de stream baseadas em dicionário (por exemplo, `/live.sdp`).
- Tenta descobrir credenciais de câmera baseadas em dicionário.
- Produz um relatório dos resultados.

<p align="center"><img src="https://assets.kitploit.com/production/public/readmes/2257/d2baa9ce614326ceb31bed5bab4254d88e2b007f8ae0ede3e11d520ff973ed49.png" width="250"/></p>

## Índice

- [Início rápido com Docker](#quick-start-with-docker)
- [Instalar o binário](#install-the-binary)
- [Instalar no Android (Termux)](#install-on-android-termux)
- [Configuração](#configuration)
- [Segurança e uso responsável](#security-and-responsible-use)
- [Saída](#output)
- [Verificar acesso à câmera](#check-camera-access)
- [Opções de linha de comando e variáveis de ambiente](#command-line-options-and-environment-variables)
- [Formato do arquivo de entrada](#input-file-format)
- [Compilar e contribuir](#build-and-contribute)
- [Perguntas frequentes](#frequently-asked-questions)
- [Exemplos](#examples)
- [Licença](#license)

---

<p align="center"><img src="https://assets.kitploit.com/production/public/readmes/2257/1a85244eb4f8753e5bfaaec4af131361fa29f61cd8c0204a1c53087c21e625b8.gif"/></p>

## Início rápido com Docker

Instale o [Docker](https://docs.docker.com/engine/installation/) e execute:

```bash
docker run --rm -t --net=host ullaakut/cameradar --targets <target>
```

Exemplo:

```bash
docker run --rm -t --net=host ullaakut/cameradar --targets 192.168.100.0/24
```

Isso verifica as portas 554, 5554 e 8554 na sub-rede alvo.
Tenta enumerar streams RTSP.
Para todas as opções, consulte a [Referência de configuração](https://github.com/Ullaakut/cameradar/wiki/Configuration-Reference).

- Alvos podem ser CIDRs, IPs, intervalos de IP ou um hostname.
    - Sub-rede: `172.16.100.0/24`
    - IP: `172.16.100.10`
    - Host: `localhost`
    - Intervalo: `172.16.100.10-20`

- Para usar dicionários personalizados, monte-os e passe ambos os flags:

    ```bash
    docker run --rm -t --net=host \
        -v /path/to/dictionaries:/tmp/dictionaries \
        ullaakut/cameradar \
        --custom-routes /tmp/dictionaries/my_routes \
        --custom-credentials /tmp/dictionaries/my_credentials.json \
        --targets 192.168.100.0/24
    ```

## Instalar o binário

Use esta opção se o Docker não estiver disponível ou se quiser uma compilação local.

### Dependências

- Go 1.25 ou superior

### Passos

1. `go install github.com/Ullaakut/cameradar/v6/cmd/cameradar@latest`

O binário `cameradar` agora está em `$GOPATH/bin`.
Para flags disponíveis, consulte a [Referência de configuração](https://github.com/Ullaakut/cameradar/wiki/Configuration-Reference).

## Instalar no Android (Termux)

Estes passos resumem uma configuração funcional do Termux para Android.
Use o Termux 117 do F-Droid ou do site oficial do Termux, não do Google Play.

### 1) Configurar Termux e Alpine

Instale os pacotes necessários no Termux:

```bash
pkg update
pkg install mc wget git nmap proot-distro
```

Instale o Alpine e faça login:

```bash
proot-distro install alpine
proot-distro login alpine
```

### 2) Instalar ferramentas de compilação no Alpine

```bash
apk add wget git go gcc clang musl-dev make
```

### 3) Compilar o Cameradar

Crie um caminho de módulo e clone o repositório:

```bash
mkdir -p go/pkg/mod/github.com/Ullaakut
cd go/pkg/mod/github.com/Ullaakut
git clone https://github.com/Ullaakut/cameradar.git
cd cameradar/cmd/cameradar
go install
```

### 4) Executar o Cameradar

Copie os dicionários e execute o binário:

```bash
mkdir -p /tmp
cp -r ../../dictionaries /tmp/dictionaries
/go/bin/cameradar --targets=<target> --custom-credentials=/tmp/dictionaries/credentials.json --custom-routes=/tmp/dictionaries/routes --ui=plain --debug 
```

Substitua `<target>` por um IP, intervalo, host ou sub-rede que você está autorizado a testar.

## Configuração

As portas padrão são `554`, `5554`, `8554`, `http`, `322` e `8322`.
Se você não especificar portas, o Cameradar usará essas.

Exemplo de verificação de portas personalizadas:

```bash
docker run --rm -t --net=host \
    ullaakut/cameradar \
    --ports "18554,19000-19010" \
    --targets localhost
```

Você pode substituir os dicionários padrão pelos seus próprios arquivos de rotas e credenciais.
O repositório fornece dicionários básicos na pasta `dictionaries`.

```bash
docker run --rm -t --net=host \
    -v /my/folder/with/dictionaries:/tmp/dictionaries \
    ullaakut/cameradar \
    --custom-routes /tmp/dictionaries/my_routes \
    --custom-credentials /tmp/dictionaries/my_credentials.json \
    --targets 172.19.124.0/24
```

### RTSPS e certificados TLS

Use URLs `rtsps://` para acessar streams RTSPS.

- Se o certificado da stream for emitido por uma AC pública confiável, nenhuma configuração extra é necessária.
- Se o certificado da stream for autoassinado ou emitido por uma AC privada, o repositório de confiança do SO pode rejeitá-lo.
- Nesse caso, aponte `SSL_CERT_FILE` para o certificado da AC (ou certificado do servidor para configuração autoassinada) ao executar o Cameradar.

Exemplo com binário local:

```bash
SSL_CERT_FILE=/path/to/ca-or-server.crt \
        cameradar \
        --targets localhost \
        --ports 8322 \
        --skip-scan \
        --custom-routes routes.txt \
        --custom-credentials credentials.json
```

Exemplo com Docker:

```bash
docker run --rm -t --net=host \
        -e SSL_CERT_FILE=/tmp/certs/server.crt \
        -v /path/to/certs:/tmp/certs:ro \
        ullaakut/cameradar \
        --targets localhost \
        --ports 8322
```

Se preferir não usar `SSL_CERT_FILE`, adicione seu certificado AC ao repositório de confiança do sistema usado pelo seu ambiente de execução.

### Pular descoberta com `--skip-scan`

Se você já conhece os endpoints RTSP, pode pular a descoberta e tratar cada alvo e porta como um candidato a stream. Este modo não executa descoberta e pode ser útil em redes restritas ou quando você deseja atacar um inventário conhecido.

Pular descoberta significa:

- O Cameradar não executa descoberta e não detecta modelos de dispositivos.
- Alvos são resolvidos para endereços IP. Hostnames são resolvidos via DNS.
- Blocos CIDR e intervalos IPv4 são expandidos para todos os endereços no intervalo.
- Intervalos grandes criam muitos alvos, portanto, use-os com cuidado.

Exemplo:

```bash
docker run --rm -t --net=host \
    ullaakut/cameradar \
    --skip-scan \
    --ports "554,8554" \
    --targets 192.168.1.10
```

Neste exemplo, o Cameradar tenta ataques de dicionário nas portas 554 e 8554 de `192.168.1.10`.

### Escolher o scanner de descoberta com `--scanner`

O Cameradar suporta dois backends de descoberta:

- `nmap` (padrão)
- `masscan`

Use `nmap` quando quiser uma descoberta RTSP mais confiável: ele realiza identificação de serviço e pode distinguir melhor RTSP de outras portas abertas.

Use `masscan` ao verificar redes muito grandes: geralmente é mais rápido e eficiente em escala, mas não fornece descoberta de serviços.

```bash
docker run --rm -t --net=host \
    ullaakut/cameradar \
    --scanner masscan \
    --ports "554,8554" \
    --targets 192.168.1.0/24
```

> [!WARNING]  
> `--scan-speed` se aplica apenas ao scanner `nmap`.

### Reduzir falsos positivos com `--framecheck`

Algumas câmeras não seguem totalmente o comportamento RTSP e podem retornar `200 OK` mesmo quando a rota ou credenciais estão erradas.

Quando você ativa `--framecheck`, o Cameradar valida cada `200 OK` tentando reprodução e aguardando um pacote RTP.

Framecheck significa:

- O Cameradar só aceita `200 OK` quando pode confirmar a geração de quadros.
- Se nenhum pacote RTP chegar, o Cameradar trata o resultado como falso positivo e continua atacando.
- As verificações de rota permanecem compatíveis com desafios de autenticação encontrados durante a sondagem.

`--framecheck` está desabilitado por padrão porque adiciona requisições RTSP e pode aumentar significativamente a duração do ataque.

Exemplo com Docker:

```bash
docker run --rm -t --net=host \
        ullaakut/cameradar \
        --targets 192.168.1.0/24 \
        --ports "554,8554" \
        --framecheck
```

Exemplo com binário local e variável de ambiente:

```bash
FRAMECHECK=true \
        cameradar \
        --targets 192.168.1.0/24 \
        --ports "554,8554"
```

## Segurança e uso responsável

O Cameradar é uma ferramenta de teste de penetração.
Verifique apenas redes e dispositivos que você possui ou tem permissão explícita para testar.
Não use esta ferramenta para acessar sistemas ou streams não autorizados.
Se você não tiver certeza, pare e obtenha aprovação por escrito antes de verificar.

## Saída

O Cameradar apresenta resultados em uma interface de terminal legível.
Ele registra os resultados no console.
O relatório inclui hosts descobertos, modelos de dispositivos identificados e rotas ou credenciais válidas.
Se você especificar um caminho para a flag `--output`, o Cameradar também escreve uma playlist M3U com as streams descobertas.

## Verificar acesso à câmera

Use o [VLC Media Player](http://www.videolan.org/vlc/) para conectar a uma stream:

`rtsp://username:password@address:port/route`

Para endpoints RTSP seguros, use:

`rtsps://username:password@address:port/route`

## Formato do arquivo de entrada

O arquivo pode conter IPs, hostnames, intervalos de IP e sub-redes.
Separe as entradas com quebras de linha.
Exemplo:

```text
0.0.0.0
localhost
192.17.0.0/16
192.168.1.140-255
192.168.2-3.0-255
```

Quando você usa `--skip-scan`, o Cameradar expande cada entrada em endereços IP explícitos antes de construir a lista de alvos.

## Opções de linha de comando e variáveis de ambiente

A referência completa da CLI e variáveis de ambiente é mantida na [Referência de configuração](https://github.com/Ullaakut/cameradar/wiki/Configuration-Reference).

Isso inclui todas as flags suportadas, padrões, valores aceitos e mapeamento de variáveis de ambiente.

## Compilar e contribuir

### Compilação Docker

Execute o seguinte comando na raiz do repositório:

`docker build . -t cameradar`

A imagem resultante é nomeada `cameradar`.

### Compilação Go

1. `go install github.com/Ullaakut/cameradar/v6/cmd/cameradar@latest`

O binário `cameradar` agora está em `$GOPATH/bin/cameradar`.

## Perguntas frequentes

Veja [Solução de problemas e FAQ](https://github.com/Ullaakut/cameradar/wiki/Troubleshooting-%26-FAQ)

## Exemplos

> Executando o cameradar em sua própria máquina para verificar portas padrão

`docker run --rm -t --net=host ullaakut/cameradar --targets localhost`

> Executando o cameradar com um arquivo de entrada, logs ativados na porta 8554

`docker run --rm -t --net=host -v /tmp:/tmp ullaakut/cameradar --targets /tmp/test.txt --ports 8554`

> Executando o cameradar em uma sub-rede com dicionários personalizados, nas portas 554, 5554, 8554, 322 e 8322

`docker run --rm -t --net=host -v /tmp:/tmp ullaakut/cameradar --targets 192.168.0.0/24 --custom-credentials "/tmp/dictionaries/credentials.json" --custom-routes "/tmp/dictionaries/routes" --ports 554,5554,8554`

> Executando o cameradar com descoberta masscan

`docker run --rm -t --net=host ullaakut/cameradar --scanner masscan --targets 192.168.0.0/24 --ports 554,8554`

## Licença

Copyright 2026 Ullaakut

É concedida permissão, gratuitamente, a qualquer pessoa que obtenha uma cópia deste software e dos arquivos de documentação associados (o "Software"), para lidar com o Software sem restrição, incluindo, sem limitação, os direitos de usar, copiar, modificar, mesclar, publicar, distribuir, sublicenciar e/ou vender cópias do Software, e permitir que as pessoas a quem o Software é fornecido o façam, sujeitas às seguintes condições:

O aviso de direitos autorais acima e este aviso de permissão devem ser incluídos em todas as cópias ou partes substanciais do Software.

O SOFTWARE É FORNECIDO "NO ESTADO EM QUE SE ENCONTRA", SEM GARANTIA DE QUALQUER TIPO, EXPRESSA OU IMPLÍCITA, INCLUINDO, MAS NÃO SE LIMITANDO ÀS GARANTIAS DE COMERCIALIZAÇÃO, ADEQUAÇÃO A UM PROPÓSITO ESPECÍFICO E NÃO VIOLAÇÃO. EM NENHUM CASO OS AUTORES OU TITULARES DOS DIREITOS AUTORAIS SERÃO RESPONSÁVEIS POR QUALQUER RECLAMAÇÃO, DANOS OU OUTRA RESPONSABILIDADE, SEJA EM UMA AÇÃO DE CONTRATO, ATO ILÍCITO OU DE OUTRA FORMA, DECORRENTE DE, OU EM CONEXÃO COM O SOFTWARE OU O USO OU OUTRAS NEGOCIAÇÕES NO SOFTWARE.
Baixar ferramenta

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 O kit definitivo de OSINT: grafo de investigação, pontuação de confiança, famílias de alias, mapa, linha do tempo e relatórios. 49 módulos, mais de 400 sites, sem necessidade de chaves de API.

    906
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicativo de Execução em Um Toque GhostLock (CVE-2026-43499)

    725
  • 3

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingere relatórios do Shadowserver no MongoDB e os reproduz como mapas interativos, análises, descobertas, avisos e painéis executivos.

    442
  • 4

    wifit3

    derv82/wifit3

    Wifite, mas apenas USB e multiplataforma.

    434
  • 5

    jumpserver

    jumpserver/jumpserver

    JumpServer é uma plataforma de código aberto de Gerenciamento de Acesso Privilegiado (PAM) que fornece às equipes de DevOps e TI acesso seguro e sob demanda a endpoints SSH, RDP, Kubernetes, Banco de Dados e RemoteApp através de um navegador web.

    412
  • 6

    SafeLine

    chaitin/safeline

    WAF auto-hospedado e proxy reverso que filtra tráfego HTTP malicioso, bloqueia injeção SQL, XSS e ataques de bots, com limitação de taxa e criptografia dinâmica de HTML/JS.

    360

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →