Files
zapret-autotune/cmd/zapret-autotune/managed_cli.go
T
ZeusinaandGPT-6 Bot eade051c2b fix(managed): guard experimental database writes before opening store
Reuse managedMonitorDatabase to validate the canonical target-owned database and private files/sidecars before openStore can create, chmod or migrate anything. Keep ordinary history read-only and experimental authorization unchanged. Cover unsafe paths, links, modes, owners and sidecars plus valid existing stores.

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

554 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)
openWriteDB func(managedDeps) (*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()) },
openWriteDB: func(d managedDeps) (*sql.DB, error) {
path, err := managedMonitorDatabase(d)
if err != nil {
return nil, err
}
return openStore(path)
},
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
}
}
m.forbidExperimentalApply = true
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...)
}