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

+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)
}