Translated ['src/pentesting-web/rate-limit-bypass.md'] to fr

src/pentesting-web/rate-limit-bypass.md

@@ -52,8 +52,66 @@ Si le système cible applique des limites de taux sur une base par compte ou par
 
 Notez que même si une limite de taux est en place, vous devriez essayer de voir si la réponse est différente lorsque le OTP valide est envoyé. Dans [**ce post**](https://mokhansec.medium.com/the-2-200-ato-most-bug-hunters-overlooked-by-closing-intruder-too-soon-505f21d56732), le chasseur de bugs a découvert que même si une limite de taux est déclenchée après 20 tentatives infructueuses en répondant avec 401, si le valide était envoyé, une réponse 200 était reçue.
 
-### Outils
+---
 
-- [**https://github.com/Hashtag-AMIN/hashtag-fuzz**](https://github.com/Hashtag-AMIN/hashtag-fuzz): hashtag-fuzz est un outil de fuzzing conçu pour tester et contourner les WAF et les CDN. En tirant parti de fonctionnalités avancées telles que l'agent utilisateur aléatoire et la valeur d'en-tête, des délais aléatoires, la gestion du multi-threading, le fractionnement sélectif des listes de mots et la rotation de proxy Round Robin pour chaque morceau, il offre une solution robuste pour les professionnels de la sécurité cherchant à identifier des vulnérabilités dans les applications web.
+### Abuser du multiplexage HTTP/2 et du pipelining des requêtes (2023-2025)
+
+Les implémentations modernes de limiteurs de taux comptent fréquemment les **connexions TCP** (ou même les requêtes HTTP/1.1 individuelles) au lieu du *nombre de flux HTTP/2* qu'une connexion contient. Lorsque la même connexion TLS est réutilisée, un attaquant peut ouvrir des centaines de flux parallèles, chacun transportant une requête distincte, tandis que la passerelle ne déduit qu'*une* requête du quota.
+```bash
+# Send 100 POST requests in a single HTTP/2 connection with curl
+seq 1 100 | xargs -I@ -P0 curl -k --http2-prior-knowledge -X POST \
+-H "Content-Type: application/json" \
+-d '{"code":"@"}' https://target/api/v2/verify &>/dev/null
+```
+Si le limiteur protège uniquement `/verify` mais pas `/api/v2/verify`, vous pouvez également combiner **la confusion de chemin** avec le multiplexage HTTP/2 pour un *extrêmement* rapide OTP ou brute-forcing de crédentiels.
+
+> 🐾  **Astuce :** Le [Turbo Intruder](https://portswigger.net/research/turbo-intruder) de PortSwigger prend en charge HTTP/2 et vous permet d'affiner `maxConcurrentConnections` et `requestsPerConnection` pour automatiser cette attaque.
+
+### Aliases GraphQL & opérations groupées
+
+GraphQL permet au client d'envoyer **plusieurs requêtes ou mutations logiquement indépendantes dans une seule requête** en les préfixant avec *des alias*. Comme le serveur exécute chaque alias mais que le limiteur de débit compte souvent seulement *une* requête, c'est un contournement fiable pour le throttling de connexion ou de réinitialisation de mot de passe.
+```graphql
+mutation bruteForceOTP {
+a: verify(code:"111111") { token }
+b: verify(code:"222222") { token }
+c: verify(code:"333333") { token }
+# … add up to dozens of aliases …
+}
+```
+Regardez la réponse : exactement un alias renverra 200 OK lorsque le code correct est atteint, tandis que les autres sont soumis à une limitation de taux.
+
+La technique a été popularisée par la recherche de PortSwigger sur “GraphQL batching & aliases” en 2023 et a été responsable de nombreux paiements récents de bug-bounty.
+
+### Abus des points de terminaison REST *batch* ou *bulk*
+
+Certaines API exposent des points de terminaison d'assistance tels que `/v2/batch` ou acceptent un **tableau d'objets** dans le corps de la requête. Si le limiteur est placé uniquement devant les points de terminaison *legacy*, envelopper plusieurs opérations dans une seule requête bulk peut complètement contourner la protection.
+```json
+[
+{"path": "/login", "method": "POST", "body": {"user":"bob","pass":"123"}},
+{"path": "/login", "method": "POST", "body": {"user":"bob","pass":"456"}}
+]
+```
+### Chronométrage de la fenêtre glissante
+
+Un limiteur classique de type token-bucket ou leaky-bucket *se réinitialise* à une frontière temporelle fixe (par exemple, chaque minute). Si la fenêtre est connue (par exemple, via des messages d'erreur tels que `X-RateLimit-Reset: 27`), effectuez le nombre maximum de requêtes autorisées **juste avant** que le seau ne se réinitialise, puis effectuez immédiatement une autre pleine rafale.
+```
+|<-- 60 s window ‑->|<-- 60 s window ‑->|
+######                 ######
+```
+Cette simple optimisation peut plus que doubler votre débit sans toucher à aucune autre technique de contournement.
+
+---
+
+## Outils
+
+- [**https://github.com/Hashtag-AMIN/hashtag-fuzz**](https://github.com/Hashtag-AMIN/hashtag-fuzz) : Outil de fuzzing qui prend en charge la randomisation des en-têtes, des listes de mots en morceaux et la rotation de proxy en round-robin.
+- [**https://github.com/ustayready/fireprox**](https://github.com/ustayready/fireprox) : Crée automatiquement des points de terminaison AWS API Gateway jetables afin que chaque requête provienne d'une adresse IP différente – parfait pour vaincre le throttling basé sur l'IP.
+- **Burp Suite – IPRotate + extension** : Utilise un pool de proxies SOCKS/HTTP (ou AWS API Gateway) pour faire tourner l'IP source de manière transparente lors des attaques *Intruder* et *Turbo Intruder*.
+- **Turbo Intruder (BApp)** : Moteur d'attaque haute performance prenant en charge le multiplexage HTTP/2 ; réglez `requestsPerConnection` à 100-1000 pour regrouper des centaines de requêtes en une seule connexion.
+
+## Références
+
+- PortSwigger Research – “Bypassing rate limits with GraphQL aliasing” (2023) <https://portswigger.net/research/graphql-authorization-bypass>
+- PortSwigger Research – “HTTP/2: The Sequel is Always Worse” (section *Connection-based throttling*) (2024) <https://portswigger.net/research/http2>
 
 {{#include ../banners/hacktricks-training.md}}