## Informazioni su Daksh SCRA

Daksh SCRA (Source Code Review Assist) è progettato per migliorare l'efficienza del processo di revisione del codice sorgente, offrendo un approccio ben strutturato e organizzato per i revisori del codice.

Piuttosto che segnalare indiscriminatamente tutto come un potenziale problema, Daksh SCRA promuove un'analisi ponderata, spingendo a indagare e confermare i potenziali problemi. Questo approccio riduce la corsa a etichettare ogni potenziale preoccupazione come un bug, tagliando la confusione e il tempo sprecato in falsi positivi.

### Debutto

Daksh SCRA è stato inizialmente presentato durante una sessione di formazione sulla revisione del codice sorgente al Black Hat USA 2022 (6-9 agosto), dove è stato mostrato in modo discreto a un pubblico specifico. Il suo debutto pubblico ufficiale è avvenuto al Black Hat USA 2023 a Las Vegas.

## Funzionalità e Caratteristiche

- **Identifica le Aree di Interesse nel Codice Sorgente:** Incoraggia un'indagine e una conferma mirate piuttosto che etichettare indiscriminatamente tutto come un bug.
- **Identifica le Aree di Interesse nei Percorsi dei File (Prima al Mondo):** Riconosce i pattern nei percorsi dei file per individuare le sezioni rilevanti da revisionare.
- **Ricognizione a Livello Software per Identificare le Tecnologie Utilizzate:** Identifica le tecnologie del progetto, consentendo ai revisori del codice di eseguire scansioni precise con regole appropriate.
- **Stima Automatica e Scientifica dello Sforzo per la Revisione del Codice (Prima al Mondo):** Fornisce un approccio misurabile per stimare lo sforzo richiesto per una revisione del codice.
- **Scansione Consapevole del Framework:** Applica automaticamente regole specifiche del framework quando viene rilevato il framework del progetto.
- **Report di Analisi del Taint:** Report HTML del flusso taint per piattaforma con temi modalità hacker e modalità professionale.
- **RDL (Rule Description Language):** Logica di regole esterna referenziata con `rdl_ref` ed eseguita dalla pipeline `core/rdl_engine.py` - supporta gate consapevoli dei file, espressioni booleane, osservazioni sul progetto e metadati di logica esportati nei report.
- **Stato di Scansione / Ripresa:** Crea checkpoint per scansioni lunghe e riprendi dopo un'interruzione.
- **Baseline di Soppressione:** Genera e applica una baseline di falsi positivi noti per sopprimerli dai report futuri.
- **Interfaccia Web:** Avvio di scansioni basato su browser con feed console in tempo reale e browser degli artefatti dei job.

> Sono in corso miglioramenti attivi. Molte nuove funzionalità e migliorie sono previste per le prossime release.

Sentiti libero di contribuire all'aggiornamento o all'aggiunta di nuove regole e allo sviluppo futuro.

Se trovi bug, segnalali a [[email protected]](mailto:[email protected]).

Documentazione dettagliata: [https://dakshlabs.com/#docs](https://dakshlabs.com/#docs)

---

## Per Iniziare

Ci sono due modi per eseguire Daksh SCRA - scegli quello che si adatta al tuo flusso di lavoro:

| | Ideale per | Vai a |
|---|---|---|
| 🌐 **Web UI (Docker)** | Il modo più semplice per iniziare - un solo comando, una dashboard nel browser, avanzamento della scansione in tempo reale e un browser per report/artefatti. Consigliato per la maggior parte degli utenti. | [Web UI (Docker)](#web-ui-docker) |
| 💻 **CLI (Python)** | Scripting, pipeline CI o esecuzione di scansioni senza Docker. | [Configurazione CLI](#cli-setup) |

Entrambi i percorsi eseguono esattamente lo stesso motore di scansione - la Web UI è un frontend nel browser sopra la stessa CLI, quindi i risultati sono identici in entrambi i casi.

---

## Web UI (Docker)

Il modo più veloce per eseguire Daksh SCRA è tramite la sua Web UI basata su browser, avviata con un singolo comando Docker Compose. Ti offre un avviatore di scansioni, un feed console in tempo reale e una cronologia navigabile dei report passati, senza bisogno di un ambiente Python locale.

La configurazione Docker esegue la Web UI e la CLI come servizi indipendenti costruiti dalla stessa immagine, così puoi usare entrambi (o uno solo) dallo stesso contenitore.

### Avvia la Web UI

Modalità in primo piano (i log vengono trasmessi al tuo terminale):```bash
docker compose up --build

Poi apri [http://localhost:8080](http://localhost:8080).

Per usare una porta diversa:```bash
DAKSH_PORT=9090 docker compose up

### Accesso

L'interfaccia Web richiede un account. Al primo avvio, viene creato un account amministratore iniziale da `DAKSH_ADMIN_USERNAME` / `DAKSH_ADMIN_PASSWORD` (impostali in `.env`); se `DAKSH_ADMIN_PASSWORD` viene lasciato vuoto, viene generata una password casuale e stampata una sola volta nel log di avvio dell'API - salvala, poiché non può essere recuperata in seguito.

Ti verrà richiesto di impostare la tua password (e, opzionalmente, il nome utente) la prima volta che accedi. Un account amministratore può creare ulteriori account tramite l'endpoint API `POST /api/v1/auth/users` (nessuna UI dedicata per questo al momento). Consulta `.env.example` per l'elenco completo delle impostazioni relative all'autenticazione (durata della sessione, sicurezza dei cookie, CORS).

### Cosa ottieni

- Builder di comandi reattivo per le modalità scan, recon, estimate, recon+estimate, list e PDF-da-JSON
- Feed della console in tempo reale e avanzamento live per fase durante l'esecuzione
- Snapshot degli artefatti per job per gli output HTML / PDF / JSON
- Navigazione rapida nel browser tra modulo di esecuzione, feed live, artefatti e job recenti
- Browser di directory integrato per selezionare i percorsi di destinazione (consapevole del sistema operativo: Windows, macOS, Linux / Docker)

Sotto il cofano, la CLI rimane la fonte di verità - esegue tutta la scansione e genera ogni output HTML / PDF / JSON. L'interfaccia Web esegue un job attivo alla volta e salva gli output di ogni job completato in `runtime/webui/jobs/<job-id>/artifacts/` così i report passati rimangono accessibili.

### Esecuzione della CLI in Docker

Non hai bisogno di un ambiente Python locale per usare la CLI - è disponibile come servizio Compose dedicato, costruito dalla stessa immagine:```bash
docker compose run --rm cli -h
docker compose run --rm cli -r auto -t /scan-targets/path/to/source

Oppure scarica l'ultimo zip da [https://github.com/coffeeandsecurity/DakshSCRA](https://github.com/coffeeandsecurity/DakshSCRA) e decomprimilo.

### 2. Configura un Ambiente Virtuale

> 💡 L'ambiente virtuale può essere creato in qualsiasi directory - non deve necessariamente trovarsi all'interno della cartella DakshSCRA.

**Opzione A: Configurazione in un unico passaggio (consigliata)**```bash
python setup_env.py

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

---

## Utilizzo da CLI

Usa `python` all'interno di un ambiente virtuale, oppure `python3` al di fuori di esso.

### Opzioni della riga di comando```
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]

### Regole e Framework delle Piattaforme Supportate```bash
python dakshscra.py -l R    # List platform rules and framework mappings
python dakshscra.py -l RF   # List platform rules, framework mappings, and filetypes

---

## Riferimento alla Configurazione

### `config/tool.yaml`

Le impostazioni predefinite del runtime di Daksh SCRA sono controllate tramite `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

#### Sequenza di scansione

Per una regola sorgente, DakshSCRA valuta la logica in questo ordine:

1. Recon seleziona le piattaforme e i framework corrispondenti.
2. La regola XML viene caricata da `rules/scanning/platform/...`.
3. `regex` trova righe candidate o corrispondenze su interi file quando presente.
4. `exclude` rimuove il rumore ovvio per quella regola, se presente.
5. Il file `.rdl` esterno da `rdl_ref` viene valutato rispetto al testo del file corrente, al percorso del file corrente e alla radice del progetto.
6. Se lo script RDL passa, DakshSCRA mantiene il risultato e unisce i metadati della logica esportata nell'output del report.
7. Se lo script RDL fallisce, la corrispondenza viene soppressa con il motivo del fallimento RDL e i metadati della traccia di decisione.

Per le regole sui percorsi file in `filepaths.xml`, si applica lo stesso modello `rdl_ref`, ma il soggetto della corrispondenza è
il percorso relativo normalizzato invece del testo del codice sorgente. In quella modalità, RDL riceve la stringa del percorso relativo
come testo del file corrente e contesto del percorso.

#### Struttura attuale delle regole```xml
<rule>
  <name>Rule Name</name>
  <regex><![CDATA[regex_to_match]]></regex>
  <rdl_ref>logic/common/core/insecure_sql_query_unsafe_string_concatenation.rdl</rdl_ref>
  <exclude><![CDATA[pattern_to_exclude_lines]]></exclude>  <!-- optional -->
  <scan_config>...</scan_config>                           <!-- optional -->
  <rule_desc>Short description of what the rule detects.</rule_desc>
  <vuln_desc>Why the pattern matters.</vuln_desc>
  <developer>Fix guidance for developers.</developer>
  <reviewer>Manual confirmation guidance for reviewers.</reviewer>
</rule>

#### Layout attuale```text
rules/
└── scanning/
    ├── platform/
    │   ├── php/php.xml
    │   ├── java/java.xml
    │   └── ...
    └── logic/
        ├── common/core/
        ├── php/core/
        ├── php/framework/laravel/
        ├── mobile/android/core/
        ├── filepaths/core/
        └── ...

External RDL:```text
VERSION 1
WHEN PRESENT /\b(?:mysql_query|mysqli_query|->query)\s*\(/i
WHEN EXPR PRESENT:\$_(GET|POST|REQUEST|COOKIE) && MISSING:\b(?:prepare|bindParam|bindValue|PDO::prepare)\b
REPORT AS area_of_interest
REASON Query execution appears to rely on direct input without parameterisation.
FAIL_REASON Query API matched, but parameterised query indicators were also found in the file.

External RDL:```text
VERSION 1
WHEN FILE_NAME_IS AndroidManifest.xml
WHEN CURRENT_FILE_MATCHES /android:exported\s*=\s*"true"/i
WHEN MISSING /android:permission\s*=\s*"/i
REPORT AS area_of_interest
REASON Exported component appears reachable without a permission guard.

External RDL:```text
VERSION 1
WHEN CURRENT_FILE_MATCHES /(^|\/)(admin|administrator|root)(\/|$)/i
UNLESS CURRENT_FILE_MATCHES /(^|\/)(tests?|docs?|samples?|examples?)(\/|$)/i
REPORT AS area_of_interest
REASON File path suggests privileged application functionality.
FAIL_REASON Path matched an excluded documentation or sample location.

I file di runtime (stato della scansione, log, inventario) vengono scritti sotto `runtime/`.

Quando si esegue tramite l'interfaccia Web, gli output di ciascun job vengono inoltre salvati come snapshot sotto `runtime/webui/jobs/<job-id>/artifacts/` (vedi [Web UI (Docker)](#web-ui-docker)).

---

## Autore

| | |
|---|---|
| Sito web | [coffeeandsecurity.com](https://www.coffeeandsecurity.com) |
| Email | [email protected] |
| Twitter / X | [@coffeensecurity](https://x.com/coffeensecurity) |
| Sorgente | [github.com/coffeeandsecurity/DakshSCRA](https://github.com/coffeeandsecurity/DakshSCRA) |
| Licenza | GNU General Public License v3.0 (GPL-3.0) |

Se DakshSCRA ha aiutato il tuo team a risparmiare tempo, sforzo o costi significativi, a ridurre la dipendenza da costosi strumenti commerciali, a migliorare la copertura delle revisioni o a rendere la revisione del codice più strutturata ed efficace, non esitare a contattarmi e condividere la tua esperienza. Sono sempre aperto a feedback ponderati e conversazioni interessanti.

Hai trovato un bug o vuoi contribuire? Apri un issue o una pull request su GitHub.