opensnitch/ebpf_prog/opensnitch-procs.c
Gustavo Iñiguez Goia 8ec86c638c
ebpf: arm improvements
- better process interception on aarch64 and armhf.
 - on armhf getting proc arguments is ignored due to an error, but we
   were not marking the event as INCOMPLETE_ARGS, so we were not reading
   the compete cmdline.
2025-04-14 17:43:41 +02:00

219 lines
7.2 KiB
C

#define KBUILD_MODNAME "opensnitch-procs"
#include "common.h"
#include <net/sock.h>
struct {
// Since kernel 5.8
__uint(type, BPF_MAP_TYPE_RINGBUF);
// max_entries must be:
// - no 0
// - multiple of 4096
__uint(max_entries, 1 << 24);
} events SEC(".maps");
struct {
__uint(type, BPF_MAP_TYPE_HASH);
__type(key, u64);
__type(value, struct data_t);
__uint(max_entries, 1024);
} execMap SEC(".maps");
static __always_inline void new_event(struct data_t* data)
{
struct task_struct *task;
struct task_struct *parent;
__builtin_memset(&task, 0, sizeof(task));
__builtin_memset(&parent, 0, sizeof(parent));
task = (struct task_struct *)bpf_get_current_task();
bpf_probe_read(&parent, sizeof(parent), &task->real_parent);
data->pid = bpf_get_current_pid_tgid() >> 32;
#if !defined(__arm__) && !defined(__i386__)
// on i686 -> invalid read from stack
bpf_probe_read(&data->ppid, sizeof(u32), &parent->tgid);
#endif
data->uid = bpf_get_current_uid_gid() & 0xffffffff;
bpf_get_current_comm(&data->comm, sizeof(data->comm));
};
/*
* send to userspace the result of the execve* call.
*/
static __always_inline void __handle_exit_execve(struct trace_sys_exit_execve *ctx)
{
u64 pid_tgid = bpf_get_current_pid_tgid();
struct data_t *proc = (struct data_t *)bpf_map_lookup_elem(&execMap, &pid_tgid);
// don't delete the pid from execMap here, delegate it to sched_process_exit
if (proc == NULL) { return; }
if (ctx->ret != 0) {
debug("exec EXIT: ret != 0: %d, pid: %d -> %s\n", ctx->ret, pid_tgid, proc->filename);
//return;
}
proc->ret_code = ctx->ret;
int ret = bpf_ringbuf_output(&events, proc, sizeof(*proc), 0);
if (ret != 0){
debug("execve send error: %d, %d, %s\n", ret, pid_tgid, proc->filename);
}
}
// https://0xax.gitbooks.io/linux-insides/content/SysCall/linux-syscall-4.html
// bprm_execve REGS_PARM3
// https://elixir.bootlin.com/linux/latest/source/fs/exec.c#L1796
SEC("tracepoint/sched/sched_process_exit")
int tracepoint__sched_sched_process_exit(struct pt_regs *ctx)
{
u64 pid_tgid = bpf_get_current_pid_tgid();
struct data_t *proc = (struct data_t *)bpf_map_lookup_elem(&execMap, &pid_tgid);
// if the pid is not in execMap cache (because it's not of a pid we've
// previously intercepted), do not send the event to userspace, because
// we won't do anything with it and it consumes CPU cycles (too much in some
// scenarios).
if (proc == NULL) { return 0; }
int zero = 0;
struct data_t *data = (struct data_t *)bpf_map_lookup_elem(&heapstore, &zero);
if (!data){ return 0; }
new_event(data);
data->type = EVENT_SCHED_EXIT;
bpf_ringbuf_output(&events, data, sizeof(*data), 0);
bpf_map_delete_elem(&execMap, &pid_tgid);
return 0;
};
SEC("tracepoint/syscalls/sys_exit_execve")
int tracepoint__syscalls_sys_exit_execve(struct trace_sys_exit_execve *ctx)
{
__handle_exit_execve(ctx);
return 0;
};
SEC("tracepoint/syscalls/sys_exit_execveat")
int tracepoint__syscalls_sys_exit_execveat(struct trace_sys_exit_execve *ctx)
{
__handle_exit_execve(ctx);
return 0;
};
SEC("tracepoint/syscalls/sys_enter_execve")
int tracepoint__syscalls_sys_enter_execve(struct trace_sys_enter_execve* ctx)
{
int zero = 0;
struct data_t *data = (struct data_t *)bpf_map_lookup_elem(&heapstore, &zero);
if (!data){
debug("sys_enter_execve: error reserving data space\n");
return 0;
}
new_event(data);
data->type = EVENT_EXEC;
data->args_count = 0;
data->args_partial = INCOMPLETE_ARGS;
bpf_probe_read_user_str(&data->filename, sizeof(data->filename), (const char *)ctx->filename);
// FIXME: on i386 arch, the following code fails with permission denied.
#if !defined(__arm__) && !defined(__i386__)
const char *argp={0};
#pragma unroll
for (int i = 0; i < MAX_ARGS; i++) {
bpf_probe_read_user(&argp, sizeof(argp), &ctx->argv[i]);
if (!argp){ data->args_partial = COMPLETE_ARGS; break; }
if (bpf_probe_read_user_str(&data->args[i], MAX_ARG_SIZE, argp) >= MAX_ARG_SIZE){
break;
}
data->args_count++;
}
#endif
// FIXME: on aarch64 we fail to save the event to execMap, so send it to userspace here.
#if defined(__aarch64__)
bpf_ringbuf_output(&events, data, sizeof(*data), 0);
#else
u64 pid_tgid = bpf_get_current_pid_tgid();
// in case of failure adding the item to the map, send it directly
if (bpf_map_update_elem(&execMap, &pid_tgid, data, BPF_ANY) != 0) {
// https://docs.ebpf.io/linux/helper-function/bpf_perf_event_output/
//
// "Each perf event is created on a specific CPU. This helper can only
// write to perf events on the same CPU as the eBPF program is running.
// Manually picking an index containing a perf event on a different CPU
// will result in a -EOPNOTSUPP error at runtime. So unless there is a
// good reason to do so, its recommended to use BPF_F_CURRENT_CPU and to
// populate the BPF_MAP_TYPE_PERF_EVENT_ARRAY map in such a way where the
// CPU indices and map indices are the same."
//
// -95 EOPNOTSUPP (op not supported) -> event on different CPU.
// https://elixir.bootlin.com/linux/v5.2.21/source/kernel/trace/bpf_trace.c#L413
// -28 ENOSPC (no space left)
// -> perf reader buffer too small.
// -> also happens after coming back from suspend state.
// -11 EAGAIN - ringbuf full?
// -7 E2BIG (arg list too long) -> too much args?
// -2 ENOENT (no such file or directory) -> map index not found. on different cpu?
bpf_ringbuf_output(&events, data, sizeof(*data), 0);
}
#endif
return 0;
};
SEC("tracepoint/syscalls/sys_enter_execveat")
int tracepoint__syscalls_sys_enter_execveat(struct trace_sys_enter_execveat* ctx)
{
int zero = 0;
struct data_t *data = {0};
data = (struct data_t *)bpf_map_lookup_elem(&heapstore, &zero);
if (!data){
debug("sys_enter_execveat: error reserving data space\n");
return 0;
}
new_event((void *)data);
data->type = EVENT_EXECVEAT;
bpf_probe_read_user_str(&data->filename, sizeof(data->filename), (const char *)ctx->filename);
data->args_count = 0;
data->args_partial = INCOMPLETE_ARGS;
// FIXME: on i386 arch, the following code fails with permission denied.
#if !defined(__arm__) && !defined(__i386__)
const char *argp={0};
#pragma unroll
for (int i = 0; i < MAX_ARGS; i++) {
bpf_probe_read_user(&argp, sizeof(argp), &ctx->argv[i]);
if (!argp){ data->args_partial = COMPLETE_ARGS; break; }
if (bpf_probe_read_user_str(&data->args[i], MAX_ARG_SIZE, argp) >= MAX_ARG_SIZE){
break;
}
data->args_count++;
}
#endif
#if defined(__aarch64__)
bpf_ringbuf_output(&events, data, sizeof(*data), 0);
#else
u64 pid_tgid = bpf_get_current_pid_tgid();
if (bpf_map_update_elem(&execMap, &pid_tgid, data, BPF_ANY) != 0) {
bpf_ringbuf_output(&events, data, sizeof(*data), 0);
}
#endif
return 0;
};
char _license[] SEC("license") = "GPL";
// this number will be interpreted by the elf loader
// to set the current running kernel version
u32 _version SEC("version") = 0xFFFFFFFE;