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>
552 lines
17 KiB
Go
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...)
|
|
}
|