Wire pure Player parsing and strict qualification planning through a compiled-in kind/version registry. Fail closed before discovery requests when the required module is absent or mismatched. Require sealed module-bound v2 evidence for new writes while preserving fresh trusted v1 apply eligibility and historical rollback. Keep legacy SOCKS5h routing, separate suffix/asset policy and public configuration unchanged; generic controller cutover and field acceptance remain pending. Co-authored-by: GPT-6 <gpt-6@openai.com>
151 lines
4.0 KiB
Go
151 lines
4.0 KiB
Go
package main
|
|
|
|
import (
|
|
"crypto/sha256"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"syscall"
|
|
)
|
|
|
|
const managedExperimentalRequestName = ".autotune-experimental-suffix-request"
|
|
|
|
func validExperimentalRequestStat(stat *syscall.Stat_t) bool {
|
|
return stat != nil && stat.Mode&(syscall.S_IFMT|07777) == syscall.S_IFREG|0600 && stat.Uid == uint32(os.Geteuid()) && stat.Nlink == 1 && stat.Size == 0
|
|
}
|
|
|
|
// A private directory excludes untrusted renames. Claim the validated inode
|
|
// before apply so no later cleanup can delete a replacement operator request.
|
|
// Failed claims stay private for diagnosis; never overwrite/retry them silently.
|
|
func managedExperimentalRequest(dir string, consume bool, apply func() error) error {
|
|
if err := managedDirectory(dir); err != nil {
|
|
return err
|
|
}
|
|
path := filepath.Join(dir, managedExperimentalRequestName)
|
|
fd, err := syscall.Open(path, syscall.O_RDONLY|syscall.O_NOFOLLOW|syscall.O_NONBLOCK|syscall.O_CLOEXEC, 0)
|
|
if errors.Is(err, syscall.ENOENT) {
|
|
return nil
|
|
}
|
|
invalid := fmt.Errorf("unsafe experimental startup request")
|
|
if err != nil {
|
|
return invalid
|
|
}
|
|
f := os.NewFile(uintptr(fd), "experimental request")
|
|
defer f.Close()
|
|
info, err := f.Stat()
|
|
if err != nil {
|
|
return invalid
|
|
}
|
|
stat, ok := info.Sys().(*syscall.Stat_t)
|
|
if !ok || !validExperimentalRequestStat(stat) {
|
|
return invalid
|
|
}
|
|
if !consume {
|
|
return nil
|
|
}
|
|
if apply == nil {
|
|
return invalid
|
|
}
|
|
claim, err := os.CreateTemp(dir, ".autotune-experimental-request-claim-*")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
claimPath := claim.Name()
|
|
if err := claim.Close(); err != nil {
|
|
return err
|
|
}
|
|
if err := os.Rename(path, claimPath); err != nil {
|
|
return err
|
|
}
|
|
claimed, err := os.Lstat(claimPath)
|
|
if err != nil || !os.SameFile(info, claimed) {
|
|
return invalid
|
|
}
|
|
claimedStat, ok := claimed.Sys().(*syscall.Stat_t)
|
|
if !ok || !validExperimentalRequestStat(claimedStat) {
|
|
return invalid
|
|
}
|
|
transaction := &managedTransaction{Dir: dir}
|
|
if err := transaction.syncDir(); err != nil {
|
|
return err
|
|
}
|
|
if err := apply(); err != nil {
|
|
return err
|
|
}
|
|
claimed, err = os.Lstat(claimPath)
|
|
if err != nil || !os.SameFile(info, claimed) {
|
|
return invalid
|
|
}
|
|
if err := os.Remove(claimPath); err != nil {
|
|
return err
|
|
}
|
|
return transaction.syncDir()
|
|
}
|
|
|
|
// Runs before the PID-1-owned monitor starts; never races a recovery worker.
|
|
// A real Player-discovered identity is saved WITHOUT cold/adaptive evidence.
|
|
func managedExperimentalSuffix(m *managedTransaction, d managedDeps) error {
|
|
if _, err := requiredYoutubeAdapter(); err != nil {
|
|
return err
|
|
}
|
|
singleton, err := acquireManagedMonitorSingleton(d)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer singleton.close()
|
|
lua, err := os.ReadFile("/opt/zapret2/lua/zapret-auto.lua")
|
|
if err != nil || fmt.Sprintf("%x", sha256.Sum256(lua)) != managedGooglevideoLuaHash {
|
|
return fmt.Errorf("native Lua identity mismatch")
|
|
}
|
|
cfg, err := parseManagedHealthConfig(d.lookup)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
body, err := requestPlayer(cfg.VideoID, cfg.SOCKSProxy, d.player)
|
|
if err != nil {
|
|
return fmt.Errorf("fresh Player discovery unavailable")
|
|
}
|
|
host, err := playerHostname(body)
|
|
if err != nil {
|
|
return fmt.Errorf("fresh GGC identity unavailable")
|
|
}
|
|
if d.openWriteDB == nil {
|
|
return fmt.Errorf("experimental candidate writer unavailable")
|
|
}
|
|
db, err := d.openWriteDB(d)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer db.Close()
|
|
current, err := m.ActiveCandidates(db)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
tx, err := db.Begin()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
id, err := insertStrategyCandidate(tx, "googlevideo", []string{host}, managedGooglevideoArgs, nil)
|
|
if err != nil {
|
|
_ = tx.Rollback()
|
|
return err
|
|
}
|
|
if err := tx.Commit(); err != nil {
|
|
return err
|
|
}
|
|
desired, err := managedFullDesiredSet(db, current, []int64{id})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
expected := map[int64]string{}
|
|
for _, id := range desired {
|
|
c, err := readStrategyCandidate(db, id)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
expected[id] = c.Group
|
|
}
|
|
return managedActivate(m, d, desired, expected, GooglevideoScopeExperimental)
|
|
}
|