opensnitch/daemon/procmon/ebpf/ebpf.go
trvon 0be4f7c4c4
daemon: event-loss diagnostics via per-module event_stats counters
Add fixed-size, process-lifetime counters (received/enqueued/dropped/
drained/dequeued/decoded/decode-errors/reader-errors/canceled) for the
process and DNS eBPF event paths, exposed as individually-atomic
snapshots. Wire DNSEventCounters and ProcessEventCounters through the
perf reader/enqueue/decode loop in daemon/dns and daemon/procmon/ebpf,
with a matching ebpf_prog/event_stats.h and a structural eBPF test.
Counters hold totals only, never event payloads.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-11-05 16:58:11 -07:00

326 lines
9 KiB
Go

package ebpf
import (
"context"
"encoding/binary"
"fmt"
"sync"
"syscall"
"unsafe"
"github.com/cilium/ebpf"
"github.com/cilium/ebpf/link"
"github.com/cilium/ebpf/ringbuf"
"github.com/cilium/ebpf/rlimit"
"github.com/evilsocket/opensnitch/daemon/core"
"github.com/evilsocket/opensnitch/daemon/log"
daemonNetlink "github.com/evilsocket/opensnitch/daemon/netlink"
"github.com/evilsocket/opensnitch/daemon/procmon"
"github.com/vishvananda/netlink"
)
// KProbeDefs holds the hooks defined in the main module, for network interception.
type KProbeDefs struct {
KProbeTCPv4Connect *ebpf.Program `ebpf:"kprobe__tcp_v4_connect"`
KretProbeTCPv4Connect *ebpf.Program `ebpf:"kretprobe__tcp_v4_connect"`
KProbeTCPv6Connect *ebpf.Program `ebpf:"kprobe__tcp_v6_connect"`
KretProbeTCPv6Connect *ebpf.Program `ebpf:"kretprobe__tcp_v6_connect"`
KProbeUDPv4Connect *ebpf.Program `ebpf:"kprobe__udp_sendmsg"`
KProbeUDPv6Connect *ebpf.Program `ebpf:"kprobe__udpv6_sendmsg"`
KProbeIPtunnelXmit *ebpf.Program `ebpf:"kprobe__iptunnel_xmit"`
KProbeInetDgramConnect *ebpf.Program `ebpf:"kprobe__inet_dgram_connect"`
KretProbeInetDgramConnect *ebpf.Program `ebpf:"kretprobe__inet_dgram_connect"`
KProbeUDPtunnel6Xmit *ebpf.Program `ebpf:"kprobe__udp_tunnel6_xmit_skb"`
}
// MapDefs holds the map definitions of the main module
type MapDefs struct {
TCPMap *ebpf.Map `ebpf:"tcpMap"`
UDPMap *ebpf.Map `ebpf:"udpMap"`
TCPv6Map *ebpf.Map `ebpf:"tcpv6Map"`
UDPv6Map *ebpf.Map `ebpf:"udpv6Map"`
}
// container of hooks and maps
type ebpfDefsT struct {
KProbeDefs
MapDefs
}
// contains pointers to ebpf maps for a given protocol (tcp/udp/v6)
type ebpfMapsForProto struct {
bpfMap *ebpf.Map
}
//Not in use, ~4usec faster lookup compared to m.LookupElement()
// mimics union bpf_attr's anonymous struct used by BPF_MAP_*_ELEM commands
// from <linux_headers>/include/uapi/linux/bpf.h
type bpf_lookup_elem_t struct {
map_fd uint64 //even though in bpf.h its type is __u32, we must make it 8 bytes long
//because "key" is of type __aligned_u64, i.e. "key" must be aligned on an 8-byte boundary
key uintptr
value uintptr
}
type alreadyEstablishedConns struct {
TCP map[*daemonNetlink.Socket]int
TCPv6 map[*daemonNetlink.Socket]int
sync.RWMutex
}
// list of returned errors
const (
NoError = iota
NotAvailable
EventsNotAvailable
)
// Error returns the error type and a message with the explanation
type Error struct {
Msg error
What int // 1 global error, 2 events error, 3 ...
}
var (
m *ebpf.Collection
eventsReader *ringbuf.Reader
eventsDiagnostics *core.EventEmissionBinding
ebpfCfg Config
lock = sync.RWMutex{}
mapSize = uint(12000)
ebpfMaps map[string]*ebpfMapsForProto
//connections which were established at the time when opensnitch started
alreadyEstablished = alreadyEstablishedConns{
TCP: make(map[*daemonNetlink.Socket]int),
TCPv6: make(map[*daemonNetlink.Socket]int),
}
ctxTasks context.Context
cancelTasks context.CancelFunc
running = false
maxKernelEvents = 32768
kernelEvents = make(chan interface{}, maxKernelEvents)
// list of local addresses of this machine
localAddresses = make(map[string]netlink.Addr)
hostByteOrder binary.ByteOrder
// "Losing the reference to the resulting Link (kp) will close the Kprobe and
// prevent further execution of prog. The Link must be Closed during program
// shutdown to avoid leaking system resources."
// https://pkg.go.dev/github.com/cilium/ebpf/link#Kprobe
// array that holds the reference to every loaded hook.
hooks = []link.Link{}
collectionMaps = make([]*ebpf.Collection, 0)
)
// Start installs ebpf kprobes
func Start(ebpfOpts Config) *Error {
setConfig(ebpfOpts)
setRunning(false)
if err := rlimit.RemoveMemlock(); err != nil {
log.Warning("[eBPF] unable to remove memlock")
}
var err error
// load definitions from the elf file.
m, err = core.LoadEbpfModule("opensnitch.o", ebpfCfg.ModulesPath)
if err != nil {
return &Error{fmt.Errorf("[eBPF] Error loading opensnitch.o: %s", err.Error()), NotAvailable}
}
determineHostByteOrder()
// create objects from the definitions
ebpfMod := ebpfDefsT{}
if err := m.Assign(&ebpfMod); err != nil {
return &Error{fmt.Errorf("[eBPF] Error loading opensnitch.o (collection): %s", err), NotAvailable}
}
collectionMaps = append(collectionMaps, m)
kp, err := link.Kprobe("tcp_v4_connect", ebpfMod.KProbeTCPv4Connect, nil)
if err != nil {
log.Warning("opening kprobe: %s", err)
}
hooks = append(hooks, kp)
kp, err = link.Kretprobe("tcp_v4_connect", ebpfMod.KretProbeTCPv4Connect, nil)
if err != nil {
log.Warning("opening kretprobe: %s", err)
}
hooks = append(hooks, kp)
kp, err = link.Kprobe("tcp_v6_connect", ebpfMod.KProbeTCPv6Connect, nil)
if err != nil {
log.Warning("opening kprobe: %s", err)
}
hooks = append(hooks, kp)
kp, err = link.Kretprobe("tcp_v6_connect", ebpfMod.KretProbeTCPv6Connect, nil)
if err != nil {
log.Warning("opening kretprobe: %s", err)
}
hooks = append(hooks, kp)
kp, err = link.Kprobe("udp_sendmsg", ebpfMod.KProbeUDPv4Connect, nil)
if err != nil {
log.Warning("opening kprobe: %s", err)
}
hooks = append(hooks, kp)
kp, err = link.Kprobe("udpv6_sendmsg", ebpfMod.KProbeUDPv6Connect, nil)
if err != nil {
log.Warning("opening kprobe: %s", err)
}
hooks = append(hooks, kp)
kp, err = link.Kprobe("iptunnel_xmit", ebpfMod.KProbeIPtunnelXmit, nil)
if err != nil {
log.Warning("opening kprobe: %s", err)
}
hooks = append(hooks, kp)
kp, err = link.Kprobe("inet_dgram_connect", ebpfMod.KProbeInetDgramConnect, nil)
if err != nil {
log.Warning("opening kprobe: %s", err)
}
hooks = append(hooks, kp)
kp, err = link.Kretprobe("inet_dgram_connect", ebpfMod.KretProbeInetDgramConnect, nil)
if err != nil {
log.Warning("opening kretprobe: %s", err)
}
hooks = append(hooks, kp)
kp, err = link.Kprobe("udp_tunnel6_xmit_skb", ebpfMod.KProbeUDPtunnel6Xmit, nil)
if err != nil {
// likely. udp_tunnel6_xmit_skb depends on the module ip6_udp_tunnel being loaded.
log.Debug("opening kprobe: %s", err)
}
hooks = append(hooks, kp)
ebpfMaps = map[string]*ebpfMapsForProto{
"tcp": {bpfMap: ebpfMod.TCPMap},
"udp": {bpfMap: ebpfMod.UDPMap},
"tcp6": {bpfMap: ebpfMod.TCPv6Map},
"udp6": {bpfMap: ebpfMod.UDPv6Map},
}
for prot, mfp := range ebpfMaps {
if mfp.bpfMap == nil {
return &Error{fmt.Errorf("eBPF module opensnitch.o malformed, bpfmap[%s] nil", prot), NotAvailable}
}
}
ctxTasks, cancelTasks = context.WithCancel(context.Background())
ebpfCache = NewEbpfCache()
errf := initEventsStreamer()
saveEstablishedConnections(uint8(syscall.AF_INET))
if core.IPv6Enabled {
saveEstablishedConnections(uint8(syscall.AF_INET6))
}
go monitorCache()
go monitorMaps()
go monitorLocalAddresses()
go monitorAlreadyEstablished()
setRunning(true)
return errf
}
func saveEstablishedConnections(commDomain uint8) error {
// save already established connections
socketListTCP, err := daemonNetlink.SocketsDump(commDomain, uint8(syscall.IPPROTO_TCP))
if err != nil {
log.Debug("eBPF could not dump TCP (%d) sockets via netlink: %v", commDomain, err)
return err
}
for _, sock := range socketListTCP {
if sock == nil {
continue
}
inode := int((*sock).INode)
pid := procmon.GetPIDFromINode(inode, fmt.Sprint(inode,
(*sock).ID.Source, (*sock).ID.SourcePort, (*sock).ID.Destination, (*sock).ID.DestinationPort))
alreadyEstablished.Lock()
alreadyEstablished.TCP[sock] = pid
alreadyEstablished.Unlock()
}
return nil
}
func setRunning(status bool) {
lock.Lock()
defer lock.Unlock()
running = status
}
// Stop stops monitoring connections using kprobes
func Stop() {
log.Debug("ebpf.Stop()")
lock.RLock()
defer lock.RUnlock()
if running == false {
return
}
cancelTasks()
ebpfCache.clear()
// Retire borrowed diagnostic maps before their collection-owned FDs close.
eventsDiagnostics.Close()
if eventsReader != nil {
eventsReader.Close()
}
for _, k := range hooks {
if k != nil {
log.Trace("[eBPF] Stop() hook: %+v\n", k)
k.Close()
}
}
for _, k := range collectionMaps {
if k != nil {
log.Trace("[eBPF] Stop() map: %+v\n", k)
k.Close()
}
}
hooks = []link.Link{}
collectionMaps = make([]*ebpf.Collection, 0)
if m != nil {
m.Close()
}
}
// TODO: remove
// make bpf() syscall with bpf_lookup prepared by the caller
func makeBpfSyscall(bpf_lookup *bpf_lookup_elem_t) uintptr {
BPF_MAP_LOOKUP_ELEM := 1 //cmd number
syscall_BPF := 321 //syscall number
sizeOfStruct := 40 //sizeof bpf_lookup_elem_t struct
r1, _, _ := syscall.Syscall(uintptr(syscall_BPF), uintptr(BPF_MAP_LOOKUP_ELEM),
uintptr(unsafe.Pointer(bpf_lookup)), uintptr(sizeOfStruct))
return r1
}
func dispatchErrorEvent(what string) {
log.Error("%s", what)
dispatchEvent(what)
}
func dispatchEvent(data interface{}) {
if len(kernelEvents) > maxKernelEvents-1 {
//fmt.Printf("kernelEvents queue full (%d)", len(kernelEvents))
<-kernelEvents
}
select {
case kernelEvents <- data:
default:
}
}
func Events() <-chan interface{} {
return kernelEvents
}