
Cameradar se infiltra en cámaras de videovigilancia 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>
## Herramienta de acceso a streams RTSP
Cameradar escanea endpoints RTSP en objetivos autorizados y utiliza ataques de diccionario para forzar sus credenciales y rutas.
### Lo que hace Cameradar
- Detecta hosts RTSP abiertos en objetivos accesibles.
- Detecta el modelo de dispositivo que transmite el feed RTSP.
- Intenta el descubrimiento basado en diccionarios de rutas de stream (por ejemplo, `/live.sdp`).
- Intenta el descubrimiento basado en diccionarios de credenciales de la cámara.
- Produce un informe de hallazgos.
<p align="center"><img src="https://assets.kitploit.com/production/public/readmes/2257/d2baa9ce614326ceb31bed5bab4254d88e2b007f8ae0ede3e11d520ff973ed49.png" width="250"/></p>
## Tabla de contenidos
- [Inicio rápido con Docker](#inicio-rápido-con-docker)
- [Instalar el binario](#instalar-el-binario)
- [Instalar en Android (Termux)](#instalar-en-android-termux)
- [Configuración](#configuración)
- [Seguridad y uso responsable](#seguridad-y-uso-responsable)
- [Salida](#salida)
- [Verificar acceso a la cámara](#verificar-acceso-a-la-cámara)
- [Opciones de línea de comandos y variables de entorno](#opciones-de-línea-de-comandos-y-variables-de-entorno)
- [Formato de archivo de entrada](#formato-de-archivo-de-entrada)
- [Construir y contribuir](#construir-y-contribuir)
- [Preguntas frecuentes](#preguntas-frecuentes)
- [Ejemplos](#ejemplos)
- [Licencia](#licencia)
---
<p align="center"><img src="https://assets.kitploit.com/production/public/readmes/2257/1a85244eb4f8753e5bfaaec4af131361fa29f61cd8c0204a1c53087c21e625b8.gif"/></p>
## Inicio rápido con Docker
Instale [Docker](https://docs.docker.com/engine/installation/) y ejecute:
```bash
docker run --rm -t --net=host ullaakut/cameradar --targets <target>
```
Ejemplo:
```bash
docker run --rm -t --net=host ullaakut/cameradar --targets 192.168.100.0/24
```
Esto escanea los puertos 554, 5554 y 8554 en la subred objetivo.
Intenta enumerar los streams RTSP.
Para todas las opciones, consulte [Referencia de configuración](https://github.com/Ullaakut/cameradar/wiki/Configuration-Reference).
- Los objetivos pueden ser CIDRs, IPs, rangos de IP o un nombre de host.
- Subred: `172.16.100.0/24`
- IP: `172.16.100.10`
- Host: `localhost`
- Rango: `172.16.100.10-20`
- Para usar diccionarios personalizados, móntelos y pase ambas banderas:
```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 el binario
Use esta opción si Docker no está disponible o si desea una compilación local.
### Dependencias
- Go 1.25 o posterior
### Pasos
1. `go install github.com/Ullaakut/cameradar/v6/cmd/cameradar@latest`
El binario `cameradar` ahora está en su `$GOPATH/bin`.
Para las banderas disponibles, consulte [Referencia de configuración](https://github.com/Ullaakut/cameradar/wiki/Configuration-Reference).
## Instalar en Android (Termux)
Estos pasos resumen una configuración funcional de Termux para Android.
Use Termux 117 desde F-Droid o el sitio oficial de Termux, no Google Play.
### 1) Configurar Termux y Alpine
Instale los paquetes necesarios en Termux:
```bash
pkg update
pkg install mc wget git nmap proot-distro
```
Instale Alpine e inicie sesión:
```bash
proot-distro install alpine
proot-distro login alpine
```
### 2) Instalar herramientas de compilación en Alpine
```bash
apk add wget git go gcc clang musl-dev make
```
### 3) Compilar Cameradar
Cree una ruta de módulo y clone el repositorio:
```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) Ejecutar Cameradar
Copie los diccionarios y ejecute el 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
```
Reemplace `<target>` con una IP, rango, host o subred que esté autorizado a probar.
## Configuración
Los puertos predeterminados son `554`, `5554`, `8554`, `http`, `322` y `8322`.
Si no especifica puertos, Cameradar usa esos.
Ejemplo de escaneo de puertos personalizados:
```bash
docker run --rm -t --net=host \
ullaakut/cameradar \
--ports "18554,19000-19010" \
--targets localhost
```
Puede reemplazar los diccionarios predeterminados con sus propios archivos de rutas y credenciales.
El repositorio proporciona diccionarios base en la carpeta `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 y certificados TLS
Use URLs `rtsps://` para acceder a streams RTSPS.
- Si el certificado del stream es emitido por una AC pública de confianza, no se necesita configuración adicional.
- Si el certificado del stream es autofirmado o emitido por una AC privada, el almacén de confianza del sistema operativo puede rechazarlo.
- En ese caso, apunte `SSL_CERT_FILE` al certificado de la AC (o al certificado del servidor para una configuración autofirmada) al ejecutar Cameradar.
Ejemplo con binario 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
```
Ejemplo 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
```
Si prefiere no usar `SSL_CERT_FILE`, agregue su certificado AC al almacén de confianza del sistema utilizado por su entorno de ejecución.
### Omitir descubrimiento con `--skip-scan`
Si ya conoce los endpoints RTSP, puede omitir el descubrimiento y tratar cada objetivo y puerto como un candidato a stream. Este modo no ejecuta descubrimiento y puede ser útil en redes restringidas o cuando desee atacar un inventario conocido.
Omitir el descubrimiento significa:
- Cameradar no ejecuta descubrimiento y no detecta modelos de dispositivos.
- Los objetivos se resuelven en direcciones IP. Los nombres de host se resuelven mediante DNS.
- Los bloques CIDR y los rangos IPv4 se expanden a cada dirección en el rango.
- Los rangos grandes crean muchos objetivos, así que úselos con cuidado.
Ejemplo:
```bash
docker run --rm -t --net=host \
ullaakut/cameradar \
--skip-scan \
--ports "554,8554" \
--targets 192.168.1.10
```
En este ejemplo, Cameradar intenta ataques de diccionario contra los puertos 554 y 8554 de `192.168.1.10`.
### Elegir el escáner de descubrimiento con `--scanner`
Cameradar admite dos backends de descubrimiento:
- `nmap` (predeterminado)
- `masscan`
Use `nmap` cuando desee un descubrimiento RTSP más confiable: realiza identificación de servicios y puede distinguir mejor RTSP de otros puertos abiertos.
Use `masscan` al escanear redes muy grandes: generalmente es más rápido y eficiente a escala, pero no proporciona descubrimiento de servicios.
```bash
docker run --rm -t --net=host \
ullaakut/cameradar \
--scanner masscan \
--ports "554,8554" \
--targets 192.168.1.0/24
```
> [!WARNING]
> `--scan-speed` solo se aplica al escáner `nmap`.
### Reducir falsos positivos con `--framecheck`
Algunas cámaras no siguen completamente el comportamiento RTSP y pueden devolver `200 OK` incluso cuando la ruta o las credenciales son incorrectas.
Cuando activa `--framecheck`, Cameradar valida cada `200 OK` intentando la reproducción y esperando un paquete RTP.
Framecheck significa:
- Cameradar solo acepta `200 OK` cuando puede confirmar la generación de fotogramas.
- Si no llega ningún paquete RTP, Cameradar trata el resultado como falso positivo y continúa atacando.
- Las comprobaciones de ruta siguen siendo compatibles con los desafíos de autenticación encontrados durante el sondeo.
`--framecheck` está desactivado por defecto porque agrega solicitudes RTSP y puede aumentar significativamente la duración del ataque.
Ejemplo con Docker:
```bash
docker run --rm -t --net=host \
ullaakut/cameradar \
--targets 192.168.1.0/24 \
--ports "554,8554" \
--framecheck
```
Ejemplo con binario local y variable de entorno:
```bash
FRAMECHECK=true \
cameradar \
--targets 192.168.1.0/24 \
--ports "554,8554"
```
## Seguridad y uso responsable
Cameradar es una herramienta de pruebas de penetración.
Solo escanee redes y dispositivos que posea o para los que tenga permiso explícito para probar.
No utilice esta herramienta para acceder a sistemas o streams no autorizados.
Si no está seguro, deténgase y obtenga aprobación por escrito antes de escanear.
## Salida
Cameradar presenta los resultados en una interfaz de terminal legible.
Registra los hallazgos en la consola.
El informe incluye hosts descubiertos, modelos de dispositivos identificados y rutas o credenciales válidas.
Si especifica una ruta para la bandera `--output`, Cameradar también escribe una lista de reproducción M3U con los streams descubiertos.
## Verificar acceso a la cámara
Use [VLC Media Player](http://www.videolan.org/vlc/) para conectarse a un stream:
`rtsp://username:password@address:port/route`
Para endpoints RTSP seguros, use:
`rtsps://username:password@address:port/route`
## Formato de archivo de entrada
El archivo puede contener IPs, nombres de host, rangos de IP y subredes.
Separe las entradas con saltos de línea.
Ejemplo:
```text
0.0.0.0
localhost
192.17.0.0/16
192.168.1.140-255
192.168.2-3.0-255
```
Cuando use `--skip-scan`, Cameradar expande cada entrada en direcciones IP explícitas antes de construir la lista de objetivos.
## Opciones de línea de comandos y variables de entorno
La referencia completa de CLI y variables de entorno se mantiene en [Referencia de configuración](https://github.com/Ullaakut/cameradar/wiki/Configuration-Reference).
Esto incluye todas las banderas compatibles, valores predeterminados, valores aceptados y mapeo de variables de entorno.
## Construir y contribuir
### Compilación con Docker
Ejecute el siguiente comando en la raíz del repositorio:
`docker build . -t cameradar`
La imagen resultante se llama `cameradar`.
### Compilación Go
1. `go install github.com/Ullaakut/cameradar/v6/cmd/cameradar@latest`
El binario `cameradar` ahora está en `$GOPATH/bin/cameradar`.
## Preguntas frecuentes
Consulte [Solución de problemas y preguntas frecuentes](https://github.com/Ullaakut/cameradar/wiki/Troubleshooting-%26-FAQ)
## Ejemplos
> Ejecutar cameradar en su propia máquina para escanear puertos predeterminados
`docker run --rm -t --net=host ullaakut/cameradar --targets localhost`
> Ejecutar cameradar con un archivo de entrada, registros habilitados en el puerto 8554
`docker run --rm -t --net=host -v /tmp:/tmp ullaakut/cameradar --targets /tmp/test.txt --ports 8554`
> Ejecutar cameradar en una subred con diccionarios personalizados, en los puertos 554, 5554, 8554, 322 y 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`
> Ejecutar cameradar con descubrimiento masscan
`docker run --rm -t --net=host ullaakut/cameradar --scanner masscan --targets 192.168.0.0/24 --ports 554,8554`
## Licencia
Copyright 2026 Ullaakut
Por la presente se concede permiso, libre de cargos, a cualquier persona que obtenga una copia de este software y los archivos de documentación asociados (el "Software"), para tratar el Software sin restricción, incluidos, entre otros, los derechos de usar, copiar, modificar, fusionar, publicar, distribuir, sublicenciar y/o vender copias del Software, y para permitir a las personas a las que se les proporcione el Software hacer lo mismo, sujeto a las siguientes condiciones:
El aviso de copyright anterior y este aviso de permiso se incluirán en todas las copias o partes sustanciales del Software.
EL SOFTWARE SE PROPORCIONA "TAL CUAL", SIN GARANTÍA DE NINGÚN TIPO, EXPRESA O IMPLÍCITA, INCLUYENDO PERO NO LIMITADO A GARANTÍAS DE COMERCIABILIDAD, IDONEIDAD PARA UN PROPÓSITO PARTICULAR Y NO INFRACCIÓN.
EN NINGÚN CASO LOS AUTORES O TITULARES DEL COPYRIGHT SERÁN RESPONSABLES DE NINGUNA RECLAMACIÓN, DAÑOS U OTRAS RESPONSABILIDADES, YA SEA EN UNA ACCIÓN DE CONTRATO, AGRAVIO O DE OTRA MANERA, DERIVADAS DE O EN CONEXIÓN CON EL SOFTWARE O EL USO U OTRAS OPERACIONES DEL SOFTWARE.