## À propos de Daksh SCRA

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

Plutôt que de signaler indistinctement tout comme un problème potentiel, Daksh SCRA favorise une analyse réfléchie, incitant à l'investigation et à la confirmation des problèmes potentiels. Cette approche réduit la précipitation à étiqueter chaque préoccupation potentielle comme un bug, diminuant ainsi la confusion et le temps perdu sur les faux positifs.

### Débuts

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

## Fonctionnalités et caractéristiques

- **Identifie les zones d'intérêt dans le code source :** Encourage une investigation et une confirmation ciblées plutôt que d'étiqueter indistinctement tout comme un bug.
- **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 repérer 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 d'effectuer des analyses précises avec les 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 l'effort requis pour une revue de code.
- **Analyse adaptée au framework :** Applique automatiquement les règles spécifiques au framework lorsque celui du projet est détecté.
- **Rapports d'analyse de flux de données (taint) :** Rapports HTML de flux de données par plateforme avec des thèmes mode hacker et mode professionnel.
- **RDL (Rule Description Language) :** Logique de règles externe référencée avec `rdl_ref` et exécutée par le pipeline `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 :** Enregistrez les analyses longues et reprenez-les après une interruption.
- **Base de référence de suppression :** Générez et appliquez une base de référence des faux positifs connus pour les supprimer des futurs rapports.
- **Interface Web :** Lanceur d'analyse basé sur navigateur avec flux de console en temps réel et navigateur d'artefacts de tâches.

> 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 bugs, signalez-les à [[email protected]](mailto:[email protected]).

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

---

## Pour commencer

Il existe deux façons d'exécuter Daksh SCRA - choisissez celle qui correspond à votre flux de travail :

| | Idéal pour | Accéder à |
|---|---|---|
| 🌐 **Interface Web (Docker)** | La façon la plus simple de démarrer - une commande, un tableau de bord navigateur, une progression d'analyse en direct et un navigateur de rapports/artefacts. Recommandé pour la plupart des utilisateurs. | [Interface Web (Docker)](#web-ui-docker) |
| 💻 **CLI (Python)** | Scripts, pipelines CI ou exécution d'analyses sans Docker. | [Configuration CLI](#cli-setup) |

Les deux chemins exécutent exactement le même moteur d'analyse - l'interface Web est un front-end navigateur au-dessus de la même CLI, donc les résultats sont identiques dans les deux cas.

---

## Interface Web (Docker)

Le moyen le plus rapide d'exécuter Daksh SCRA est via son interface Web basée sur navigateur, lancée avec une seule commande Docker Compose. Elle vous offre un lanceur d'analyse, un flux de console en direct et un historique consultable des rapports passés, sans nécessiter d'environnement Python local.

La configuration Docker exécute l'interface Web et la CLI comme des services indépendants construits à partir de la même image, vous pouvez donc utiliser l'un ou l'autre (ou les deux) à partir du même conteneur.

### Lancer l'interface Web

Mode avant-plan (les journaux sont diffusés dans votre terminal) :```bash
docker compose up --build

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

Pour utiliser un autre port :```bash
DAKSH_PORT=9090 docker compose up

### Connexion

L'interface Web nécessite un compte. Au premier démarrage, un compte administrateur initial est créé à partir de `DAKSH_ADMIN_USERNAME` / `DAKSH_ADMIN_PASSWORD` (définissez-les dans `.env`) ; si `DAKSH_ADMIN_PASSWORD` n'est pas défini, un mot de passe aléatoire est généré et affiché une seule fois dans le journal de démarrage de l'API — conservez-le, car il ne peut pas être récupéré par la suite.

Vous devrez définir votre propre mot de passe (et, éventuellement, votre nom d'utilisateur) lors de votre première connexion. Un compte administrateur peut créer d'autres comptes via le point de terminaison d'API `POST /api/v1/auth/users` (aucune interface dédiée pour cela pour l'instant). Consultez `.env.example` pour la liste complète des paramètres liés à l'authentification (durée de session, sécurité des cookies, CORS).

### Ce que vous obtenez

- Générateur de commandes réactif pour les modes scan, recon, estimate, recon+estimate, list et PDF-depuis-JSON
- Flux de console en temps réel et progression en direct par étape pendant l'exécution
- Instantanés d'artefacts par tâche pour les sorties HTML / PDF / JSON
- Navigation rapide dans le navigateur entre le formulaire d'exécution, le flux en direct, les artefacts et les tâches récentes
- Navigateur de répertoires intégré pour sélectionner les chemins cibles (compatible OS : Windows, macOS, Linux / Docker)

Sous le capot, la CLI reste la source de vérité — elle effectue toutes les analyses et génère chaque sortie HTML / PDF / JSON. L'interface Web exécute une tâche active à la fois et capture les sorties de chaque tâche terminée dans `runtime/webui/jobs/<job-id>/artifacts/` afin que les rapports passés restent accessibles.

### Exécution de la CLI dans Docker

Vous n'avez pas non plus besoin d'un environnement Python local pour utiliser la CLI — elle est disponible en tant que service Compose dédié, construit à partir de la même image :```bash
docker compose run --rm cli -h
docker compose run --rm cli -r auto -t /scan-targets/path/to/source

Ou téléchargez la dernière archive zip depuis [https://github.com/coffeeandsecurity/DakshSCRA](https://github.com/coffeeandsecurity/DakshSCRA) et décompressez-la.

### 2. Configurer un environnement virtuel

> 💡 L’environnement virtuel peut être créé dans n’importe quel répertoire — il n’est pas nécessaire qu’il se trouve dans le dossier DakshSCRA.

**Option A : Configuration en une étape (recommandée)**```bash
python setup_env.py

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

---

## Utilisation en ligne de commande

Utilisez `python` dans un environnement virtuel, ou `python3` en dehors de celui-ci.

### Options de la ligne de commande```
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]

### Règles et frameworks de plateformes pris en charge```bash
python dakshscra.py -l R    # List platform rules and framework mappings
python dakshscra.py -l RF   # List platform rules, framework mappings, and filetypes

---

## Référence de configuration

### `config/tool.yaml`

Les valeurs par défaut du runtime de Daksh SCRA sont contrôlées via `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

#### Séquence de scan

Pour une règle source, DakshSCRA évalue la logique dans cet ordre :

1. Recon sélectionne les plateformes et frameworks correspondants.
2. La règle XML est chargée depuis `rules/scanning/platform/...`.
3. `regex` identifie les lignes candidates ou les correspondances sur l'ensemble du fichier lorsqu'elles sont présentes.
4. `exclude` supprime le bruit évident pour cette règle, s'il est présent.
5. Le fichier externe `.rdl` de `rdl_ref` est évalué par rapport au texte du fichier actuel, au chemin du fichier actuel et à la racine du projet.
6. Si le script RDL réussit, DakshSCRA conserve la découverte et fusionne les métadonnées de logique exportées dans la sortie du rapport.
7. Si le script RDL échoue, la correspondance est supprimée avec la raison de l'échec RDL et les métadonnées de trace de décision.

Pour les règles de chemin de fichier dans `filepaths.xml`, le même modèle `rdl_ref` s'applique, mais le sujet de correspondance est
le chemin relatif normalisé au lieu du texte du code source. Dans ce mode, RDL reçoit la chaîne du chemin relatif
comme texte du fichier actuel et contexte de chemin.

#### Structure actuelle des règles```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>

#### Disposition actuelle```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.

Les fichiers d’exécution (état d’analyse, journaux, inventaire) sont écrits sous `runtime/`.

Lors de l’exécution via l’interface Web, les sorties de chaque tâche sont en outre enregistrées sous forme d’instantanés dans `runtime/webui/jobs/<job-id>/artifacts/` (voir [Interface Web (Docker)](#web-ui-docker)).

---

## Auteur

| | |
|---|---|
| Site web | [coffeeandsecurity.com](https://www.coffeeandsecurity.com) |
| E-mail | [email protected] |
| Twitter / X | [@coffeensecurity](https://x.com/coffeensecurity) |
| Source | [github.com/coffeeandsecurity/DakshSCRA](https://github.com/coffeeandsecurity/DakshSCRA) |
| Licence | Licence publique générale GNU v3.0 (GPL-3.0) |

Si DakshSCRA a aidé votre équipe à économiser un temps, des efforts ou des coûts considérables, à réduire sa dépendance aux outils commerciaux onéreux, à 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 souhaitez contribuer ? Ouvrez une issue ou une pull request sur GitHub.