
Cameradar si intrufola nelle telecamere di videosorveglianza RTSP
## 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>
## Strumento di accesso ai flussi RTSP
Cameradar esegue la scansione degli endpoint RTSP su target autorizzati e utilizza attacchi a dizionario per forzare le loro credenziali e rotte.
### Cosa fa Cameradar
- Rileva host RTSP aperti su target accessibili.
- Rileva il modello del dispositivo che trasmette il flusso RTSP.
- Tenta la scoperta basata su dizionario delle rotte del flusso (ad esempio, `/live.sdp`).
- Tenta la scoperta basata su dizionario delle credenziali della telecamera.
- Produce un report dei risultati.
<p align="center"><img src="https://assets.kitploit.com/production/public/readmes/2257/d2baa9ce614326ceb31bed5bab4254d88e2b007f8ae0ede3e11d520ff973ed49.png" width="250"/></p>
## Indice
- [Avvio rapido con Docker](#quick-start-with-docker)
- [Installare il binario](#install-the-binary)
- [Installazione su Android (Termux)](#install-on-android-termux)
- [Configurazione](#configuration)
- [Sicurezza e uso responsabile](#security-and-responsible-use)
- [Output](#output)
- [Controllare l'accesso alla telecamera](#check-camera-access)
- [Opzioni da riga di comando e variabili d'ambiente](#command-line-options-and-environment-variables)
- [Formato del file di input](#input-file-format)
- [Costruire e contribuire](#build-and-contribute)
- [Domande frequenti](#frequently-asked-questions)
- [Esempi](#examples)
- [Licenza](#license)
---
<p align="center"><img src="https://assets.kitploit.com/production/public/readmes/2257/1a85244eb4f8753e5bfaaec4af131361fa29f61cd8c0204a1c53087c21e625b8.gif"/></p>
## Avvio rapido con Docker
Installa [Docker](https://docs.docker.com/engine/installation/) ed esegui:
```bash
docker run --rm -t --net=host ullaakut/cameradar --targets <target>
```
Esempio:
```bash
docker run --rm -t --net=host ullaakut/cameradar --targets 192.168.100.0/24
```
Questo esegue la scansione delle porte 554, 5554 e 8554 sulla sottorete target.
Tenta di enumerare i flussi RTSP.
Per tutte le opzioni, consulta [Reference di Configurazione](https://github.com/Ullaakut/cameradar/wiki/Configuration-Reference).
- I target possono essere CIDR, IP, intervalli di IP o un nome host.
- Sottorete: `172.16.100.0/24`
- IP: `172.16.100.10`
- Host: `localhost`
- Intervallo: `172.16.100.10-20`
- Per utilizzare dizionari personalizzati, montali e passa entrambi i flag:
```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
```
## Installare il binario
Usa questa opzione se Docker non è disponibile o se vuoi una build locale.
### Dipendenze
- Go 1.25 o successivo
### Passi
1. `go install github.com/Ullaakut/cameradar/v6/cmd/cameradar@latest`
Il binario `cameradar` ora si trova in `$GOPATH/bin`.
Per i flag disponibili, consulta [Reference di Configurazione](https://github.com/Ullaakut/cameradar/wiki/Configuration-Reference).
## Installazione su Android (Termux)
Questi passi riassumono una configurazione Termux funzionante per Android.
Usa Termux 117 da F-Droid o dal sito ufficiale di Termux, non da Google Play.
### 1) Configurare Termux e Alpine
Installa i pacchetti necessari in Termux:
```bash
pkg update
pkg install mc wget git nmap proot-distro
```
Installa Alpine e accedi:
```bash
proot-distro install alpine
proot-distro login alpine
```
### 2) Installare gli strumenti di build in Alpine
```bash
apk add wget git go gcc clang musl-dev make
```
### 3) Costruire Cameradar
Crea un modulo di percorso e clona il repository:
```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) Eseguire Cameradar
Copia i dizionari ed esegui il binario:
```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
```
Sostituisci `<target>` con un IP, intervallo, host o sottorete che hai l'autorizzazione di testare.
## Configurazione
Le porte predefinite sono `554`, `5554`, `8554`, `http`, `322` e `8322`.
Se non specifichi le porte, Cameradar utilizza queste.
Esempio di scansione con porte personalizzate:
```bash
docker run --rm -t --net=host \
ullaakut/cameradar \
--ports "18554,19000-19010" \
--targets localhost
```
Puoi sostituire i dizionari predefiniti con i tuoi file di rotte e credenziali.
Il repository fornisce dizionari di base nella cartella `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 certificati TLS
Usa URL `rtsps://` per accedere a flussi RTSPS.
- Se il certificato del flusso è emesso da una CA pubblica attendibile, non è necessaria alcuna configurazione aggiuntiva.
- Se il certificato del flusso è autofirmato o emesso da una CA privata, il negozio di trust del sistema operativo potrebbe rifiutarlo.
- In tal caso, imposta `SSL_CERT_FILE` sul certificato della CA (o sul certificato del server per una configurazione autofirmata) quando esegui Cameradar.
Esempio con binario locale:
```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
```
Esempio con 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 preferisci non utilizzare `SSL_CERT_FILE`, aggiungi il tuo certificato CA al negozio di trust di sistema utilizzato dal tuo ambiente di esecuzione.
### Saltare la scoperta con `--skip-scan`
Se conosci già gli endpoint RTSP, puoi saltare la scoperta e trattare ogni target e porta come candidato per il flusso. Questa modalità non esegue la scoperta e può essere utile su reti limitate o quando vuoi attaccare un inventario noto.
Saltare la scoperta significa:
- Cameradar non esegue la scoperta e non rileva modelli di dispositivi.
- I target vengono risolti in indirizzi IP. I nomi host vengono risolti tramite DNS.
- I blocchi CIDR e gli intervalli IPv4 vengono espansi a ogni indirizzo nell'intervallo.
- Intervalli grandi creano molti target, quindi usali con cautela.
Esempio:
```bash
docker run --rm -t --net=host \
ullaakut/cameradar \
--skip-scan \
--ports "554,8554" \
--targets 192.168.1.10
```
In questo esempio, Cameradar tenta attacchi a dizionario sulle porte 554 e 8554 di `192.168.1.10`.
### Scegliere lo scanner di scoperta con `--scanner`
Cameradar supporta due backend di scoperta:
- `nmap` (predefinito)
- `masscan`
Usa `nmap` quando desideri una scoperta RTSP più affidabile: esegue l'identificazione del servizio e può distinguere meglio RTSP da altre porte aperte.
Usa `masscan` quando esegui la scansione di reti molto grandi: è generalmente più veloce ed efficiente su larga scala, ma non fornisce la scoperta del servizio.
```bash
docker run --rm -t --net=host \
ullaakut/cameradar \
--scanner masscan \
--ports "554,8554" \
--targets 192.168.1.0/24
```
> [!WARNING]
> `--scan-speed` si applica solo allo scanner `nmap`.
### Ridurre i falsi positivi con `--framecheck`
Alcune telecamere non seguono completamente il comportamento RTSP e possono restituire `200 OK` anche quando la rotta o le credenziali sono errate.
Quando abiliti `--framecheck`, Cameradar convalida ogni `200 OK` tentando la riproduzione e attendendo un pacchetto RTP.
Framecheck significa:
- Cameradar accetta `200 OK` solo quando può confermare la generazione di frame.
- Se non arriva alcun pacchetto RTP, Cameradar tratta il risultato come un falso positivo e continua l'attacco.
- I controlli delle rotte rimangono compatibili con le sfide di autenticazione incontrate durante il sondaggio.
`--framecheck` è disabilitato per impostazione predefinita perché aggiunge richieste RTSP e può aumentare significativamente la durata dell'attacco.
Esempio con Docker:
```bash
docker run --rm -t --net=host \
ullaakut/cameradar \
--targets 192.168.1.0/24 \
--ports "554,8554" \
--framecheck
```
Esempio con binario locale e variabile d'ambiente:
```bash
FRAMECHECK=true \
cameradar \
--targets 192.168.1.0/24 \
--ports "554,8554"
```
## Sicurezza e uso responsabile
Cameradar è uno strumento di penetration testing.
Scansiona solo reti e dispositivi di tua proprietà o per i quali hai esplicita autorizzazione al test.
Non utilizzare questo strumento per accedere a sistemi o flussi non autorizzati.
In caso di dubbio, fermati e ottieni un'autorizzazione scritta prima di eseguire la scansione.
## Output
Cameradar presenta i risultati in un'interfaccia terminale leggibile.
Registra i risultati nella console.
Il report include gli host scoperti, i modelli di dispositivi identificati e le rotte o credenziali valide.
Se specifichi un percorso per il flag `--output`, Cameradar scrive anche una playlist M3U con i flussi scoperti.
## Controllare l'accesso alla telecamera
Usa [VLC Media Player](http://www.videolan.org/vlc/) per connetterti a un flusso:
`rtsp://username:password@address:port/route`
Per endpoint RTSP sicuri, usa:
`rtsps://username:password@address:port/route`
## Formato del file di input
Il file può contenere IP, nomi host, intervalli IP e sottoreti.
Separa le voci con nuove righe.
Esempio:
```text
0.0.0.0
localhost
192.17.0.0/16
192.168.1.140-255
192.168.2-3.0-255
```
Quando usi `--skip-scan`, Cameradar espande ogni voce in indirizzi IP espliciti prima di costruire l'elenco dei target.
## Opzioni da riga di comando e variabili d'ambiente
Il riferimento completo di CLI e variabili d'ambiente è mantenuto in [Reference di Configurazione](https://github.com/Ullaakut/cameradar/wiki/Configuration-Reference).
Include tutti i flag supportati, i valori predefiniti, i valori accettati e la mappatura delle variabili d'ambiente.
## Costruire e contribuire
### Build Docker
Esegui il seguente comando nella radice del repository:
`docker build . -t cameradar`
L'immagine risultante si chiama `cameradar`.
### Build Go
1. `go install github.com/Ullaakut/cameradar/v6/cmd/cameradar@latest`
Il binario `cameradar` ora si trova in `$GOPATH/bin/cameradar`.
## Domande frequenti
Vedi [Risoluzione dei problemi e FAQ](https://github.com/Ullaakut/cameradar/wiki/Troubleshooting-%26-FAQ)
## Esempi
> Esecuzione di cameradar sulla propria macchina per scansionare le porte predefinite
`docker run --rm -t --net=host ullaakut/cameradar --targets localhost`
> Esecuzione di cameradar con un file di input, log abilitati sulla porta 8554
`docker run --rm -t --net=host -v /tmp:/tmp ullaakut/cameradar --targets /tmp/test.txt --ports 8554`
> Esecuzione di cameradar su una sottorete con dizionari personalizzati, sulle porte 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`
> Esecuzione di cameradar con scoperta masscan
`docker run --rm -t --net=host ullaakut/cameradar --scanner masscan --targets 192.168.0.0/24 --ports 554,8554`
## Licenza
Copyright 2026 Ullaakut
Con la presente viene concessa, gratuitamente, a chiunque ottenga una copia di questo software e dei file di documentazione associati (il "Software"), il permesso di utilizzare, copiare, modificare, unire, pubblicare, distribuire, concedere in licenza e/o vendere copie del Software, e di consentire alle persone a cui il Software viene fornito di fare altrettanto, alle seguenti condizioni:
L'avviso di copyright sopra riportato e questa nota di autorizzazione devono essere inclusi in tutte le copie o parti sostanziali del Software.
IL SOFTWARE VIENE FORNITO "COSÌ COM'È", SENZA GARANZIA DI ALCUN TIPO, ESPRESSA O IMPLICITA, IVI INCLUSE, MA NON SOLO, LE GARANZIE DI COMMERCIABILITÀ, IDONEITÀ PER UNO SCOPO PARTICOLARE E NON VIOLAZIONE.
IN NESSUN CASO GLI AUTORI O I TITOLARI DEL COPYRIGHT SARANNO RESPONSABILI PER QUALSIASI RECLAMO, DANNO O ALTRA RESPONSABILITÀ, DERIVANTE DA O IN CONNESSIONE CON IL SOFTWARE O L'USO O ALTRE OPERAZIONI DEL SOFTWARE.