//go:build linux package procmon import ( "container/list" "encoding/hex" "hash" "io" "os" "sync" "syscall" "time" ) // This is an optimization of primary /proc/PID/exe reads, not an authority for // paths or verdicts. Fallbacks may borrow a previously verified primary image, // but never seed the cache. Memory dumps retain their original behavior. // Entries hold no FDs, processes, goroutines, or policy state. var executableChecksums = newImageChecksumCache(512, 64, 128, 100*time.Millisecond) const imageChecksumSettle = 2 * time.Second type imageChecksumKey struct { algorithm string dev, ino uint64 size int64 mtimeSec, mtimeNsec, ctimeSec, ctimeNsec int64 mode, uid, gid uint32 links uint64 } type imageChecksumResult struct { digest string stable bool err error } type imageChecksumEntry struct { key imageChecksumKey digest string } type imageChecksumFlight struct { done chan struct{} result imageChecksumResult } type imageChecksumCache struct { mu sync.Mutex entries map[imageChecksumKey]*list.Element lru *list.List flights map[imageChecksumKey]*imageChecksumFlight capacity, maxFlights, maxWaiters, waiters int wait time.Duration } func newImageChecksumCache(capacity, flights, waiters int, wait time.Duration) *imageChecksumCache { return &imageChecksumCache{entries: make(map[imageChecksumKey]*list.Element), lru: list.New(), flights: make(map[imageChecksumKey]*imageChecksumFlight), capacity: capacity, maxFlights: flights, maxWaiters: waiters, wait: wait} } // lookup is read-only with respect to cache membership: a fallback cannot seed // an arbitrary file or join an unverified computation. func (c *imageChecksumCache) lookup(k imageChecksumKey) (imageChecksumResult, bool) { c.mu.Lock() defer c.mu.Unlock() return c.lookupLocked(k) } func (c *imageChecksumCache) lookupLocked(k imageChecksumKey) (imageChecksumResult, bool) { if e := c.entries[k]; e != nil { c.lru.MoveToFront(e) return imageChecksumResult{digest: e.Value.(imageChecksumEntry).digest, stable: true}, true } return imageChecksumResult{}, false } // get never holds mu during IO or starts a worker. Overload, timeout, failed or // unstable owners fall back to the caller's own complete hash, never "clean". // reused distinguishes a borrowed digest from one already read from our FD. func (c *imageChecksumCache) get(k imageChecksumKey, compute func() imageChecksumResult) (imageChecksumResult, bool) { c.mu.Lock() if r, ok := c.lookupLocked(k); ok { c.mu.Unlock() return r, true } if f := c.flights[k]; f != nil { if c.wait <= 0 || c.waiters >= c.maxWaiters { c.mu.Unlock() return compute(), false } c.waiters++ c.mu.Unlock() defer func() { c.mu.Lock(); c.waiters--; c.mu.Unlock() }() timer := time.NewTimer(c.wait) defer timer.Stop() select { case <-f.done: if f.result.err == nil && f.result.stable { return f.result, true } case <-timer.C: } return compute(), false } if c.capacity <= 0 || c.maxFlights <= 0 || len(c.flights) >= c.maxFlights { c.mu.Unlock() return compute(), false } f := &imageChecksumFlight{done: make(chan struct{})} c.flights[k] = f c.mu.Unlock() // Also release waiters on a panic. No digest is published until compute has // returned success and explicitly confirmed the opened image stayed stable. r := imageChecksumResult{} defer func() { c.mu.Lock() if r.err == nil && r.stable { e := c.lru.PushFront(imageChecksumEntry{key: k, digest: r.digest}) c.entries[k] = e if len(c.entries) > c.capacity { last := c.lru.Back() delete(c.entries, last.Value.(imageChecksumEntry).key) c.lru.Remove(last) } } f.result = r delete(c.flights, k) close(f.done) c.mu.Unlock() }() r = compute() return r, false } type imageChecksumFile interface { io.Reader Stat() (os.FileInfo, error) Fd() uintptr } // Local kernel filesystems with at most one-second ctime granularity. Exclude // FUSE/network/overlay/unknown filesystems: their metadata is not this trust // boundary. Refusing reuse must simply perform the original complete hash. func nativeChecksumFilesystem(kind int64) bool { switch uint64(kind) & 0xffffffff { case 0xef53, 0x58465342, 0x9123683e, 0x01021994, 0xf2f52010, 0x2fc12fc1: // ext*, XFS, Btrfs, tmpfs, F2FS, ZFS return true } return false } func imageChecksumIdentity(info os.FileInfo, algo string, fsKind int64, now time.Time) (imageChecksumKey, bool) { if info == nil || !info.Mode().IsRegular() || !nativeChecksumFilesystem(fsKind) || (algo != HashMD5 && algo != HashSHA1) { return imageChecksumKey{}, false } st, ok := info.Sys().(*syscall.Stat_t) if !ok || st.Size < 0 || st.Nlink == 0 || st.Ctim.Nsec < 0 || st.Ctim.Nsec >= 1e9 || st.Mtim.Nsec < 0 || st.Mtim.Nsec >= 1e9 { return imageChecksumKey{}, false } // A writable file can change twice within one coarse ctime tick. Never seed // an entry from that tick. Primary executable images have kernel write // exclusion, unlike arbitrary files with outstanding writable mmap mappings. // Root/clock manipulation and lying filesystems are not metadata guarantees. if time.Unix(int64(st.Ctim.Sec), int64(st.Ctim.Nsec)).After(now.Add(-imageChecksumSettle)) { return imageChecksumKey{}, false } return imageChecksumKey{algorithm: algo, dev: uint64(st.Dev), ino: st.Ino, size: st.Size, mtimeSec: int64(st.Mtim.Sec), mtimeNsec: int64(st.Mtim.Nsec), ctimeSec: int64(st.Ctim.Sec), ctimeNsec: int64(st.Ctim.Nsec), mode: st.Mode, uid: st.Uid, gid: st.Gid, links: uint64(st.Nlink)}, true } func openedImageChecksumKey(f imageChecksumFile, algo string) (imageChecksumKey, bool) { info, err := f.Stat() if err != nil { return imageChecksumKey{}, false } var fs syscall.Statfs_t if syscall.Fstatfs(int(f.Fd()), &fs) != nil { return imageChecksumKey{}, false } return imageChecksumIdentity(info, algo, int64(fs.Type), time.Now()) } // checksumVerifiedFallback never publishes a fallback's bytes as a verified // primary image. Without an existing success it performs the original IO. func checksumVerifiedFallback(f imageChecksumFile, h hash.Hash, algo string, c *imageChecksumCache) (string, error) { if k, eligible := openedImageChecksumKey(f, algo); eligible { if r, found := c.lookup(k); found { if after, ok := openedImageChecksumKey(f, algo); ok && after == k { return r.digest, nil } } } if _, err := io.Copy(h, f); err != nil { return "", err } return hex.EncodeToString(h.Sum(nil)), nil } func checksumPrimaryImage(f imageChecksumFile, h hash.Hash, algo string, c *imageChecksumCache) (string, error) { k, eligible := openedImageChecksumKey(f, algo) read := func() imageChecksumResult { n, err := io.Copy(h, f) if err != nil { return imageChecksumResult{err: err} } digest := hex.EncodeToString(h.Sum(nil)) after, ok := openedImageChecksumKey(f, algo) return imageChecksumResult{digest: digest, stable: eligible && ok && after == k && n == k.size} } if !eligible { r := read() return r.digest, r.err } r, reused := c.get(k, read) if reused { // Our separately opened FD may have changed while another owner was hashing // or between lookup and return. It is still unread, so fall back normally. after, ok := openedImageChecksumKey(f, algo) if !ok || after != k { r = read() } } return r.digest, r.err }