opensnitch/daemon/netlink/procmon/procmon.go
Gustavo Iñiguez Goia 7a9bb17829
allow to filter connections by process checksum
Now you can create rules to filter processes by checksum. Only md5 is
available at the moment.

There's a global configuration option that you can use to enable or
disable this feature, from the config file or from the Preferences
dialog.

As part of this feature there have been more changes:

   - New proc monitor method (PROCESS CONNECTOR) that listens for
     exec/exit events from the kernel.
     This feature depends on CONFIG_PROC_EVENTS kernel option.

   - Only one cache of active processes for ebpf and proc monitor
     methods.

More info and details: #413.
2023-09-22 00:36:26 +02:00

149 lines
3.6 KiB
Go

package procmon
import (
"runtime"
"time"
"github.com/evilsocket/opensnitch/daemon/log"
"github.com/vishvananda/netlink"
"github.com/vishvananda/netns"
)
var (
// ProcEventsChannel channel of events to read
ProcEventsChannel = make(chan ProcEvent)
)
// ProcEvent represents the struct returned from kernel
type ProcEvent struct {
ev netlink.ProcEvent
TimeStamp uint64
PID uint32
PPID uint32
TGID uint32
PTGID uint32
}
// ProcEventsMonitor listens for process events from kernel.
// We listen for events via netlink, from the Process Events Conector:
// https://lwn.net/Articles/157150/
// The kernel must have the options CONFIG_CONECTOR and CONFIG_PROC_EVENTS enabled.
func ProcEventsMonitor(done <-chan struct{}) {
log.Info("ProcEventMonitor started\n")
runtime.LockOSThread()
defer runtime.UnlockOSThread()
pid1ns, err := netns.GetFromPid(1)
if err != nil {
log.Warning("unable to start netlink.ProcEventMonitor (0): %s", err)
return
}
err = netns.Set(pid1ns)
if err != nil {
log.Warning("unable to start netlink.ProcEventMonitor (1): %s", err)
return
}
ch := make(chan netlink.ProcEvent)
errChan := make(chan error)
if err := netlink.ProcEventMonitor(ch, done, errChan); err != nil {
log.Warning("unable to start netlink.ProcEventMonitor (2): %s", err)
return
}
for {
select {
case <-done:
goto Exit
case errc := <-errChan:
// We may receive "no buffer space available" when:
// - the daemon is stopped (ptrace, signal, etc).
// - sometimes after coming back from suspend.
log.Error("ProcEventMonitor error: %s", errc)
goto Error
case e := <-ch:
p := NewProcEvent(e)
if !p.IsExec() && !p.IsExit() {
// Msg may be nil in case of error
if p.ev.Msg == nil {
log.Warning("ProcEventMonitor Msg == nil")
goto Error
}
continue
}
ProcEventsChannel <- p
}
}
Error:
log.Info("reinitiating ProcEventMonitor")
time.Sleep(time.Second)
ProcEventsMonitor(done)
return
Exit:
log.Debug("netlink.ProcEventsMonitor stopped")
}
// NewProcEvent returns a new event received from kernel
func NewProcEvent(ev netlink.ProcEvent) ProcEvent {
pv := ProcEvent{ev: ev, TimeStamp: ev.Timestamp}
if pv.IsExec() {
if execEv, ok := pv.Msg().(*netlink.ExecProcEvent); ok {
pv.PID = execEv.ProcessPid
pv.TGID = execEv.ProcessTgid
}
} else if pv.IsExit() {
if exitEv, ok := pv.Msg().(*netlink.ExitProcEvent); ok {
pv.PID = exitEv.ProcessPid
pv.PPID = exitEv.ParentPid
pv.TGID = exitEv.ProcessTgid
pv.PTGID = exitEv.ParentTgid
}
}
/*else if pv.IsFork() {
if forkEv, ok := pv.Msg().(*netlink.ForkProcEvent); ok {
pv.PID = forkEv.ChildPid
pv.PPID = forkEv.ParentPid
pv.TGID = forkEv.ChildTgid
pv.PTGID = forkEv.ParentTgid
}
} else if pv.IsComm() {
fmt.Printf("COMM: %d\n", ev.Msg.Pid())
if commEv, ok := pv.Msg().(*netlink.CommProcEvent); ok {
fmt.Println("COMM EVENT ->", string(commEv.Comm[:]))
}
*/
return pv
}
// Msg returns the message received from netlink
func (pe *ProcEvent) Msg() interface{} {
return pe.ev.Msg
}
// Pid returns the pid of the event
func (pe *ProcEvent) Pid() uint32 {
return pe.ev.Msg.Pid()
}
// IsFork returns if the event is fork
func (pe *ProcEvent) IsFork() bool {
return pe.ev.What == netlink.PROC_EVENT_FORK
}
// IsExec returns if the event is exec
func (pe *ProcEvent) IsExec() bool {
return pe.ev.What == netlink.PROC_EVENT_EXEC
}
// IsComm returns if the event is comm
func (pe *ProcEvent) IsComm() bool {
return pe.ev.What == netlink.PROC_EVENT_COMM
}
// IsExit returns if the event is exit
func (pe *ProcEvent) IsExit() bool {
return pe.ev.What == netlink.PROC_EVENT_EXIT
}