Strumento di analisi statica del codice consapevole del framework per la revisione automatica del codice sorgente con regole specifiche per piattaforma, analisi del taint, stima dello sforzo e baseline di soppressione.
# Daksh SCRA (Source Code Review Assist) ``` Author: - Debasis Mohanty ([email protected]) - Twitter / X: @coffeensecurity - www.coffeeandsecurity.com ``` ## Informazioni su Daksh SCRA Daksh SCRA (Source Code Review Assist) è progettato per migliorare l'efficienza del processo di revisione del codice sorgente, fornendo un approccio ben strutturato e organizzato per i revisori del codice. Invece di segnalare indiscriminatamente tutto come potenziale problema, Daksh SCRA promuove un'analisi ponderata, esortando all'indagine e alla conferma dei potenziali problemi. Questo approccio mitiga la corsa a etichettare ogni potenziale criticità come bug, riducendo la confusione e il tempo sprecato in falsi positivi. ### Debutto Daksh SCRA è stato introdotto inizialmente durante una sessione di formazione sulla revisione del codice sorgente al Black Hat USA 2022 (6-9 agosto), dove è stato presentato in modo discreto a un pubblico specifico. Il suo debutto pubblico ufficiale ha avuto luogo al Black Hat USA 2023 a Las Vegas. ## Funzionalità e capacità DakshSCRA riunisce capacità distintive per la revisione manuale del codice sorgente, dalle aree di interesse nei percorsi dei file alla stima dell'impegno, fino alla ricognizione del software, alle regole contestuali e all'analisi tra file. | Funzionalità | Tag | Perché è importante | |---|---|---| | **Aree di interesse nei percorsi dei file** | Prima al mondo* | Analizza i nomi dei file e delle directory stessi, insieme al codice, per segnalare percorsi sospetti come file di backup, endpoint di debug, dump di configurazione e file di credenziali che i revisori spesso trascurano. | | **Stima scientifica dell'impegno** | Prima al mondo* | Produce una stima quantificata dell'impegno di revisione manuale basata sulle dimensioni della base di codice e sui segnali del progetto. Ipotesi configurabili rendono la pianificazione dell'incarico esplicita e ripetibile. | | **Ricognizione del software** | Seconda al mondo* | Rileva linguaggi, framework e infrastrutture dai contenuti dei file e dalla struttura del progetto prima dell'analisi. Collega l'inventario tecnologico alla selezione automatica delle regole, all'analisi semantica e alla pianificazione della revisione. | | **Analisi semantica avanzata e tra file** | La più avanzata open source al momento del rilascio* | Traccia i dati controllati dall'utente dalla sorgente al sink attraverso i confini dei file supportati utilizzando un'analisi appositamente sviluppata. Advanced Analysis è stata rilasciata insieme all'RDL originale a marzo 2026; RDL v2 estende la valutazione delle regole semantiche tra i file. | * Basato su ricerche generali al momento dell'introduzione di ciascuna funzionalità. Non è stata trovata alcuna funzionalità simile negli strumenti open source per la revisione del codice di sicurezza. Per la stima dell'impegno, non è stato trovato alcun approccio simile nemmeno negli strumenti commerciali. La ricognizione si è classificata seconda dopo Microsoft Application Inspector. L'analisi tra file era la più avanzata tra gli strumenti open source per la revisione del codice al momento del suo rilascio. ### Cronologia delle funzionalità e prove | Funzionalità / traguardo | Data | Rilascio | Prove / ambito | |---|---|---|---| | Beta iniziale e regole sui percorsi dei file | 22 ottobre 2022 | v0.1-beta | [Rilascio iniziale; il codice sorgente conservato include l'inventario dedicato delle regole sui percorsi dei file.](https://github.com/coffeeandsecurity/DakshSCRA/releases/tag/v0.1-beta) | | Ricognizione del software (introduzione pubblicata) | 9 luglio 2023 | v0.3-beta | [Le note di rilascio introducono la ricognizione; il codice precedente del repository costituisce una prova di implementazione separata.](https://github.com/coffeeandsecurity/DakshSCRA/releases/tag/v0.3-beta) | | Stima dell'impegno di revisione manuale (implementazione) | 29 luglio 2023 | Commit di implementazione | [Aggiunto un modulo di stima dedicato; non è la data del successivo rilascio di correzione.](https://github.com/coffeeandsecurity/DakshSCRA/commit/65d5c6a) | | RDL originale e Advanced Analysis tra file | 2 marzo 2026 | v0.31-beta | [La logica condizionale delle regole e l'analisi indipendente tra file sono state rilasciate insieme. La data visualizzata del rilascio è il 2 marzo; il timestamp di pubblicazione è il 1° marzo 2026 alle 18:39 UTC.](https://github.com/coffeeandsecurity/DakshSCRA/commit/d90ba51) | ### Prove comparative - **Predecessore della ricognizione:** [Microsoft Application Inspector](https://www.microsoft.com/en-us/security/blog/2020/01/16/introducing-microsoft-application-inspector/) (16 gennaio 2020) documenta un precedente strumento per le caratteristiche del codice sorgente. La ricognizione di Daksh SCRA è collocata al secondo posto dopo di esso. Le date identificano traguardi del repository o dei rilasci. DakshSCRA è stato introdotto durante la formazione **Black Hat USA 2022** e ha debuttato pubblicamente a **Black Hat USA 2023**. Queste date descrivono l'introduzione del progetto, non tutte le funzionalità attuali. > Sono in corso miglioramenti attivi. Diverse nuove funzionalità e miglioramenti sono previsti per le prossime release. Sentiti libero di contribuire all'aggiornamento o all'aggiunta di nuove regole e allo sviluppo futuro. Se trovi dei 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 meglio 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 lo stesso identico motore di scansione - la Web UI è un front end browser sopra la stessa CLI, quindi i risultati sono identici in entrambi i casi. --- ## Web UI (Docker) Il modo più rapido per eseguire Daksh SCRA è tramite la sua Web UI basata su browser, avviata con l'helper di avvio Docker consapevole dell'host. Offre un launcher per le scansioni, un feed console in tempo reale e una cronologia navigabile dei report passati. L'helper di avvio richiede Python 3 (solo libreria standard); l'applicazione e le sue dipendenze vengono eseguite in Docker. La configurazione Docker esegue la Web UI e la CLI come servizi indipendenti costruiti dalla stessa immagine, così puoi usare l'una o l'altra (o entrambe) dallo stesso container. ### Avviare la Web UI Dopo aver scaricato Daksh SCRA da GitHub, **estrai prima l'archivio ZIP**. Apri un terminale (PowerShell o Prompt dei comandi su Windows) all'interno della cartella del progetto estratta contenente `docker-compose.yml` e `dakshscra.py`. **Esegui tutti i comandi di avvio e Docker Compose riportati di seguito da quella cartella.** Se il terminale si apre altrove, spostati prima nella cartella estratta: ```text cd "path/to/extracted/DakshSCRA-folder" ``` Sostituisci il percorso di esempio con la tua effettiva posizione di download e il nome della cartella. Se invece hai clonato il repository, esegui `cd DakshSCRA` dalla sua cartella padre. L'helper di avvio riconosce Windows, WSL, Linux e macOS, quindi monta la root dell'host, le unità Windows disponibili e le cartelle comuni in sola lettura prima di avviare i container. Eseguilo sul computer che esegue Docker. Linux, macOS o WSL (in primo piano): ```bash python3 tools/start_webui.py ``` Windows PowerShell o Prompt dei comandi (in primo piano): ```powershell py tools/start_webui.py ``` Per eseguire in modalità detached (in background), aggiungi `--detach`. I container continuano a funzionare dopo che il comando di avvio è terminato, lasciando il terminale disponibile. Linux, macOS o WSL (detached): ```bash python3 tools/start_webui.py --detach ``` Windows PowerShell o Prompt dei comandi (scollegato): ```powershell py tools/start_webui.py --detach ``` Usa `--dry-run` per ispezionare i percorsi rilevati senza avviare i container. Le sostituzioni di percorso esistenti in `.env` vengono rispettate. Account, scansioni e il volume di runtime vengono preservati quando i container vengono ricreati. Docker Desktop potrebbe richiedere l'autorizzazione per condividere i percorsi host selezionati. Se rifiuta un mount, consenti quella posizione in Docker Desktop ed esegui nuovamente l'helper. Un browser remoto vede le cartelle dell'**host Docker**, non le unità del proprio computer. Il rilevamento automatico richiede un motore Docker locale; esegui l'helper sull'host del motore quando utilizzi un contesto Docker remoto. Per i mount configurati manualmente, `docker compose up --build -d api web` rimane disponibile. La sua configurazione di base monta il repository su `/scan-targets` e `${DAKSH_HOST_MOUNT:-/}` su `/host/root`. Usa l'helper per il rilevamento delle unità Windows e le scorciatoie alle cartelle comuni; il semplice Compose non può rilevare il sistema operativo del client. Poi apri [http://localhost:3030](http://localhost:3030). Per usare una porta diversa: ```bash DAKSH_PORT=9090 python3 tools/start_webui.py ``` Interrompi lo stack con: ```bash docker compose down ``` ### Liberare spazio su disco dopo build Docker ripetute Usa gli helper di pulizia separati dalla cartella del repository. Per impostazione predefinita eseguono solo un'anteprima: **Questa operazione elimina container, immagini dei servizi, reti e volumi di Daksh, inclusi gli account salvati, la cronologia delle scansioni e gli artefatti memorizzati nel volume di runtime. Esegui prima il backup di tutto ciò che vuoi conservare.** ```bash python3 tools/clean_project_docker.py python3 tools/purge_all_docker.py ``` Aggiungi `--execute` per eliminare, quindi digita la conferma richiesta. Il primo helper rimuove i container, le reti, le immagini dei servizi e i volumi di questo progetto, preservando la cache di build condivisa. Il secondo rimuove forzatamente i container di **tutti i progetti sul motore Docker selezionato** ed esegue la pulizia di immagini, reti, volumi con nome/anonimi e della cache del builder predefinito. Può influire su un motore remoto. Nessuno dei due elimina i file host montati tramite bind mount né disinstalla Docker. Gli utenti Windows possono sostituire `python3` con `py`. Consulta [ambito di pulizia e comandi](https://github.com/coffeeandsecurity/dakshscra/blob/main/docs/usage-guide.md#docker-cleanup-and-full-purge) per nomi di progetto personalizzati, esclusioni e dettagli sull'eliminazione. Controlla l'utilizzo residuo dello spazio disco Docker con: ```bash docker system df ``` Per liberare solo la cache di build inutilizzata mantenendo i dati Daksh salvati, esegui semplicemente `docker builder prune --all --force`. I file nelle cartelle host montate tramite bind mount, inclusi il repository e i target di scansione, rimangono sul disco. Riavvia con `python3 tools/start_webui.py --detach` quando sei pronto. ### Accesso La Web UI richiede un account. **Primo accesso** 1. Avvia il portale (`python3 tools/start_webui.py --detach`) e apri [http://localhost:3030](http://localhost:3030). 2. La pagina di login rileva la configurazione iniziale. Precompila il nome utente `admin` e la password iniziale, e mostra un avviso di configurazione iniziale. | Impostazione | Valore | |---|---| | Nome utente | `admin` (oppure `DAKSH_ADMIN_USERNAME` da `.env`) | | Password iniziale | `Daksh@ChangeMe1` (oppure `DAKSH_ADMIN_PASSWORD` da `.env`) | 3. Fai clic su **Sign in**. Appare una schermata a tutto schermo per il **cambio password** che non può essere saltata. Inserisci la password iniziale come password corrente, scegli una nuova password (almeno 8 caratteri, diversa da quella corrente) e, facoltativamente, cambia il nome utente. 4. Dopo il salvataggio, vieni portato alla dashboard. Da quel momento la pagina di login non precompila più nulla; accedi con le tue credenziali. La password iniziale viene utilizzata solo finché il database non contiene account e smette di funzionare non appena viene cambiata. Fino a quel momento, chiunque possa raggiungere il portale può accedere con essa, quindi imposta `DAKSH_ADMIN_PASSWORD` in `.env` prima del primo avvio se il portale è raggiungibile da altri. Un account amministratore può creare ulteriori account tramite l'endpoint API `POST /api/v1/auth/users` (non esiste ancora un'interfaccia dedicata). Anche gli account nuovi e quelli reimpostati devono cambiare la password assegnata al primo accesso. Consulta `.env.example` per l'elenco completo delle impostazioni relative all'autenticazione (durata della sessione, sicurezza dei cookie, CORS). ### Cosa ottieni - Generatore di comandi responsive per le modalità scan, recon, estimate, recon+estimate, list e PDF-from-JSON - Feed della console in tempo reale e avanzamento live per ogni fase durante l'esecuzione - Snapshot degli artefatti per ogni job per gli output HTML / PDF / JSON - Guida in modalità Developer Mode, Code Review Mode o Both per risultati e report; Both è l'impostazione predefinita - Navigazione rapida nel browser tra modulo di esecuzione, feed live, artefatti e job recenti - Browser di directory integrato per selezionare i percorsi target (compatibile con il sistema operativo: Windows, macOS, Linux / Docker) Dietro le quinte, la CLI rimane la fonte di verità: esegue tutte le scansioni e genera ogni output HTML / PDF / JSON. La Web UI esegue un solo job attivo alla volta e salva gli output di ogni job completato in `runtime/webui/jobs/<job-id>/artifacts/` così i report passati restano accessibili. ### Eseguire la CLI in Docker Non hai bisogno di un ambiente Python locale nemmeno 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 ``` ### Cosa c'è nell'immagine - Backend FastAPI + frontend Web UI - La CLI completa di Daksh SCRA, come servizio separato - Playwright Chromium, per la generazione di PDF - Volumi persistenti `reports/` e `runtime/` - Mount di percorsi host per consentire alle scansioni di raggiungere gli alberi dei sorgenti dall'interno del container **Punti di mount principali:** | Mount | Percorso all'interno del container | |---|---| | Sorgente del progetto | `/app` | | Radice di scansione predefinita (repository, o `DAKSH_SCAN_ROOT`) | `/scan-targets` | | Filesystem host (unità di sistema su Windows) | `/host/root` | | Unità Windows/WSL aggiuntive | `/host/drives/<letter>` | | Home dell'utente corrente | `/host/user` | | Cartelle host comuni | `/host/locations/<name>` | | `DAKSH_HOST_SOURCE` opzionale | `/host/source` | Copiare `.env.example` in `.env` per override opzionali di percorsi e autenticazione. `DAKSH_BROWSE_ROOTS` è un elenco di percorsi **container** consentiti separati da virgola; lasciarlo non impostato per rilevare automaticamente le posizioni montate. Gli elenchi di percorsi consentiti obsoleti `/host/c`, `/host/d` o `/mnt` dovrebbero essere rimossi o aggiornati quando si passa all'helper. Le cartelle host sono in sola lettura; i report e i dati di runtime rimangono scrivibili nelle loro posizioni applicative esistenti. Riavviare usando l'helper dopo aver collegato un'altra unità. Non è necessario alcun socket Docker o container privilegiato. --- ## Configurazione della CLI Preferisci eseguire Daksh SCRA direttamente con Python? Ecco come configurarlo localmente. ### Prerequisiti - Python 3.8+ - Tutte le librerie elencate in `requirements.txt` ### 1. Scaricare Daksh SCRA ```bash git clone https://github.com/coffeeandsecurity/DakshSCRA.git ``` Oppure scarica l'ultimo zip da [https://github.com/coffeeandsecurity/DakshSCRA](https://github.com/coffeeandsecurity/DakshSCRA) e estrailo. ### 2. Configurare 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 solo passaggio (consigliata)** ```bash python setup_env.py ``` Questo script crea l'ambiente virtuale, installa tutte le dipendenze e installa il browser Chromium di Playwright (necessario per l'esportazione in PDF). **Opzione B: Configurazione manuale** Windows: ```bash python -m venv daksh-env .\daksh-env\Scripts\activate ``` macOS / Linux: ```bash python3 -m venv daksh-env source daksh-env/bin/activate ``` Poi installa le dipendenze: ```bash cd path/to/DakshSCRA pip install -r requirements.txt playwright install chromium ``` ## 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] ``` | Opzione | Descrizione | |---|---| | `-r RULES` | Regole della piattaforma (es. `php`, `java`, `php,java`) o `auto` per il rilevamento automatico | | `-f FILE_TYPES` | Sovrascrive i filetypes predefiniti per la scansione | | `-v` | Livello di verbosità (`-v`, `-vv`, `-vvv`) | | `-t TARGET_DIR` | Directory del codice sorgente di destinazione | | `-l {R,RF}` | Elenca le regole della piattaforma + i framework `[R]` o includi i filetypes `[RF]` | | `--recon` | Esegue la ricognizione (rilevamento piattaforma / framework / linguaggio) | | `--rs`, `--recon-strict` | Ricognizione rigorosa: solo rilevamenti ad alta affidabilità (da usare con `--recon`) | | `--estimate` | Stima l'impegno della revisione del codice in base alla dimensione della codebase | | `-rpt`, `--report FORMATS` | Formati di report: `html`, `pdf`, `docx`, `json`, o una combinazione separata da virgole (predefinito: `html`) | | `--pdf-from-json` | Genera report PDF da output JSON esistenti senza rieseguire la scansione | | `--json-input-dir PATH` | Directory dei report JSON (predefinito: `./reports/data`) | | `--pdf-output PATH` | Percorso di output per un singolo PDF (predefinito: `./reports/scan/pdf/report.pdf`) | | `--pdf-multi-dir PATH` | Directory di output per PDF multi-file (predefinito: `./reports/scan/pdf/multi-file`) | | `--pdf-single-only` | Genera solo il PDF combinato in un unico file; salta il set multi-file per piattaforma | | `--skip-analysis` | Disabilita la fase di analisi per questa esecuzione | | `--loc` | Conta le righe di codice effettive | | `--baseline-file PATH` | File di baseline per la soppressione (JSON) | | `--baseline-generate` | Genera la baseline di soppressione dai risultati correnti | | `--no-baseline` | Disabilita la soppressione tramite baseline per questa esecuzione | | `--review-config PATH` | File di triage dei risultati (JSON); sopprime dai report i falsi positivi già revisionati | | `--resume-scan` | Riprende una scansione precedentemente interrotta dal file di stato | | `--state-file PATH` | Percorso personalizzato del file di stato / checkpoint della scansione | | `--no-state` | Disabilita il checkpoint dello stato della scansione per questa esecuzione | | `--state` | Forza l'abilitazione del checkpoint dello stato della scansione per questa esecuzione | ### Esempio di utilizzo > `-f` (tipi di file) è opzionale. Se non specificato, DakshSCRA utilizza i filetypes predefiniti per la/e piattaforma/e selezionata/e. ```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 ``` ### 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 ``` Piattaforme e mappature dei framework attualmente supportate: <!-- supported-platforms:start --> | Piattaforma | Framework | |---|---| | 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 --> Questa tabella elenca i pacchetti di regole registrati. Un trattino indica che non è registrato alcun pacchetto di framework separato. La copertura dell'analisi varia in base al linguaggio e alle regole. Dopo aver modificato i registri delle piattaforme o dei framework, aggiorna questa tabella e verificala prima di inviare le modifiche: ```bash python3 tools/supported_platforms.py python3 tools/supported_platforms.py --check ``` Per ottenere le piattaforme e i framework supportati più recenti, eseguire sempre: ```bash python dakshscra.py -l R ``` ## Riferimento alla configurazione ### `config/tool.yaml` I valori predefiniti di runtime di Daksh SCRA sono controllati 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 ``` **Opzioni di configurazione dell'analizzatore:** - `analysis.run_by_default` - `true`: l'analizzatore viene eseguito automaticamente durante la scansione - `false`: analizzatore disabilitato a meno che non venga riabilitato nella configurazione o tramite CLI - `analysis.include_frameworks` - `true`: includi le voci dell'analizzatore a livello di framework dove esiste il rilevamento del framework - `false`: solo output dell'analizzatore a livello di piattaforma - `analysis.report_theme` - `hacker_mode`: tema moderno dell'analizzatore scuro ad alto contrasto (predefinito) - `professional_mode`: tema moderno dell'analizzatore chiaro - `both`: genera entrambe le varianti del tema affiancate ### Regole di Pattern e Regole Semantiche **Le Regole di Pattern identificano aree di interesse utilizzando pattern e condizioni contestuali. Un revisore verifica se rappresentano problemi di sicurezza effettivi.** **Le Regole Semantiche forniscono prove più solide analizzando le relazioni tra il codice, la propagazione degli input e le protezioni modellate. Possono supportare un risultato o una soppressione, ma una modellazione incompleta, le impostazioni di distribuzione e il comportamento a runtime possono comunque influenzare la conclusione.** Seleziona `--rule-mode pattern|semantic|both` (predefinito `both`), oppure scegli le stesse modalità in New Scan. La modalità solo semantica salta le baseline testuali native mantenendo i controlli raffinati su sorgente/configurazione mobile e i modelli di flusso supportati. Un risultato supportato richiede comunque la conferma del revisore; la soppressione non stabilisce la sicurezza. I controlli integrati sono scritti come Regole di Pattern a file singolo sotto [`rules/scanning/platform/`](https://github.com/coffeeandsecurity/dakshscra/blob/main/rules/scanning/platform), preservando le directory di piattaforma e framework. Ad esempio, i controlli Java risiedono in `java/java.rules/*.yaml` e i controlli Spring in `java/framework/spring.rules/*.yaml`. Ogni file conserva il pattern, le condizioni contestuali, le descrizioni della regola e dell'impatto, le indicazioni per sviluppatori e revisori, le raccomandazioni e tutte le impostazioni di contesto del codice ed evidenziazione. I `review_steps` e le `recommendations` attuabili estendono le indicazioni originali con istruzioni operative. Aggiungi un file YAML a un pack esistente, validalo con `python3 tools/rdl_lint.py rules/scanning/platform`, quindi scansiona un piccolo fixture positivo/negativo. Lo scanner lo rileva senza modificare XML o un file RDL v1 separato. Le definizioni semantiche rimangono sotto [`rules/scanning/logic/rdl/v2/`](https://github.com/coffeeandsecurity/dakshscra/blob/main/rules/scanning/logic/rdl/v2). Le baseline testuali native valutate da quel motore rimangono Regole di Pattern. Le selezioni legacy `--rdl-engine` rimangono compatibili con le scansioni salvate e gli script esistenti. Consulta la [guida alla creazione e migrazione delle regole](https://github.com/coffeeandsecurity/dakshscra/blob/main/docs/usage-guide.md#pattern-rules-and-semantic-rules) per il formato YAML, le condizioni, la validazione, le impostazioni delle prove e l'importazione XML esterna. I pack di piattaforma e framework applicabili includono anche candidati alla revisione delle operazioni di sicurezza. I modelli semantici distinguono i valori di origine della risposta, le sorgenti di binding in blocco e gli argomenti delle chiavi crittografiche, e possono tracciare i fallback di configurazione supportati nelle operazioni chiave. I risultati appena generati associano le dichiarazioni di controllo di metodo/classe supportate all'operazione; la revisione tipizzata dei modelli C# può conservare le politiche dei campi dichiarate. L'isolamento dei tenant richiede un invariante specifico dell'applicazione. Si tratta di capacità di revisione supportate da prove con limiti di modellazione espliciti, non di rilevamento garantito di ogni difetto di autorizzazione o di logica di business. Consulta [contesto delle operazioni di sicurezza e dei controlli](https://github.com/coffeeandsecurity/dakshscra/blob/main/docs/usage-guide.md#security-operation-and-control-context). --- ## Struttura dell'output del report Gli output della CLI vengono conservati per scansione sotto `reports/<project>/<scan>/`. Le esportazioni della CLI e della Web UI condividono la raccolta dei dati salvati e i renderer per HTML, PDF, Word e JSON. L'HTML completo apre un riepilogo/indice leggero con pagine di dettaglio collegate e paginate. Nella Web UI, genera un'esportazione in **Reports**; estrai lo ZIP HTML e apri prima `index.html`. ``` 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 ``` I file di runtime (stato della scansione, log, inventario) vengono scritti in `runtime/`. Quando si esegue tramite la Web UI, gli output di ciascun job vengono inoltre salvati come snapshot in `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, impegno 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, sentiti libero di contattarmi e condividere la tua esperienza. Sono sempre aperto a feedback ponderati e conversazioni interessanti. Hai trovato un bug o vuoi contribuire? Apri una issue o una pull request su GitHub. --- [Read more](https://github.com/coffeeandsecurity/dakshscra)
Scopri gli strumenti più utilizzati dalla nostra community.
Nessun dato di popolarità ancora.