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
perfokernel.unprivileged_bpf_disableestá 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 llamasshdcon un sufijo). - Solución: Use
strncmp(comm, "sshd", 4) == 0o elimine el filtro para validar.
5.4 Performance impact alto
- Síntoma: La carga del servidor aumenta notablemente al ejecutar trazas.
- Recomendación:
- Limite los eventos con
if (pid == TARGET_PID). - Utilice
perf top -e syscalls:sys_enter_* -cpara identificar syscalls más costosos. - Reduzca la frecuencia de
intervalo utilice buffers de anillo en vez de prints directos.
- Limite los eventos con
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.