When replacing a process with the same PID (fork/clone), and ebpf.QueueEventsSize is > 0 we may receive out or order events. For example if the checksum calculation takes too much time. Now we avoid updating the process in this scenario.
376 lines
9.9 KiB
Go
376 lines
9.9 KiB
Go
package procmon
|
|
|
|
import (
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/evilsocket/opensnitch/daemon/log"
|
|
)
|
|
|
|
var (
|
|
// EventsCache is the cache of processes
|
|
EventsCache *EventsStore
|
|
eventsCacheTicker *time.Ticker
|
|
|
|
// When we receive an Exit event, we'll delete it from cache if the PID is not alive.
|
|
// This TTL defines how much time we retain a PID on cache, before we receive
|
|
// an Exit event.
|
|
pidTTL = 20 // seconds
|
|
|
|
// Delay the deletion time of an item.
|
|
// Sometimes we may receive a connection event AFTER the Exit of the process.
|
|
// In these scenarios, we need to delay the deletion from cache a little bit.
|
|
// [exec] /bin/xxx, pid 1234
|
|
// [exit] /bin/xxx, pid 1234
|
|
// [new conn] pid 1234 -> process unknown (no /proc entry)
|
|
exitDelay, _ = time.ParseDuration("2s")
|
|
)
|
|
|
|
func init() {
|
|
EventsCache = NewEventsStore()
|
|
go monitorEventsCache()
|
|
}
|
|
|
|
// ProcessEvent represents an process event
|
|
type ProcessEvent struct {
|
|
Filename string
|
|
Args string
|
|
Comm string
|
|
PID uint64
|
|
PPID uint64
|
|
UID uint64
|
|
}
|
|
|
|
// ExecEventItem represents an item of the cache
|
|
type ExecEventItem struct {
|
|
//sync.RWMutex
|
|
Proc Process
|
|
LastSeen int64
|
|
TTL int32
|
|
}
|
|
|
|
func (e *ExecEventItem) isValid() bool {
|
|
lastSeen := time.Now().Sub(
|
|
time.Unix(0, e.LastSeen),
|
|
)
|
|
return int(lastSeen.Seconds()) < pidTTL
|
|
}
|
|
|
|
//EventsStore is the cache of exec events
|
|
type EventsStore struct {
|
|
eventByPID map[int]ExecEventItem
|
|
checksums map[string]uint
|
|
mu *sync.RWMutex
|
|
checksumsEnabled bool
|
|
}
|
|
|
|
// NewEventsStore creates a new store of events.
|
|
func NewEventsStore() *EventsStore {
|
|
if eventsCacheTicker != nil {
|
|
eventsCacheTicker.Stop()
|
|
}
|
|
eventsCacheTicker = time.NewTicker(10 * time.Second)
|
|
|
|
return &EventsStore{
|
|
mu: &sync.RWMutex{},
|
|
checksums: make(map[string]uint, 2),
|
|
eventByPID: make(map[int]ExecEventItem, 500),
|
|
}
|
|
}
|
|
|
|
// Add adds a new process to cache.
|
|
// If computing checksums is enabled, new checksums will be computed if needed,
|
|
// or reused existing ones otherwise.
|
|
func (e *EventsStore) Add(proc *Process) {
|
|
log.Debug("[cache] EventsStore.Add() %d, %s, %s, %d, total: %d", proc.ID, proc.Path, proc.Tree, proc.Starttime, e.Len())
|
|
// Add the item to cache ASAP,
|
|
// then calculate the checksums if needed.
|
|
e.UpdateItem(proc)
|
|
if e.GetComputeChecksums() {
|
|
if e.ComputeChecksums(proc) {
|
|
e.UpdateItem(proc)
|
|
}
|
|
}
|
|
log.Debug("[cache] EventsStore.Add() finished %d, %s, %s", proc.ID, proc.Path, proc.Tree)
|
|
}
|
|
|
|
// UpdateItem updates a cache item
|
|
func (e *EventsStore) UpdateItem(proc *Process) {
|
|
log.Trace("[cache] updateItem() updating events store (total: %d), pid: %d, path: %s, %d, %v", e.Len(), proc.ID, proc.Path, proc.Starttime, proc.Tree)
|
|
if proc.Path == "" {
|
|
return
|
|
}
|
|
e.mu.Lock()
|
|
defer e.mu.Unlock()
|
|
|
|
oldItem := e.eventByPID[proc.ID]
|
|
|
|
// Avoid replacing new procs with old ones.
|
|
// This can occur when QueueEventsSize is > 0 and computing the checksum takes more time than expected.
|
|
if oldItem.Proc.Path != proc.Path && oldItem.Proc.Starttime > proc.Starttime {
|
|
log.Trace("skipping out-of-order updateItem: %s (%d) -> %s (%d)", oldItem.Proc.Path, oldItem.Proc.Starttime, proc.Path, proc.Starttime)
|
|
return
|
|
}
|
|
|
|
ev := ExecEventItem{
|
|
Proc: *proc,
|
|
LastSeen: time.Now().UnixNano(),
|
|
}
|
|
e.eventByPID[proc.ID] = ev
|
|
}
|
|
|
|
// ReplaceItem replaces an existing process with a new one.
|
|
func (e *EventsStore) ReplaceItem(oldProc, newProc *Process) {
|
|
log.Trace("[event inCache, replacement] new: %d, %s -> inCache: %d -> %s - %d, Trees: %s, %s", newProc.ID, newProc.Path, oldProc.ID, oldProc.Path, newProc.Starttime, oldProc.Tree, newProc.Tree)
|
|
|
|
newProc.PPID = oldProc.ID
|
|
e.UpdateItem(newProc)
|
|
|
|
if newProc.ChecksumsCount() == 0 {
|
|
e.ComputeChecksums(newProc)
|
|
e.UpdateItem(newProc)
|
|
}
|
|
|
|
if len(oldProc.Tree) == 0 {
|
|
oldProc.GetParent()
|
|
oldProc.BuildTree()
|
|
e.UpdateItem(oldProc)
|
|
}
|
|
|
|
// TODO: work on improving the process tree (specially with forks/clones*)
|
|
if len(newProc.Tree) == 0 {
|
|
newProc.Parent = oldProc
|
|
newProc.BuildTree()
|
|
e.UpdateItem(newProc)
|
|
}
|
|
}
|
|
|
|
// Update ...
|
|
func (e *EventsStore) Update(oldProc, proc *Process) {
|
|
log.Debug("[cache Update old] %d in cache -> %s", oldProc.ID, oldProc.Path)
|
|
|
|
update := false
|
|
updateOld := false
|
|
|
|
// forked process. Update cache.
|
|
// execEvent -> pid: 12345, /usr/bin/exec-wrapper
|
|
// execEvent -> pid: 12345, /usr/bin/telnet
|
|
if proc != nil && (proc.ID == oldProc.ID && proc.Path != oldProc.Path) {
|
|
e.ReplaceItem(oldProc, proc)
|
|
return
|
|
}
|
|
|
|
if len(oldProc.Tree) == 0 {
|
|
oldProc.GetParent()
|
|
oldProc.BuildTree()
|
|
updateOld = true
|
|
}
|
|
|
|
if proc != nil && (len(oldProc.Tree) > 0 && len(proc.Tree) == 0 && oldProc.ID == proc.ID) {
|
|
proc.Tree = oldProc.Tree
|
|
update = true
|
|
}
|
|
|
|
if updateOld {
|
|
log.Trace("[cache] Update end, updating oldProc: %d, %s, %v", oldProc.ID, oldProc.Path, oldProc.Tree)
|
|
e.UpdateItem(oldProc)
|
|
}
|
|
if update {
|
|
log.Trace("[cache] Update end, updating newProc: %d, %s, %v", proc.ID, proc.Path, proc.Tree)
|
|
e.UpdateItem(proc)
|
|
}
|
|
}
|
|
|
|
func (e *EventsStore) needsUpdate(cachedProc, proc *Process) bool {
|
|
sumsCount := cachedProc.ChecksumsCount()
|
|
|
|
cachedProc.RLock()
|
|
defer cachedProc.RUnlock()
|
|
|
|
// check if this PID has replaced the PPID:
|
|
// systemd, pid:1234 -> curl, pid:1234 -> curl (i.e.: pid 1234) opens x.x.x.x:443
|
|
// Without this, we would display for example "systemd is connecting to x.x.x.x:443",
|
|
// instead of "curl is connecting to ..."
|
|
// The previous pid+path will still exist as parent of the new child, in proc.Parent
|
|
if proc != nil && (proc.ID == cachedProc.ID && proc.Path != cachedProc.Path) {
|
|
return true
|
|
}
|
|
|
|
if proc != nil && sumsCount > 0 && cachedProc.IsAlive() {
|
|
return false
|
|
}
|
|
|
|
if cachedProc != nil && sumsCount == 0 {
|
|
return true
|
|
}
|
|
|
|
if proc != nil && len(proc.Tree) == 0 {
|
|
return true
|
|
}
|
|
if cachedProc != nil && len(cachedProc.Tree) == 0 {
|
|
return true
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
// IsInStore checks if a PID is in the store.
|
|
// If the PID is in cache, we may need to update it if the PID
|
|
// is reusing the PID of the parent.
|
|
func (e *EventsStore) IsInStore(key int, proc *Process) (item ExecEventItem, needsUpdate, found bool) {
|
|
|
|
item, found = e.IsInStoreByPID(key)
|
|
if !found {
|
|
return
|
|
}
|
|
if found && e.needsUpdate(&item.Proc, proc) {
|
|
needsUpdate = true
|
|
return
|
|
}
|
|
|
|
log.Debug("[cache] Event found by PID: %d, %s", key, item.Proc.Path)
|
|
|
|
return
|
|
}
|
|
|
|
// IsInStoreByPID checks if a pid exists in cache.
|
|
func (e *EventsStore) IsInStoreByPID(key int) (item ExecEventItem, found bool) {
|
|
e.mu.RLock()
|
|
item, found = e.eventByPID[key]
|
|
e.mu.RUnlock()
|
|
|
|
if !found {
|
|
return
|
|
}
|
|
|
|
e.mu.Lock()
|
|
item.LastSeen = time.Now().UnixNano()
|
|
e.mu.Unlock()
|
|
|
|
return
|
|
}
|
|
|
|
// Len returns the number of items in cache.
|
|
func (e *EventsStore) Len() int {
|
|
e.mu.RLock()
|
|
defer e.mu.RUnlock()
|
|
return len(e.eventByPID)
|
|
}
|
|
|
|
// Delete schedules an item to be deleted from cache.
|
|
func (e *EventsStore) Delete(key int) {
|
|
e.mu.Lock()
|
|
ev, found := e.eventByPID[key]
|
|
e.mu.Unlock()
|
|
|
|
if !found {
|
|
return
|
|
}
|
|
time.AfterFunc(exitDelay, func() {
|
|
e.mu.Lock()
|
|
defer e.mu.Unlock()
|
|
if !ev.Proc.IsAlive() {
|
|
log.Trace("[cache delete] deleted %d: %s", key, ev.Proc.Path)
|
|
delete(e.eventByPID, key)
|
|
}
|
|
})
|
|
}
|
|
|
|
// DeleteOldItems deletes items that have exited and exceeded the TTL.
|
|
// Keeping them in cache for a short period of time sometimes helps to
|
|
// link some connections to processes.
|
|
// Alived processes are not deleted.
|
|
func (e *EventsStore) DeleteOldItems() {
|
|
e.mu.Lock()
|
|
defer e.mu.Unlock()
|
|
|
|
log.Debug("[cache] deleting old events, total byPID: %d", len(e.eventByPID))
|
|
for k, item := range e.eventByPID {
|
|
if !item.isValid() && !item.Proc.IsAlive() {
|
|
log.Trace("[cache] deleting old item: %d", k)
|
|
delete(e.eventByPID, k)
|
|
}
|
|
}
|
|
}
|
|
|
|
// ComputeChecksums obtains the checksums of the process
|
|
func (e *EventsStore) ComputeChecksums(proc *Process) bool {
|
|
|
|
if !e.checksumsEnabled || proc != nil && proc.IsAlive() && proc.ChecksumsCount() > 0 {
|
|
log.Debug("[cache] ComputeChecksums, already hashed: %s -> %v", proc.Path, proc.Checksums)
|
|
return false
|
|
}
|
|
proc.ComputeChecksums(e.checksums)
|
|
|
|
return true
|
|
}
|
|
|
|
// AddChecksumHash adds a new hash algorithm to compute checksums
|
|
func (e *EventsStore) AddChecksumHash(hash string) {
|
|
e.mu.Lock()
|
|
e.checksums[hash]++
|
|
e.mu.Unlock()
|
|
}
|
|
|
|
// DelChecksumHash deletes a hash algorithm from the list
|
|
func (e *EventsStore) DelChecksumHash(hash string) {
|
|
e.mu.Lock()
|
|
if _, found := e.checksums[hash]; found {
|
|
e.checksums[hash]--
|
|
}
|
|
e.mu.Unlock()
|
|
}
|
|
|
|
// SetComputeChecksums configures if we compute checksums of processes.
|
|
// When enabling this functionality, some already stored process may don't have
|
|
// the checksums computed yet, so when enabling compute them.
|
|
func (e *EventsStore) SetComputeChecksums(compute bool) {
|
|
e.mu.Lock()
|
|
defer e.mu.Unlock()
|
|
|
|
if compute == e.checksumsEnabled {
|
|
log.Debug("SetComputeChecksums(), no changes (%v, %v)", e.checksumsEnabled, compute)
|
|
return
|
|
}
|
|
e.checksumsEnabled = compute
|
|
if !compute {
|
|
log.Debug("SetComputeChecksums() disabled, deleting saved checksums")
|
|
for _, item := range e.eventByPID {
|
|
// XXX: reset saved checksums? or keep them in cache?
|
|
item.Proc.ResetChecksums()
|
|
}
|
|
return
|
|
}
|
|
log.Debug("SetComputeChecksums() enabled, recomputing cached checksums")
|
|
for _, item := range e.eventByPID {
|
|
if item.Proc.ChecksumsCount() == 0 {
|
|
item.Proc.ComputeChecksums(e.checksums)
|
|
}
|
|
}
|
|
}
|
|
|
|
// DisableChecksums disables computing checksums functionality.
|
|
func (e *EventsStore) DisableChecksums() {
|
|
e.mu.Lock()
|
|
defer e.mu.Unlock()
|
|
e.checksumsEnabled = false
|
|
e.checksums = make(map[string]uint)
|
|
}
|
|
|
|
// GetComputeChecksums returns if computing checksums is enabled or not.
|
|
// Disabled -> if there're no rules with checksum field.
|
|
// Disabled -> if events monitors are not available.
|
|
// Disabled -> if the user disables it globally.
|
|
// TODO: Disabled -> if there were n rules with checksums, but the user delete them.
|
|
func (e *EventsStore) GetComputeChecksums() bool {
|
|
e.mu.RLock()
|
|
defer e.mu.RUnlock()
|
|
return e.checksumsEnabled
|
|
}
|
|
|
|
func monitorEventsCache() {
|
|
for {
|
|
<-eventsCacheTicker.C
|
|
EventsCache.DeleteOldItems()
|
|
}
|
|
}
|