feat(apply): guard managed target activation

Co-authored-by: GPT-6 <gpt-6@openai.com>
This commit is contained in:
ZeusinaandGPT-6 Bot committed 2026-10-10 08:29:56 +03:00
1 parent 71e37ffaef
commit cdeb67f0dd
7 files changed
+914 -46

No files matched your search

+5
View File
@@ -15,6 +15,8 @@ Commands:
discover youtube --video-id ID --proxy socks5://HOST:PORT
Discover cache hostname only (no media-transfer check)
health youtube One-shot Player API health through configured loopback SOCKS
managed init|status|apply
Manual activation inside the designated managed-test target only
check youtube Refuse checks until probe URLs/video IDs are configured and agreed
tune youtube Test youtube.com frontend only; print options without applying
tune googlevideo --video-id ID --proxy socks5://HOST:PORT
@@ -33,6 +35,9 @@ func run(args []string, stdout, stderr io.Writer) int {
}
func runWithPlayer(args []string, stdout, stderr io.Writer, player playerRunner) int {
if len(args) > 0 && args[0] == "managed" {
return managedCLI(args[1:], stdout, stderr, managedDependencies(player))
}
if len(args) == 2 && args[0] == "health" && args[1] == "youtube" {
return healthYoutube(stdout, stderr, player)
}
+336
View File
@@ -0,0 +1,336 @@
package main
import (
"context"
"crypto/rand"
"database/sql"
"encoding/hex"
"encoding/json"
"fmt"
"io"
"os"
"os/exec"
"path/filepath"
"strconv"
"strings"
"syscall"
"time"
)
const managedMarkerName = ".autotune-target.json"
const managedTargetID = "zapret-autotune-managed-v1"
const managedTargetDirectory = "/var/lib/zapret-autotune/target"
const managedTargetConfig = managedTargetDirectory + "/config"
const managedBaseline = "# Autotuner-owned disabled baseline\nNFQWS2_ENABLE=0\nINIT_APPLY_FW=0\nNFQWS2_OPT=''\n"
type managedIdentity struct {
Role, Directory, ID string
}
type managedDeps struct {
lookup func(string) (string, bool)
openDB func() (*sql.DB, error)
player playerRunner
run func(string, ...string) error
script, directory string
verifyRuntime func(string) error
verifySOCKS func(int) error
}
func managedDependencies(player playerRunner) managedDeps {
return managedDeps{
lookup: os.LookupEnv, player: player,
openDB: func() (*sql.DB, error) { return openHistoryStore(databasePath()) },
script: "/opt/zapret2/init.d/sysv/zapret2", directory: managedTargetDirectory,
verifyRuntime: verifyManagedRuntime, verifySOCKS: verifyManagedSOCKS,
run: func(path string, args ...string) error {
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
if err := exec.CommandContext(ctx, path, args...).Run(); err != nil {
return fmt.Errorf("daemon-only reload failed")
}
return nil
},
}
}
func managedArguments(args []string) (string, []int64, error) {
if len(args) == 1 && (args[0] == "init" || args[0] == "status") {
return args[0], nil, nil
}
if len(args) == 5 && args[0] == "apply" {
ids := make([]int64, 2)
seen := map[string]bool{}
for i := 1; i < len(args); i += 2 {
key := args[i]
if seen[key] || (key != "--frontend-candidate" && key != "--googlevideo-candidate") || args[i+1] == "" || strings.Trim(args[i+1], "0123456789") != "" {
break
}
seen[key] = true
id, err := strconv.ParseInt(args[i+1], 10, 64)
if err != nil || id <= 0 {
break
}
index := 0
if key == "--googlevideo-candidate" {
index = 1
}
ids[index] = id
}
if ids[0] > 0 && ids[1] > 0 && ids[0] != ids[1] {
return "apply", ids, nil
}
}
return "", nil, fmt.Errorf("managed accepts init, status, or apply --frontend-candidate ID --googlevideo-candidate ID (positive distinct IDs); no path flags")
}
// Provisioning supplies the directory. Never create it or follow aliases.
func managedDirectory(dir string) error {
if !filepath.IsAbs(dir) || filepath.Clean(dir) != dir || dir == "/" {
return fmt.Errorf("ZAPRET_AUTOTUNE_TARGET_DIR requires an absolute dedicated clean directory")
}
for p := filepath.Dir(dir); ; p = filepath.Dir(p) {
info, err := os.Lstat(p)
if err != nil {
return err
}
if !info.IsDir() || info.Mode()&os.ModeSymlink != 0 {
return fmt.Errorf("unsafe target ancestor")
}
if p == "/" {
break
}
}
info, err := os.Lstat(dir)
if err != nil {
return err
}
stat, ok := info.Sys().(*syscall.Stat_t)
if !info.IsDir() || info.Mode().Perm()&0077 != 0 || !ok || stat.Uid != uint32(os.Geteuid()) {
return fmt.Errorf("target directory must be private and owned by this runtime user")
}
return nil
}
func managedPrivateFile(path string) error {
info, err := os.Lstat(path)
if err != nil {
return err
}
stat, ok := info.Sys().(*syscall.Stat_t)
if !info.Mode().IsRegular() || info.Mode().Perm()&0077 != 0 || !ok || stat.Uid != uint32(os.Geteuid()) || stat.Nlink != 1 {
return fmt.Errorf("unsafe managed file")
}
return nil
}
func managedInitialize(m *managedTransaction) error {
entries, err := os.ReadDir(m.Dir)
if err != nil {
return err
}
for _, entry := range entries {
if entry.Name() != "config" {
return fmt.Errorf("init requires a fresh dedicated directory (already initialized or nonempty)")
}
}
path := filepath.Join(m.Dir, "config")
f, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600)
if err == nil {
_, err = io.WriteString(f, managedBaseline)
if err == nil {
err = f.Sync()
}
closeErr := f.Close()
if err == nil {
err = closeErr
}
} else if os.IsExist(err) {
err = managedPrivateFile(path)
if err == nil {
var b []byte
b, err = os.ReadFile(path)
if err == nil && string(b) != managedBaseline {
err = fmt.Errorf("existing config is not the disabled baseline; not overwritten or adopted")
}
}
}
if err != nil {
return err
}
if err := m.Initialize(); err != nil {
return err
}
id := make([]byte, 16)
if _, err := rand.Read(id); err != nil {
return err
}
marker, err := json.Marshal(managedIdentity{Role: "managed-test", Directory: m.Dir, ID: hex.EncodeToString(id)})
if err != nil {
return err
}
return m.replace(managedMarkerName, marker)
}
func managedCheckIdentity(m *managedTransaction) error {
for _, name := range []string{managedMarkerName, "config", managedJournalName, managedBackupName} {
if err := managedPrivateFile(filepath.Join(m.Dir, name)); err != nil {
return err
}
}
b, err := m.read(managedMarkerName)
if err != nil {
return err
}
var identity managedIdentity
if err := json.Unmarshal(b, &identity); err != nil {
return fmt.Errorf("invalid target identity")
}
id, err := hex.DecodeString(identity.ID)
if err != nil || len(id) != 16 || identity.Role != "managed-test" || identity.Directory != m.Dir {
return fmt.Errorf("invalid target identity")
}
return nil
}
func managedStatus(m *managedTransaction, out io.Writer) error {
return m.locked(func() error {
j, err := m.load()
if err != nil {
return err
}
b, err := m.read("config")
if err != nil {
return err
}
if j.State != "committed" {
return fmt.Errorf("pending transaction; managed apply must reconcile before activation")
}
if managedHash(b) != j.Hash {
return errManagedDrift
}
groups := "none (disabled)"
if strings.Contains(string(b), "\nNFQWS2_ENABLE=1\n") {
groups = "frontend,googlevideo"
}
_, err = fmt.Fprintf(out, "managed-test generation=%d hash=%s groups=%s\nLive health: NOT CHECKED (Player API is not playback)\n", j.Generation, j.Hash, groups)
return err
})
}
func managedCLI(args []string, stdout, stderr io.Writer, d managedDeps) int {
command, ids, err := managedArguments(args)
if err != nil {
fmt.Fprintln(stderr, "error:", err)
return 2
}
role, _ := d.lookup("ZAPRET_AUTOTUNE_TARGET_ROLE")
if role != "managed-test" {
fmt.Fprintln(stderr, "error: ZAPRET_AUTOTUNE_TARGET_ROLE must be managed-test")
return 2
}
for key, expected := range map[string]string{
"ZAPRET_AUTOTUNE_TARGET_ID": managedTargetID,
"ZAPRET_AUTOTUNE_TARGET_DIR": managedTargetDirectory,
"ZAPRET_CONFIG": managedTargetConfig,
} {
if value, _ := d.lookup(key); value != expected {
fmt.Fprintln(stderr, "error:", key, "does not match the fresh managed target contract")
return 2
}
}
portText, _ := d.lookup("SOCKS_PORT")
port, portErr := strconv.Atoi(portText)
proxy, _ := d.lookup("ZAPRET_AUTOTUNE_SOCKS_PROXY")
if portErr != nil || port < 1 || port > 65535 || strconv.Itoa(port) != portText || proxy != "socks5://127.0.0.1:"+portText {
fmt.Fprintln(stderr, "error: managed SOCKS proxy must match the target SOCKS_PORT listener")
return 2
}
if d.verifyRuntime == nil || d.verifySOCKS == nil {
fmt.Fprintln(stderr, "error: managed runtime validators unavailable")
return 1
}
if err := d.verifyRuntime(managedTargetDirectory); err != nil {
fmt.Fprintln(stderr, "error:", err)
return 1
}
if err := d.verifySOCKS(port); err != nil {
fmt.Fprintln(stderr, "error:", err)
return 1
}
dir := d.directory
if err := managedDirectory(dir); err != nil {
fmt.Fprintln(stderr, "error:", err)
return 1
}
m := &managedTransaction{Dir: dir, Name: "config", Reload: func() error { return d.run(d.script, "restart-daemons") }, Health: func() (string, error) { return "", fmt.Errorf("health not configured") }}
if command == "init" {
err = managedInitialize(m)
} else if err = managedCheckIdentity(m); err == nil {
if command == "status" {
err = managedStatus(m, stdout)
} else {
err = managedActivate(m, d, ids)
}
}
if err != nil {
fmt.Fprintln(stderr, "error:", err)
return 1
}
if command != "status" {
if _, err := fmt.Fprintln(stdout, "managed-test "+command+": OK"); err != nil {
return 1
}
}
return 0
}
func managedActivate(m *managedTransaction, d managedDeps, ids []int64) error {
info, err := os.Stat(d.script)
if err != nil || !info.Mode().IsRegular() || info.Mode().Perm()&0111 == 0 {
return fmt.Errorf("target zapret daemon init executable unavailable")
}
cfg, err := parseHealthConfig(d.lookup)
if err != nil {
return err
}
m.Health = func() (string, error) {
portText, _ := d.lookup("SOCKS_PORT")
port, err := strconv.Atoi(portText)
if err != nil {
return "", fmt.Errorf("target SOCKS_PORT unavailable")
}
if err := d.verifySOCKS(port); err != nil {
return "", err
}
body, err := requestPlayer(cfg.VideoID, cfg.SOCKSProxy, d.player)
if err == nil {
err = playerHealth(body)
}
if err != nil {
return "", err
}
return "OK", nil
}
db, err := d.openDB()
if err != nil {
return fmt.Errorf("candidate database unavailable")
}
if db == nil {
return fmt.Errorf("candidate database missing")
}
defer db.Close()
for i, group := range []string{"frontend", "googlevideo"} {
c, err := readStrategyCandidate(db, ids[i])
if err != nil || c.Group != group {
return fmt.Errorf("invalid %s candidate ID", group)
}
}
if _, err := renderManagedConfig(db, ids); err != nil {
return err
}
if err := m.Reconcile(); err != nil {
return err
}
return m.Apply(db, ids)
}
+374
View File
@@ -0,0 +1,374 @@
package main
import (
"bytes"
"context"
"database/sql"
"errors"
"fmt"
"io"
"os"
"path/filepath"
"reflect"
"strings"
"testing"
)
func managedCLIFixture(t *testing.T) (managedDeps, map[string]string, *int) {
t.Helper()
root := t.TempDir()
env := map[string]string{
"ZAPRET_AUTOTUNE_TARGET_ROLE": "managed-test", "ZAPRET_AUTOTUNE_TARGET_ID": managedTargetID,
"ZAPRET_AUTOTUNE_TARGET_DIR": managedTargetDirectory, "ZAPRET_CONFIG": managedTargetConfig,
"SOCKS_PORT": "11080", "ZAPRET_AUTOTUNE_SOCKS_PROXY": "socks5://127.0.0.1:11080",
}
calls := new(int)
d := managedDeps{
lookup: func(key string) (string, bool) { value, ok := env[key]; return value, ok },
script: filepath.Join(root, "zapret2"), directory: filepath.Join(root, "target"),
verifyRuntime: func(dir string) error {
if dir != managedTargetDirectory {
return errors.New("wrong runtime directory")
}
return nil
},
verifySOCKS: func(port int) error {
if port != 11080 {
return errors.New("wrong ss-local port")
}
return nil
},
run: func(path string, args ...string) error {
*calls++
if path != filepath.Join(root, "zapret2") || !reflect.DeepEqual(args, []string{"restart-daemons"}) {
t.Fatalf("unexpected executable/argv: %q %q", path, args)
}
return nil
},
player: func(_ context.Context, args []string, stdout, _ io.Writer) error {
if !strings.Contains(strings.Join(args, "|"), "--noproxy||--proxy|socks5://127.0.0.1:11080|") {
t.Fatalf("unsafe health argv: %q", args)
}
_, err := io.WriteString(stdout, `{"playabilityStatus":{"status":"OK"}}`)
return err
},
openDB: func() (*sql.DB, error) { t.Fatal("unexpected DB access"); return nil, nil },
}
if err := os.WriteFile(d.script, []byte("not executed"), 0700); err != nil {
t.Fatal(err)
}
if err := os.Mkdir(d.directory, 0700); err != nil {
t.Fatal(err)
}
return d, env, calls
}
func callManaged(t *testing.T, d managedDeps, args ...string) (int, string, string) {
t.Helper()
var out, diagnostic bytes.Buffer
code := managedCLI(args, &out, &diagnostic, d)
return code, out.String(), diagnostic.String()
}
func initManagedCLI(t *testing.T, d managedDeps) {
t.Helper()
if code, _, diagnostic := callManaged(t, d, "init"); code != 0 {
t.Fatalf("init: %d %s", code, diagnostic)
}
}
func TestManagedCLIArguments(t *testing.T) {
for _, args := range [][]string{nil, {"unknown"}, {"init", "--dir", "/etc"}, {"status", "extra"}, {"apply"}, {"apply", "--frontend-candidate", "1", "--frontend-candidate", "2"}, {"apply", "--frontend-candidate", "1", "--googlevideo-candidate", "1"}, {"apply", "--frontend-candidate", "-1", "--googlevideo-candidate", "2"}, {"apply", "--frontend-candidate", "1;id", "--googlevideo-candidate", "2"}, {"apply", "--frontend-candidate", "9223372036854775808", "--googlevideo-candidate", "2"}, {"apply", "--frontend-candidate", "0", "--googlevideo-candidate", "2"}} {
d, _, calls := managedCLIFixture(t)
if code, _, _ := callManaged(t, d, args...); code != 2 || *calls != 0 {
t.Fatalf("accepted %q", args)
}
}
command, ids, err := managedArguments([]string{"apply", "--googlevideo-candidate", "2", "--frontend-candidate", "1"})
if err != nil || command != "apply" || !reflect.DeepEqual(ids, []int64{1, 2}) {
t.Fatalf("%s %v %v", command, ids, err)
}
// Exercise the actual top-level dispatch without a runner or network call.
t.Setenv("ZAPRET_AUTOTUNE_TARGET_ROLE", "old-container")
var out, diagnostic bytes.Buffer
if code := run([]string{"managed", "status"}, &out, &diagnostic); code != 2 || !strings.Contains(diagnostic.String(), "TARGET_ROLE") {
t.Fatalf("dispatch: %d %s", code, diagnostic.String())
}
}
func TestManagedCLIRoleAndDirectoryGuards(t *testing.T) {
for _, role := range []string{"", "dev", "managed-test ", "old-container"} {
d, env, _ := managedCLIFixture(t)
env["ZAPRET_AUTOTUNE_TARGET_ROLE"] = role
if code, _, _ := callManaged(t, d, "init"); code != 2 {
t.Fatalf("accepted role %q", role)
}
if entries, err := os.ReadDir(d.directory); err != nil || len(entries) != 0 {
t.Fatal("guard wrote target directory")
}
}
for _, path := range []string{"", "relative", "/", "/tmp/../etc"} {
d, env, _ := managedCLIFixture(t)
env["ZAPRET_AUTOTUNE_TARGET_DIR"] = path
if code, _, _ := callManaged(t, d, "init"); code == 0 {
t.Fatalf("accepted path %q", path)
}
}
for _, mode := range []string{"symlink", "public", "ancestor"} {
d, env, _ := managedCLIFixture(t)
dir := d.directory
var err error
if mode == "public" {
err = os.Chmod(dir, 0755)
} else {
if err := os.Remove(dir); err != nil {
t.Fatal(err)
}
err = os.Symlink(t.TempDir(), dir)
if mode == "ancestor" {
env["ZAPRET_AUTOTUNE_TARGET_DIR"] = filepath.Join(dir, "nested")
}
}
if err != nil {
t.Fatal(err)
}
if code, _, _ := callManaged(t, d, "init"); code == 0 {
t.Fatalf("accepted %s", mode)
}
}
}
func TestManagedCLIInitNonOverwrite(t *testing.T) {
d, _, calls := managedCLIFixture(t)
dir := d.directory
path := filepath.Join(dir, "config")
secret := "EXISTING_SECRET='do not overwrite'\n"
if err := os.WriteFile(path, []byte(secret), 0600); err != nil {
t.Fatal(err)
}
if code, _, _ := callManaged(t, d, "init"); code == 0 {
t.Fatal("adopted non-baseline config")
}
b, err := os.ReadFile(path)
if err != nil || string(b) != secret || *calls != 0 {
t.Fatalf("config=%q err=%v", b, err)
}
if err := os.WriteFile(path, []byte(managedBaseline), 0600); err != nil {
t.Fatal(err)
}
initManagedCLI(t, d)
if code, _, _ := callManaged(t, d, "init"); code == 0 {
t.Fatal("reinitialized identity")
}
if code, out, diagnostic := callManaged(t, d, "status"); code != 0 || !strings.Contains(out, "generation=0") || !strings.Contains(out, "none (disabled)") {
t.Fatalf("status %d %s %s", code, out, diagnostic)
}
if *calls != 0 {
t.Fatal("init/status reloaded")
}
}
func TestManagedCLIApplyAndRollback(t *testing.T) {
for _, mode := range []string{"success", "health", "reload", "unqualified", "wrong-group", "missing-id", "missing-script", "wrong-binding", "bad-proxy", "missing-marker", "drift"} {
t.Run(mode, func(t *testing.T) {
d, env, calls := managedCLIFixture(t)
initManagedCLI(t, d)
db := testStore(t)
front := managedCandidateFixture(t, db, "frontend", "youtube.com", "--lua-desync=fake", mode != "unqualified")
ggc := managedCandidateFixture(t, db, "googlevideo", "rr1.googlevideo.com", "--lua-desync=multisplit", true)
d.openDB = func() (*sql.DB, error) { return db, nil }
config := filepath.Join(d.directory, "config")
switch mode {
case "health":
d.player = func(_ context.Context, _ []string, stdout, _ io.Writer) error {
_, err := io.WriteString(stdout, `{"playabilityStatus":{"status":"ERROR","secret":"do-not-print"}}`)
return err
}
case "reload":
fixed := d.run
d.run = func(path string, args ...string) error {
if err := fixed(path, args...); err != nil {
return err
}
if *calls == 1 {
return errors.New("reload failed")
}
return nil
}
case "wrong-group":
front, ggc = ggc, front
case "missing-id":
front = 999999
case "missing-script":
if err := os.Remove(d.script); err != nil {
t.Fatal(err)
}
case "wrong-binding":
env["ZAPRET_CONFIG"] = "/opt/zapret2/config"
case "bad-proxy":
env["ZAPRET_AUTOTUNE_SOCKS_PROXY"] = "socks5://192.0.2.1:1080"
case "missing-marker":
if err := os.Remove(filepath.Join(d.directory, managedMarkerName)); err != nil {
t.Fatal(err)
}
case "drift":
if err := os.WriteFile(config, []byte("EXTERNAL_SECRET=private\n"), 0600); err != nil {
t.Fatal(err)
}
}
code, out, diagnostic := callManaged(t, d, "apply", "--frontend-candidate", fmt.Sprint(front), "--googlevideo-candidate", fmt.Sprint(ggc))
if (mode == "success") != (code == 0) {
t.Fatalf("apply: %d %s %s", code, out, diagnostic)
}
if strings.Contains(out+diagnostic, "do-not-print") || strings.Contains(out+diagnostic, "EXTERNAL_SECRET") {
t.Fatal("leaked config/response")
}
b, err := os.ReadFile(config)
if err != nil {
t.Fatal(err)
}
wantCalls := 0
if mode == "success" {
wantCalls = 1
if !strings.Contains(string(b), "--hostlist-domains=^rr1.googlevideo.com") {
t.Fatalf("wrong applied scope: %s", b)
}
code, out, diagnostic = callManaged(t, d, "status")
if code != 0 || !strings.Contains(out, "generation=1") || !strings.Contains(out, "groups=frontend,googlevideo") || strings.Contains(out, "lua-desync") || strings.Contains(out, "rr1") {
t.Fatalf("status: %d %s %s", code, out, diagnostic)
}
} else if mode == "drift" {
if string(b) != "EXTERNAL_SECRET=private\n" {
t.Fatal("drift overwritten")
}
} else {
if string(b) != managedBaseline {
t.Fatalf("baseline not restored: %s", b)
}
if mode == "health" || mode == "reload" {
wantCalls = 2
}
}
if *calls != wantCalls {
t.Fatalf("reloads=%d want=%d", *calls, wantCalls)
}
})
}
}
func TestManagedCLIIdentityAndStatusRedaction(t *testing.T) {
for _, mode := range []string{"identity", "symlink", "hardlink", "journal", "drift"} {
t.Run(mode, func(t *testing.T) {
d, _, calls := managedCLIFixture(t)
initManagedCLI(t, d)
dir := d.directory
path := filepath.Join(dir, managedMarkerName)
switch mode {
case "identity":
if err := os.WriteFile(path, []byte(`{"Role":"dev","Directory":"secret"}`), 0600); err != nil {
t.Fatal(err)
}
case "symlink", "hardlink":
outside := filepath.Join(t.TempDir(), "outside")
if err := os.Rename(path, outside); err != nil {
t.Fatal(err)
}
var err error
if mode == "symlink" {
err = os.Symlink(outside, path)
} else {
err = os.Link(outside, path)
}
if err != nil {
t.Fatal(err)
}
if mode == "hardlink" {
if err := os.Link(outside, outside+"-second"); err != nil {
t.Fatal(err)
}
}
case "journal":
if err := os.Remove(filepath.Join(dir, managedJournalName)); err != nil {
t.Fatal(err)
}
case "drift":
if err := os.WriteFile(filepath.Join(dir, "config"), []byte("PASSWORD=secret\n"), 0600); err != nil {
t.Fatal(err)
}
}
code, out, diagnostic := callManaged(t, d, "status")
if code == 0 || strings.Contains(out+diagnostic, "secret") || *calls != 0 {
t.Fatalf("status: %d %s %s", code, out, diagnostic)
}
})
}
}
func TestManagedCLIFreshTargetContract(t *testing.T) {
for _, mode := range []string{"wrong-id", "missing-id", "old-env", "other-directory", "old-config", "other-config", "non-mountpoint", "missing-base-runtime", "wrong-port", "other-loopback", "wrong-process", "missing-proxy", "missing-port"} {
for _, command := range []string{"init", "status", "apply"} {
t.Run(mode+"/"+command, func(t *testing.T) {
d, env, calls := managedCLIFixture(t)
if command != "init" {
initManagedCLI(t, d)
}
switch mode {
case "wrong-id":
env["ZAPRET_AUTOTUNE_TARGET_ID"] = "another-target"
case "missing-id":
delete(env, "ZAPRET_AUTOTUNE_TARGET_ID")
case "old-env":
// A role and a self-created directory/identity alone cannot pass.
delete(env, "ZAPRET_AUTOTUNE_TARGET_ID")
delete(env, "ZAPRET_CONFIG")
delete(env, "SOCKS_PORT")
case "other-directory":
env["ZAPRET_AUTOTUNE_TARGET_DIR"] = d.directory
case "old-config":
env["ZAPRET_CONFIG"] = "/opt/zapret2/config"
case "other-config":
env["ZAPRET_CONFIG"] = "/etc/config"
case "non-mountpoint", "missing-base-runtime":
d.verifyRuntime = func(string) error { return errors.New(mode) }
case "wrong-port":
env["SOCKS_PORT"] = "1080"
case "other-loopback":
env["ZAPRET_AUTOTUNE_SOCKS_PROXY"] = "socks5://127.0.0.1:1080"
case "wrong-process":
d.verifySOCKS = func(int) error { return errors.New("listener belongs to another process") }
case "missing-proxy":
delete(env, "ZAPRET_AUTOTUNE_SOCKS_PROXY")
case "missing-port":
delete(env, "SOCKS_PORT")
}
args := []string{command}
if command == "apply" {
args = append(args, "--frontend-candidate", "1", "--googlevideo-candidate", "2")
}
if code, _, _ := callManaged(t, d, args...); code == 0 || *calls != 0 {
t.Fatal("unsafe target contract accepted or reloaded")
}
if command == "init" {
entries, err := os.ReadDir(d.directory)
if err != nil || len(entries) != 0 {
t.Fatal("refused init modified target")
}
}
})
}
}
}
func TestManagedMountpoint(t *testing.T) {
for _, path := range []string{"/", filepath.Dir(managedTargetDirectory), managedTargetDirectory + "-other"} {
if managedMountpoint("1 2 0:3 / "+path+" rw - tmpfs tmpfs rw\n", managedTargetDirectory) {
t.Fatal("accepted another mount")
}
}
if !managedMountpoint("1 2 0:3 / "+managedTargetDirectory+" rw - ext4 /dev/test rw\n", managedTargetDirectory) {
t.Fatal("dedicated mount rejected")
}
if err := verifyManagedRuntime("/opt/zapret2"); err == nil {
t.Fatal("production verifier accepted arbitrary directory")
}
}
+82
View File
@@ -0,0 +1,82 @@
package main
import (
"fmt"
"os"
"path/filepath"
"strconv"
"strings"
)
// Provisioning, not managed init, supplies this marker and the dedicated mount.
func verifyManagedRuntime(dir string) error {
if dir != managedTargetDirectory {
return fmt.Errorf("unexpected managed target path")
}
marker, err := os.ReadFile("/etc/zapret-autotune/target-id")
if err != nil || string(marker) != managedTargetID+"\n" {
return fmt.Errorf("fresh target runtime marker unavailable")
}
mounts, err := os.ReadFile("/proc/self/mountinfo")
if err != nil || !managedMountpoint(string(mounts), dir) {
return fmt.Errorf("managed target directory must be a dedicated mountpoint")
}
for _, path := range []string{"/opt/zapret2/init.d/sysv/zapret2", "/opt/zapret2/nfq2/nfqws2", "/usr/bin/blockcheckw"} {
info, err := os.Stat(path)
if err != nil || !info.Mode().IsRegular() || info.Mode().Perm()&0111 == 0 {
return fmt.Errorf("zapret base runtime executable unavailable")
}
}
return nil
}
func managedMountpoint(mountinfo, dir string) bool {
for _, line := range strings.Split(mountinfo, "\n") {
fields := strings.Fields(line)
if len(fields) >= 10 && fields[4] == dir {
return true
}
}
return false
}
// Match the listening socket to an ss-local executable in this PID/network
// namespace. Merely finding a process or an arbitrary loopback proxy is unsafe.
func verifyManagedSOCKS(port int) error {
tcp, err := os.ReadFile("/proc/net/tcp")
if err != nil {
return fmt.Errorf("target SOCKS listener unavailable")
}
inodes := map[string]bool{}
for _, line := range strings.Split(string(tcp), "\n") {
f := strings.Fields(line)
if len(f) > 9 && f[3] == "0A" && (f[1] == fmt.Sprintf("0100007F:%04X", port) || f[1] == fmt.Sprintf("00000000:%04X", port)) {
inodes["socket:["+f[9]+"]"] = true
}
}
processes, err := os.ReadDir("/proc")
if err != nil {
return fmt.Errorf("target ss-local runtime unavailable")
}
for _, process := range processes {
if _, err := strconv.Atoi(process.Name()); err != nil {
continue
}
root := filepath.Join("/proc", process.Name())
exe, err := os.Readlink(filepath.Join(root, "exe"))
if err != nil || filepath.Base(exe) != "ss-local" {
continue
}
fds, err := os.ReadDir(filepath.Join(root, "fd"))
if err != nil {
continue
}
for _, fd := range fds {
link, err := os.Readlink(filepath.Join(root, "fd", fd.Name()))
if err == nil && inodes[link] {
return nil
}
}
}
return fmt.Errorf("target SOCKS_PORT listener is not owned by ss-local")
}