opensnitch/daemon/procmon/checksum_reuse_linux_test.go
trvon 8abb02a808
procmon: reuse verified executable checksums
Cache stable executable digests by file identity and algorithm, coalescing
concurrent requests within bounded limits. Revalidate opened files and
fall back to full hashing on misses or uncertainty.

Keep fallback lookups read-only and protect checksum map reads and logging.
Add regression coverage for reuse, mutation, failure and contention.
2026-11-03 15:05:53 -07:00

289 lines
7.8 KiB
Go

//go:build linux
package procmon
import (
"crypto/md5"
"crypto/sha1"
"encoding/hex"
"hash"
"io"
"os"
"path/filepath"
"strconv"
"strings"
"sync"
"syscall"
"testing"
"time"
)
// These tests exercise the real production checksum method. Distinct Process
// objects refer to our own live image; they do not launch or inspect other apps.
// rchar measures bytes returned by reads (including page-cache reads), not disk IO.
func checksumReadChars(tb testing.TB) uint64 {
tb.Helper()
raw, err := os.ReadFile("/proc/self/io")
if err != nil {
tb.Fatal(err)
}
for _, line := range strings.Split(string(raw), "\n") {
if strings.HasPrefix(line, "rchar:") {
n, err := strconv.ParseUint(strings.TrimSpace(strings.TrimPrefix(line, "rchar:")), 10, 64)
if err != nil {
tb.Fatal(err)
}
return n
}
}
tb.Fatal("missing rchar in /proc/self/io")
return 0
}
func checksumLiveImage(tb testing.TB) (string, int64) {
tb.Helper()
path, err := os.Executable()
if err != nil {
tb.Fatal(err)
}
info, err := os.Stat(ProcSelfExe)
if err != nil {
tb.Fatal(err)
}
// A conservative cache may refuse recently changed files. Settle our newly
// linked test image with one bounded wait; do not forge filesystem timestamps.
st, ok := info.Sys().(*syscall.Stat_t)
if !ok {
tb.Fatal("missing Linux stat")
}
wait := time.Until(time.Unix(st.Ctim.Sec, st.Ctim.Nsec).Add(2100 * time.Millisecond))
if wait > 0 {
if wait > 3*time.Second {
tb.Fatal("unexpected future executable ctime")
}
timer := time.NewTimer(wait)
defer timer.Stop()
<-timer.C
}
return path, info.Size()
}
func checksumFixtureProcess(id int, path, exe string) *Process {
p := NewProcessEmpty(100000000+id, "checksum-test")
p.Path = path
p.RealPath = path
p.pathExe = exe
p.pathProc = "/proc/self"
// Keep memory-dump fallbacks bound to the synthetic, nonexistent PID.
return p
}
func checksumExpected(tb testing.TB, path, algo string) string {
tb.Helper()
var h hash.Hash
if algo == HashMD5 {
h = md5.New()
} else {
h = sha1.New()
}
f, err := os.Open(path)
if err != nil {
tb.Fatal(err)
}
defer f.Close()
if _, err = io.Copy(h, f); err != nil {
tb.Fatal(err)
}
return hex.EncodeToString(h.Sum(nil))
}
func TestChecksumReuseAcrossProcesses(t *testing.T) {
path, size := checksumLiveImage(t)
want := checksumExpected(t, ProcSelfExe, HashMD5)
before := checksumReadChars(t)
for i := 0; i < 12; i++ {
p := checksumFixtureProcess(i, path, ProcSelfExe)
p.ComputeChecksum(HashMD5)
if p.Checksums[HashMD5] != want {
t.Fatalf("incorrect MD5 for process %d", i)
}
}
reads := checksumReadChars(t) - before
t.Logf("distinct_processes=12 image_bytes=%d read_chars=%d", size, reads)
if reads > uint64(2*size+128*1024) {
t.Fatalf("redundant executable hashing: %d read chars for twelve processes, image=%d", reads, size)
}
}
func TestChecksumConcurrentImageReads(t *testing.T) {
path, size := checksumLiveImage(t)
want := checksumExpected(t, ProcSelfExe, HashSHA1)
const n = 12
procs := make([]*Process, n)
for i := range procs {
procs[i] = checksumFixtureProcess(100+i, path, ProcSelfExe)
}
start := make(chan struct{})
var ready, done sync.WaitGroup
ready.Add(n)
done.Add(n)
for _, p := range procs {
go func(p *Process) { defer done.Done(); ready.Done(); <-start; p.ComputeChecksum(HashSHA1) }(p)
}
ready.Wait()
before := checksumReadChars(t)
close(start)
done.Wait()
reads := checksumReadChars(t) - before
for _, p := range procs {
if p.Checksums[HashSHA1] != want {
t.Fatal("concurrent SHA1 mismatch")
}
}
t.Logf("concurrent_processes=%d image_bytes=%d read_chars=%d", n, size, reads)
if reads > uint64(2*size+128*1024) {
t.Fatalf("redundant concurrent executable hashing: %d read chars, image=%d", reads, size)
}
}
func TestChecksumFileIdentityAndAlgorithms(t *testing.T) {
dir := t.TempDir()
a := filepath.Join(dir, "image-a")
b := filepath.Join(dir, "image-b")
if err := os.WriteFile(a, []byte("image one"), 0600); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(b, []byte("image two"), 0600); err != nil {
t.Fatal(err)
}
for i, f := range []string{a, b} {
// Same reported name, distinct opened images: namespace/path aliases must
// never acquire each other's digests.
p := checksumFixtureProcess(200+i, "/same/reported/path", f)
for _, algo := range []string{HashMD5, HashSHA1} {
p.ComputeChecksum(algo)
if p.Checksums[algo] != checksumExpected(t, f, algo) {
t.Fatal("opened image/algorithm conflation")
}
}
}
replacement := filepath.Join(dir, "replacement")
if err := os.WriteFile(replacement, []byte("new image"), 0600); err != nil {
t.Fatal(err)
}
if err := os.Rename(replacement, a); err != nil {
t.Fatal(err)
}
p := checksumFixtureProcess(203, a, a)
p.ComputeChecksum(HashMD5)
if p.Checksums[HashMD5] != checksumExpected(t, a, HashMD5) {
t.Fatal("replaced pathname reused old digest")
}
if err := os.WriteFile(a, []byte("new bytes"), 0600); err != nil {
t.Fatal(err)
}
p = checksumFixtureProcess(204, a, a)
p.ComputeChecksum(HashMD5)
if p.Checksums[HashMD5] != checksumExpected(t, a, HashMD5) {
t.Fatal("mutated image reused old digest")
}
}
func TestChecksumReadFailureIsNotSuccess(t *testing.T) {
dir := t.TempDir()
p := checksumFixtureProcess(300, dir, dir)
p.ComputeChecksum(HashMD5)
if p.Checksums[HashMD5] != "" {
t.Fatal("directory read error reported as checksum success")
}
if err := os.Remove(dir); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(dir, []byte("recover after read failure"), 0600); err != nil {
t.Fatal(err)
}
p = checksumFixtureProcess(301, dir, dir)
p.ComputeChecksum(HashMD5)
if p.Checksums[HashMD5] != checksumExpected(t, dir, HashMD5) {
t.Fatal("read failure poisoned subsequent image")
}
}
func BenchmarkChecksumNewProcessImage(b *testing.B) {
path, size := checksumLiveImage(b)
before := checksumReadChars(b)
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
p := checksumFixtureProcess(i, path, ProcSelfExe)
p.ComputeChecksum(HashMD5)
if len(p.Checksums[HashMD5]) != 32 {
b.Fatal("missing checksum")
}
}
b.StopTimer()
reads := checksumReadChars(b) - before
b.ReportMetric(float64(reads)/float64(b.N), "read-B/op")
b.ReportMetric(float64(size), "image-B")
}
// A missing primary exe must retain the existing full-hash fallback. This is
// the cold/nonshareable path, with no mutation of any production cache in tests.
func BenchmarkChecksumColdFallback(b *testing.B) {
path, size := checksumLiveImage(b)
before := checksumReadChars(b)
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
p := checksumFixtureProcess(i, path, ProcSelfExe+"/unavailable")
p.RealPath = ProcSelfExe
p.ComputeChecksum(HashMD5)
if len(p.Checksums[HashMD5]) != 32 {
b.Fatal("missing fallback checksum")
}
}
b.StopTimer()
reads := checksumReadChars(b) - before
b.ReportMetric(float64(reads)/float64(b.N), "read-B/op")
b.ReportMetric(float64(size), "image-B")
}
func BenchmarkChecksumExistingProcess(b *testing.B) {
path, size := checksumLiveImage(b)
p := checksumFixtureProcess(0, path, ProcSelfExe)
p.ComputeChecksum(HashMD5)
before := checksumReadChars(b)
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
p.ComputeChecksum(HashMD5)
}
b.StopTimer()
reads := checksumReadChars(b) - before
b.ReportMetric(float64(reads)/float64(b.N), "read-B/op")
b.ReportMetric(float64(size), "image-B")
}
func BenchmarkChecksumConcurrentNewProcesses(b *testing.B) {
path, size := checksumLiveImage(b)
before := checksumReadChars(b)
b.SetParallelism(8)
b.ReportAllocs()
b.ResetTimer()
var idMu sync.Mutex
id := 0
b.RunParallel(func(pb *testing.PB) {
for pb.Next() {
idMu.Lock()
id++
n := id
idMu.Unlock()
p := checksumFixtureProcess(n, path, ProcSelfExe)
p.ComputeChecksum(HashMD5)
}
})
b.StopTimer()
reads := checksumReadChars(b) - before
b.ReportMetric(float64(reads)/float64(b.N), "read-B/op")
b.ReportMetric(float64(size), "image-B")
}