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>
150 lines
5.2 KiB
Go
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)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|