Files
zapret-autotune/cmd/zapret-autotune/resource_monitor_status_test.go
T
ZeusinaandGPT-6 Bot 5c85f3f0b9 fix: validate live resource monitor ownership in status
Bind authenticated snapshots to controller PID/starttime and validate process identity and held inode anchors before reporting current check health. Preserve identical signed foreign replacements and fail closed when live ownership is unavailable.

Co-authored-by: GPT-6 <gpt-6@openai.com>
2026-10-14 00:28:24 +03:00

150 lines
5.2 KiB
Go

package main
import (
"bytes"
"os"
"path/filepath"
"strconv"
"strings"
"testing"
"time"
)
func TestResourceStatusLiveOwnership(t *testing.T) {
for _, change := range []string{"state", "key", "directory", "lock", "dead", "pid-reuse", "exe", "argv", "uid", "parent", "namespace", "missing-owner"} {
t.Run(change, func(t *testing.T) {
dir := filepath.Join(t.TempDir(), "state")
if err := os.Mkdir(dir, 0700); err != nil {
t.Fatal(err)
}
store, err := openResourceMonitorStore(dir, true)
if err != nil {
t.Fatal(err)
}
defer store.close()
write := func(path, contents string) {
t.Helper()
if err := os.WriteFile(path, []byte(contents), 0600); err != nil {
t.Fatal(err)
}
}
link := func(path, target string) {
t.Helper()
if err := os.Symlink(target, path); err != nil {
t.Fatal(err)
}
}
lockPath := filepath.Join(dir, managedMonitorLockName)
write(lockPath, "")
lock, err := os.Open(lockPath)
if err != nil {
t.Fatal(err)
}
defer lock.Close()
source, _ := resourceMonitorFixture(t)
state := resourceMonitorState{Version: 1, Updated: time.Now().UnixMilli(), Controller: &resourceMonitorOwner{PID: 42, Start: 123}, Rows: reconcileResourceRows(store.key, source, nil)}
for i := range state.Rows {
state.Rows[i].Health, state.Rows[i].Outcome = "HEALTHY", "pass"
state.Rows[i].LastCompleted, state.Rows[i].NextDue = state.Updated, state.Updated+60000
}
if err := store.save(state); err != nil {
t.Fatal(err)
}
state, err = store.load()
if err != nil {
t.Fatal(err)
}
proc := t.TempDir()
for _, sub := range []string{"self/ns", "42/ns", "42/fd"} {
if err := os.MkdirAll(filepath.Join(proc, sub), 0700); err != nil {
t.Fatal(err)
}
}
exe, err := os.Executable()
if err != nil {
t.Fatal(err)
}
link(filepath.Join(proc, "self/exe"), exe)
link(filepath.Join(proc, "42/exe"), exe)
for _, ns := range []string{"pid", "net"} {
link(filepath.Join(proc, "self/ns", ns), ns+"[1]")
link(filepath.Join(proc, "42/ns", ns), ns+"[1]")
}
fields := append([]string{"S"}, strings.Fields(strings.Repeat("0 ", 18))...)
fields = append(fields, "123")
stat := "42 (monitor) " + strings.Join(fields, " ")
write(filepath.Join(proc, "42/stat"), stat)
uid := strconv.Itoa(os.Geteuid())
write(filepath.Join(proc, "42/status"), "PPid:\t1\nUid:\t"+strings.Join([]string{uid, uid, uid, uid}, "\t")+"\n")
config := "/private/checks.json"
write(filepath.Join(proc, "42/cmdline"), strings.Join([]string{exe, "managed", "monitor", "--resource-config", config}, "\x00")+"\x00")
for i, f := range []*os.File{store.dir, store.keyFile, store.stateFile, lock} {
link(filepath.Join(proc, "42/fd", strconv.Itoa(i)), "/proc/self/fd/"+strconv.FormatUint(uint64(f.Fd()), 10))
}
if err := resourceMonitorLiveOwner(store, state, config, proc); err != nil {
t.Fatal("valid live owner refused", err)
}
if resourceSnapshotStale(state, time.Now().UnixMilli()) {
t.Fatal("fixture already stale")
}
var preservedPath string
var preserved []byte
switch change {
case "state", "key", "lock":
name := map[string]string{"state": resourceStateName, "key": resourceKeyName, "lock": managedMonitorLockName}[change]
preservedPath = filepath.Join(dir, name)
preserved, err = os.ReadFile(preservedPath)
if err != nil {
t.Fatal(err)
}
write(preservedPath+".replacement", string(preserved))
if err := os.Rename(preservedPath+".replacement", preservedPath); err != nil {
t.Fatal(err)
}
case "directory":
if err := os.Rename(dir, dir+".old"); err != nil {
t.Fatal(err)
}
if err := os.Mkdir(dir, 0700); err != nil {
t.Fatal(err)
}
case "dead":
os.Remove(filepath.Join(proc, "42/stat"))
case "pid-reuse":
write(filepath.Join(proc, "42/stat"), strings.TrimSuffix(stat, "123")+"124")
case "exe":
os.Remove(filepath.Join(proc, "42/exe"))
link(filepath.Join(proc, "42/exe"), "/bin/sh")
case "argv":
write(filepath.Join(proc, "42/cmdline"), exe+"\x00managed\x00resource-status\x00")
case "uid":
write(filepath.Join(proc, "42/status"), "PPid:\t1\nUid:\t9999\t9999\t9999\t9999\n")
case "parent":
write(filepath.Join(proc, "42/status"), "PPid:\t2\nUid:\t"+strings.Join([]string{uid, uid, uid, uid}, "\t")+"\n")
case "namespace":
os.Remove(filepath.Join(proc, "42/ns/net"))
link(filepath.Join(proc, "42/ns/net"), "net[2]")
case "missing-owner":
state.Controller = nil
if err := store.save(state); err != nil {
t.Fatal(err)
}
}
if resourceMonitorLiveOwner(store, state, config, proc) == nil {
t.Fatal("invalid live ownership accepted")
}
target := managedDeps{directory: dir, lookup: func(name string) (string, bool) { return config, name == "ZAPRET_AUTOTUNE_RESOURCE_CONFIG" }}
var out bytes.Buffer
if resourceStatusCLIAt(&out, target, proc) != 1 || out.String() != "{\"health\":\"BLOCKED\",\"stale\":true}\n" {
t.Fatal("cached status hid live failure", out.String())
}
if preservedPath != "" {
got, err := os.ReadFile(preservedPath)
if err != nil || !bytes.Equal(got, preserved) {
t.Fatal("foreign entry modified", err)
}
}
})
}
}