Framework-bewusstes statisches Code-Analyse-Tool für automatisierte Quellcode-Reviews mit plattformspezifischen Regeln, Taint-Analyse, Aufwandsabschätzung und Unterdrückungsbaselines.
# Daksh SCRA (Unterstützung bei der Quellcode-Überprüfung) ``` Author: - Debasis Mohanty ([email protected]) - Twitter / X: @coffeensecurity - www.coffeeandsecurity.com ``` ## Über Daksh SCRA Daksh SCRA (Source Code Review Assist) wurde entwickelt, um die Effizienz des Quellcode-Review-Prozesses zu steigern und Code-Reviewern einen wohlstrukturierten und organisierten Ansatz zu bieten. Anstatt unterschiedslos alles als potenzielles Problem zu kennzeichnen, fördert Daksh SCRA eine sorgfältige Analyse und drängt auf die Untersuchung und Bestätigung potenzieller Probleme. Dieser Ansatz mildert das hektische Bestreben, jede mögliche Besorgnis als Bug zu markieren, und reduziert die Verwirrung und die verschwendete Zeit durch Fehlalarme. ### Debüt Daksh SCRA wurde erstmals während einer Schulung zum Quellcode-Review auf der Black Hat USA 2022 (6.–9. August) vorgestellt, wo es einem spezifischen Publikum dezent präsentiert wurde. Sein offizielles öffentliches Debüt fand auf der Black Hat USA 2023 in Las Vegas statt. ## Funktionen und Funktionalitäten DakshSCRA vereint unverwechselbare Fähigkeiten für das manuelle Quellcode-Review, von Dateipfad-Interessenbereichen und Aufwandsschätzung bis hin zu Software-Reconnaissance, kontextuellen Regeln und dateiübergreifender Analyse. | Funktion | Tag | Warum sie wichtig ist | |---|---|---| | **Dateipfad-Interessenbereiche** | Weltweit erste* | Durchsucht Datei- und Verzeichnisnamen selbst, neben dem Code, um verdächtige Pfade wie Backup-Dateien, Debug-Endpunkte, Konfigurations-Dumps und Anmeldedatendateien zu kennzeichnen, die Reviewer oft übersehen. | | **Wissenschaftliche Aufwandsschätzung** | Weltweit erste* | Erstellt eine quantifizierte Schätzung des manuellen Review-Aufwands basierend auf der Codebasis-Größe und Projektsignalen. Konfigurierbare Annahmen machen die Einsatzplanung explizit und wiederholbar. | | **Software-Reconnaissance** | Weltweit zweite* | Erkennt Sprachen, Frameworks und Infrastruktur aus Dateiinhalten und Projektstruktur vor dem Scannen. Verbindet das Technologie-Inventar mit automatischer Regelauswahl, semantischer Analyse und Review-Planung. | | **Fortschrittliche semantische und dateiübergreifende Analyse** | Fortschrittlichste Open Source zum Release-Zeitpunkt* | Verfolgt benutzergesteuerte Daten von der Quelle bis zur Senke über unterstützte Dateigrenzen hinweg mithilfe zweckgebundener Analyse. Die Advanced Analysis wurde zusammen mit der ursprünglichen RDL im März 2026 veröffentlicht; RDL v2 erweitert die semantische Regelauswertung über Dateien hinweg. | * Basierend auf allgemeinen Suchen zum Zeitpunkt der Einführung jeder Funktion. Es wurde keine ähnliche Funktion in Open-Source-Sicherheits-Code-Review-Tools gefunden. Für die Aufwandsschätzung wurde auch in kommerziellen Tools kein ähnlicher Ansatz gefunden. Recon kam nach Microsoft Application Inspector auf den zweiten Platz. Die dateiübergreifende Analyse war zum Zeitpunkt ihrer Veröffentlichung die fortschrittlichste unter den Open-Source-Code-Review-Tools. ### Funktionshistorie und Belege | Funktion / Meilenstein | Datum | Release | Beleg / Umfang | |---|---|---|---| | Erste Beta und Dateipfad-Regeln | 22. Oktober 2022 | v0.1-beta | [Erstveröffentlichung; der erhaltene Quellcode enthält das dedizierte Inventar der Dateipfad-Regeln.](https://github.com/coffeeandsecurity/DakshSCRA/releases/tag/v0.1-beta) | | Software-Reconnaissance (veröffentlichte Einführung) | 9. Juli 2023 | v0.3-beta | [Die Release-Notes führen Recon ein; früherer Repository-Code ist separater Implementierungsbeleg.](https://github.com/coffeeandsecurity/DakshSCRA/releases/tag/v0.3-beta) | | Aufwandsschätzung für manuelles Review (Implementierung) | 29. Juli 2023 | Implementierungs-Commit | [Dediziertes Schätzmodul hinzugefügt; nicht das Datum des späteren Fix-Releases.](https://github.com/coffeeandsecurity/DakshSCRA/commit/65d5c6a) | | Ursprüngliche RDL und dateiübergreifende Advanced Analysis | 2. März 2026 | v0.31-beta | [Bedingte Regellogik und unabhängige dateiübergreifende Analyse wurden zusammen veröffentlicht. Das angezeigte Release-Datum ist der 2. März; der Veröffentlichungszeitstempel ist der 1. März 2026 um 18:39 UTC.](https://github.com/coffeeandsecurity/DakshSCRA/commit/d90ba51) | ### Vergleichende Belege - **Recon-Vorgänger:** [Microsoft Application Inspector](https://www.microsoft.com/en-us/security/blog/2020/01/16/introducing-microsoft-application-inspector/) (16. Januar 2020) dokumentiert ein früheres Tool zur Analyse von Quellcode-Eigenschaften. Daksh SCRA Recon wird dahinter auf den zweiten Platz gesetzt. Die Daten kennzeichnen Repository- oder Release-Meilensteine. DakshSCRA wurde während der **Black Hat USA 2022**-Schulung vorgestellt und debütierte öffentlich auf der **Black Hat USA 2023**. Diese Daten beschreiben die Einführung des Projekts, nicht jedes aktuelle Feature. > Aktive Verbesserungen sind fortlaufend. Mehrere neue Funktionen und Verbesserungen sind für kommende Releases geplant. Fühlen Sie sich frei, zur Aktualisierung oder Hinzufügung neuer Regeln und zur zukünftigen Entwicklung beizutragen. Wenn Sie Fehler finden, melden Sie diese an [[email protected]](mailto:[email protected]). Ausführliche Dokumentation: [https://dakshlabs.com/#docs](https://dakshlabs.com/#docs) --- ## Erste Schritte Es gibt zwei Möglichkeiten, Daksh SCRA auszuführen – wählen Sie diejenige, die zu Ihrem Workflow passt: | | Am besten geeignet für | Springen zu | |---|---|---| | 🌐 **Web UI (Docker)** | Der einfachste Einstieg – ein Befehl, ein Browser-Dashboard, Live-Scan-Fortschritt und ein Berichts-/Artefakt-Browser. Für die meisten Benutzer empfohlen. | [Web UI (Docker)](#web-ui-docker) | | 💻 **CLI (Python)** | Skripterstellung, CI-Pipelines oder Ausführen von Scans ohne Docker. | [CLI-Einrichtung](#cli-setup) | Beide Wege führen dieselbe Scan-Engine aus – die Web UI ist eine Browser-Oberfläche über derselben CLI, sodass die Ergebnisse in beiden Fällen identisch sind. --- ## Web UI (Docker) Der schnellste Weg, Daksh SCRA auszuführen, ist über seine browserbasierte Web UI, die mit dem host-bewussten Docker-Starthelfer gestartet wird. Sie bietet einen Scan-Starter, einen Live-Konsolen-Feed und einen durchsuchbaren Verlauf vergangener Berichte. Der Starthelfer benötigt Python 3 (nur Standardbibliothek); die Anwendung und ihre Abhängigkeiten laufen in Docker. Das Docker-Setup führt die Web UI und die CLI als unabhängige Dienste aus, die aus demselben Image erstellt werden, sodass Sie beide (oder eine von beiden) aus demselben Container verwenden können. ### Starten der Web UI Nachdem Sie Daksh SCRA von GitHub heruntergeladen haben, **extrahieren Sie zuerst das ZIP-Archiv**. Öffnen Sie ein Terminal (PowerShell oder Eingabeaufforderung unter Windows) innerhalb des extrahierten Projektordners, der `docker-compose.yml` und `dakshscra.py` enthält. **Führen Sie alle unten aufgeführten Start- und Docker-Compose-Befehle aus diesem Ordner aus.** Wenn Ihr Terminal an einer anderen Stelle geöffnet wird, wechseln Sie zuerst in den extrahierten Ordner: ```text cd "path/to/extracted/DakshSCRA-folder" ``` Ersetzen Sie den Beispielpfad durch Ihren tatsächlichen Download-Speicherort und Ordnernamen. Wenn Sie stattdessen das Repository geklont haben, führen Sie `cd DakshSCRA` aus dessen übergeordnetem Ordner aus. Das Start-Hilfsskript erkennt Windows, WSL, Linux und macOS und bindet dann das Host-Stammverzeichnis, verfügbare Windows-Laufwerke und gängige Ordner schreibgeschützt ein, bevor die Container gestartet werden. Führen Sie es auf dem Computer aus, auf dem Docker läuft. Linux, macOS oder WSL (Vordergrund): ```bash python3 tools/start_webui.py ``` Windows PowerShell oder Eingabeaufforderung (Vordergrund): ```powershell py tools/start_webui.py ``` Um im detached (Hintergrund-)Modus auszuführen, fügen Sie `--detach` hinzu. Die Container laufen weiter, nachdem der Startbefehl zurückgekehrt ist, sodass Ihr Terminal verfügbar bleibt. Linux, macOS oder WSL (detached): ```bash python3 tools/start_webui.py --detach ``` Windows PowerShell oder Eingabeaufforderung (getrennt): ```powershell py tools/start_webui.py --detach ``` Verwenden Sie `--dry-run`, um erkannte Pfade zu prüfen, ohne die Container zu starten. Bestehende `.env`-Pfadüberschreibungen werden berücksichtigt. Konten, Scans und das Laufzeit- Volume bleiben erhalten, wenn Container neu erstellt werden. Docker Desktop kann die Berechtigung erfordern, die ausgewählten Host-Pfade freizugeben. Wenn es einen Mount ablehnt, erlauben Sie diesen Speicherort in Docker Desktop und führen Sie das Hilfsprogramm erneut aus. Ein entfernter Browser sieht die Ordner des **Docker-Hosts**, nicht die Laufwerke seines eigenen Computers. Die automatische Erkennung erfordert eine lokale Docker-Engine; führen Sie das Hilfsprogramm auf dem Engine- Host aus, wenn Sie einen entfernten Docker-Kontext verwenden. Für manuell konfigurierte Mounts bleibt `docker compose up --build -d api web` weiterhin verfügbar. Dessen Basisversion mountet das Repository unter `/scan-targets` und `${DAKSH_HOST_MOUNT:-/}` unter `/host/root`. Verwenden Sie das Hilfsprogramm für die Windows-Laufwerkserkennung und Verknüpfungen zu gängigen Ordnern; reines Compose kann das Client-Betriebssystem nicht erkennen. Öffnen Sie dann [http://localhost:3030](http://localhost:3030). Um einen anderen Port zu verwenden: ```bash DAKSH_PORT=9090 python3 tools/start_webui.py ``` Beenden Sie den Stack mit: ```bash docker compose down ``` ### Freigeben von Speicherplatz nach wiederholten Docker-Builds Verwenden Sie die separaten Bereinigungshilfsprogramme aus dem Repository-Ordner. Sie zeigen standardmäßig eine Vorschau an: **Dies löscht Daksh-Container, Service-Images, Netzwerke und Volumes, einschließlich gespeicherter Konten, Scan-Verlauf und im Runtime-Volume gespeicherter Artefakte. Sichern Sie zuerst alles, was Sie behalten möchten.** ```bash python3 tools/clean_project_docker.py python3 tools/purge_all_docker.py ``` Fügen Sie `--execute` zum Löschen hinzu und geben Sie dann die angeforderte Bestätigung ein. Der erste Helfer entfernt die Container, Netzwerke, Service-Images und Volumes dieses Projekts und bewahrt dabei den gemeinsamen Build-Cache. Der zweite entfernt gewaltsam Container über **alle Projekte auf der ausgewählten Docker-Engine** hinweg und bereinigt Images, Netzwerke, benannte/anonyme Volumes und den Cache des Standard-Builders. Er kann eine entfernte Engine betreffen. Keiner der beiden löscht bind-gemountete Host-Dateien oder deinstalliert Docker. Windows-Benutzer können `python3` durch `py` ersetzen. Siehe [Bereinigungsumfang und Befehle](https://github.com/coffeeandsecurity/dakshscra/blob/main/docs/usage-guide.md#docker-cleanup-and-full-purge) für benutzerdefinierte Projektnamen, Ausschlüsse und Löschdetails. Prüfen Sie die verbleibende Docker-Datenträgerbelegung mit: ```bash docker system df ``` Um nur den ungenutzten Build-Cache freizugeben und dabei gespeicherte Daksh-Daten zu behalten, führen Sie einfach `docker builder prune --all --force` aus. Dateien in bind-gemounteten Host-Ordnern, einschließlich des Repositorys und der Scan-Ziele, bleiben auf der Festplatte. Starten Sie bei Bedarf erneut mit `python3 tools/start_webui.py --detach`. ### Anmelden Die Web-UI erfordert ein Konto. **Erstmalige Anmeldung** 1. Starten Sie das Portal (`python3 tools/start_webui.py --detach`) und öffnen Sie [http://localhost:3030](http://localhost:3030). 2. Die Anmeldeseite erkennt die erstmalige Einrichtung. Sie füllt den Benutzernamen `admin` und das initiale Passwort vor und zeigt einen Hinweis zur erstmaligen Einrichtung an. | Einstellung | Wert | |---|---| | Benutzername | `admin` (oder `DAKSH_ADMIN_USERNAME` aus `.env`) | | Initiales Passwort | `Daksh@ChangeMe1` (oder `DAKSH_ADMIN_PASSWORD` aus `.env`) | 3. Klicken Sie auf **Anmelden**. Ein bildschirmfüllender Schritt zum **Ändern des Passworts** erscheint, der nicht übersprungen werden kann. Geben Sie das initiale Passwort als aktuelles Passwort ein, wählen Sie ein neues Passwort (mindestens 8 Zeichen, abweichend vom aktuellen) und ändern Sie optional den Benutzernamen. 4. Nach dem Speichern gelangen Sie zum Dashboard. Von da an füllt die Anmeldeseite nichts mehr vor; melden Sie sich mit Ihren eigenen Zugangsdaten an. Das initiale Passwort wird nur verwendet, solange die Datenbank keine Konten enthält, und es funktioniert nicht mehr, sobald es geändert wurde. Bis dahin kann sich jeder, der das Portal erreichen kann, damit anmelden. Setzen Sie daher `DAKSH_ADMIN_PASSWORD` in `.env` vor dem ersten Start, wenn das Portal für andere erreichbar ist. Ein Admin-Konto kann weitere Konten über den API-Endpunkt `POST /api/v1/auth/users` erstellen (dafür gibt es noch keine eigene UI). Neue und zurückgesetzte Konten müssen ihr zugewiesenes Passwort ebenfalls bei der ersten Anmeldung ändern. Die vollständige Liste der authentifizierungsbezogenen Einstellungen (Sitzungsdauer, Cookie-Sicherheit, CORS) finden Sie in `.env.example`. ### Was Sie erhalten - Responsiver Befehlsgenerator für die Modi Scan, Recon, Estimate, Recon+Estimate, List und PDF-from-JSON - Echtzeit-Konsolen-Feed und Live-Fortschritt pro Phase während der Ausführung - Artefakt-Snapshots pro Job für HTML-/PDF-/JSON-Ausgaben - Developer Mode, Code Review Mode oder Both als Anleitung für Ergebnisse und Berichte; Both ist der Standard - Schnelle Navigation im Browser zwischen Ausführungsformular, Live-Feed, Artefakten und letzten Jobs - Integrierter Verzeichnisbrowser zur Auswahl von Zielpfaden (OS-bewusst: Windows, macOS, Linux / Docker) Im Hintergrund bleibt die CLI die maßgebliche Quelle – sie führt das gesamte Scanning durch und erzeugt jede HTML-/PDF-/JSON-Ausgabe. Die Web-UI führt jeweils einen aktiven Job aus und speichert die Ausgaben jedes abgeschlossenen Jobs als Snapshot in `runtime/webui/jobs/<job-id>/artifacts/`, damit vergangene Berichte zugänglich bleiben. ### Ausführen der CLI in Docker Sie benötigen auch für die CLI keine lokale Python-Umgebung – sie ist als eigener Compose-Dienst verfügbar, der aus demselben Image gebaut wird: ```bash docker compose run --rm cli -h docker compose run --rm cli -r auto -t /scan-targets/path/to/source ``` ### Was im Image enthalten ist - FastAPI-Backend + Web-UI-Frontend - Die vollständige Daksh SCRA CLI als separater Dienst - Playwright Chromium für die PDF-Erzeugung - Persistente Volumes `reports/` und `runtime/` - Host-Pfad-Mounts, damit Scans Quellbäume aus dem Container heraus erreichen können **Wichtige Mount-Punkte:** | Mount | Pfad im Container | |---|---| | Projektquelle | `/app` | | Standard-Scan-Root (Repository oder `DAKSH_SCAN_ROOT`) | `/scan-targets` | | Host-Dateisystem (Systemlaufwerk unter Windows) | `/host/root` | | Zusätzliche Windows/WSL-Laufwerke | `/host/drives/<letter>` | | Home-Verzeichnis des aktuellen Benutzers | `/host/user` | | Gängige Host-Ordner | `/host/locations/<name>` | | Optionales `DAKSH_HOST_SOURCE` | `/host/source` | Kopieren Sie `.env.example` nach `.env` für optionale Pfad- und Authentifizierungs-Überschreibungen. `DAKSH_BROWSE_ROOTS` ist eine kommagetrennte Allow-List von **Container**-Pfaden; lassen Sie es ungesetzt, um die gemounteten Orte zu ermitteln. Veraltete Allow-Lists wie `/host/c`, `/host/d` oder `/mnt` sollten beim Wechsel zum Helper entfernt oder aktualisiert werden. Host-Ordner sind schreibgeschützt; Berichte und Laufzeitdaten bleiben an ihren bestehenden Anwendungsspeicherorten beschreibbar. Starten Sie nach dem Anhängen eines weiteren Laufwerks mit dem Helper neu. Es wird kein Docker-Socket und kein privilegierter Container benötigt. --- ## CLI-Setup Möchten Sie Daksh SCRA lieber direkt mit Python ausführen? So richten Sie es lokal ein. ### Voraussetzungen - Python 3.8+ - Alle in `requirements.txt` aufgeführten Bibliotheken ### 1. Daksh SCRA herunterladen ```bash git clone https://github.com/coffeeandsecurity/DakshSCRA.git ``` Oder laden Sie die neueste Zip-Datei von [https://github.com/coffeeandsecurity/DakshSCRA](https://github.com/coffeeandsecurity/DakshSCRA) herunter und entpacken Sie sie. ### 2. Virtuelle Umgebung einrichten > 💡 Die virtuelle Umgebung kann in einem beliebigen Verzeichnis erstellt werden – sie muss sich nicht im DakshSCRA-Ordner befinden. **Option A: Einrichtung in einem Schritt (empfohlen)** ```bash python setup_env.py ``` Dieses Skript erstellt die virtuelle Umgebung, installiert alle Abhängigkeiten und installiert Playwrights Chromium-Browser (erforderlich für den PDF-Export). **Option B: Manuelle Einrichtung** Windows: ```bash python -m venv daksh-env .\daksh-env\Scripts\activate ``` macOS / Linux: ```bash python3 -m venv daksh-env source daksh-env/bin/activate ``` Dann installieren Sie die Abhängigkeiten: ```bash cd path/to/DakshSCRA pip install -r requirements.txt playwright install chromium ``` ## CLI-Nutzung Verwenden Sie `python` innerhalb einer virtuellen Umgebung oder `python3` außerhalb einer solchen. ### Befehlszeilenoptionen ``` 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] ``` | Option | Beschreibung | |---|---| | `-r RULES` | Plattform-Regeln (z. B. `php`, `java`, `php,java`) oder `auto` für automatische Erkennung | | `-f FILE_TYPES` | Standard-Dateitypen für das Scannen überschreiben | | `-v` | Ausführlichkeitsstufe (`-v`, `-vv`, `-vvv`) | | `-t TARGET_DIR` | Zielverzeichnis des Quellcodes | | `-l {R,RF}` | Plattform-Regeln + Frameworks `[R]` auflisten oder Dateitypen `[RF]` einschließen | | `--recon` | Aufklärung (Reconnaissance) ausführen (Plattform-/Framework-/Spracherkennung) | | `--rs`, `--recon-strict` | Strikte Aufklärung: nur Erkennungen mit hoher Konfidenz (mit `--recon` verwenden) | | `--estimate` | Aufwand für die Code-Review basierend auf der Codebasis-Größe schätzen | | `--rpt`, `--report FORMATS` | Berichtsformate: `html`, `pdf`, `docx`, `json` oder eine kommagetrennte Kombination (Standard: `html`) | | `--pdf-from-json` | PDF-Bericht(e) aus vorhandenen JSON-Ausgaben generieren, ohne erneut zu scannen | | `--json-input-dir PATH` | JSON-Berichtsverzeichnis (Standard: `./reports/data`) | | `--pdf-output PATH` | Ausgabepfad für eine einzelne PDF (Standard: `./reports/scan/pdf/report.pdf`) | | `--pdf-multi-dir PATH` | Ausgabeverzeichnis für PDFs mit mehreren Dateien (Standard: `./reports/scan/pdf/multi-file`) | | `--pdf-single-only` | Nur die kombinierte Einzeldatei-PDF generieren; den plattformspezifischen Multi-Datei-Satz überspringen | | `--skip-analysis` | Die Analyzer-Stufe für diesen Lauf deaktivieren | | `--loc` | Effektive Codezeilen zählen | | `--baseline-file PATH` | Unterdrückungs-Baseline-Datei (JSON) | | `--baseline-generate` | Unterdrückungs-Baseline aus aktuellen Befunden generieren | | `--no-baseline` | Baseline-Unterdrückung für diesen Lauf deaktivieren | | `--review-config PATH` | Triage-Datei für Befunde (JSON); zuvor überprüfte False Positives aus Berichten unterdrücken | | `--resume-scan` | Einen zuvor unterbrochenen Scan aus der Statusdatei fortsetzen | | `--state-file PATH` | Benutzerdefinierter Pfad für Scan-Status-/Checkpoint-Datei | | `--no-state` | Checkpointing des Scan-Status für diesen Lauf deaktivieren | | `--state` | Checkpointing des Scan-Status für diesen Lauf erzwingen | ### Beispielverwendung > `-f` (Dateitypen) ist optional. Wenn nicht angegeben, verwendet DakshSCRA die Standard-Dateitypen für die ausgewählte(n) Plattform(en). ```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 ``` ### Unterstützte Plattformregeln und Frameworks ```bash python dakshscra.py -l R # List platform rules and framework mappings python dakshscra.py -l RF # List platform rules, framework mappings, and filetypes ``` Aktuell unterstützte Plattformen und Framework-Zuordnungen: <!-- supported-platforms:start --> | Plattform | 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 --> Diese Tabelle listet die registrierten Regelpakete auf. Ein Bindestrich bedeutet, dass kein separates Framework-Paket registriert ist. Die Analyseabdeckung variiert je nach Sprache und Regel. Nach Änderungen an den Plattform- oder Framework-Registrierungen muss diese Tabelle aktualisiert und vor dem Einreichen von Änderungen überprüft werden: ```bash python3 tools/supported_platforms.py python3 tools/supported_platforms.py --check ``` Um die neuesten unterstützten Plattformen und Frameworks zu erhalten, führen Sie immer aus: ```bash python dakshscra.py -l R ``` ## Konfigurationsreferenz ### `config/tool.yaml` Die Laufzeit-Standardwerte von Daksh SCRA werden über `config/tool.yaml` gesteuert. ```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 ``` **Analyzer-Konfigurationsoptionen:** - `analysis.run_by_default` - `true`: Analyzer läuft während des Scans automatisch - `false`: Analyzer deaktiviert, sofern nicht in der Konfiguration oder über die CLI erneut aktiviert - `analysis.include_frameworks` - `true`: Framework-bezogene Analyzer-Einträge einbeziehen, sofern Framework-Erkennung vorhanden ist - `false`: nur Ausgabe des Analyzers auf Plattformebene - `analysis.report_theme` - `hacker_mode`: dunkles, kontrastreiches modernes Analyzer-Theme (Standard) - `professional_mode`: helles modernes Analyzer-Theme - `both`: beide Theme-Varianten nebeneinander erzeugen ### Pattern Rules und Semantic Rules **Pattern Rules identifizieren Interessenbereiche anhand von Mustern und kontextuellen Bedingungen. Ein Prüfer untersucht, ob sie tatsächliche Sicherheitsprobleme darstellen.** **Semantic Rules liefern stärkere Belege durch die Analyse von Codebeziehungen, Eingabeweiterleitung und modellierten Schutzmechanismen. Sie können einen Befund stützen oder eine Unterdrückung rechtfertigen, doch unvollständige Modellierung, Deployment-Einstellungen und Laufzeitverhalten können die Schlussfolgerung dennoch beeinflussen.** Wählen Sie `--rule-mode pattern|semantic|both` (Standard `both`) oder wählen Sie dieselben Modi in New Scan. Der reine Semantic-Modus überspringt native Text-Baselines, behält jedoch verfeinerte Prüfungen von Mobile-Quellcode/-Konfiguration und unterstützte Flow-Modelle bei. Ein unterstützter Befund erfordert weiterhin die Bestätigung durch einen Prüfer; eine Unterdrückung belegt keine Sicherheit. Integrierte Prüfungen sind als Single-File Pattern Rules unter [`rules/scanning/platform/`](https://github.com/coffeeandsecurity/dakshscra/blob/main/rules/scanning/platform) verfasst und bewahren die Verzeichnisse für Plattformen und Frameworks. Beispielsweise liegen Java-Prüfungen in `java/java.rules/*.yaml` und Spring-Prüfungen in `java/framework/spring.rules/*.yaml`. Jede Datei behält das Muster, die kontextuellen Bedingungen, Regel- und Auswirkungsbeschreibungen, Hinweise für Entwickler und Prüfer, Empfehlungen sowie alle Einstellungen für Codekontext und Hervorhebung bei. Handlungsorientierte `review_steps` und `recommendations` erweitern die ursprünglichen Hinweise um umsetzbare Anweisungen. Fügen Sie eine YAML-Datei zu einem bestehenden Paket hinzu, validieren Sie sie mit `python3 tools/rdl_lint.py rules/scanning/platform` und scannen Sie dann ein kleines positives/negatives Fixture. Der Scanner erkennt sie, ohne dass XML oder eine separate RDL-v1-Datei bearbeitet werden muss. Semantische Definitionen verbleiben unter [`rules/scanning/logic/rdl/v2/`](https://github.com/coffeeandsecurity/dakshscra/blob/main/rules/scanning/logic/rdl/v2). Native Text-Baselines, die von dieser Engine ausgewertet werden, bleiben Pattern Rules. Legacy-Auswahlen über `--rdl-engine` bleiben mit gespeicherten Scans und bestehenden Skripten kompatibel. Siehe den [Leitfaden zur Regel-Erstellung und Migration](https://github.com/coffeeandsecurity/dakshscra/blob/main/docs/usage-guide.md#pattern-rules-and-semantic-rules) für das YAML-Format, Bedingungen, Validierung, Evidenz-Einstellungen und den externen XML-Import. Anwendbare Plattform- und Framework-Pakete enthalten zudem Kandidaten für die Prüfung von Sicherheitsoperationen. Semantische Modelle unterscheiden Werte mit Antwortursprung, Quellen für Bulk-Binding und kryptografische Schlüsselargumente und können unterstützte Konfigurations-Fallbacks bis in Schlüsseloperationen zurückverfolgen. Neu erzeugte Befunde verknüpfen unterstützte Steuerungsdeklarationen für Methoden/Klassen mit der Operation; die typisierte C#-Modellprüfung kann deklarierte Feldrichtlinien beibehalten. Mandantentrennung erfordert eine anwendungsspezifische Invariante. Dies sind evidenzgestützte Prüffunktionen mit ausdrücklichen Modellierungsgrenzen, keine garantierte Erkennung jeder Autorisierungs- oder Business-Logic-Schwachstelle. Siehe [Sicherheitsoperationen und Steuerungskontext](https://github.com/coffeeandsecurity/dakshscra/blob/main/docs/usage-guide.md#security-operation-and-control-context). --- ## Struktur der Berichtsausgabe CLI-Ausgaben werden pro Scan unter `reports/<project>/<scan>/` aufbewahrt. CLI- und Web-UI-Exporte nutzen gemeinsame Sammlungen gespeicherter Daten und Renderer für HTML, PDF, Word und JSON. Das vollständige HTML öffnet eine leichtgewichtige Zusammenfassung/Index mit verlinkten, paginierten Detailseiten. Generieren Sie in der Web-UI einen Export unter **Reports**; entpacken Sie das HTML-ZIP und öffnen Sie zuerst `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 ``` Laufzeitdateien (Scan-Status, Logs, Inventar) werden unter `runtime/` geschrieben. Bei der Ausführung über die Web-UI werden die Ausgaben jedes Jobs zusätzlich unter `runtime/webui/jobs/<job-id>/artifacts/` gesichert (siehe [Web UI (Docker)](#web-ui-docker)). --- ## Autor | | | |---|---| | Website | [coffeeandsecurity.com](https://www.coffeeandsecurity.com) | | E-Mail | [email protected] | | Twitter / X | [@coffeensecurity](https://x.com/coffeensecurity) | | Quelle | [github.com/coffeeandsecurity/DakshSCRA](https://github.com/coffeeandsecurity/DakshSCRA) | | Lizenz | GNU General Public License v3.0 (GPL-3.0) | Wenn DakshSCRA Ihrem Team geholfen hat, erheblich Zeit, Aufwand oder Kosten zu sparen, die Abhängigkeit von teuren kommerziellen Tools zu verringern, die Prüfabdeckung zu verbessern oder Code-Reviews strukturierter und effektiver zu gestalten, können Sie sich gerne melden und Ihre Erfahrungen teilen. Ich freue mich immer über durchdachtes Feedback und interessante Gespräche. Einen Fehler gefunden oder möchten Sie etwas beitragen? Öffnen Sie ein Issue oder einen Pull Request auf GitHub. --- [Read more](https://github.com/coffeeandsecurity/dakshscra)
Entdecken Sie die meistgenutzten Tools unserer Community.
Noch keine Beliebtheitsdaten.