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.
127 lines
3.6 KiB
Go
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
|
|
}
|