Skip to content
KitploitKITPLOIT
HerramientasExploitsBlog
Log in
Enviar
HerramientasExploitsBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

FeedsContactoPrivacidad© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
DakshSCRA — Herramienta de análisis estático de código sensible al framework para la revisión automatizada del código fuente con reglas específicas de plataforma, análisis de contaminación, estimación de esfuerzo y líneas de base de supresión. | Kitploit
Herramientas/GitHubGitHub/coffeeandsecurity/dakshscra
Análisis EstáticoEscáneres de VulnerabilidadesAnálisis Estático de Código (SAST)Análisis de VulnerabilidadesAnálisis de CódigoSeguridad WebPruebas de PenetraciónDevSecOpsSeguridad Móvil
Aprendizaje y Educación
GitHubcoffeeandsecurity/dakshscra

DakshSCRA

Herramienta de análisis estático de código sensible al framework para la revisión automatizada del código fuente con reglas específicas de plataforma, análisis de contaminación, estimación de esfuerzo y líneas de base de supresión.

Ver Repositorio
457150hace 15 díasRevisado por Kitploit
Compartir
# Daksh SCRA (Asistente de Revisión de Código Fuente)

```
Author:
- Debasis Mohanty ([email protected])
- Twitter / X: @coffeensecurity
- www.coffeeandsecurity.com
```

## Acerca de Daksh SCRA

Daksh SCRA (Source Code Review Assist) está diseñado para mejorar la eficiencia del proceso de revisión de código fuente, proporcionando un enfoque bien estructurado y organizado para los revisores de código.

En lugar de señalar indiscriminadamente todo como un posible problema, Daksh SCRA promueve un análisis reflexivo, instando a la investigación y confirmación de los posibles problemas. Este enfoque mitiga la carrera por etiquetar cada posible preocupación como un error, reduciendo la confusión y el tiempo perdido en falsos positivos.

### Debut

Daksh SCRA se presentó inicialmente durante una sesión de formación en revisión de código fuente en Black Hat USA 2022 (6-9 de agosto), donde se presentó de forma discreta ante una audiencia específica. Su debut público oficial tuvo lugar en Black Hat USA 2023 en Las Vegas.

## Características y funcionalidades

DakshSCRA reúne capacidades distintivas para la revisión manual de código fuente, desde áreas de interés en rutas de archivos y estimación del esfuerzo hasta reconocimiento de software, reglas contextuales y análisis entre archivos.

| Característica | Etiqueta | Por qué es importante |
|---|---|---|
| **Áreas de interés en rutas de archivos** | Primero en el mundo* | Analiza los nombres de archivos y directorios en sí mismos, junto con el código, para señalar rutas sospechosas como archivos de respaldo, endpoints de depuración, volcados de configuración y archivos de credenciales que los revisores suelen pasar por alto. |
| **Estimación científica del esfuerzo** | Primero en el mundo* | Produce una estimación cuantificada del esfuerzo de revisión manual basada en el tamaño del código base y las señales del proyecto. Los supuestos configurables hacen que la planificación del trabajo sea explícita y repetible. |
| **Reconocimiento de software** | Segundo en el mundo* | Detecta lenguajes, frameworks e infraestructura a partir del contenido de los archivos y la estructura del proyecto antes del escaneo. Conecta el inventario tecnológico con la selección automática de reglas, el análisis semántico y la planificación de la revisión. |
| **Análisis semántico avanzado y entre archivos** | El más avanzado de código abierto en su lanzamiento* | Rastrea datos controlados por el usuario desde el origen hasta el destino a través de los límites de archivos compatibles mediante un análisis específicamente diseñado. Advanced Analysis se lanzó junto con el RDL original en marzo de 2026; RDL v2 amplía la evaluación de reglas semánticas entre archivos. |

* Basado en búsquedas generales en el momento en que se introdujo cada característica. No se encontró ninguna característica similar en herramientas de código abierto para la revisión de seguridad de código. Para la estimación del esfuerzo, tampoco se encontró un enfoque similar en herramientas comerciales. Recon quedó en segundo lugar después de Microsoft Application Inspector. El análisis entre archivos fue el más avanzado entre las herramientas de código abierto para la revisión de código en el momento de su lanzamiento.

### Historial de características y evidencia

| Característica / hito | Fecha | Versión | Evidencia / alcance |
|---|---|---|---|
| Beta inicial y reglas de rutas de archivos | 22 de octubre de 2022 | v0.1-beta | [Versión inicial; el código fuente conservado incluye el inventario dedicado de reglas de rutas de archivos.](https://github.com/coffeeandsecurity/DakshSCRA/releases/tag/v0.1-beta) |
| Reconocimiento de software (introducción publicada) | 9 de julio de 2023 | v0.3-beta | [Las notas de la versión introducen recon; el código anterior del repositorio constituye evidencia de implementación separada.](https://github.com/coffeeandsecurity/DakshSCRA/releases/tag/v0.3-beta) |
| Estimación del esfuerzo de revisión manual (implementación) | 29 de julio de 2023 | Commit de implementación | [Se añadió un módulo de estimación dedicado; no es la fecha de la versión de corrección posterior.](https://github.com/coffeeandsecurity/DakshSCRA/commit/65d5c6a) |
| RDL original y Advanced Analysis entre archivos | 2 de marzo de 2026 | v0.31-beta | [La lógica condicional de reglas y el análisis independiente entre archivos se lanzaron juntos. La fecha mostrada de la versión es el 2 de marzo; la marca de tiempo de publicación es el 1 de marzo de 2026 a las 18:39 UTC.](https://github.com/coffeeandsecurity/DakshSCRA/commit/d90ba51) |

### Evidencia comparativa

- **Predecesor de recon:** [Microsoft Application Inspector](https://www.microsoft.com/en-us/security/blog/2020/01/16/introducing-microsoft-application-inspector/) (16 de enero de 2020) documenta una herramienta anterior de características del código fuente. El recon de Daksh SCRA se sitúa en segundo lugar después de ella.

Las fechas identifican hitos del repositorio o de las versiones.

DakshSCRA se presentó durante la formación de **Black Hat USA 2022** y debutó públicamente en **Black Hat USA 2023**. Esas fechas describen la presentación del proyecto, no todas las funcionalidades actuales.

> Las mejoras activas están en curso. Hay múltiples funcionalidades nuevas y mejoras planificadas para próximas versiones.

Siéntete libre de contribuir a la actualización o adición de nuevas reglas y al desarrollo futuro.

Si encuentras algún error, repórtalo a [[email protected]](mailto:[email protected]).

Documentación detallada: [https://dakshlabs.com/#docs](https://dakshlabs.com/#docs)

---

## Primeros pasos

Hay dos formas de ejecutar Daksh SCRA: elige la que mejor se adapte a tu flujo de trabajo:

| | Ideal para | Ir a |
|---|---|---|
| 🌐 **Interfaz web (Docker)** | La forma más sencilla de empezar: un solo comando, un panel en el navegador, progreso del escaneo en vivo y un navegador de informes/artefactos. Recomendado para la mayoría de los usuarios. | [Interfaz web (Docker)](#web-ui-docker) |
| 💻 **CLI (Python)** | Scripting, pipelines de CI o ejecutar escaneos sin Docker. | [Configuración de la CLI](#cli-setup) |

Ambas rutas ejecutan exactamente el mismo motor de escaneo: la interfaz web es un front end de navegador sobre la misma CLI, por lo que los resultados son idénticos en ambos casos.

---

## Interfaz web (Docker)

La forma más rápida de ejecutar Daksh SCRA es a través de su interfaz web basada en navegador, lanzada con el asistente de inicio de Docker con reconocimiento del host. Proporciona un lanzador de escaneos, una consola en vivo y un historial navegable de informes anteriores. El asistente de inicio requiere Python 3 (solo biblioteca estándar); la aplicación y sus dependencias se ejecutan en Docker.

La configuración de Docker ejecuta la interfaz web y la CLI como servicios independientes construidos a partir de la misma imagen, por lo que puedes usar cualquiera de ellos (o ambos) desde el mismo contenedor.

### Lanzar la interfaz web

Después de descargar Daksh SCRA desde GitHub, **extrae primero el archivo ZIP**.
Abre una terminal (PowerShell o Símbolo del sistema en Windows) dentro de la carpeta
del proyecto extraída que contiene `docker-compose.yml` y `dakshscra.py`.
**Ejecuta todos los comandos de inicio y de Docker Compose que aparecen a continuación desde esa carpeta.**

Si tu terminal se abre en otro directorio, primero cambia a la carpeta extraída:

```text
cd "path/to/extracted/DakshSCRA-folder"
```

Reemplace la ruta de ejemplo con su ubicación de descarga y nombre de carpeta reales.
Si en su lugar clonó el repositorio, ejecute `cd DakshSCRA` desde su carpeta principal.

El asistente de inicio reconoce Windows, WSL, Linux y macOS, luego monta la
raíz del host, las unidades de Windows disponibles y las carpetas comunes en modo de solo lectura antes de
iniciar los contenedores. Ejecútelo en el equipo que ejecuta Docker.

Linux, macOS o WSL (primer plano):

```bash
python3 tools/start_webui.py
```

Windows PowerShell o Símbolo del sistema (primer plano):

```powershell
py tools/start_webui.py
```

Para ejecutar en modo independiente (en segundo plano), añade `--detach`. Los contenedores siguen ejecutándose
después de que el comando de inicio retorne, dejando tu terminal disponible.

Linux, macOS o WSL (independiente):

```bash
python3 tools/start_webui.py --detach
```

Windows PowerShell o Símbolo del sistema (independiente):

```powershell
py tools/start_webui.py --detach
```

Use `--dry-run` para inspeccionar las rutas detectadas sin iniciar los contenedores.
Se respetan las sobrescrituras de rutas existentes en `.env`. Las cuentas, los escaneos y el
volumen de tiempo de ejecución se conservan cuando se recrean los contenedores.

Docker Desktop puede requerir permiso para compartir las rutas de host seleccionadas. Si
rechaza un montaje, permita esa ubicación en Docker Desktop y vuelva a ejecutar el asistente.
Un navegador remoto ve las carpetas del **host de Docker**, no las unidades de su propio equipo.
La detección automática requiere un motor de Docker local; ejecute el asistente en el host del
motor cuando utilice un contexto de Docker remoto.

Para montajes configurados manualmente, `docker compose up --build -d api web` sigue
disponible. Su configuración base monta el repositorio en `/scan-targets` y
`${DAKSH_HOST_MOUNT:-/}` en `/host/root`. Utilice el asistente para el descubrimiento de unidades de Windows
y los accesos directos a carpetas comunes; Compose simple no puede detectar el SO del cliente.

Luego abra [http://localhost:3030](http://localhost:3030).

Para usar un puerto diferente:

```bash
DAKSH_PORT=9090 python3 tools/start_webui.py
```

Detén el stack con:

```bash
docker compose down
```

### Liberar espacio en disco tras compilaciones repetidas de Docker

Utiliza los ayudantes de limpieza separados de la carpeta del repositorio. Por defecto, solo muestran una vista previa:

**Esto elimina los contenedores, imágenes de servicio, redes y volúmenes de Daksh, incluidos las cuentas guardadas, el historial de escaneos y los artefactos almacenados en el volumen de tiempo de ejecución. Haz una copia de seguridad de todo lo que quieras conservar primero.**

```bash
python3 tools/clean_project_docker.py
python3 tools/purge_all_docker.py
```

Añade `--execute` para eliminar, luego escribe la confirmación solicitada. El primer helper
elimina los contenedores, redes, imágenes de servicio y volúmenes de este proyecto, preservando
la caché de compilación compartida. El segundo elimina forzosamente los contenedores de **todos los proyectos en
el motor Docker seleccionado** y purga imágenes, redes, volúmenes con nombre/anónimos
y la caché del constructor predeterminado. Puede afectar a un motor remoto. Ninguno elimina
archivos del host montados con bind ni desinstala Docker. Los usuarios de Windows pueden reemplazar `python3`
con `py`. Consulta [alcance y comandos de limpieza](https://github.com/coffeeandsecurity/dakshscra/blob/main/docs/usage-guide.md#docker-cleanup-and-full-purge)
para nombres de proyecto personalizados, exclusiones y detalles de eliminación.

Comprueba el uso de disco restante de Docker con:

```bash
docker system df
```

Para liberar únicamente la caché de compilación no utilizada mientras se conservan los datos guardados de Daksh, ejecute simplemente `docker builder prune --all --force`. Los archivos en las carpetas del host montadas con bind, incluidos el repositorio y los objetivos de escaneo, permanecen en el disco. Vuelva a iniciar con `python3 tools/start_webui.py --detach` cuando esté listo.

### Iniciar sesión

La interfaz web requiere una cuenta.

**Primer inicio de sesión**

1. Inicie el portal (`python3 tools/start_webui.py --detach`) y abra [http://localhost:3030](http://localhost:3030).
2. La página de inicio de sesión detecta la configuración inicial. Rellena previamente el nombre de usuario `admin` y la contraseña inicial, y muestra un aviso de configuración inicial.

   | Ajuste | Valor |
   |---|---|
   | Nombre de usuario | `admin` (o `DAKSH_ADMIN_USERNAME` de `.env`) |
   | Contraseña inicial | `Daksh@ChangeMe1` (o `DAKSH_ADMIN_PASSWORD` de `.env`) |

3. Haga clic en **Sign in**. Aparece un paso de **cambio de contraseña** a pantalla completa que no se puede omitir. Introduzca la contraseña inicial como contraseña actual, elija una nueva contraseña (al menos 8 caracteres, distinta de la actual) y, opcionalmente, cambie el nombre de usuario.
4. Tras guardar, se le lleva al panel de control. A partir de entonces, la página de inicio de sesión ya no rellena nada previamente; inicie sesión con sus propias credenciales.

La contraseña inicial solo se utiliza mientras la base de datos no tiene cuentas, y deja de funcionar en cuanto se cambia. Hasta entonces, cualquiera que pueda acceder al portal puede iniciar sesión con ella, así que establezca `DAKSH_ADMIN_PASSWORD` en `.env` antes del primer inicio si el portal es accesible por otras personas. Una cuenta de administrador puede crear más cuentas mediante el endpoint de la API `POST /api/v1/auth/users` (todavía no hay una interfaz dedicada para esto). Las cuentas nuevas y restablecidas también tienen que cambiar su contraseña asignada en el primer inicio de sesión. Consulte `.env.example` para ver la lista completa de ajustes relacionados con la autenticación (duración de la sesión, seguridad de las cookies, CORS).

### Lo que obtienes

- Generador de comandos adaptable para los modos scan, recon, estimate, recon+estimate, list y PDF-from-JSON
- Consola en tiempo real y progreso en vivo por etapa durante la ejecución
- Instantáneas de artefactos por trabajo para las salidas HTML / PDF / JSON
- Guía en modo Developer Mode, Code Review Mode o Both para resultados e informes; Both es el predeterminado
- Navegación rápida en el navegador entre el formulario de ejecución, el feed en vivo, los artefactos y los trabajos recientes
- Explorador de directorios integrado para seleccionar rutas de destino (compatible con el sistema operativo: Windows, macOS, Linux / Docker)

En esencia, la CLI sigue siendo la fuente de verdad: realiza todo el escaneo y genera cada salida HTML / PDF / JSON. La interfaz web ejecuta un trabajo activo a la vez y guarda instantáneas de las salidas de cada trabajo completado en `runtime/webui/jobs/<job-id>/artifacts/` para que los informes anteriores sigan siendo accesibles.

### Ejecutar la CLI en Docker

Tampoco necesita un entorno local de Python para usar la CLI: está disponible como su propio servicio de Compose, construido a partir de la misma imagen:

```bash
docker compose run --rm cli -h
docker compose run --rm cli -r auto -t /scan-targets/path/to/source
```

### Qué contiene la imagen

- Backend FastAPI + frontend de interfaz web
- La CLI completa de Daksh SCRA, como servicio independiente
- Playwright Chromium, para la generación de PDF
- Volúmenes persistentes `reports/` y `runtime/`
- Montajes de rutas del host para que los escaneos puedan acceder a los árboles de código fuente desde dentro del contenedor

**Puntos de montaje clave:**

| Montaje | Ruta dentro del contenedor |
|---|---|
| Código fuente del proyecto | `/app` |
| Raíz de escaneo predeterminada (repositorio, o `DAKSH_SCAN_ROOT`) | `/scan-targets` |
| Sistema de archivos del host (unidad del sistema en Windows) | `/host/root` |
| Unidades adicionales de Windows/WSL | `/host/drives/<letter>` |
| Directorio home del usuario actual | `/host/user` |
| Carpetas comunes del host | `/host/locations/<name>` |
| `DAKSH_HOST_SOURCE` opcional | `/host/source` |

Copie `.env.example` a `.env` para las anulaciones opcionales de rutas y autenticación.
`DAKSH_BROWSE_ROOTS` es una lista de permitidos separada por comas de rutas del **contenedor**;
déjela sin definir para descubrir las ubicaciones montadas. Las listas de permitidos obsoletas `/host/c`, `/host/d`
o `/mnt` deben eliminarse o actualizarse al cambiar al helper.
Las carpetas del host son de solo lectura; los informes y los datos de tiempo de ejecución permanecen escribibles en sus
ubicaciones existentes de la aplicación. Reinicie usando el helper después de conectar otra
unidad. No se necesita el socket de Docker ni un contenedor privilegiado.

---

## Configuración de la CLI

¿Prefiere ejecutar Daksh SCRA directamente con Python? Así es como se configura localmente.

### Requisitos previos

- Python 3.8+
- Todas las bibliotecas listadas en `requirements.txt`

### 1. Descargar Daksh SCRA

```bash
git clone https://github.com/coffeeandsecurity/DakshSCRA.git
```

O descargue el último zip desde [https://github.com/coffeeandsecurity/DakshSCRA](https://github.com/coffeeandsecurity/DakshSCRA) y descomprímalo.

### 2. Configurar un entorno virtual

> 💡 El entorno virtual se puede crear en cualquier directorio; no es necesario que esté dentro de la carpeta DakshSCRA.

**Opción A: Configuración en un solo paso (recomendada)**

```bash
python setup_env.py
```

Este script crea el entorno virtual, instala todas las dependencias e instala el navegador Chromium de Playwright (necesario para la exportación a PDF).

**Opción B: Configuración manual**

Windows:
```bash
python -m venv daksh-env
.\daksh-env\Scripts\activate
```

macOS / Linux:
```bash
python3 -m venv daksh-env
source daksh-env/bin/activate
```

Luego instala las dependencias:
```bash
cd path/to/DakshSCRA
pip install -r requirements.txt
playwright install chromium
```

## Uso de la CLI

Use `python` dentro de un entorno virtual, o `python3` fuera de uno.

### Opciones de línea de comandos

```
usage: dakshscra.py [-h] [-r RULES] [-f FILE_TYPES] [-v] [-t TARGET_DIR]
                    [-l {R,RF}] [--recon] [--rs] [--estimate]
                    [-rpt FORMATS] [--pdf-from-json]
                    [--json-input-dir PATH] [--pdf-output PATH]
                    [--pdf-multi-dir PATH] [--pdf-single-only]
                    [--skip-analysis] [--loc]
                    [--baseline-file PATH] [--baseline-generate] [--no-baseline]
                    [--review-config PATH]
                    [--resume-scan] [--state-file PATH] [--no-state] [--state]
```

| Opción | Descripción |
|---|---|
| `-r RULES` | Reglas de plataforma (p. ej. `php`, `java`, `php,java`) o `auto` para detección automática |
| `-f FILE_TYPES` | Sobrescribir los tipos de archivo predeterminados para el escaneo |
| `-v` | Nivel de verbosidad (`-v`, `-vv`, `-vvv`) |
| `-t TARGET_DIR` | Directorio del código fuente objetivo |
| `-l {R,RF}` | Listar reglas de plataforma + frameworks `[R]` o incluir tipos de archivo `[RF]` |
| `--recon` | Ejecutar reconocimiento (detección de plataforma / framework / lenguaje) |
| `--rs`, `--recon-strict` | Reconocimiento estricto: solo detecciones de alta confianza (usar con `--recon`) |
| `--estimate` | Estimar el esfuerzo de revisión de código según el tamaño del código base |
| `-rpt`, `--report FORMATS` | Formatos de informe: `html`, `pdf`, `docx`, `json`, o una combinación separada por comas (predeterminado: `html`) |
| `--pdf-from-json` | Generar informe(s) PDF a partir de salidas JSON existentes sin volver a escanear |
| `--json-input-dir PATH` | Directorio de informes JSON (predeterminado: `./reports/data`) |
| `--pdf-output PATH` | Ruta de salida de un único PDF (predeterminado: `./reports/scan/pdf/report.pdf`) |
| `--pdf-multi-dir PATH` | Directorio de salida de PDF de múltiples archivos (predeterminado: `./reports/scan/pdf/multi-file`) |
| `--pdf-single-only` | Generar solo el PDF combinado de un único archivo; omitir el conjunto multifile por plataforma |
| `--skip-analysis` | Deshabilitar la etapa del analizador para esta ejecución |
| `--loc` | Contar líneas de código efectivas |
| `--baseline-file PATH` | Archivo de línea base de supresión (JSON) |
| `--baseline-generate` | Generar línea base de supresión a partir de los hallazgos actuales |
| `--no-baseline` | Deshabilitar la supresión por línea base para esta ejecución |
| `--review-config PATH` | Archivo de triaje de hallazgos (JSON); suprimir de los informes los falsos positivos revisados previamente |
| `--resume-scan` | Reanudar un escaneo interrumpido previamente desde el archivo de estado |
| `--state-file PATH` | Ruta personalizada del archivo de estado / punto de control del escaneo |
| `--no-state` | Deshabilitar el guardado de puntos de control del estado del escaneo para esta ejecución |
| `--state` | Forzar la habilitación del guardado de puntos de control del estado del escaneo para esta ejecución |

### Ejemplo de uso

> `-f` (tipos de archivo) es opcional. Si no se especifica, DakshSCRA utiliza los tipos de archivo predeterminados para la(s) plataforma(s) seleccionada(s).

```bash
# Single platform scan
python dakshscra.py -r php -t /path/to/source

# Multiple platforms
python dakshscra.py -r php,java,cpp -t /path/to/source

# Auto-detect platform and apply matching rules
python dakshscra.py -r auto -t /path/to/source

# Override filetypes
python dakshscra.py -r php -f dotnet -t /path/to/source

# Reconnaissance only (no scanning)
python dakshscra.py --recon -t /path/to/source

# Reconnaissance + scanning
python dakshscra.py --recon -r php -t /path/to/source

# Strict recon (high-confidence detections only)
python dakshscra.py --recon --rs -t /path/to/source

# Effort estimation
python dakshscra.py --estimate -t /path/to/source

# Scan with HTML + PDF report output
python dakshscra.py -r auto -t /path/to/source -rpt html,pdf

# Verbosity levels
python dakshscra.py -r php -v -t /path/to/source     # default
python dakshscra.py -r php -vvv -t /path/to/source   # show all pattern checks

# Generate suppression baseline from current findings
python dakshscra.py -r auto -t /path/to/source --baseline-generate

# Apply suppression baseline (suppress known FPs)
python dakshscra.py -r auto -t /path/to/source --baseline-file config/suppressions.json

# Disable baseline for this run
python dakshscra.py -r auto -t /path/to/source --no-baseline

# Apply findings triage / review config
python dakshscra.py -r auto -t /path/to/source --review-config config/review.json

# Scan with checkpoint state enabled
python dakshscra.py -r auto -t /path/to/source --state

# Resume an interrupted scan
python dakshscra.py -r auto -t /path/to/source --resume-scan

# Resume with a custom state file
python dakshscra.py -r auto -t /path/to/source --resume-scan --state-file runtime/scan_state.json

# Generate PDF from existing JSON outputs (no re-scan)
python dakshscra.py --pdf-from-json

# Generate PDF from a custom JSON directory
python dakshscra.py --pdf-from-json --json-input-dir ./custom/reports/data

# Custom output paths for PDF
python dakshscra.py --pdf-from-json --pdf-output ./reports/scan/pdf/custom.pdf --pdf-multi-dir ./reports/scan/pdf/multi-file

# Single combined PDF only (skip per-platform set)
python dakshscra.py --pdf-from-json --pdf-single-only
```

### Reglas y marcos de plataforma compatibles

```bash
python dakshscra.py -l R    # List platform rules and framework mappings
python dakshscra.py -l RF   # List platform rules, framework mappings, and filetypes
```

Plataformas y mapeos de frameworks compatibles actualmente:

<!-- supported-platforms:start -->
| Plataforma | Frameworks |
|---|---|
| dotnet | aspnetcore, blazor, entityframework, identity |
| php | codeigniter, drupal, laravel, symfony, wordpress, yii |
| java | hibernate, mybatis, spring, springboot, struts |
| javascript | angular, electron, express, nestjs, nextjs, react, vue |
| kotlin | exposed, ktor, springkotlin |
| python | django, fastapi, flask, sqlalchemy |
| go | echo, fiber, gin, gorilla, gorm |
| c | freertos |
| cpp | boost, qt |
| android | cordova-android, flutter-android, ionic-android, jetpack, nativescript-android, reactnative-android, retrofit, room, xamarin-android |
| ios | alamofire, cordova-ios, coredata, flutter-ios, ionic-ios, nativescript-ios, reactnative-ios, swiftui, uikit, xamarin-ios |
| reactnative | expo, reactnative |
| flutter | flutter, flutter-dio, flutter-hive |
| xamarin | xamarin |
| maui | - |
| kmp | - |
| ionic | ionic |
| nativescript | nativescript |
| cordova | cordova |
| bash | - |
| powershell | - |
| dockerfile | - |
| terraform | terraform-aws, terraform-azure, terraform-gcp |
| kubernetes | - |
| ruby | rails, sinatra |
| rust | actix, axum, rocket |
| common | - |
<!-- supported-platforms:end -->

Esta tabla enumera los paquetes de reglas registrados. Un guion significa que no hay un paquete de framework separado registrado. La cobertura del análisis varía según el lenguaje y la regla.

Después de cambiar los registros de plataformas o frameworks, actualice esta tabla y revísela antes de enviar cambios:

```bash
python3 tools/supported_platforms.py
python3 tools/supported_platforms.py --check
```

Para obtener las plataformas y frameworks compatibles más recientes, ejecute siempre:

```bash
python dakshscra.py -l R
```

## Referencia de configuración

### `config/tool.yaml`

Los valores predeterminados del entorno de ejecución de Daksh SCRA se controlan a través de `config/tool.yaml`.

```yaml
state_management:
  enabled: false
  resume_mode: manual
  persist_after_seconds: 300
  persist_interval_seconds: 30
  default_state_file: runtime/scan_state.json
  cleanup_on_success: false

analysis:
  run_by_default: true
  include_frameworks: true
  report_theme: hacker_mode
```

**Opciones de configuración del analizador:**

- `analysis.run_by_default`
  - `true`: el analizador se ejecuta automáticamente durante el escaneo
  - `false`: el analizador está deshabilitado a menos que se vuelva a habilitar en la configuración o mediante la CLI
- `analysis.include_frameworks`
  - `true`: incluye entradas del analizador a nivel de framework donde exista detección de framework
  - `false`: solo salida del analizador a nivel de plataforma
- `analysis.report_theme`
  - `hacker_mode`: tema moderno del analizador oscuro de alto contraste (predeterminado)
  - `professional_mode`: tema moderno del analizador claro
  - `both`: genera ambas variantes de tema en paralelo

### Reglas de Patrón y Reglas Semánticas

**Las Reglas de Patrón identifican áreas de interés utilizando patrones y condiciones contextuales. Un revisor investiga si representan problemas de seguridad reales.**

**Las Reglas Semánticas proporcionan evidencia más sólida al analizar relaciones de código, propagación de entrada y protecciones modeladas. Pueden respaldar un hallazgo o una supresión, pero el modelado incompleto, la configuración de despliegue y el comportamiento en tiempo de ejecución aún pueden afectar la conclusión.**

Seleccione `--rule-mode pattern|semantic|both` (predeterminado `both`), o elija los mismos modos en New Scan. El modo solo semántico omite las líneas base de texto nativas mientras conserva las comprobaciones refinadas de código fuente/configuración móvil y los modelos de flujo compatibles. Un hallazgo compatible aún requiere la confirmación del revisor; la supresión no establece seguridad.

Las comprobaciones integradas se crean como Reglas de Patrón de archivo único bajo [`rules/scanning/platform/`](https://github.com/coffeeandsecurity/dakshscra/blob/main/rules/scanning/platform), preservando los directorios de plataforma y framework. Por ejemplo, las comprobaciones de Java se encuentran en `java/java.rules/*.yaml` y las comprobaciones de Spring en `java/framework/spring.rules/*.yaml`. Cada archivo conserva el patrón, las condiciones contextuales, las descripciones de regla e impacto, la guía para desarrolladores y revisores, las recomendaciones y todas las configuraciones de contexto de código y resaltado. Los `review_steps` y las `recommendations` accionables amplían la guía original con instrucciones accionables. Agregue un archivo YAML a un paquete existente, valídelo con `python3 tools/rdl_lint.py rules/scanning/platform`, luego escanee un pequeño fixture positivo/negativo. El escáner lo descubre sin editar XML ni un archivo RDL v1 separado.

Las definiciones semánticas permanecen bajo [`rules/scanning/logic/rdl/v2/`](https://github.com/coffeeandsecurity/dakshscra/blob/main/rules/scanning/logic/rdl/v2). Las líneas base de texto nativas evaluadas por ese motor siguen siendo Reglas de Patrón. Las selecciones heredadas de `--rdl-engine` siguen siendo compatibles con los escaneos guardados y los scripts existentes.

Consulte la [guía de creación y migración de reglas](https://github.com/coffeeandsecurity/dakshscra/blob/main/docs/usage-guide.md#pattern-rules-and-semantic-rules) para el formato YAML, las condiciones, la validación, la configuración de evidencia y la importación de XML externo.

Los paquetes de plataforma y framework aplicables también incluyen candidatos de revisión de operaciones de seguridad. Los modelos semánticos distinguen valores de origen de respuesta, fuentes de enlace masivo y argumentos de clave criptográfica, y pueden rastrear los respaldos de configuración compatibles hasta las operaciones clave. Los hallazgos recién generados asocian las declaraciones de control de método/clase compatibles con la operación; la revisión de modelos C# tipados puede conservar las políticas de campo declaradas. El aislamiento de inquilinos requiere un invariante específico de la aplicación. Estas son capacidades de revisión respaldadas por evidencia con límites de modelado explícitos, no una detección garantizada de cada falla de autorización o lógica de negocio. Consulte [contexto de operaciones de seguridad y control](https://github.com/coffeeandsecurity/dakshscra/blob/main/docs/usage-guide.md#security-operation-and-control-context).

---

## Estructura de Salida del Informe

Las salidas de la CLI se conservan por escaneo bajo `reports/<project>/<scan>/`. Las exportaciones de la CLI y la Web UI comparten la recopilación de datos guardados y los renderizadores para HTML, PDF, Word y JSON. El HTML completo abre un resumen/índice ligero con páginas de detalle vinculadas y paginadas. En la Web UI, genere una exportación en **Reports**; extraiga el ZIP HTML y abra `index.html` primero.

```
reports/<project>/<scan>/
├── scan/
│   ├── html/
│   │   ├── report.html                 # Summary and report index (open first)
│   │   ├── report-files/               # Linked detail pages and saved-results.json
│   │   └── multi-file/                 # Per-platform HTML report set
│   ├── pdf/
│   │   ├── report.pdf                  # Single-file PDF scan report
│   │   └── multi-file/                 # Per-platform PDF report set
│   ├── word/
│   │   └── report.docx                 # Editable Word report when requested
│   ├── json/
│   │   └── report.json                 # Complete structured report document
│   ├── recon/
│   │   └── reconnaissance.html         # Reconnaissance HTML report
│   └── estimate/
│       └── estimation.html             # Effort estimation HTML report
├── analysis/
│   └── <platform>/
│       ├── analysis.html               # Taint analysis report (default theme)
│       ├── analysis_professional.html  # Professional theme (if theme=both)
│       ├── analysis_xref.html          # Cross-reference report
│       └── analysis.json               # Structured analysis data
└── data/
    ├── areas_of_interest.json          # AoI findings
    ├── filepaths_aoi.json              # File path AoI findings
    ├── summary.json                    # Scan summary
    ├── recon.json                      # Recon summary
    └── analysis.json                   # Analyzer output
```

Los archivos de tiempo de ejecución (estado del escaneo, registros, inventario) se escriben bajo `runtime/`.

Cuando se ejecuta a través de la Web UI, las salidas de cada trabajo se guardan adicionalmente como instantáneas bajo `runtime/webui/jobs/<job-id>/artifacts/` (consulte [Web UI (Docker)](#web-ui-docker)).

---

## Autor

| | |
|---|---|
| Sitio web | [coffeeandsecurity.com](https://www.coffeeandsecurity.com) |
| Correo electrónico | [email protected] |
| Twitter / X | [@coffeensecurity](https://x.com/coffeensecurity) |

---

[Read more](https://github.com/coffeeandsecurity/dakshscra)
Descargar herramienta

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 El kit de herramientas OSINT definitivo: grafo de investigación, puntuación de confianza, familias de alias, mapa, línea de tiempo e informes. 49 módulos, más de 400 sitios, sin necesidad de claves API.

    786
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicación de Ejecución con un Solo Toque GhostLock (CVE-2026-43499)

    506
  • 3

    ARTEX

    baarai/artex

    Plataforma de pruebas de penetración autónoma multiagente basada en LLM con agentes planificadores/trabajadores, grafos de activos y de exploración, registro de tráfico MITM y reevaluación de vulnerabilidades.

    429
  • 4

    redforge

    cybersecurity91/redforge

    Kit de herramientas de red team del lado del navegador con 102 herramientas offline para reconocimiento, generación de payloads, ataques de credenciales, criptografía, codificación y elaboración de informes de compromiso.

    345
  • 5

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    El sistema de acción para la ciberseguridad nativa de IA—donde la intención se convierte en ejecución gobernada, la evidencia se convierte en memoria operativa y cada operación mejora la siguiente.

    262
  • 6

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingiere informes de Shadowserver en MongoDB y los reproduce como mapas interactivos, análisis, hallazgos, avisos y paneles ejecutivos.

    256

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →