# TCP Session Hijacking

## **📋 Índice**

1. [Conceitos Fundamentais](#-conceitos-fundamentais)
2. [Sequestro de Sessão vs Roubo de Cookie](#-sequestro-de-sessão-vs-roubo-de-cookie)
3. [Mecanismos de Ataque](#-mecanismos-de-ataque)
4. [Técnicas de Exploração](#-técnicas-de-exploração)
5. [Cenários de Exploração Prática](#-cenários-de-exploração-prática)
6. [Detecção e Ferramentas](#-detecção-e-ferramentas)
7. [Mitigação e Prevenção](#-mitigação-e-prevenção)

***

## **🔍 Conceitos Fundamentais**

O **TCP Session Hijacking** (Sequestro de Sessão TCP) consiste em um atacante assumir uma conexão TCP ativa entre um cliente e um servidor. Ao contrário do roubo de session tokens em nível de aplicação (HTTP), o sequestro TCP ocorre na camada de transporte, permitindo que o atacante injete comandos ou interaja com sistemas que não usam autenticação persistente em cada pacote (como Telnet ou conexões SSH legadas).

***

## **⚖️ Sequestro de Sessão vs Roubo de Cookie**

| Característica   | Session Hijacking (TCP)       | Session Hijacking (Web/App)      |
| ---------------- | ----------------------------- | -------------------------------- |
| **Camada OSI**   | Camada 4 (Transporte)         | Camada 7 (Aplicação)             |
| **Alvo**         | Números de Sequência TCP      | Cookies, JWT, Session ID         |
| **Persistência** | Dura enquanto a conexão durar | Dura enquanto o token for válido |
| **Protocolos**   | Qualquer TCP (TCP/IP)         | HTTP, HTTPS                      |

***

## **🏗️ Mecanismos de Ataque**

Para sequestrar uma sessão, o atacante precisa:

1. **IP Spoofing:** Fingir ser o IP da vítima.
2. **Adivinhação de SEQ/ACK:** Descobrir os números de sequência e reconhecimento esperados pelo servidor.

### **O Estado "ACK Storm"**

Quando o atacante injeta dados, o servidor aumenta seu número de sequência. A vítima original envia um pacote com o número antigo, o servidor rejeita e envia um ACK informando o número correto. A vítima envia novamente e isso gera um loop de pacotes ACK infinito, conhecido como **ACK Storm**, que frequentemente derruba a performance da rede.

***

## **🔧 Técnicas de Exploração**

### **1. Man-in-the-Middle (MitM)**

Se o atacante estiver no caminho entre o cliente e o servidor (ex: ARP Spoofing), ele pode simplesmente ler os números de sequência em tempo real e alterar os pacotes sem que nenhuma das partes perceba.

### **2. Blind Hijacking**

O atacante não vê o tráfego. Ele dispara milhares de pacotes com diferentes números de sequência até que um seja aceito pelo servidor. Isso é muito difícil em redes modernas com números de sequência aleatórios (TCP Initial Sequence Number - ISN randomization).

### **3. IP Source Routing**

Uma técnica antiga (quase sempre desabilitada hoje) onde o atacante especifica o caminho que o pacote deve percorrer, forçando-o a passar por sua máquina.

***

## **🚀 Cenários de Exploração Prática**

### **Cenário A: Sequestro de Telnet com Shijack**

O Telnet é vulnerável por não possuir criptografia. Ferramentas como o `shijack` automatizam o processo.

```bash
./shijack eth0 192.168.1.5 23 192.168.1.10
```

* `eth0`: Interface de rede.
* `192.168.1.5`: IP da vítima.
* `23`: Porta Telnet.
* `192.168.1.10`: IP do servidor.

### **Cenário B: Uso do Scapy para Captura e Injeção**

```python
# Script conceitual para injetar comandos em sessão ativa
from scapy.all import *

victim_ip = "192.168.1.5"
target_ip = "192.168.1.10"

def hijack(packet):
    if packet[IP].src == victim_ip and packet.haslayer(TCP):
        # Cria pacote forjado com comando "ls" ou "whoami"
        new_pkt = IP(src=victim_ip, dst=target_ip) / \
                  TCP(sport=packet[TCP].sport, dport=23, \
                      flags="PA", seq=packet[TCP].seq, ack=packet[TCP].ack) / \
                  "whoami\n"
        send(new_pkt)

sniff(filter=f"ip src {victim_ip}", prn=hijack)
```

***

## **🔍 Detecção e Ferramentas**

### **1. Wireshark**

Procure por retransmissões excessivas (TCP Retransmissions) e por muitos pacotes com a mesma flag ACK, o que indica uma possível "ACK Storm".

### **2. IDS/IPS (Snort)**

Sistemas de detecção de intrusão possuem assinaturas específicas para detectar ataques de desvio de número de sequência TCP.

***

## **🛡️ Mitigação e Prevenção**

### **1. Uso de Criptografia (Obrigatório)**

Protocolos como **SSH**, **HTTPS** e **IPSec** utilizam criptografia e autenticação de integridade de pacotes, tornando o sequestro TCP inútil mesmo que o atacante descubra os números de sequência.

### **2. ISN Randomization**

Garantir que o Sistema Operacional utilize geradores de números aleatórios fortes para os números de sequência iniciais do TCP.

### **3. Proteção contra ARP Spoofing**

Implementar segurança de porta (Port Security) e inspeção dinâmica de ARP (DAI) em switches para impedir ataques MitM locais.

***

> O TCP Session Hijacking clássico é raro em aplicações web modernas devido ao TLS (HTTPS), mas continua sendo uma ameaça real em sistemas industriais (SCADA) e redes legadas que ainda dependem de protocolos sem criptografia.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://0xmorte.gitbook.io/bibliadopentestbr/tecnicas/rede-and-infraestrutura/tcp/tcp-session-hijacking.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.