
Cameradar hackt sich in RTSP-Videoüberwachungskameras
## 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>
## RTSP-Stream-Zugriffstool
Cameradar scannt RTSP-Endpunkte auf autorisierten Zielen und nutzt Wörterbuchangriffe, um deren Anmeldedaten und Routen zu erraten.
### Was Cameradar tut
- Erkennt offene RTSP-Hosts auf erreichbaren Zielen.
- Erkennt das Gerätemodell, das den RTSP-Stream liefert.
- Führt wörterbuchbasierte Ermittlung von Stream-Routen durch (z. B. `/live.sdp`).
- Führt wörterbuchbasierte Ermittlung von Kamera-Anmeldedaten durch.
- Erstellt einen Ergebnisbericht.
<p align="center"><img src="https://assets.kitploit.com/production/public/readmes/2257/d2baa9ce614326ceb31bed5bab4254d88e2b007f8ae0ede3e11d520ff973ed49.png" width="250"/></p>
## Inhaltsverzeichnis
- [Schnellstart mit Docker](#schnellstart-mit-docker)
- [Binärdatei installieren](#binärdatei-installieren)
- [Installation auf Android (Termux)](#installation-auf-android-termux)
- [Konfiguration](#konfiguration)
- [Sicherheit und verantwortungsvolle Nutzung](#sicherheit-und-verantwortungsvolle-nutzung)
- [Ausgabe](#ausgabe)
- [Kamerazugriff prüfen](#kamerazugriff-prüfen)
- [Befehlszeilenoptionen und Umgebungsvariablen](#befehlszeilenoptionen-und-umgebungsvariablen)
- [Eingabedateiformat](#eingabedateiformat)
- [Erstellen und Beitragen](#erstellen-und-beitragen)
- [Häufig gestellte Fragen](#häufig-gestellte-fragen)
- [Beispiele](#beispiele)
- [Lizenz](#lizenz)
---
<p align="center"><img src="https://assets.kitploit.com/production/public/readmes/2257/1a85244eb4f8753e5bfaaec4af131361fa29f61cd8c0204a1c53087c21e625b8.gif"/></p>
## Schnellstart mit Docker
Installieren Sie [Docker](https://docs.docker.com/engine/installation/) und führen Sie aus:
```bash
docker run --rm -t --net=host ullaakut/cameradar --targets <target>
```
Beispiel:
```bash
docker run --rm -t --net=host ullaakut/cameradar --targets 192.168.100.0/24
```
Dies scannt die Ports 554, 5554 und 8554 im Zielsubnetz.
Es versucht, RTSP-Streams zu ermitteln.
Für alle Optionen siehe [Konfigurationsreferenz](https://github.com/Ullaakut/cameradar/wiki/Configuration-Reference).
- Ziele können CIDRs, IPs, IP-Bereiche oder ein Hostname sein.
- Subnetz: `172.16.100.0/24`
- IP: `172.16.100.10`
- Host: `localhost`
- Bereich: `172.16.100.10-20`
- Um benutzerdefinierte Wörterbücher zu verwenden, mounten Sie diese und übergeben Sie beide 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
```
## Binärdatei installieren
Nutzen Sie diese Option, wenn Docker nicht verfügbar ist oder Sie eine lokale Kompilierung wünschen.
### Abhängigkeiten
- Go 1.25 oder neuer
### Schritte
1. `go install github.com/Ullaakut/cameradar/v6/cmd/cameradar@latest`
Die `cameradar`-Binärdatei befindet sich nun in Ihrem `$GOPATH/bin`.
Für verfügbare Flags siehe [Konfigurationsreferenz](https://github.com/Ullaakut/cameradar/wiki/Configuration-Reference).
## Installation auf Android (Termux)
Diese Schritte fassen eine funktionierende Termux-Einrichtung für Android zusammen.
Verwenden Sie Termux 117 von F-Droid oder der offiziellen Termux-Website, nicht aus dem Google Play Store.
### 1) Termux und Alpine einrichten
Installieren Sie die erforderlichen Pakete in Termux:
```bash
pkg update
pkg install mc wget git nmap proot-distro
```
Installieren Sie Alpine und melden Sie sich an:
```bash
proot-distro install alpine
proot-distro login alpine
```
### 2) Build-Tools in Alpine installieren
```bash
apk add wget git go gcc clang musl-dev make
```
### 3) Cameradar erstellen
Erstellen Sie einen Modulpfad und klonen Sie das 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) Cameradar ausführen
Kopieren Sie die Wörterbücher und führen Sie die Binärdatei aus:
```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
```
Ersetzen Sie `<target>` durch eine IP, einen Bereich, einen Host oder ein Subnetz, das Sie testen dürfen.
## Konfiguration
Die Standard-Ports sind `554`, `5554`, `8554`, `http`, `322` und `8322`.
Wenn Sie keine Ports angeben, verwendet Cameradar diese.
Beispiel für das Scannen benutzerdefinierter Ports:
```bash
docker run --rm -t --net=host \
ullaakut/cameradar \
--ports "18554,19000-19010" \
--targets localhost
```
Sie können die Standard-Wörterbücher durch Ihre eigenen Routen- und Anmeldedatendateien ersetzen.
Das Repository enthält Basis-Wörterbücher im Ordner `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 und TLS-Zertifikate
Verwenden Sie `rtsps://`-URLs, um auf RTSPS-Streams zuzugreifen.
- Wenn das Stream-Zertifikat von einer vertrauenswürdigen öffentlichen CA ausgestellt wurde, ist keine zusätzliche Einrichtung erforderlich.
- Wenn das Stream-Zertifikat selbstsigniert oder von einer privaten CA ausgestellt ist, könnte der Betriebssystem-Trust-Store es ablehnen.
- Setzen Sie in diesem Fall `SSL_CERT_FILE` auf das CA-Zertifikat (oder Serverzertifikat für eine selbstsignierte Einrichtung), wenn Sie Cameradar ausführen.
Beispiel mit lokaler Binärdatei:
```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
```
Beispiel mit 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
```
Wenn Sie `SSL_CERT_FILE` nicht verwenden möchten, fügen Sie Ihr CA-Zertifikat dem System-Trust-Store hinzu, den Ihre Laufzeitumgebung verwendet.
### Überspringen der Erkennung mit `--skip-scan`
Wenn Sie die RTSP-Endpunkte bereits kennen, können Sie die Erkennung überspringen und jedes Ziel und jeden Port als Stream-Kandidaten behandeln. Dieser Modus führt keine Erkennung durch und kann in eingeschränkten Netzwerken nützlich sein oder wenn Sie einen bekannten Bestand angreifen möchten.
Das Überspringen der Erkennung bedeutet:
- Cameradar führt keine Erkennung durch und erkennt keine Gerätemodelle.
- Ziele werden in IP-Adressen aufgelöst. Hostnamen werden per DNS aufgelöst.
- CIDR-Blöcke und IPv4-Bereiche werden auf jede Adresse im Bereich erweitert.
- Große Bereiche erzeugen viele Ziele, verwenden Sie sie daher mit Vorsicht.
Beispiel:
```bash
docker run --rm -t --net=host \
ullaakut/cameradar \
--skip-scan \
--ports "554,8554" \
--targets 192.168.1.10
```
In diesem Beispiel führt Cameradar Wörterbuchangriffe gegen die Ports 554 und 8554 von `192.168.1.10` durch.
### Auswahl des Erkennungsscanners mit `--scanner`
Cameradar unterstützt zwei Erkennungs-Backends:
- `nmap` (Standard)
- `masscan`
Verwenden Sie `nmap`, wenn Sie eine zuverlässigere RTSP-Erkennung wünschen: Es führt eine Service-Identifikation durch und kann RTSP besser von anderen offenen Ports unterscheiden.
Verwenden Sie `masscan` beim Scannen sehr großer Netzwerke: Es ist in der Regel schneller und effizienter im großen Maßstab, bietet aber keine Service-Erkennung.
```bash
docker run --rm -t --net=host \
ullaakut/cameradar \
--scanner masscan \
--ports "554,8554" \
--targets 192.168.1.0/24
```
> [!WARNING]
> `--scan-speed` gilt nur für den `nmap`-Scanner.
### Reduzierung von Fehlalarmen mit `--framecheck`
Einige Kameras befolgen das RTSP-Verhalten nicht vollständig und können selbst dann `200 OK` zurückgeben, wenn die Route oder die Anmeldedaten falsch sind.
Wenn Sie `--framecheck` aktivieren, validiert Cameradar jedes `200 OK`, indem es eine Wiedergabe versucht und auf ein RTP-Paket wartet.
Framecheck bedeutet:
- Cameradar akzeptiert `200 OK` nur, wenn es die Erzeugung von Frames bestätigen kann.
- Wenn kein RTP-Paket eintrifft, behandelt Cameradar das Ergebnis als Fehlalarm und setzt den Angriff fort.
- Routenprüfungen bleiben mit Authentifizierungsherausforderungen kompatibel, die während der Sondierung auftreten.
`--framecheck` ist standardmäßig deaktiviert, da es RTSP-Anfragen hinzufügt und die Angriffsdauer erheblich verlängern kann.
Beispiel mit Docker:
```bash
docker run --rm -t --net=host \
ullaakut/cameradar \
--targets 192.168.1.0/24 \
--ports "554,8554" \
--framecheck
```
Beispiel mit lokaler Binärdatei und Umgebungsvariable:
```bash
FRAMECHECK=true \
cameradar \
--targets 192.168.1.0/24 \
--ports "554,8554"
```
## Sicherheit und verantwortungsvolle Nutzung
Cameradar ist ein Penetrationstest-Tool.
Scannen Sie nur Netzwerke und Geräte, die Ihnen gehören oder für die Sie ausdrücklich die Erlaubnis zum Testen haben.
Verwenden Sie dieses Tool nicht, um auf nicht autorisierte Systeme oder Streams zuzugreifen.
Wenn Sie unsicher sind, halten Sie an und holen Sie schriftliche Genehmigung ein, bevor Sie scannen.
## Ausgabe
Cameradar präsentiert die Ergebnisse in einer lesbaren Terminal-Benutzeroberfläche.
Es protokolliert die Ergebnisse auf der Konsole.
Der Bericht enthält gefundene Hosts, identifizierte Gerätemodelle sowie gültige Routen oder Anmeldedaten.
Wenn Sie einen Pfad für das `--output`-Flag angeben, schreibt Cameradar zusätzlich eine M3U-Playlist mit den gefundenen Streams.
## Kamerazugriff prüfen
Verwenden Sie [VLC Media Player](http://www.videolan.org/vlc/), um eine Verbindung zu einem Stream herzustellen:
`rtsp://username:password@address:port/route`
Für sichere RTSP-Endpunkte verwenden Sie:
`rtsps://username:password@address:port/route`
## Eingabedateiformat
Die Datei kann IPs, Hostnamen, IP-Bereiche und Subnetze enthalten.
Trennen Sie Einträge mit Zeilenumbrüchen.
Beispiel:
```text
0.0.0.0
localhost
192.17.0.0/16
192.168.1.140-255
192.168.2-3.0-255
```
Wenn Sie `--skip-scan` verwenden, erweitert Cameradar jeden Eintrag in explizite IP-Adressen, bevor die Zielliste erstellt wird.
## Befehlszeilenoptionen und Umgebungsvariablen
Die vollständige Referenz der CLI- und Umgebungsvariablen wird in der [Konfigurationsreferenz](https://github.com/Ullaakut/cameradar/wiki/Configuration-Reference) verwaltet.
Dies umfasst alle unterstützten Flags, Standardwerte, akzeptierte Werte und die Zuordnung von Umgebungsvariablen.
## Erstellen und Beitragen
### Docker-Build
Führen Sie den folgenden Befehl im Repository-Stammverzeichnis aus:
`docker build . -t cameradar`
Das resultierende Image heißt `cameradar`.
### Go-Build
1. `go install github.com/Ullaakut/cameradar/v6/cmd/cameradar@latest`
Die `cameradar`-Binärdatei befindet sich nun in `$GOPATH/bin/cameradar`.
## Häufig gestellte Fragen
Siehe [Fehlerbehebung & FAQ](https://github.com/Ullaakut/cameradar/wiki/Troubleshooting-%26-FAQ)
## Beispiele
> Ausführen von cameradar auf Ihrem eigenen Rechner, um nach Standard-Ports zu scannen
`docker run --rm -t --net=host ullaakut/cameradar --targets localhost`
> Ausführen von cameradar mit einer Eingabedatei, Logs aktiviert, auf Port 8554
`docker run --rm -t --net=host -v /tmp:/tmp ullaakut/cameradar --targets /tmp/test.txt --ports 8554`
> Ausführen von cameradar in einem Subnetz mit benutzerdefinierten Wörterbüchern, auf den Ports 554, 5554, 8554, 322 und 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`
> Ausführen von cameradar mit masscan-Erkennung
`docker run --rm -t --net=host ullaakut/cameradar --scanner masscan --targets 192.168.0.0/24 --ports 554,8554`
## Lizenz
Copyright 2026 Ullaakut
Hiermit wird jeder Person, die eine Kopie dieser Software und der zugehörigen Dokumentationsdateien (die "Software") erhält, kostenlos die Erlaubnis erteilt, die Software ohne Einschränkung zu nutzen, einschließlich und ohne Einschränkung der Rechte zur Nutzung, Vervielfältigung, Änderung, Zusammenführung, Veröffentlichung, Verteilung, Unterlizenzierung und/oder zum Verkauf von Kopien der Software, und Personen, denen die Software zur Verfügung gestellt wird, diese Rechte unter den folgenden Bedingungen zu gewähren:
Der obige Urheberrechtshinweis und dieser Genehmigungshinweis müssen in allen Kopien oder wesentlichen Teilen der Software enthalten sein.
DIE SOFTWARE WIRD OHNE MÄNGELGEWÄHR UND OHNE JEGLICHE AUSDRÜCKLICHE ODER STILLSCHWEIGENDE GEWÄHRLEISTUNG BEREITGESTELLT, EINSCHLIESSLICH, ABER NICHT BESCHRÄNKT AUF DIE GEWÄHRLEISTUNG DER MARKTGÄNGIGKEIT, DER EIGNUNG FÜR EINEN BESTIMMTEN ZWECK UND DER NICHTVERLETZUNG VON RECHTEN DRITTER. IN KEINEM FALL SIND DIE AUTOREN ODER URHEBERRECHTSINHABER HAFTBAR FÜR ANSPRÜCHE, SCHÄDEN ODER ANDERE VERPFLICHTUNGEN, OB AUS VERTRAG, UNERLAUBTER HANDLUNG ODER ANDERWEITIG, DIE AUS ODER IN VERBINDUNG MIT DER SOFTWARE ODER DER NUTZUNG ODER ANDEREN GESCHÄFTEN MIT DER SOFTWARE ENTSTEHEN.