fix(managed): guard dropped-UID queue ownership inspection

Require effective SYS_PTRACE only for native owned workers and distinguish denied FD inspection from foreign queue ownership. Keep inode proof authoritative and constrain deployment to its private PID namespace.

Co-authored-by: GPT-6 <gpt-6@openai.com>
This commit is contained in:
ZeusinaandGPT-6 Bot committed 2026-10-11 21:48:06 +03:00
1 parent 18038e4112
commit 0398e6fe28
5 files changed
+120 -15

No files matched your search

+29 -11
View File
@@ -50,15 +50,7 @@ func newManagedAssetRuntime(target managedDeps) managedAssetRuntime {
if err != nil {
return err
}
for _, line := range strings.Split(string(status), "\n") {
if strings.HasPrefix(line, "CapEff:") {
bits, err := strconv.ParseUint(strings.TrimSpace(strings.TrimPrefix(line, "CapEff:")), 16, 64)
if err == nil && bits&(1<<5) != 0 && bits&(1<<12) != 0 {
return nil
}
}
}
return errors.New("asset verifier requires CAP_KILL and CAP_NET_ADMIN")
return managedAssetCapabilityGuard(string(status))
}
r.nft = func(ctx context.Context, input string) (string, error) {
cmd := exec.CommandContext(ctx, "nft", "-f", "-")
@@ -89,6 +81,19 @@ func newManagedAssetRuntime(target managedDeps) managedAssetRuntime {
return r
}
func managedAssetCapabilityGuard(status string) error {
const required = 1<<5 | 1<<12 | 1<<19 // KILL, NET_ADMIN, SYS_PTRACE
for _, line := range strings.Split(status, "\n") {
if strings.HasPrefix(line, "CapEff:") {
bits, err := strconv.ParseUint(strings.TrimSpace(strings.TrimPrefix(line, "CapEff:")), 16, 64)
if err == nil && bits&required == required {
return nil
}
}
}
return errors.New("asset verifier requires CAP_KILL, CAP_NET_ADMIN and CAP_SYS_PTRACE")
}
// Queue peer portid is a netlink socket id, not necessarily a process id.
func managedAssetQueueReady(pid int) (bool, error) {
queues, err := os.ReadFile("/proc/net/netfilter/nfnetlink_queue")
@@ -125,15 +130,28 @@ func managedAssetQueueReady(pid int) (bool, error) {
inodes["socket:["+f[9]+"]"] = true
}
}
fds, err := os.ReadDir(fmt.Sprintf("/proc/%d/fd", pid))
return managedAssetQueueFDReady(fmt.Sprintf("/proc/%d/fd", pid), inodes, os.Readlink)
}
func managedAssetQueueFDReady(dir string, inodes map[string]bool, readlink func(string) (string, error)) (bool, error) {
fds, err := os.ReadDir(dir)
if err != nil {
return false, err
}
denied := false
for _, fd := range fds {
link, err := os.Readlink(fmt.Sprintf("/proc/%d/fd/%s", pid, fd.Name()))
link, err := readlink(dir + "/" + fd.Name())
if err == nil && inodes[link] {
return true, nil
}
if errors.Is(err, os.ErrPermission) {
denied = true
} else if err != nil && !errors.Is(err, os.ErrNotExist) {
return false, err
}
}
if denied {
return false, errors.New("asset queue ownership inspection denied")
}
return false, errors.New("asset queue belongs to another process")
}
@@ -71,6 +71,81 @@ func assetRuntimeFixture(t *testing.T) (managedAssetRuntime, *[]string, chan err
return r, &events, done
}
func TestManagedAssetTargetQueueOwnershipCapability(t *testing.T) {
// nfqws drops UID and becomes nondumpable. The queue ownership check must
// still be able to read its socket symlinks, without sharing host processes.
raw, err := os.ReadFile("../../deploy/managed-target/compose.yaml")
if err != nil {
t.Fatal(err)
}
manifest := string(raw)
_, capabilities, ok := strings.Cut(manifest, "cap_add: [")
if !ok {
t.Fatal("target capabilities missing")
}
capabilities, _, ok = strings.Cut(capabilities, "]")
if !ok || !strings.Contains(","+strings.ReplaceAll(capabilities, " ", "")+",", ",SYS_PTRACE,") {
t.Fatal("queue socket ownership requires SYS_PTRACE for dropped-UID workers")
}
if !strings.Contains(manifest, "privileged: false") || strings.Contains(manifest, "pid:") {
t.Fatal("queue inspection must remain confined to an unprivileged private PID namespace")
}
}
func TestManagedAssetCapabilityGuard(t *testing.T) {
const required uint64 = 1<<5 | 1<<12 | 1<<19
for _, bits := range []uint64{required, required | 1<<13, required &^ (1 << 5), required &^ (1 << 12), required &^ (1 << 19), 0} {
err := managedAssetCapabilityGuard("CapEff:\t" + strconv.FormatUint(bits, 16) + "\n")
if (err == nil) != (bits&required == required) {
t.Fatalf("capabilities %x: %v", bits, err)
}
}
for _, status := range []string{"", "CapEff: invalid", "CapPrm: 81020"} {
if err := managedAssetCapabilityGuard(status); err == nil {
t.Fatalf("accepted %q", status)
}
}
}
func TestManagedAssetQueueFDReady(t *testing.T) {
dir := t.TempDir()
for _, fd := range []string{"1", "2"} {
if err := os.WriteFile(filepath.Join(dir, fd), nil, 0600); err != nil {
t.Fatal(err)
}
}
ioErr := errors.New("proc read failure")
for _, tc := range []struct {
name string
firstErr error
secondLink string
wantReady bool
wantErr string
}{
{"foreign", nil, "socket:[other]", false, "asset queue belongs to another process"},
{"denied", os.ErrPermission, "socket:[other]", false, "asset queue ownership inspection denied"},
{"missing transient", os.ErrNotExist, "socket:[owned]", true, ""},
{"match despite denial", os.ErrPermission, "socket:[owned]", true, ""},
{"missing foreign", os.ErrNotExist, "socket:[other]", false, "asset queue belongs to another process"},
{"read failure", ioErr, "socket:[other]", false, ioErr.Error()},
} {
t.Run(tc.name, func(t *testing.T) {
ready, err := managedAssetQueueFDReady(dir, map[string]bool{"socket:[owned]": true}, func(path string) (string, error) {
if filepath.Base(path) == "1" {
return "socket:[other]", tc.firstErr
}
return tc.secondLink, nil
})
if ready != tc.wantReady || (err == nil) != (tc.wantErr == "") || err != nil && err.Error() != tc.wantErr {
t.Fatalf("ready=%v err=%v", ready, err)
}
})
}
if _, err := managedAssetQueueFDReady(filepath.Join(dir, "absent"), nil, os.Readlink); !errors.Is(err, os.ErrNotExist) {
t.Fatalf("directory error lost: %v", err)
}
}
func TestManagedAssetRuntimeOwnedCollector(t *testing.T) {
d, front, _ := recoveryFixture(t, true)
if err := d.transaction.Apply(d.db, []int64{front}); err != nil {