When getting a connection from the cache, use the UID of the connection, instead of the process UID. more info: https://github.com/evilsocket/opensnitch/issues/1315#issuecomment-2829072245 Closes: #1315
235 lines
7.6 KiB
Go
235 lines
7.6 KiB
Go
package ebpf
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"fmt"
|
|
"net"
|
|
"strconv"
|
|
|
|
"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"
|
|
)
|
|
|
|
// we need to manually remove old connections from a bpf map
|
|
|
|
// GetPid looks up process pid in a bpf map.
|
|
// If it's not found, it searches already-established TCP connections.
|
|
// Returns the process if found.
|
|
// Additionally, if the process has been found by swapping fields, it'll return
|
|
// a flag indicating it.
|
|
func GetPid(proto string, srcPort uint, srcIP net.IP, dstIP net.IP, dstPort uint) (*procmon.Process, bool, error) {
|
|
if proc := getPidFromEbpf(proto, srcPort, srcIP, dstIP, dstPort); proc != nil {
|
|
return proc, false, nil
|
|
}
|
|
if findAddressInLocalAddresses(dstIP) {
|
|
// NOTE:
|
|
// Sometimes we may receive response packets instead of new outbound connections:
|
|
// 443:public-ip -> local-ip:local-port.
|
|
// @see: e090833d29738274c1d171eba53e239c1c49ea7c
|
|
// This occurs mainly when using Conntrack to intercept outbound connections.
|
|
// Swapping connection fields helps to identify the connection + pid + process, and continue working as usual.
|
|
|
|
return nil, false, fmt.Errorf("[ebpf conn] unknown source IP: %s", srcIP)
|
|
}
|
|
//check if it comes from already established TCP
|
|
if proto == "tcp" || proto == "tcp6" {
|
|
if pid, uid, err := findInAlreadyEstablishedTCP(proto, srcPort, srcIP, dstIP, dstPort); err == nil {
|
|
proc := procmon.NewProcess(pid, "")
|
|
proc.UID = uid
|
|
return proc, false, nil
|
|
}
|
|
}
|
|
|
|
//using netlink.GetSocketInfo to check if UID is 0 (in-kernel connection)
|
|
if uid, _ := daemonNetlink.GetSocketInfo(proto, srcIP, srcPort, dstIP, dstPort); uid == 0 {
|
|
return nil, false, nil
|
|
}
|
|
return nil, false, nil
|
|
}
|
|
|
|
// getPidFromEbpf looks up a connection in bpf map and returns PID if found
|
|
// the lookup keys and values are defined in opensnitch.c , e.g.
|
|
//
|
|
// struct tcp_key_t {
|
|
// u16 sport;
|
|
// u32 daddr;
|
|
// u16 dport;
|
|
// u32 saddr;
|
|
// }__attribute__((packed));
|
|
|
|
// struct tcp_value_t{
|
|
// u64 pid;
|
|
// u64 uid;
|
|
// u64 counter;
|
|
// char[TASK_COMM_LEN] comm; // 16 bytes
|
|
// }__attribute__((packed));
|
|
|
|
func getPidFromEbpf(proto string, srcPort uint, srcIP net.IP, dstIP net.IP, dstPort uint) (proc *procmon.Process) {
|
|
// Some connections, like broadcasts, are only seen in eBPF once,
|
|
// but some applications send 1 connection per network interface.
|
|
// If we delete the eBPF entry the first time we see it, we won't find
|
|
// the connection the next times.
|
|
delItemIfFound := true
|
|
|
|
_, ok := ebpfMaps[proto]
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
var value networkEventT
|
|
var key []byte
|
|
var isIP4 bool = (proto == "tcp") || (proto == "udp") || (proto == "udplite")
|
|
|
|
if isIP4 {
|
|
key = make([]byte, 12)
|
|
copy(key[2:6], dstIP)
|
|
binary.BigEndian.PutUint16(key[6:8], uint16(dstPort))
|
|
copy(key[8:12], srcIP)
|
|
} else { // IPv6
|
|
key = make([]byte, 36)
|
|
copy(key[2:18], dstIP)
|
|
binary.BigEndian.PutUint16(key[18:20], uint16(dstPort))
|
|
copy(key[20:36], srcIP)
|
|
}
|
|
hostByteOrder.PutUint16(key[0:2], uint16(srcPort))
|
|
|
|
k := core.ConcatStrings(
|
|
proto,
|
|
strconv.FormatUint(uint64(srcPort), 10),
|
|
srcIP.String(),
|
|
dstIP.String(),
|
|
strconv.FormatUint(uint64(dstPort), 10))
|
|
if cacheItem, isInCache := ebpfCache.isInCache(k); isInCache {
|
|
deleteEbpfEntry(proto, key)
|
|
if p := isPIDinEventsCache(cacheItem.Pid, cacheItem.UID); p != nil {
|
|
proc = p
|
|
return
|
|
}
|
|
}
|
|
|
|
err := ebpfMaps[proto].bpfMap.Lookup(&key, &value)
|
|
if err != nil {
|
|
// key not found
|
|
// sometimes srcIP is 0.0.0.0. Happens especially with UDP sendto()
|
|
// for example:
|
|
// - 57621:10.0.3.1 -> 10.0.3.255:57621 , reported as: 0.0.0.0 -> 10.0.3.255
|
|
// - 58306:192.168.11.241 -> 1.2.3.4:54703, reported as: 58306:0.0.0.0 -> 1.2.3.4:54703
|
|
// ^ incoming connection to port 58306
|
|
// ---
|
|
// Sometimes the srcIP is specified in ancillary messages, using IP_PKTINFO.
|
|
// bind(226, {sa_family=AF_INET6, sin6_port=htons(5353), sin6_flowinfo=htonl(0), inet_pton(AF_INET6, "::", &sin6_addr), sin6_scope_id=0}, 28) = 0
|
|
// socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0) = 227
|
|
// setsockopt(226, SOL_IPV6, IPV6_MULTICAST_IF, [3], 4) = 0
|
|
// setsockopt(226, SOL_IPV6, IPV6_ADD_MEMBERSHIP, {inet_pton(AF_INET6, "ff02::fb", &ipv6mr_multiaddr), ipv6mr_interface=if_nametoindex("wlp3s0")}, 20) = 0
|
|
//
|
|
nkey := key
|
|
if isIP4 {
|
|
zeroes := make([]byte, 4)
|
|
copy(nkey[8:12], zeroes)
|
|
} else {
|
|
zeroes := make([]byte, 16)
|
|
copy(nkey[20:36], zeroes)
|
|
}
|
|
err = ebpfMaps[proto].bpfMap.Lookup(&nkey, &value)
|
|
if err == nil {
|
|
log.Trace("[eBPF] found via srcIP == 0.0.0.0 (%s): %+v -> %+v", proto, srcIP, dstIP)
|
|
delItemIfFound = false
|
|
}
|
|
}
|
|
if err != nil {
|
|
nkey := key
|
|
if isIP4 {
|
|
copy(key[2:6], srcIP)
|
|
copy(key[8:12], dstIP)
|
|
} else {
|
|
copy(nkey[2:18], srcIP)
|
|
copy(nkey[20:36], dstIP)
|
|
}
|
|
err = ebpfMaps[proto].bpfMap.Lookup(&nkey, &value)
|
|
if err == nil {
|
|
log.Error("[eBPF] found via dstIP -> srcIP: %+v -> %+v", srcIP, dstIP)
|
|
delItemIfFound = false
|
|
}
|
|
}
|
|
|
|
if err != nil {
|
|
// key not found in bpf maps
|
|
return nil
|
|
}
|
|
|
|
proc = findConnProcess(&value, k)
|
|
|
|
log.Debug("[ebpf conn] adding item to cache: %s", k)
|
|
ebpfCache.addNewItem(k, key, proc.ID, int(value.UID))
|
|
if delItemIfFound {
|
|
deleteEbpfEntry(proto, key)
|
|
}
|
|
return
|
|
}
|
|
|
|
// Check if the PID of the connection is in the cache.
|
|
func isPIDinEventsCache(pid, uid int) (proc *procmon.Process) {
|
|
if ev, found := procmon.EventsCache.IsInStoreByPID(pid); found {
|
|
// In some cases, a process may have dropped its privileges, from 0 to 123 for example.
|
|
// In these cases use socket's UID. This is the UID that we've always used,
|
|
ev.Proc.UID = uid
|
|
proc = &ev.Proc
|
|
log.Debug("[ebpf conn] not in cache, but in execEvents, pid: %d, uid: %d -> %s -> %s", proc.ID, proc.UID, proc.Path, proc.Args)
|
|
return proc
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// findConnProcess finds the process' details of a connection.
|
|
// By default we only receive the PID of the process, so we need to get
|
|
// the rest of the details.
|
|
// TODO: get the details from kernel, with mm_struct (exe_file, fd_path, etc).
|
|
func findConnProcess(value *networkEventT, connKey string) (proc *procmon.Process) {
|
|
|
|
if p := isPIDinEventsCache(int(value.Pid), int(value.UID)); p != nil {
|
|
return p
|
|
}
|
|
|
|
// We'll end here if the events module has not been loaded, or if the process is not in cache.
|
|
comm := byteArrayToString(value.Comm[:])
|
|
proc = procmon.NewProcess(int(value.Pid), comm)
|
|
proc.UID = int(value.UID)
|
|
procmon.EventsCache.Add(proc)
|
|
procmon.EventsCache.Update(proc, nil)
|
|
log.Debug("[ebpf conn] not in cache, NOR in execEvents: %s, %d -> %s -> %s", connKey, proc.ID, proc.Path, proc.Args)
|
|
|
|
return
|
|
}
|
|
|
|
// FindInAlreadyEstablishedTCP searches those TCP connections which were already established at the time
|
|
// when opensnitch started
|
|
func findInAlreadyEstablishedTCP(proto string, srcPort uint, srcIP net.IP, dstIP net.IP, dstPort uint) (int, int, error) {
|
|
alreadyEstablished.RLock()
|
|
defer alreadyEstablished.RUnlock()
|
|
|
|
var _alreadyEstablished map[*daemonNetlink.Socket]int
|
|
if proto == "tcp" {
|
|
_alreadyEstablished = alreadyEstablished.TCP
|
|
} else if proto == "tcp6" {
|
|
_alreadyEstablished = alreadyEstablished.TCPv6
|
|
}
|
|
|
|
for sock, v := range _alreadyEstablished {
|
|
if (*sock).ID.SourcePort == uint16(srcPort) && (*sock).ID.Source.Equal(srcIP) &&
|
|
(*sock).ID.Destination.Equal(dstIP) && (*sock).ID.DestinationPort == uint16(dstPort) {
|
|
return v, int((*sock).UID), nil
|
|
}
|
|
}
|
|
return -1, -1, fmt.Errorf("eBPF inode not found")
|
|
}
|
|
|
|
//returns true if addr is in the list of this machine's addresses
|
|
func findAddressInLocalAddresses(addr net.IP) bool {
|
|
lock.RLock()
|
|
_, found := localAddresses[addr.String()]
|
|
lock.RUnlock()
|
|
return found
|
|
}
|