Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
Strumenti/GitHubGitHub/ullaakut/cameradar
Sicurezza IoTAttacchi alle PasswordRaccolta InformazioniSicurezza di RetePenetration Testing
GitHubullaakut/cameradar

cameradar

Cameradar si intrufola nelle telecamere di videosorveglianza RTSP

Vedi Repository
5.2k6281255 giorni faRevisionato da Kitploit
Condividi
## 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.
Scarica lo strumento

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Il toolkit OSINT definitivo: grafo di indagine, punteggio di affidabilità, famiglie di alias, mappa, timeline e report. 49 moduli, oltre 400 siti, nessuna chiave API richiesta.

    906
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # App di esecuzione con un tocco GhostLock (CVE-2026-43499)

    725
  • 3

    looking-glass

    anonghosty/looking-glass

    Piattaforma CSIRT che importa i report di Shadowserver in MongoDB e li riproduce come mappe interattive, analisi, risultati, avvisi e dashboard executive.

    442
  • 4

    wifit3

    derv82/wifit3

    Wifite ma solo USB e multipiattaforma.

    434
  • 5

    jumpserver

    jumpserver/jumpserver

    JumpServer è una piattaforma open-source di gestione degli accessi privilegiati (PAM) che fornisce ai team DevOps e IT un accesso sicuro e on-demand a endpoint SSH, RDP, Kubernetes, database e RemoteApp tramite un browser web.

    412
  • 6

    SafeLine

    chaitin/safeline

    WAF self-hosted e reverse proxy che filtra il traffico HTTP malevolo, blocca SQL injection, XSS e attacchi bot, con limitazione del tasso e crittografia dinamica HTML/JS.

    360

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →