Admin-Sistemas ·

Implementación práctica de eBPF con BPF‑trace y perf para monitoreo de syscalls

En los últimos años eBPF (extended Berkeley Packet Filter) se ha convertido en una herramienta esencial para el diagnóstico y la seguridad de sistemas Linux. Gracias a su capacidad de ejecutar código en modo kernel sin necesidad de recompilar el núcleo, permite crear sondas de bajo impacto que capturan eventos en tiempo real. En este artículo veremos cómo combinar bpf‑trace y perf para monitorizar syscalls y detectar patrones de comportamiento sospechosos en servidores de producción.

1. Preparación del entorno

1.1 Requisitos de kernel y paquetes

eBPF está disponible a partir del kernel 4.9, aunque para aprovechar todas las funcionalidades (maps, ring buffers, etc.) se recomienda 5.8 o superior. Verifique la versión con:

uname -r

Instale los paquetes necesarios:

sudo apt-get update
sudo apt-get install -y bpftrace linux-tools-$(uname -r) linux-headers-$(uname -r) clang llvm libelf-dev

En distribuciones basadas en RHEL/Fedora:

sudo dnf install -y bpftrace perf clang llvm elfutils-libelf-devel

1.2 Configuración de permisos

Por defecto, sólo el usuario root puede cargar programas eBPF. Si desea que usuarios sin privilegios ejecuten trazas, añada su UID al grupo perf y habilite kernel.unprivileged_bpf_disable:

sudo usermod -aG perf $USER
sudo sysctl -w kernel.unprivileged_bpf_disable=0
# Persistir
echo "kernel.unprivileged_bpf_disable=0" | sudo tee -a /etc/sysctl.d/99-bpf.conf
sudo sysctl -p /etc/sysctl.d/99-bpf.conf

2. Captura básica de syscalls con bpf‑trace

2.1 Primer script: monitorizar open()

El siguiente script imprime cada llamada a openat con su PID, nombre de archivo y flags:

# bpftrace -e '
tracepoint:syscalls:sys_enter_openat {
    printf("%-6d %-16s %s\n", pid, comm, str(args->filename));
}'

Ejecute como root y abra algunos archivos para ver la salida.

2.2 Filtrado por proceso crítico

Para centrar la vigilancia en sshd (PID variable) use un filtro dinámico:

# bpftrace -e '
kprobe:sys_openat {
    @pid = pid;
    if (comm == "sshd") {
        printf("[sshd] %d %s\n", pid, str(arg0));
    }
}'

Esta traza solo muestra llamadas de sshd, reduciendo ruido.

2.3 Uso de maps para contar invocaciones

Un hash map permite acumular estadísticas por proceso:

# bpftrace -e '
tracepoint:syscalls:sys_enter_openat {
    @opens[comm] = count();
}'

Pulse Ctrl+C para detener y se mostrará un resumen como:

@opens[sshd]               342
@opens[nginx]              127
@opens[apache2]            215

3. Análisis avanzado con perf y eBPF

3.1 Perf record con eventos de syscalls

Perf puede capturar eventos de kernel y combinarse con scripts eBPF. Por ejemplo, registre todas las execve durante 30 s:

sudo perf record -e syscalls:sys_enter_execve -a -g -- sleep 30

Luego visualice el árbol de llamadas:

sudo perf script | perl -ne 'print if /execve/'
sudo perf report

3.2 Integrar BPF program con perf

Perf permite cargar un programa BPF con la opción -j. Creamos un programa que envía cada execve a un ring buffer:

cat > execve_monitor.c <<'EOF'
#include <linux/bpf.h>
#include <bpf/bpf_helpers.h>

struct { __uint(type, BPF_MAP_TYPE_RINGBUF); __uint(max_entries, 1 << 20); // 1 MiB } events SEC(“.maps”);

struct data_t { u32 pid; char comm[16]; char filename[256]; };

SEC(“tracepoint/syscalls/sys_enter_execve”) int trace_execve(struct trace_event_raw_sys_enter *ctx) { struct data_t *data; data = bpf_ringbuf_reserve(&events, sizeof(*data), 0); if (!data) return 0;

data->pid = bpf_get_current_pid_tgid() >> 32;
bpf_get_current_comm(&data->comm, sizeof(data->comm));
bpf_probe_read_user_str(&data->filename, sizeof(data->filename), (void *)ctx->args[0]);

bpf_ringbuf_submit(data, 0);
return 0;

} char LICENSE[] SEC(“license”) = “GPL”; EOF

sudo clang -O2 -target bpf -c execve_monitor.c -o execve_monitor.o sudo perf record -e bpftrace:tracepoint:syscalls:sys_enter_execve -j execve_monitor.o -a — sleep 20

Los datos se pueden leer con bpftrace -e 'ringbuf(&events)' o con un pequeño programa en C/Python.

3.3 Detección de patrones sospechosos

Un caso típico es la creación masiva de procesos sh desde contenedores comprometidos. Utilice un script que alerte cuando un mismo UID ejecuta más de 5 execve en 10 s:

# bpftrace -e '
tracepoint:syscalls:sys_enter_execve {
    @cnt[uid] = hist(count(), 1s);
}
interval:s:10 {
    foreach(k in @cnt) {
        if (@cnt[k] > 5) {
            printf("ALERTA: UID %d ejecutó %d procesos en los últimos 10s\n", k, @cnt[k]);
        }
        delete(@cnt[k]);
    }
}'

Este enfoque combina un mapa de histograma con una cláusula interval para generar alertas en tiempo real.

4. Estrategias de detección de actividades sospechosas

4.1 Identificación de comandos de escalada

Busque syscalls típicas de escalada: ptrace, chmod a binarios críticos, setuid. Ejemplo de traza combinada:

# bpftrace -e '
tracepoint:syscalls:sys_enter_ptrace { @ptrace[comm] = count(); }
tracepoint:syscalls:sys_enter_chmod  { @chmod[comm] = count(); }
tracepoint:syscalls:sys_enter_setuid { @setuid[comm] = count(); }

interval:s:30 { print(@ptrace); print(@chmod); print(@setuid); clear(@ptrace); clear(@chmod); clear(@setuid); }’

4.2 Correlación con logs de autenticación

Combine la salida de bpf‑trace con journalctl para verificar si un proceso que realiza muchos openat se ejecutó después de un login SSH exitoso:

# Obtener últimos logins
journalctl _SYSTEMD_UNIT=ssh.service --since "5 minutes ago" | grep "Accepted"

En paralelo, ejecutar bpf‑trace y guardar en /tmp/open.log

bpftrace -e ‘tracepoint:syscalls:sys_enter_openat { @open[pid] = count(); }’ -o /tmp/open.log &

Posteriormente, cruce PID y timestamps con un script Python.

5. Troubleshooting y errores comunes

5.1 Error: permission denied al cargar programa BPF

  • Causa: El usuario no está en el grupo perf o kernel.unprivileged_bpf_disable está activado.
  • Solución: Añada el usuario al grupo y desactive la restricción (ver sección 1.2).

5.2 Error: cannot find symbol 'bpf_probe_read_user_str'

  • Causa: Uso de una versión de clang/libbpf que no soporta la función.
  • Solución: Actualice clang a la versión 12 o superior y compile con -target bpf.

5.3 Falta de eventos en la salida

  • Causa: Filtrado demasiado estricto (p.ej., comm == "sshd" pero el proceso se llama sshd con un sufijo).
  • Solución: Use strncmp(comm, "sshd", 4) == 0 o elimine el filtro para validar.

5.4 Performance impact alto

  • Síntoma: La carga del servidor aumenta notablemente al ejecutar trazas.
  • Recomendación:
    1. Limite los eventos con if (pid == TARGET_PID).
    2. Utilice perf top -e syscalls:sys_enter_* -c para identificar syscalls más costosos.
    3. Reduzca la frecuencia de interval o utilice buffers de anillo en vez de prints directos.

Conclusión

eBPF, junto con herramientas como bpf‑trace y perf, brinda a los administradores de sistemas una capacidad sin precedentes para observar syscalls en tiempo real y detectar actividades sospechosas sin afectar la disponibilidad del servicio. La clave está en combinar filtros precisos, mapas de agregación y ciclos de alerta que permitan actuar rápidamente ante comportamientos anómalos. Con la configuración adecuada de permisos y una correcta compilación de los programas, cualquier servidor Linux puede transformarse en un sensor de seguridad proactivo, capaz de identificar intentos de escalada, malware o abuso de recursos antes de que se conviertan en incidentes críticos.