Files
zapret-autotune/cmd/zapret-autotune/managed_cli.go
T
ZeusinaandGPT-6 Bot f88c8e9c45 fix(managed): guard experimental authorization and startup requests
Reject explicit candidate-ID and inherited-policy CLI bypasses of the guarded native-circular operator path. Validate empty private runtime-owned request inodes without following links before state mutation, atomically claim and sync them before apply, retain failed claims, and never delete replacement requests. Keep internal journal reconciliation and legacy qualification unchanged.

Co-authored-by: GPT-6 <gpt-6@openai.com>
2026-10-12 07:14:20 +03:00

552 lines
17 KiB
Go

package main
import (
"context"
"crypto/rand"
"database/sql"
"encoding/hex"
"encoding/json"
"errors"
"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\n" + managedFirewallConfig + "NFQWS2_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("target-local firewall/daemon restart failed: %w", err)
}
return nil
},
}
}
func managedArguments(args []string) (string, []int64, error) {
invalid := fmt.Errorf("managed accepts init, reconcile, status [--assets], active-ids, or apply with frontend/googlevideo/asset candidate flags (full desired set); no path flags")
if len(args) == 2 && args[0] == "status" && args[1] == "--assets" {
return "status", nil, nil
}
if len(args) == 1 && (args[0] == "init" || args[0] == "reconcile" || args[0] == "status" || args[0] == "active-ids" || args[0] == "experimental-request-check") {
return args[0], nil, nil
}
if len(args) < 3 || len(args)%2 != 1 || args[0] != "apply" {
return "", nil, invalid
}
selected := map[string][]int64{}
seen := map[int64]bool{}
scopeSeen := false
experiment := false
request := false
var scope GooglevideoScope
for i := 1; i < len(args); i += 2 {
key := args[i]
if key == "--googlevideo-request" {
if request || args[i+1] != "startup" {
return "", nil, invalid
}
request = true
continue
}
if key == "--googlevideo-experiment" {
if experiment || args[i+1] != "native-circular" {
return "", nil, invalid
}
experiment = true
continue
}
if key == "--googlevideo-scope" {
scope = GooglevideoScope(args[i+1])
if scopeSeen || !scope.valid() || scope == "" {
return "", nil, invalid
}
scopeSeen = true
continue
}
if (len(selected[key]) != 0 && key != "--asset-candidate") || (key != "--frontend-candidate" && key != "--googlevideo-candidate" && key != "--asset-candidate") {
return "", nil, invalid
}
values := strings.Split(args[i+1], ",")
if key != "--asset-candidate" && len(values) != 1 {
return "", nil, invalid
}
for _, value := range values {
if value == "" || strings.Trim(value, "0123456789") != "" {
return "", nil, invalid
}
id, err := strconv.ParseInt(value, 10, 64)
if err != nil || id <= 0 || seen[id] {
return "", nil, invalid
}
seen[id] = true
selected[key] = append(selected[key], id)
}
if len(selected["--asset-candidate"]) > 2 {
return "", nil, invalid
}
}
var ids []int64
if experiment {
if !scopeSeen || scope != GooglevideoScopeExperimental || len(selected) != 0 {
return "", nil, invalid
}
return "experiment", nil, nil
}
if request || scope == GooglevideoScopeExperimental {
return "", nil, invalid
}
for _, key := range []string{"--frontend-candidate", "--googlevideo-candidate", "--asset-candidate"} {
ids = append(ids, selected[key]...)
}
if len(ids) == 0 || (scopeSeen && len(selected["--googlevideo-candidate"]) == 0) {
return "", nil, invalid
}
return "apply", ids, nil
}
// 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
}
// Status and supervisor reads share the same locked, DB-validated snapshot.
func managedReport(m *managedTransaction, out io.Writer, openDB func() (*sql.DB, error), activeOnly bool, requestAssets ...bool) error {
return m.locked(func() error {
j, err := m.load()
if err != nil {
return err
}
b, err := m.read(m.Name)
if err != nil {
return err
}
if j.State != "committed" && activeOnly {
return fmt.Errorf("pending transaction; reconcile before reading active IDs")
}
if managedHash(b) != j.Hash && (j.State != "prepared" || managedHash(b) != j.Next) {
return errManagedDrift
}
groups := map[string]bool{}
assetHosts := map[string]bool{}
known := j.State == "committed" && j.Version >= 2 && string(b) == managedBaseline && len(j.Candidates) == 0
if j.State == "committed" && j.Version >= 2 && len(j.Candidates) != 0 {
db, err := openDB()
if db != nil {
defer db.Close()
}
if err == nil && db != nil {
rendered, err := renderStoredManagedConfigScope(db, j.Candidates, j.Scope)
if err == nil && managedHash(rendered) == j.Hash {
known = true
for _, id := range j.Candidates {
c, err := readStrategyCandidatePolicy(db, id, false)
if err != nil || (!c.Qualified && !experimentalGooglevideo(j.Scope, c)) {
known = false
break
}
groups[c.Group] = true
if experimentalGooglevideo(j.Scope, c) {
groups[c.Group] = false
}
if c.Group == "assets" {
for _, host := range c.Endpoints {
assetHosts[host] = true
}
}
}
}
}
}
if !known {
groups = map[string]bool{}
// Unvalidated journal references are not active recovery candidates.
j.Candidates = nil
}
var active, missing []string
for _, group := range []string{"frontend", "googlevideo"} {
if groups[group] {
active = append(active, group)
} else {
missing = append(missing, group)
}
}
if groups["assets"] {
active = append(active, "assets")
}
if (groups["assets"] || (len(requestAssets) != 0 && requestAssets[0])) && (!known || len(assetHosts) != 2) {
missing = append(missing, "assets")
}
if activeOnly {
if !known {
return fmt.Errorf("active candidate IDs unresolved; deployment preserved by hash")
}
return json.NewEncoder(out).Encode(struct {
IDs []int64 `json:"active_candidate_ids"`
Missing []string `json:"unresolved_groups"`
}{append([]int64{}, j.Candidates...), missing})
}
groupText := strings.Join(active, ",")
if groupText == "" {
groupText = "none (disabled)"
if !known {
groupText = "unknown"
}
}
var reportIDs []int64
if known {
reportIDs = j.Candidates
}
_, err = fmt.Fprintf(out, "managed-test generation=%d hash=%s state=%s groups=%s active_candidate_ids=%v unresolved_groups=%s\nLive health: NOT CHECKED (Player API is not GGC/video playback)\n", j.Generation, j.Hash, j.State, groupText, reportIDs, strings.Join(missing, ","))
if err == nil && j.Version == 3 {
_, err = fmt.Fprintf(out, "Googlevideo scope: %s (suffix is authorized extrapolation, not all-host qualification)\n", j.Scope)
}
return err
})
}
func managedRuntimeGuard(d managedDeps) (int, error) {
role, _ := d.lookup("ZAPRET_AUTOTUNE_TARGET_ROLE")
if role != "managed-test" {
return 2, fmt.Errorf("ZAPRET_AUTOTUNE_TARGET_ROLE must be managed-test")
}
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 {
return 2, fmt.Errorf("%s does not match the fresh managed target contract", key)
}
}
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 {
return 2, fmt.Errorf("managed SOCKS proxy must match the target SOCKS_PORT listener")
}
if d.verifyRuntime == nil || d.verifySOCKS == nil {
return 1, fmt.Errorf("managed runtime validators unavailable")
}
if err := d.verifyRuntime(managedTargetDirectory); err != nil {
return 1, err
}
if err := d.verifySOCKS(port); err != nil {
return 1, err
}
return 0, nil
}
func managedCLI(args []string, stdout, stderr io.Writer, d managedDeps) int {
if len(args) > 0 && args[0] == "monitor" {
return managedMonitorCLI(args[1:], stdout, stderr, d)
}
command, ids, err := managedArguments(args)
if err != nil {
fmt.Fprintln(stderr, "error:", err)
return 2
}
if code, err := managedRuntimeGuard(d); err != nil {
fmt.Fprintln(stderr, "error:", err)
return code
}
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") }, Health: func() (string, error) { return "", fmt.Errorf("health not configured") }}
if command == "experimental-request-check" {
err = managedExperimentalRequest(dir, false, nil)
} else if command == "init" {
err = managedInitialize(m)
} else if err = managedCheckIdentity(m); err == nil {
if command == "reconcile" {
err = managedPrestartReconcile(m, d)
} else if command == "status" || command == "active-ids" {
err = managedReport(m, stdout, d.openDB, command == "active-ids", len(args) == 2 && args[1] == "--assets")
} else if command == "experiment" {
startup := false
for i := 1; i < len(args); i += 2 {
startup = startup || args[i] == "--googlevideo-request"
}
if startup {
err = managedExperimentalRequest(dir, true, func() error { return managedExperimentalSuffix(m, d) })
} else {
err = managedExperimentalSuffix(m, d)
}
} else {
expected := map[int64]string{}
var scopes []GooglevideoScope
for i := 1; i < len(args); i += 2 {
if args[i] == "--googlevideo-scope" {
scopes = append(scopes, GooglevideoScope(args[i+1]))
continue
}
group := strings.TrimSuffix(strings.TrimPrefix(args[i], "--"), "-candidate")
if group == "asset" {
group = "assets"
}
for _, value := range strings.Split(args[i+1], ",") {
id, _ := strconv.ParseInt(value, 10, 64)
expected[id] = group
}
}
journal, loadErr := m.load()
if loadErr != nil {
err = loadErr
} else if journal.Scope == GooglevideoScopeExperimental && len(scopes) == 0 {
err = fmt.Errorf("experimental CLI apply requires explicit guarded operator path")
} else {
err = managedActivate(m, d, ids, expected, scopes...)
}
}
}
if err != nil {
fmt.Fprintln(stderr, "error:", err)
if errors.Is(err, errManagedScopeUnresolved) {
return 78
}
return 1
}
if command == "init" || command == "reconcile" || command == "apply" || command == "experiment" {
if _, err := fmt.Fprintln(stdout, "managed-test "+command+": OK"); err != nil {
return 1
}
if command == "apply" || command == "experiment" {
if _, err := fmt.Fprintln(stdout, "Player API only; not full-profile/GGC/playback health. Use managed status for unresolved groups."); err != nil {
return 1
}
}
}
return 0
}
// Startup may activate only a known baseline or DB-qualified rendered config.
// Reconcile restores bytes before its fixed target-local restart hook runs.
func managedPrestartReconcile(m *managedTransaction, d managedDeps) (err error) {
path, err := managedMonitorDatabase(d)
if err != nil {
return err
}
db, err := openStore(path)
if err != nil {
return fmt.Errorf("candidate database unavailable")
}
defer func() {
if closeErr := db.Close(); closeErr != nil && err == nil {
err = closeErr
}
}()
// The transaction engine supports legacy hash-only state for other callers;
// initial activation must never adopt it, even with a matching hash.
err = m.locked(func() error {
j, err := m.load()
if err != nil {
return err
}
baselineHash := managedHash([]byte(managedBaseline))
if j.Version < 2 || (len(j.Candidates) == 0 && j.Hash != baselineHash) || (j.State == "prepared" && len(j.PendingCandidates) == 0 && j.Next != baselineHash) {
return fmt.Errorf("startup candidate state unresolved; refusing activation")
}
return nil
})
if err != nil {
return err
}
if err := m.Reconcile(db); err != nil {
return err
}
_, err = m.ActiveCandidates(db)
return err
}
var errManagedScopeUnresolved = errors.New("managed deployment policy unresolved; explicit reconcile or fresh managed state required")
func managedActivate(m *managedTransaction, d managedDeps, ids []int64, expected map[int64]string, scopes ...GooglevideoScope) 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()
if _, err := m.ActiveCandidates(db); err != nil {
return fmt.Errorf("%w: %v", errManagedScopeUnresolved, err)
}
for _, id := range ids {
group := expected[id]
c, err := readStrategyCandidate(db, id)
if err != nil || c.Group != group {
return fmt.Errorf("invalid %s candidate ID", group)
}
}
if err := m.Reconcile(db); err != nil {
return err
}
return m.Apply(db, ids, scopes...)
}