opensnitch/daemon/procmon/ebpf/utils.go
Gustavo Iñiguez Goia fbc72bb96a
mount tracefs path if it's not mounted
Some kernels or systems may not have tracefs mounted or available
by default.

We need the path /sys/kernel/tracing to be mounted, in order to add
syscalls ebpf probes.

So from now on we'll try to mount /sys/kernel/tracing if it's not
already mounted.

-check-requirements parameter updated to check if this option is
available.

Closes #1450.
2025-11-23 23:40:37 +01:00

127 lines
3.6 KiB
Go

package ebpf
import (
"bytes"
"encoding/binary"
"fmt"
"unsafe"
"github.com/evilsocket/opensnitch/daemon/core"
"github.com/evilsocket/opensnitch/daemon/log"
)
func determineHostByteOrder() {
lock.Lock()
//determine host byte order
buf := [2]byte{}
*(*uint16)(unsafe.Pointer(&buf[0])) = uint16(0xABCD)
switch buf {
case [2]byte{0xCD, 0xAB}:
hostByteOrder = binary.LittleEndian
case [2]byte{0xAB, 0xCD}:
hostByteOrder = binary.BigEndian
default:
log.Error("Could not determine host byte order.")
}
lock.Unlock()
}
func mountTraceFS() error {
tracefsPath := "/sys/kernel/tracing/"
kprobesPath := fmt.Sprint(tracefsPath, "kprobe_events")
if core.Exists(kprobesPath) == false {
if _, err := core.Exec("mount", []string{"-t", "tracefs", "none", tracefsPath}); err != nil {
log.Warning("eBPF tracefs error: %s", err)
return fmt.Errorf(`%s
Unable to access debugfs filesystem, needed for eBPF to work, likely caused by a hardened or customized kernel.
Change process monitor method to 'proc' to stop receiving this alert
`, err)
}
}
return nil
}
// Trim null characters, and return the left part of the byte array.
// NOTE: using BPF_MAP_TYPE_PERCPU_ARRAY does not initialize strings to 0,
// so we end up receiving events as follow:
// event.filename -> /usr/bin/iptables
// event.filename -> /bin/lsn/iptables (should be /bin/ls)
// It turns out, that there's a 0x00 character between "/bin/ls" and "n/iptables":
// [47 115 98 105 110 47 100 117 109 112 101 50 102 115 0 0 101 115
// ^^^
// TODO: investigate if there's any way of initializing the struct to 0
// like using __builtin_memset() (can't be used with PERCPU apparently)
func byteArrayToString(arr []byte) string {
temp := bytes.SplitAfter(arr, []byte("\x00"))[0]
return string(bytes.Trim(temp[:], "\x00"))
}
func deleteEbpfEntry(proto string, key []byte) bool {
if err := ebpfMaps[proto].bpfMap.Delete(&key); err != nil {
log.Trace("[eBPF] error deleting ebpf entry: %s", err)
return false
}
return true
}
func getItems(proto string, isIPv6 bool) (items uint) {
//isDup := make(map[string]uint8)
var lookupKey []byte
var nextKey []byte
if !isIPv6 {
lookupKey = make([]byte, 12)
nextKey = make([]byte, 12)
} else {
lookupKey = make([]byte, 36)
nextKey = make([]byte, 36)
}
prot, ok := ebpfMaps[proto]
if !ok || prot.bpfMap == nil {
log.Trace("[eBPF] getItems: %s", proto)
return
}
for err := prot.bpfMap.NextKey(nil, &lookupKey); ; err = prot.bpfMap.NextKey(&lookupKey, &nextKey) {
if err != nil {
break
}
log.Trace("[eBPF] %d cache item %s, key: %+v -> next: %+v", items, proto, lookupKey, nextKey)
lookupKey = nextKey
items++
}
return items
}
// deleteOldItems deletes maps' elements in order to keep them below maximum capacity.
// If ebpf maps are full they don't allow any more insertions, ending up lossing events.
func deleteOldItems(proto string, isIPv6 bool, maxToDelete uint) (deleted uint) {
var lookupKey []byte
var nextKey []byte
if !isIPv6 {
lookupKey = make([]byte, 12)
nextKey = make([]byte, 12)
} else {
lookupKey = make([]byte, 36)
nextKey = make([]byte, 36)
}
prot, ok := ebpfMaps[proto]
if !ok || prot.bpfMap == nil {
log.Trace("[eBPF] DELETE ITEMS: %s", proto)
return
}
for err := prot.bpfMap.NextKey(nil, &lookupKey); ; err = prot.bpfMap.NextKey(&lookupKey, &nextKey) {
log.Trace("[eBPF] DELETE ITEMS %s: %s -> %+v -> %+v", proto, err, lookupKey, nextKey)
if err != nil {
break
}
log.Trace("[eBPF] DELETE ITEMS %s: %+v -> %+v", proto, lookupKey, nextKey)
prot.bpfMap.Delete(&lookupKey)
lookupKey = nextKey
}
return
}