feat(apply): guard managed target activation
Co-authored-by: GPT-6 <gpt-6@openai.com>
This commit is contained in:
1 parent
71e37ffaef
commit
cdeb67f0dd
7 files changed
+914
-46
No files matched your search
@@ -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)
|
||||
}
|
||||
Reference in new issue
Block a user