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