RatRace

---

Quel problème résout-il

Les conditions de concurrence représentent l'une des vulnérabilités de sécurité les plus impactantes dans les applications modernes, mais elles restent mal couvertes par les scanners automatisés. Alors que des outils comme Nuclei, ffuf et sqlmap excellent dans la détection des vulnérabilités statiques, ils sont fondamentalement aveugles aux problèmes liés à la concurrence.

Les testeurs d'intrusion sont aujourd'hui confrontés à un choix : écrire manuellement des scripts jetables pour chaque mission, ou ignorer complètement les tests de conditions de concurrence. Aucune des deux options n'est scalable ou professionnelle.

RatRace résout ce problème en fournissant un flux de travail soigné et reproductible pour les tests de conditions de concurrence — transformant ce qui était autrefois du script ad-hoc en un processus systématique qui s'intègre aux pipelines CI/CD et génère des rapports professionnels.

Impact dans le monde réel

Les vulnérabilités de conditions de concurrence apparaissent fréquemment dans des zones à fort impact :

• E-commerce : Commandes en double, survente d'inventaire, cumul de réductions
• Fintech : Transferts en double, escalade de privilèges par concurrence, rejeu de transactions
• Authentification : Épuisement de jetons, fixation de session, réinitialisations simultanées de mots de passe
• Limitation de débit : Contournement via requêtes concurrentes, abus distribué

Ces bugs rapportent systématiquement les plus hautes primes dans les programmes de bug bounty car ils menacent directement le chiffre d'affaires et la confiance des clients.

---

Capacités principales

Tests pilotés par modèles

Définissez une fois les scénarios de concurrence en YAML, réutilisez-les entre projets. Le format reprend celui des modèles Nuclei pour une familiarité immédiate :

id: checkout-race
info:
  name: Checkout Duplicate Order Race
  severity: critical
race:
  mode: burst
  concurrency: 20
  request:
    method: POST
    path: /api/v1/checkout
    headers:
      Authorization: "Bearer {{session}}"
    body: '{"item_id": "SKU-001"}'
validate:
  follow_up:
    method: GET
    path: /api/v1/orders?user={{user_id}}
  expect:
    json_field: "orders.length"
    condition: equals
    value: 1

Modes d'attaque multiples

Mode Rafale (Burst) — Requêtes parallèles basées sur goroutines avec synchronisation précise (stable, prêt pour la production)

• Lance N goroutines qui se synchronisent à la microseconde près
• Idéal pour la plupart des applications avec fenêtres de concurrence >5ms

Synchronisation du dernier octet (Last-Byte Sync) — Attaque au niveau TCP HTTP/1.1 (implémentation prête, phase de test)

• Maintient toutes les connexions au dernier octet du corps de la requête
• Déclenchement par diffusion close() pour des fenêtres sub-milliseconde
• Efficace contre les cibles réparties par charge et limitées en débit

Paquet unique (Single-Packet) — Attaque basée sur les trames HTTP/2 (implémentation prête, phase de test)

• Envoie toutes les requêtes dans un seul segment TCP
• Exploite le multiplexage pour une réception quasi simultanée par le serveur
• Contourne certains mécanismes de limitation de débit

Validation intelligente

RatRace automatiquement :

• Empreinte les réponses par code d'état + hash du corps pour détecter les anomalies
• Regroupe les résultats pour identifier les différences statistiquement significatives
• Calcule des scores de confiance basés sur la fréquence et l'ampleur des anomalies
• Exécute des requêtes de suivi pour confirmer les changements d'état (ex. : "l'article a-t-il vraiment été acheté deux fois ?")
• Prend en charge la validation conditionnelle avec les opérateurs : equals, not_equals, greater_than, contains

Intégration dans les flux de travail

Importer des requêtes existantes :

# Depuis des commandes curl
ratrace import --curl 'curl -X POST https://api.example.com/checkout ...' -o template.yaml

# Depuis des fichiers HAR exportés de Burp
ratrace import --har session.har -o template.yaml

Automatisation CI/CD :

ratrace race -u $TARGET -t template.yaml --silent
echo $?  # Code de sortie 10 = concurrence détectée, 0 = propre

Génération de rapports professionnels :

# JSON pour l'automatisation
ratrace race -u $TARGET -t template.yaml -o results/

# Rapports HTML (prévus en V2)
ratrace report --input results.json --format html

---

Installation

Depuis les sources

git clone https://github.com/bogdanticu88/ratrace.git
cd ratrace
go build ./cmd/ratrace
./ratrace --help

Prérequis : Go 1.24+

Docker

docker build -t ratrace:latest .
docker run --rm -it ratrace:latest race -u https://api.example.com -t template.yaml

---

Utilisation

Démarrage rapide : exécuter un test de concurrence

# 1. Importer depuis curl ou utiliser un modèle existant
ratrace import --curl 'curl -X POST https://api.example.com/checkout ...' -o checkout.yaml

# 2. Exécuter la concurrence
ratrace race -u https://api.example.com -t checkout.yaml -m burst -c 20

# 3. Examiner les résultats
# La sortie affiche :
# 🔴 [CRITICAL] Checkout Duplicate Order Race
#     Anomaly Rate: 91.7%
#     Confidence:   84%

Exemple : concurrence de checkout e-commerce

ratrace race \
  -u https://shop.example.com \
  -t examples/templates/checkout-race.yaml \
  -m burst \
  -c 25 \
  --output results/

Exemple : mode silencieux (pour CI/CD)

# S'exécute sans logs verbeux, se termine avec un code sémantique
ratrace race -u https://api.example.com -t template.yaml --silent

# Vérifier le code de sortie
if [ $? -eq 10 ]; then
  echo "Condition de concurrence détectée !"
  exit 1
fi

---

Référence des commandes

race — Exécuter une attaque par concurrence

ratrace race -u <url> -t <template> [options]

Options :
  -m, --mode string          burst|lastbyte|singlepacket (par défaut depuis le modèle)
  -c, --concurrency int      Nombre de goroutines (par défaut 20)
  -H, --header strings       En-têtes personnalisés (répétables)
  -x, --proxy string         URL du proxy pour les requêtes
  -o, --output string        Répertoire de sortie pour les résultats
  --timeout duration         Délai d'attente de la requête (par défaut 10s)
  --insecure                 Ignorer la vérification du certificat TLS
  --dry-run                  Analyser le modèle et quitter
  --silent                   Supprimer les logs, afficher uniquement les résultats

import — Convertir des requêtes en modèles

ratrace import [--curl <command> | --har <file>] -o <output.yaml>

Convertit les requêtes existantes (commandes curl ou exports HAR) en modèles RatRace.
Utile pour s'intégrer aux flux de travail existants.

report — Générer des rapports

ratrace report --input results.json --format [html|json] --output report.html

Génère des rapports lisibles par l'humain à partir des résultats des tests de concurrence.