## À propos de Daksh SCRA

L'outil Daksh SCRA (Source Code Review Assist) est conçu pour améliorer l'efficacité du processus de revue de code source, offrant une approche bien structurée et organisée pour les réviseurs de code.

Plutôt que de signaler indiscriminément tout comme un problème potentiel, Daksh SCRA favorise une analyse réfléchie, incitant à enquêter et à confirmer les problèmes potentiels. Cette approche réduit la précipitation à étiqueter chaque préoccupation potentielle comme un bogue, limitant ainsi la confusion et le temps perdu sur les faux positifs.

## Début

Daksh SCRA a été initialement présenté lors d'une session de formation sur la revue de code source à Black Hat USA 2022 (6-9 août), où il a été présenté subtilement à un public spécifique. Ses débuts officiels publics ont eu lieu à Black Hat USA 2023 à Las Vegas.

## Fonctionnalités et Capacités

### Caractéristiques Distinctives

- **Identifie les zones d'intérêt dans le code source :** Encourage une enquête et une confirmation ciblées plutôt que d'étiqueter indistinctement tout comme un bogue.
- **Identifie les zones d'intérêt dans les chemins de fichiers (Première mondiale) :** Reconnaît les motifs dans les chemins de fichiers pour cibler les sections pertinentes à examiner.
- **Reconnaissance au niveau logiciel pour identifier les technologies utilisées :** Identifie les technologies du projet, permettant aux réviseurs de code de mener des analyses précises avec des règles appropriées.
- **Estimation scientifique automatisée de l'effort pour la revue de code (Première mondiale) :** Fournit une approche mesurable pour estimer les efforts nécessaires à un processus de revue de code.
- **Analyse sensible au framework :** Applique automatiquement les règles spécifiques au framework lorsque le framework du projet est détecté.
- **Rapports d'analyse de contamination :** Rapports de flux de contamination HTML par plateforme avec des thèmes mode hacker et mode professionnel.
- **RDL (Rule Description Language) :** Logique de règle externe référencée avec `rdl_ref` et exécutée par le pipeline actuel `core/rdl_engine.py` - prend en charge les portes sensibles aux fichiers, les expressions booléennes, les observations du projet et les métadonnées de logique exportées dans les rapports.
- **État d'analyse / Reprise :** Enregistre les points de contrôle des analyses longues et reprend après interruption.
- **Référence de suppression :** Générer et appliquer une base de référence de faux positifs connus pour les supprimer des rapports futurs.
- **Interface Web :** Lanceur d'analyse basé sur navigateur avec flux console en temps réel et navigateur d'artefacts de tâche.

> Des améliorations actives sont en cours. De nombreuses nouvelles fonctionnalités et améliorations sont prévues pour les prochaines versions.

N'hésitez pas à contribuer à la mise à jour ou à l'ajout de nouvelles règles et au développement futur.

Si vous trouvez des bogues, signalez-les à [[email protected]](mailto:[email protected]).

Documentation détaillée : [https://dakshlabs.com/#docs](https://dakshlabs.com/#docs)

---

## Configuration de l'outil

### Prérequis

- Python 3.8+
- Toutes les bibliothèques listées dans `requirements.txt`

### 1. Télécharger Daksh SCRA```bash
git clone https://github.com/coffeeandsecurity/DakshSCRA.git

Ce script crée l'environnement virtuel, installe toutes les dépendances, et installe le navigateur Chromium de Playwright (nécessaire pour l'export PDF).

#### Option B: Configuration manuelle

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

Ensuite, installez les dépendances :```bash
cd path/to/DakshSCRA
pip install -r requirements.txt
playwright install chromium

| Option | Description |
|---|---|
| `-r RULES` | Règles de la plateforme (ex. `php`, `java`, `php,java`) ou `auto` pour la détection automatique |
| `-f FILE_TYPES` | Remplacer les types de fichiers par défaut pour l'analyse |
| `-v` | Niveau de verbosité (`-v`, `-vv`, `-vvv`) |
| `-t TARGET_DIR` | Répertoire cible du code source |
| `-l {R,RF}` | Lister les règles de la plateforme + frameworks `[R]` ou inclure les types de fichiers `[RF]` |
| `--recon` | Exécuter la reconnaissance (détection de la plateforme / framework / langage) |
| `--rs`, `--recon-strict` | Reconnaissance stricte : détections haute confiance uniquement (à utiliser avec `--recon`) |
| `--estimate` | Estimer l'effort de revue de code en fonction de la taille de la base de code |
| `-rpt`, `--report FORMATS` | Formats de rapport : `html`, `pdf` ou `html,pdf` (par défaut : `html`) |
| `--pdf-from-json` | Générer un ou plusieurs rapports PDF à partir de sorties JSON existantes sans re-scanner |
| `--json-input-dir PATH` | Répertoire des rapports JSON (par défaut : `./reports/data`) |
| `--pdf-output PATH` | Chemin de sortie PDF unique (par défaut : `./reports/scan/pdf/report.pdf`) |
| `--pdf-multi-dir PATH` | Répertoire de sortie PDF multi-fichier (par défaut : `./reports/scan/pdf/multi-file`) |
| `--pdf-single-only` | Générer uniquement le PDF combiné en un seul fichier ; ignorer l'ensemble multi-fichier par plateforme |
| `--skip-analysis` | Désactiver l'étape d'analyse pour cette exécution |
| `--loc` | Compter les lignes de code effectives |
| `--baseline-file PATH` | Fichier de base de suppression (JSON) |
| `--baseline-generate` | Générer une base de suppression à partir des résultats actuels |
| `--no-baseline` | Désactiver la suppression de base pour cette exécution |
| `--review-config PATH` | Fichier de triage des résultats (JSON) ; supprimer les faux positifs déjà examinés des rapports |
| `--resume-scan` | Reprendre une analyse interrompue précédemment à partir du fichier d'état |
| `--state-file PATH` | Chemin personnalisé du fichier d'état/point de contrôle d'analyse |
| `--no-state` | Désactiver la création de points de contrôle d'état pour cette exécution |
| `--state` | Forcer l'activation de la création de points de contrôle d'état pour cette exécution |

### Exemple d'utilisation

> `-f` (types de fichiers) est optionnel. S'il n'est pas spécifié, DakshSCRA utilise les types de fichiers par défaut pour la ou les plateformes sélectionnées.```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

Plateforme | Frameworks
|---|---|
| dotnet | aspnetcore, entityframework |
| php | codeigniter, drupal, laravel, symfony, wordpress |
| java | hibernate, spring, springboot |
| javascript | angular, express, nestjs, nextjs, react, vue |
| kotlin | ktor, springkotlin |
| python | django, fastapi, flask |
| go | echo, fiber, gin |
| c | freertos |
| cpp | boost, qt |
| android | cordova-android, flutter-android, ionic-android, jetpack, nativescript-android, reactnative-android, xamarin-android |
| ios | cordova-ios, flutter-ios, ionic-ios, nativescript-ios, reactnative-ios, swiftui, uikit, xamarin-ios |
| reactnative | reactnative |
| flutter | flutter |
| xamarin | xamarin |
| ionic | ionic |
| nativescript | nativescript |
| cordova | cordova |
| ruby | rails, sinatra |
| rust | actix, axum, rocket |
| common | - |

Pour obtenir les dernières plateformes et frameworks pris en charge, exécutez toujours :```bash
python dakshscra.py -l R

**Options de configuration de l'analyseur :**

- `analysis.run_by_default`
  - `true` : l'analyseur s'exécute automatiquement lors de l'analyse
  - `false` : l'analyseur est désactivé sauf s'il est réactivé dans la configuration ou via l'interface en ligne de commande
- `analysis.include_frameworks`
  - `true` : inclure les entrées d'analyseur au niveau du framework lorsque la détection de framework existe
  - `false` : uniquement la sortie de l'analyseur au niveau de la plateforme
- `analysis.report_theme`
  - `hacker_mode` : thème d'analyseur moderne sombre à fort contraste (par défaut)
  - `professional_mode` : thème d'analyseur moderne clair
  - `both` : générer les deux variantes de thème côte à côte

### Rédaction de règles RDL

RDL (Rule Description Language) est la couche de logique de règles externalisée de DakshSCRA. Dans l'architecture actuelle :

- Les règles XML restent l'inventaire des règles et portent des métadonnées telles que `name`, `regex`, des descriptions, et un `scan_config` optionnel.
- La logique RDL est exécutée par [`core/rdl_engine.py`](https://github.com/coffeeandsecurity/dakshscra/blob/HEAD/mnt/c/_Source/Developement/DakshSCRA/core/rdl_engine.py).
- Les fichiers de logique de règles se trouvent sous `rules/scanning/logic/...` et sont référencés depuis le XML avec `<rdl_ref>`.
- Les valeurs `rdl_ref` sont résolues par rapport à `rules/scanning/`, par exemple : `logic/php/core/some_rule.rdl` -> `rules/scanning/logic/php/core/some_rule.rdl`
- Les résultats de logique sont exportés dans le rapport JSON en tant que métadonnées telles que `logic_engine`, `logic_source`, `logic_reason`, `logic_trace`, `logic_consulted_files` et `logic_outcome`.

L'ancienne forme inline `<rdl>` n'est plus l'architecture active et ne doit pas être utilisée pour les nouvelles règles.

#### Aperçu de l'architecture RDL```text
XML rule
  -> regex / exclude / scan_config / descriptions
  -> rdl_ref
       -> rules/scanning/logic/<platform>/<scope>/<rule>.rdl
           -> core/rdl_engine.py
               -> pass / fail
               -> reason / fail_reason
               -> trace / consulted_files / outcome

RDL externe :```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.

RDL externe:```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.

RDL externe :```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.

Les fichiers d'exécution (état du scan, journaux, inventaire) sont écrits sous `runtime/`.

---

## Interface Web

Daksh SCRA inclut une interface frontale basée sur navigateur pour lancer des scans et suivre la progression en temps réel.```bash
docker compose up --build

Ensuite, ouvrez : [http://localhost:8080](http://localhost:8080)

**Exécutez la CLI dans Docker :**```bash
docker compose run --rm cli -h
docker compose run --rm cli -r auto -t /scan-targets/path/to/source

**Ce que Docker inclut :**

- FastAPI + interface web
- CLI complète de Daksh SCRA en tant que service séparé
- Playwright Chromium pour la génération de PDF
- Volumes persistants `reports/` et `runtime/`
- Montages de chemins hôtes pour que les analyses puissent atteindre les arborescences source depuis l'intérieur du conteneur

**Points de montage clés :**

| Montage | Chemin dans le conteneur |
|---|---|
| Source du projet | `/app` |
| Racine d'analyse par défaut | `/scan-targets` |
| Alias de lecteurs hôtes | `/host`, `/host/c`, `/host/d` |
| Montages WSL | `/mnt`, `/run/desktop/mnt/host` |

**Variables d'environnement (à configurer dans `.env`) :**

| Variable | Description |
|---|---|
| `DAKSH_PORT` | Port de l'interface web (par défaut : `8080`) |
| `DAKSH_SCAN_ROOT` | Répertoire cible par défaut dans le conteneur |
| `DAKSH_HOST_SOURCE` | Chemin hôte à monter en tant que `/scan-targets` (par défaut : `/tmp`) |
| `DAKSH_HOST_MOUNT` | Racine de montage hôte supplémentaire |
| `DAKSH_HOST_C` | Chemin du lecteur Windows C: (WSL) |
| `DAKSH_HOST_D` | Chemin du lecteur Windows D: (WSL) |
| `DAKSH_DESKTOP_MOUNT` | Chemin de montage du bureau WSL |
| `DAKSH_BROWSE_ROOTS` | Remplacer les racines du navigateur de répertoires (séparées par des virgules) |

Copiez `.env.example` vers `.env` et définissez les chemins pour votre machine avant d'exécuter Docker.

---

## Author

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

Si DakshSCRA a aidé votre équipe à économiser du temps, des efforts ou des coûts importants, à réduire la dépendance à des outils commerciaux coûteux, à améliorer la couverture des revues, ou à rendre la revue de code plus structurée et efficace, n'hésitez pas à nous contacter et à partager votre expérience. Je suis toujours ouvert aux retours réfléchis et aux conversations intéressantes.

Vous avez trouvé un bug ou vous souhaitez contribuer ? Ouvrez un problème ou une pull request sur GitHub.