feat: extract versioned YouTube service adapter

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>
This commit is contained in:
ZeusinaandGPT-6 Bot committed 2026-10-15 16:23:54 +03:00
1 parent d324b4137b
commit f4853173b3
21 files changed
+1176 -74

No files matched your search

+26 -3
View File
@@ -9,6 +9,8 @@ import (
"math"
"strings"
"time"
"zapret-autotune/internal/adapter/youtube"
)
// Additive only: old proposals are not independently qualified candidates.
@@ -351,6 +353,7 @@ type GooglevideoHostProof struct {
}
type GooglevideoQualificationProof struct {
Adapter *youtube.Binding `json:"adapter,omitempty"`
Version int `json:"version"`
Mode QualificationMode `json:"mode"`
SourceKind string `json:"source_kind"`
@@ -371,7 +374,25 @@ func (p GooglevideoQualificationProof) validate(c storedCandidate) error {
}
func (p GooglevideoQualificationProof) validateStored(c storedCandidate) error {
if p.Version != 1 || p.Mode != c.Mode || p.Args != c.Args || len(p.Hosts) != len(c.Endpoints) || len(p.Hosts) < 3 {
// Missing binding is explicitly the immutable legacy YouTube v1 policy,
// never the current registry default. Retain historical reconstruction.
if p.Version == 1 {
if p.Adapter != nil {
return fmt.Errorf("legacy proof cannot carry adapter binding")
}
} else {
if p.Mode != QualificationAdaptive || p.Adapter == nil {
return fmt.Errorf("version-bound adaptive proof required")
}
module, err := lookupServiceAdapter(p.Adapter.Kind, p.Adapter.Version)
if err != nil {
return err
}
if *p.Adapter != module.Binding() {
return fmt.Errorf("adapter policy mismatch")
}
}
if (p.Version != 1 && p.Version != 2) || p.Mode != c.Mode || p.Args != c.Args || len(p.Hosts) != len(c.Endpoints) || len(p.Hosts) < 3 {
return fmt.Errorf("invalid representative proof definition")
}
if (p.Mode == QualificationCold && p.SourceKind != "media-range") || (p.Mode == QualificationAdaptive && p.SourceKind != NativeCircularPostWarmup) || (p.Mode != QualificationCold && p.Mode != QualificationAdaptive) {
@@ -380,7 +401,7 @@ func (p GooglevideoQualificationProof) validateStored(c storedCandidate) error {
if err := (&candidate{Args: p.Args}).validateArgs(); err != nil {
return err
}
if err := validateGooglevideoHosts(c.Endpoints); err != nil {
if err := validateLegacyYoutubeV1Hosts(c.Endpoints); err != nil {
return err
}
if p.Mode == QualificationCold && p.Attestation != nil {
@@ -494,7 +515,9 @@ func validateAdaptiveGooglevideoEvidence(db *sql.DB, c storedCandidate, fresh bo
// One transactional insert, no cold candidate_evidence summaries. A private
// producer seal is required as well as valid DTO facts and stored definition.
func saveAdaptiveGooglevideoEvidence(tx *sql.Tx, id int64, proof GooglevideoQualificationProof) error {
if proof.producerSeal == nil || *proof.producerSeal != googlevideoProofSeal(proof) {
// Existing trusted v1 rows retain their original read/apply contract. Only
// this new-write boundary requires the version-bound producer protocol.
if proof.Version != 2 || proof.producerSeal == nil || *proof.producerSeal != googlevideoProofSeal(proof) {
return fmt.Errorf("completed owned collector attestation required")
}
var c storedCandidate
+3
View File
@@ -148,6 +148,9 @@ func discoverYoutube(args []string, stdout, stderr io.Writer, runner playerRunne
}
func requestPlayer(videoID, proxy string, runner playerRunner) ([]byte, error) {
if _, err := requiredYoutubeAdapter(); err != nil {
return nil, err
}
payload, _ := json.Marshal(map[string]interface{}{
"videoId": videoID,
"context": map[string]interface{}{"client": map[string]interface{}{
+4
View File
@@ -44,6 +44,10 @@ func googlevideoProposal(flags []string, stdout, stderr io.Writer, discover play
fmt.Fprintln(stderr, "error: tune googlevideo", err)
return 2
}
if _, err := requiredYoutubeAdapter(); err != nil {
fmt.Fprintln(stderr, "error: tune googlevideo", err)
return 1
}
started := time.Now()
db, err := openStore(databasePath())
if err != nil {
@@ -71,6 +71,9 @@ type managedServiceInventory struct {
func managedServiceResources(cfg healthConfig, player func(context.Context) ([]byte, error), page playerRunner) func(context.Context) (managedServiceInventory, error) {
return func(ctx context.Context) (managedServiceInventory, error) {
i := managedServiceInventory{images: make(map[string]string), proxy: cfg.SOCKSProxy, runner: runResourceCurl}
if _, err := requiredYoutubeAdapter(); err != nil {
return i, err
}
if err := ctx.Err(); err != nil {
return i, managedRecoveryContextError(ctx, err)
}
@@ -105,6 +108,9 @@ func managedServiceResources(cfg healthConfig, player func(context.Context) ([]b
}
i.media, _, err = playerMediaResource(body)
if err != nil {
if errors.Is(err, errServiceAdapterUnavailable) {
return i, err
}
i.resourceErr = &managedResourceFailure{"media", "unknown", err}
}
for attempt := 0; attempt < 2; attempt++ {
@@ -152,6 +158,9 @@ func managedServiceResources(cfg healthConfig, player func(context.Context) ([]b
func managedServiceHealth(proxy string, front func(context.Context) (string, error), inventory func(context.Context) (managedServiceInventory, error), runner subprocessRunner) func(context.Context) (string, error) {
return func(ctx context.Context) (string, error) {
if _, err := requiredYoutubeAdapter(); err != nil {
return "DEGRADED", err
}
status, err := front(ctx)
if err != nil || status != "OK" {
return "DEGRADED", &managedResourceFailure{"front", managedFrontendHost, err}
+6
View File
@@ -597,6 +597,9 @@ func managedPrestartReconcile(m *managedTransaction, d managedDeps) (err error)
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 {
if _, err := requiredYoutubeAdapter(); err != nil {
return err
}
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")
@@ -606,6 +609,9 @@ func managedActivate(m *managedTransaction, d managedDeps, ids []int64, expected
return err
}
m.Health = func() (string, error) {
if _, err := requiredYoutubeAdapter(); err != nil {
return "", err
}
portText, _ := d.lookup("SOCKS_PORT")
port, err := strconv.Atoi(portText)
if err != nil {
@@ -86,6 +86,9 @@ func managedExperimentalRequest(dir string, consume bool, apply func() error) er
// 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
@@ -179,7 +179,7 @@ func TestExperimentalPromotionRequiresRepresentativeOwnedProof(t *testing.T) {
}
assertActiveCandidates(t, d.transaction, d.db, []int64{front, thumb, avatar, id})
p, err := readGooglevideoProof(d.db, id)
if err != nil || p.Version != 1 || len(p.Hosts) != 3 {
if err != nil || p.Version != 2 || p.Adapter == nil || len(p.Hosts) != 3 {
t.Fatal(p, err)
}
c, err := readStrategyCandidate(d.db, experiment)
@@ -5,9 +5,10 @@ import (
"errors"
"fmt"
"sort"
"strconv"
"strings"
"time"
"zapret-autotune/internal/adapter/youtube"
)
// Ordinary unresolved state, not a target/ownership guard failure.
@@ -28,7 +29,7 @@ const managedGooglevideoDiscoveryTimeout = 3 * time.Minute
// Three hosts each need up to 120s warmup + six 35s transfers. Leave margin
// for daemon lifecycle as well; short-lived URLs are refetched, never rewritten.
const managedGooglevideoSampleTTL = 20 * time.Minute
const managedGooglevideoSampleTTL = youtube.InventoryTTL
func freshGooglevideoSample(r mediaResource) bool {
// The same exact GGC hostname syntax as the representative gate; reject bad
@@ -37,13 +38,10 @@ func freshGooglevideoSample(r mediaResource) bool {
if !ok || !strings.HasSuffix(r.host, ".googlevideo.com") || !validDomain(r.host) || r.host != strings.ToLower(r.host) || root == "" || len(prefix) < 3 || !strings.HasPrefix(prefix, "rr") || strings.Trim(prefix[2:], "0123456789") != "" {
return false
}
u, err := privateResourceURL(r.url, r.host)
if err != nil || u.Path != "/videoplayback" || (r.kind != "video/mp4" && r.kind != "audio/mp4") {
if _, err := privateResourceURL(r.url, r.host); err != nil {
return false
}
q := u.Query()
expires, err := strconv.ParseInt(q.Get("expire"), 10, 64)
return err == nil && expires > time.Now().Add(managedGooglevideoSampleTTL).Unix() && (q.Get("sig") != "" || q.Get("signature") != "" || q.Get("lsig") != "")
return youtube.SignedSampleFresh(youtube.Resource{URL: r.url, Host: r.host, Kind: r.kind}, time.Now(), managedGooglevideoSampleTTL)
}
// Choose exactly three actual hosts passing the unchanged representative gate.
@@ -70,6 +68,9 @@ func representativeGooglevideoSamples(byHost map[string]mediaResource) []mediaRe
func managedGooglevideoSamples(ids []string, request func(context.Context, string) ([]byte, error)) func(context.Context) ([]mediaResource, error) {
ids = append([]string(nil), ids...)
return func(ctx context.Context) ([]mediaResource, error) {
if _, err := requiredYoutubeAdapter(); err != nil {
return nil, err
}
if len(ids) == 0 || len(ids) > 5 || request == nil {
return nil, &managedRecoveryFatal{Err: errors.New("invalid sample collector configuration")}
}
@@ -108,6 +109,9 @@ func managedGooglevideoSamples(ids []string, request func(context.Context, strin
}
r, _, err := playerMediaResource(body)
if err != nil {
if errors.Is(err, errServiceAdapterUnavailable) {
return nil, err
}
stats.Unavailable++
continue
} // Missing/SABR is unknown, never fabricated.
@@ -9,9 +9,10 @@ import (
"os"
"os/exec"
"reflect"
"strconv"
"strings"
"time"
"zapret-autotune/internal/adapter/youtube"
)
// ponytail: one audited composite only. New native variants need an explicit
@@ -93,45 +94,47 @@ func newManagedGooglevideoVerifier(target managedDeps) func(context.Context, sto
}
func (r managedAssetRuntime) verifyGooglevideo(ctx context.Context, c storedCandidate, resources []mediaResource) (GooglevideoQualificationProof, error) {
p := GooglevideoQualificationProof{Version: 1, Mode: QualificationAdaptive, SourceKind: NativeCircularPostWarmup, Args: c.Args}
p := GooglevideoQualificationProof{Version: 2, Mode: QualificationAdaptive, SourceKind: NativeCircularPostWarmup, Args: c.Args}
if c.Group != "googlevideo" || c.Mode != QualificationAdaptive {
return p, errors.New("adaptive googlevideo definition required")
}
if err := validateNativeGooglevideoArgs(c.Args); err != nil {
return p, err
}
module, err := requiredYoutubeAdapter()
if err != nil {
return p, err
}
binding := module.Binding()
p.Adapter = &binding
byHost := map[string]mediaResource{}
var samples []youtube.Resource
for _, resource := range resources {
u, err := privateResourceURL(resource.url, resource.host)
if err != nil || u.Path != "/videoplayback" || (resource.kind != "video/mp4" && resource.kind != "audio/mp4") {
return p, errGooglevideoInsufficientSamples
}
q := u.Query()
expires, err := strconv.ParseInt(q.Get("expire"), 10, 64)
if err != nil || expires <= time.Now().Unix()+120 || (q.Get("sig") == "" && q.Get("signature") == "" && q.Get("lsig") == "") {
if _, err := privateResourceURL(resource.url, resource.host); err != nil {
return p, errGooglevideoInsufficientSamples
}
byHost[resource.host] = resource
samples = append(samples, youtube.Resource{URL: resource.url, Host: resource.host, Kind: resource.kind})
}
// Validate representative host diversity using the shared gate before capture.
for _, host := range c.Endpoints {
if _, ok := byHost[host]; !ok {
return p, errGooglevideoInsufficientSamples
}
p.Hosts = append(p.Hosts, GooglevideoHostProof{Host: host})
}
if err := validateGooglevideoHosts(c.Endpoints); err != nil {
if validateGooglevideoHosts(c.Endpoints) != nil {
return p, errGooglevideoInsufficientSamples
}
err := r.withOwnedWorker(ctx, c.Endpoints, c.Args, func(probeCtx context.Context) error {
plan, err := module.PlanQualification(c.Endpoints, samples, time.Now())
if err != nil {
return p, errGooglevideoInsufficientSamples
}
for _, host := range plan.Hosts {
p.Hosts = append(p.Hosts, GooglevideoHostProof{Host: host})
}
err = r.withOwnedWorker(ctx, c.Endpoints, c.Args, func(probeCtx context.Context) error {
for i := range p.Hosts {
h := &p.Hosts[i]
h.WarmupLimit = 10
h.WarmupLimit = plan.WarmupLimit
start := time.Now()
warmCtx, cancel := context.WithTimeout(probeCtx, 120*time.Second)
warmCtx, cancel := context.WithTimeout(probeCtx, plan.WarmupTimeout)
learned := map[string]bool{}
for h.WarmupAttempts < h.WarmupLimit && len(learned) < 2 && warmCtx.Err() == nil {
protocol := []string{"tls12", "tls13"}[h.WarmupAttempts%2]
for h.WarmupAttempts < h.WarmupLimit && len(learned) < len(plan.Protocols) && warmCtx.Err() == nil {
protocol := plan.Protocols[h.WarmupAttempts%len(plan.Protocols)]
h.WarmupAttempts++
_, pass, err := collectMediaTransfer(warmCtx, r.proxy, byHost[h.Host], protocol, r.curl)
if err != nil {
@@ -140,7 +143,7 @@ func (r managedAssetRuntime) verifyGooglevideo(ctx context.Context, c storedCand
cancel()
return err
}
} else if pass.Bytes < 1024 {
} else if pass.Bytes < plan.MinBytes {
h.WarmupFailures++
} else {
learned[protocol] = true
@@ -151,11 +154,11 @@ func (r managedAssetRuntime) verifyGooglevideo(ctx context.Context, c storedCand
if probeCtx.Err() != nil {
return probeCtx.Err()
}
if len(learned) != 2 || h.WarmupMS > 120000 {
if len(learned) != len(plan.Protocols) || h.WarmupMS > float64(plan.WarmupTimeout/time.Millisecond) {
return errCandidateNonpass
}
for _, protocol := range []string{"tls12", "tls13"} {
for n := 0; n < 3; n++ {
for _, protocol := range plan.Protocols {
for n := 0; n < plan.Samples; n++ {
_, pass, err := collectMediaTransfer(probeCtx, r.proxy, byHost[h.Host], protocol, r.curl)
if err != nil {
if managedGooglevideoTransferNonpass(err) {
@@ -163,7 +166,7 @@ func (r managedAssetRuntime) verifyGooglevideo(ctx context.Context, c storedCand
}
return err
}
if pass.Bytes < 1024 {
if pass.Bytes < plan.MinBytes {
return errCandidateNonpass
}
h.Passes = append(h.Passes, pass)
@@ -239,16 +242,28 @@ func managedResourceTransferNonpass(err error, metadata, image bool) bool {
}
func validateGooglevideoHosts(hosts []string) error {
seen, roots, prefixes := map[string]bool{}, map[string]bool{}, map[string]bool{}
for _, host := range hosts {
prefix, root, ok := strings.Cut(strings.TrimSuffix(host, ".googlevideo.com"), "---sn-")
if !ok || !strings.HasSuffix(host, ".googlevideo.com") || !validDomain(host) || host != strings.ToLower(host) || seen[host] || root == "" || len(prefix) < 3 || !strings.HasPrefix(prefix, "rr") || strings.Trim(prefix[2:], "0123456789") != "" {
if !validDomain(host) {
return errGooglevideoInsufficientSamples
}
seen[host], roots[strings.Split(root, "-")[0]], prefixes[prefix] = true, true, true
}
if len(hosts) < 3 || len(roots) < 2 || len(prefixes) < 2 {
module, err := requiredYoutubeAdapter()
if err != nil {
return err
}
if module.ValidateHosts(hosts) != nil {
return errGooglevideoInsufficientSamples
}
return nil
}
// Historical v1 reconstruction must not depend on a future registry default.
// This pinned contract remains available even when the execution module is absent.
func validateLegacyYoutubeV1Hosts(hosts []string) error {
for _, host := range hosts {
if !validDomain(host) {
return errGooglevideoInsufficientSamples
}
}
return (youtube.Module{}).ValidateHosts(hosts)
}
+6
View File
@@ -47,6 +47,9 @@ type managedRecoveryDeps struct {
// The injected command runner receives only fixed script/argv from orchestration.
func managedRecoveryDependencies(target managedDeps, db *sql.DB, scan cacheScan, check cacheCheck, run func(context.Context, string, ...string) error) (managedRecoveryDeps, error) {
d := managedRecoveryDeps{db: db, scan: scan, check: check, run: run}
if _, err := requiredYoutubeAdapter(); err != nil {
return d, err
}
if target.lookup == nil || target.player == nil || db == nil || scan == nil || check == nil || run == nil {
return d, fmt.Errorf("complete target-local recovery adapter dependencies required")
}
@@ -59,6 +62,9 @@ func managedRecoveryDependencies(target managedDeps, db *sql.DB, scan cacheScan,
}
d.transaction = &managedTransaction{Dir: target.directory, Name: "config"}
requestVideo := func(ctx context.Context, videoID string) ([]byte, error) {
if _, err := requiredYoutubeAdapter(); err != nil {
return nil, err
}
if err := ctx.Err(); err != nil {
return nil, err
}
+9 -31
View File
@@ -190,39 +190,17 @@ type mediaCapability struct {
// SABR is deliberately unknown/not supported, never fabricated as readiness.
func playerMediaResource(body []byte) (mediaResource, mediaCapability, error) {
var p struct {
PlayabilityStatus struct {
Status string `json:"status"`
} `json:"playabilityStatus"`
StreamingData struct {
Formats []struct {
URL string `json:"url"`
MimeType string `json:"mimeType"`
} `json:"formats"`
AdaptiveFormats []struct {
URL string `json:"url"`
MimeType string `json:"mimeType"`
} `json:"adaptiveFormats"`
} `json:"streamingData"`
module, err := requiredYoutubeAdapter()
if err != nil {
return mediaResource{}, mediaCapability{}, err
}
if len(body) > playerResponseLimit || json.Unmarshal(body, &p) != nil || p.PlayabilityStatus.Status != "OK" {
return mediaResource{}, mediaCapability{}, errors.New("invalid playable metadata")
resources, err := module.DiscoverResponse(body)
if err != nil {
return mediaResource{}, mediaCapability{}, err
}
for _, f := range append(p.StreamingData.Formats, p.StreamingData.AdaptiveFormats...) {
u, err := url.Parse(f.URL)
if err != nil {
continue
}
host := u.Hostname()
if !strings.HasSuffix(host, ".googlevideo.com") {
continue
}
if _, err := privateResourceURL(f.URL, host); err != nil {
continue
}
kind, _, err := mime.ParseMediaType(f.MimeType)
if err == nil && (kind == "video/mp4" || kind == "audio/mp4") {
return mediaResource{f.URL, host, kind}, mediaCapability{OrdinaryURL: true}, nil
for _, r := range resources {
if _, err := privateResourceURL(r.URL, r.Host); err == nil {
return mediaResource{r.URL, r.Host, r.Kind}, mediaCapability{OrdinaryURL: true}, nil
}
}
return mediaResource{}, mediaCapability{}, nil
+54
View File
@@ -0,0 +1,54 @@
package main
import (
"errors"
"sync"
"zapret-autotune/internal/adapter"
"zapret-autotune/internal/adapter/youtube"
)
// Trusted compiled-in dispatch, deliberately not a public config/plugin API.
// An empty registry is a supported fail-closed seam; no HTTP fallback exists.
type serviceAdapterKey struct {
kind string
version int
}
type serviceAdapterRegistry map[serviceAdapterKey]adapter.Module
var errServiceAdapterUnavailable = errors.New("required service adapter unavailable")
// The registry is immutable in production. The lock permits race-free test
// replacement while request callbacks/owned lifecycle children are running.
var serviceAdapters = struct {
sync.RWMutex
modules serviceAdapterRegistry
}{modules: serviceAdapterRegistry{{youtube.Kind, youtube.Version}: youtube.Module{}}}
func requiredYoutubeAdapter() (adapter.Module, error) {
serviceAdapters.RLock()
m, err := serviceAdapters.modules.lookup(youtube.Kind, youtube.Version)
serviceAdapters.RUnlock()
if err != nil || m.Binding() != (youtube.Module{}).Binding() {
return nil, &managedRecoveryFatal{Err: errServiceAdapterUnavailable}
}
return m, nil
}
func (r serviceAdapterRegistry) lookup(kind string, version int) (adapter.Module, error) {
m, ok := r[serviceAdapterKey{kind, version}]
if !ok || m == nil {
return nil, errServiceAdapterUnavailable
}
b := m.Binding()
if b.Kind != kind || b.Version != version {
return nil, errServiceAdapterUnavailable
}
return m, nil
}
func lookupServiceAdapter(kind string, version int) (adapter.Module, error) {
serviceAdapters.RLock()
defer serviceAdapters.RUnlock()
return serviceAdapters.modules.lookup(kind, version)
}
@@ -0,0 +1,284 @@
package main
import (
"context"
"encoding/json"
"errors"
"io"
"testing"
"time"
"zapret-autotune/internal/adapter"
"zapret-autotune/internal/adapter/youtube"
)
func replaceServiceAdapters(t *testing.T, modules serviceAdapterRegistry) {
t.Helper()
serviceAdapters.Lock()
previous := serviceAdapters.modules
serviceAdapters.modules = modules
serviceAdapters.Unlock()
t.Cleanup(func() {
serviceAdapters.Lock()
serviceAdapters.modules = previous
serviceAdapters.Unlock()
})
}
func TestServiceAdapterDispatchFailClosed(t *testing.T) {
for _, key := range []serviceAdapterKey{{"unknown", 1}, {youtube.Kind, 0}, {youtube.Kind, 2}} {
if _, err := lookupServiceAdapter(key.kind, key.version); err == nil {
t.Fatal("unsupported adapter accepted")
}
}
if _, err := (serviceAdapterRegistry{}).lookup(youtube.Kind, youtube.Version); err == nil {
t.Fatal("absent adapter accepted")
}
replaceServiceAdapters(t, serviceAdapterRegistry{})
if _, _, err := playerMediaResource([]byte(`{"playabilityStatus":{"status":"OK"}}`)); err == nil {
t.Fatal("discovery bypassed registry")
}
r, c, resources, events := googlevideoRuntimeFixture(t)
if _, err := r.verifyGooglevideo(context.Background(), c, resources); err == nil || len(*events) != 0 {
t.Fatal("qualification bypassed registry")
}
}
type mismatchedServiceAdapter struct{ adapter.Module }
func (m mismatchedServiceAdapter) Binding() adapter.Binding {
b := m.Module.Binding()
b.Version++
return b
}
func TestServiceAdapterIdentityBeforeExecution(t *testing.T) {
replaceServiceAdapters(t, serviceAdapterRegistry{{youtube.Kind, youtube.Version}: mismatchedServiceAdapter{youtube.Module{}}})
r, c, resources, events := googlevideoRuntimeFixture(t)
if _, err := r.verifyGooglevideo(context.Background(), c, resources); err == nil || len(*events) != 0 {
t.Fatal("identity mismatch reached worker")
}
}
func TestServiceAdapterStoredProofRefusals(t *testing.T) {
r, c, resources, _ := googlevideoRuntimeFixture(t)
p, err := r.verifyGooglevideo(context.Background(), c, resources)
if err != nil {
t.Fatal(err)
}
db := testStore(t)
tx, err := db.Begin()
if err != nil {
t.Fatal(err)
}
defer tx.Rollback()
id, err := insertStrategyCandidate(tx, c.Group, c.Endpoints, c.Args, nil, c.Mode)
if err != nil {
t.Fatal(err)
}
if err := saveAdaptiveGooglevideoEvidence(tx, id, p); err != nil {
t.Fatal(err)
}
if err := tx.Commit(); err != nil {
t.Fatal(err)
}
front := managedCandidateFixture(t, db, "frontend", "www.youtube.com", "--lua-desync=multisplit", true)
for _, mode := range []string{"kind", "version", "digest", "missing", "unknown-proof", "downgrade", "attestation"} {
t.Run(mode, func(t *testing.T) {
raw, _ := json.Marshal(p)
var proof GooglevideoQualificationProof
if err := json.Unmarshal(raw, &proof); err != nil {
t.Fatal(err)
}
switch mode {
case "kind":
proof.Adapter.Kind = "unknown"
case "version":
proof.Adapter.Version++
case "digest":
proof.Adapter.PolicySHA256 = "changed"
case "missing":
proof.Adapter = nil
case "unknown-proof":
proof.Version = 3
case "downgrade":
proof.Version = 1
case "attestation":
proof.Attestation = nil
}
if proof.validateStored(c) == nil {
t.Fatal("malformed proof reconstructed")
}
raw, _ = json.Marshal(proof)
if _, err := db.Exec("UPDATE googlevideo_scope_evidence SET proof=? WHERE candidate_id=?", string(raw), id); err != nil {
t.Fatal(err)
}
m, reloads := managedFixture(t)
if err := m.Apply(db, []int64{front, id}, GooglevideoScopeSuffix); err == nil || *reloads != 0 {
t.Fatal("invalid proof reached apply", err, *reloads)
}
})
}
}
func TestServiceAdapterProofBoundary(t *testing.T) {
r, c, resources, _ := googlevideoRuntimeFixture(t)
p, err := r.verifyGooglevideo(context.Background(), c, resources)
if err != nil {
t.Fatal(err)
}
if p.Version != 2 || p.Adapter == nil || *p.Adapter != (youtube.Module{}).Binding() {
t.Fatal("missing module identity")
}
seal := googlevideoProofSeal(p)
for _, mutate := range []func(){
func() { p.Adapter.Kind = "unknown" },
func() { p.Adapter.Version++ },
func() { p.Adapter.PolicySHA256 = "changed" },
} {
original := *p.Adapter
mutate()
if p.validateStored(c) == nil || googlevideoProofSeal(p) == seal {
t.Fatal("module boundary not bound to evidence")
}
*p.Adapter = original
}
// Reads retain the original v1 contract, including fresh apply eligibility.
p.Version, p.Adapter = 1, nil
raw, err := json.Marshal(p)
if err != nil {
t.Fatal(err)
}
legacy, err := decodeGooglevideoProof(string(raw))
if err != nil || legacy.validateStored(c) != nil {
t.Fatal("legacy reconstruction lost", err)
}
if legacy.validate(c) != nil {
t.Fatal("fresh trusted legacy adaptive proof lost apply eligibility")
}
legacy.Attestation.CheckedAt = time.Now().Add(-25 * time.Hour)
if legacy.validate(c) == nil {
t.Fatal("expired legacy adaptive proof authorized new apply")
}
replaceServiceAdapters(t, serviceAdapterRegistry{})
if legacy.validateStored(c) != nil {
t.Fatal("historical reconstruction depends on current execution registry")
}
}
type changedPolicyServiceAdapter struct{ adapter.Module }
func (m changedPolicyServiceAdapter) Binding() adapter.Binding {
b := m.Module.Binding()
b.PolicySHA256 = "changed"
return b
}
func TestServiceAdapterDiscoveryPreflight(t *testing.T) {
for _, mode := range []string{"missing", "version", "digest"} {
t.Run(mode, func(t *testing.T) {
modules := serviceAdapterRegistry{}
if mode == "version" {
modules[serviceAdapterKey{youtube.Kind, youtube.Version}] = mismatchedServiceAdapter{youtube.Module{}}
}
if mode == "digest" {
modules[serviceAdapterKey{youtube.Kind, youtube.Version}] = changedPolicyServiceAdapter{youtube.Module{}}
}
calls := 0
player := func(context.Context, []string, io.Writer, io.Writer) error { calls++; return nil }
request := func(context.Context) ([]byte, error) { calls++; return nil, nil }
target, _, _ := managedCLIFixture(t)
target.player = player
target.verifySOCKS = func(int) error { calls++; return nil }
r, _, _ := recoveryFixture(t, false)
bound, err := managedRecoveryDependencies(target, r.db, r.scan, r.check, r.run)
if err != nil {
t.Fatal(err)
}
calls = 0 // Construction guard is allowed before removing the module.
replaceServiceAdapters(t, modules)
cfg := healthConfig{VideoID: "dQw4w9WgXcQ", SOCKSProxy: "socks5://127.0.0.1:1080"}
assertBlocked := func(err error) {
t.Helper()
var fatal *managedRecoveryFatal
if !errors.Is(err, errServiceAdapterUnavailable) || !errors.As(err, &fatal) || errors.Is(err, errNoQualifiedStrategy) || errors.Is(err, errGooglevideoInsufficientSamples) || managedResourceTransferNonpass(err, true, true) {
t.Fatal("adapter configuration became a retryable absence", err)
}
if calls != 0 {
t.Fatal("preflight made network calls", calls)
}
}
_, err = requestPlayer(cfg.VideoID, cfg.SOCKSProxy, player)
assertBlocked(err)
if managedResourceTransferNonpass(errors.Join(err, context.DeadlineExceeded), true, true) || managedRecoveryCooldown(errors.Join(err, errNoQualifiedStrategy), time.Minute) != time.Minute {
t.Fatal("mixed fatal adapter failure became transfer-negative/2h absence")
}
_, err = bound.discover(context.Background())
assertBlocked(err)
_, err = bound.health(context.Background())
assertBlocked(err)
_, err = managedGooglevideoSamples([]string{cfg.VideoID}, func(ctx context.Context, _ string) ([]byte, error) { return request(ctx) })(context.Background())
assertBlocked(err)
inventory := managedServiceResources(cfg, request, player)
_, err = inventory(context.Background())
assertBlocked(err)
_, err = managedServiceHealth(cfg.SOCKSProxy, func(context.Context) (string, error) { calls++; return "OK", nil }, inventory, func(context.Context, []string, io.Reader, io.Writer, io.Writer) error { calls++; return nil })(context.Background())
assertBlocked(err)
if code := discoverYoutube([]string{"--video-id", cfg.VideoID, "--proxy", cfg.SOCKSProxy}, io.Discard, io.Discard, player); code != 1 || calls != 0 {
t.Fatal("legacy CLI bypassed preflight", code, calls)
}
_, err = managedRecoveryDependencies(target, r.db, r.scan, r.check, r.run)
assertBlocked(err)
assertBlocked(managedExperimentalSuffix(nil, managedDeps{}))
assertBlocked(managedActivate(nil, managedDeps{}, nil, nil))
for _, saved := range []bool{false, true} {
code := googlevideoProposal([]string{"--video-id", cfg.VideoID, "--proxy", cfg.SOCKSProxy}, io.Discard, io.Discard, player, func(context.Context, string, string, io.Writer, io.Writer) (string, error) { calls++; return "", nil }, func(context.Context, string, string, string, string, io.Writer, io.Writer) error { calls++; return nil }, saved)
if code != 1 || calls != 0 {
t.Fatal("proposal pipeline bypassed preflight", code, calls)
}
}
runtime, c, resources, events := googlevideoRuntimeFixture(t)
_, err = runtime.verifyGooglevideo(context.Background(), c, resources)
assertBlocked(err)
if len(*events) != 0 {
t.Fatal("preflight launched worker")
}
})
}
}
func TestServiceAdapterLegacyNewWriteRefused(t *testing.T) {
r, c, resources, _ := googlevideoRuntimeFixture(t)
p, err := r.verifyGooglevideo(context.Background(), c, resources)
if err != nil {
t.Fatal(err)
}
p.Version, p.Adapter = 1, nil
if p.validate(c) != nil {
t.Fatal("trusted legacy read invalid")
}
// Even an internally constructed seal cannot authorize NEW v1 publication.
seal := googlevideoProofSeal(p)
p.producerSeal = &seal
db := testStore(t)
tx, err := db.Begin()
if err != nil {
t.Fatal(err)
}
defer tx.Rollback()
id, err := insertStrategyCandidate(tx, c.Group, c.Endpoints, c.Args, nil, c.Mode)
if err != nil {
t.Fatal(err)
}
if saveAdaptiveGooglevideoEvidence(tx, id, p) == nil {
t.Fatal("new sealed v1 write accepted")
}
raw, _ := json.Marshal(p)
var dto GooglevideoQualificationProof
if err := json.Unmarshal(raw, &dto); err != nil {
t.Fatal(err)
}
if saveAdaptiveGooglevideoEvidence(tx, id, dto) == nil {
t.Fatal("unsealed v1 DTO write accepted")
}
}
@@ -0,0 +1,168 @@
package main
// Portable trusted-history fixtures: run unchanged on archived d324b41 too.
// Direct SQL below models an existing trusted v1 database, not an import API.
import (
"bytes"
"context"
"database/sql"
"encoding/json"
"errors"
"reflect"
"testing"
"time"
)
func legacyYoutubeV1Fixture(t *testing.T, db *sql.DB) (int64, GooglevideoQualificationProof) {
t.Helper()
r, c, resources, _ := googlevideoRuntimeFixture(t)
p, err := r.verifyGooglevideo(context.Background(), c, resources)
if err != nil {
t.Fatal(err)
}
raw, _ := json.Marshal(p)
var fields map[string]json.RawMessage
if err := json.Unmarshal(raw, &fields); err != nil {
t.Fatal(err)
}
delete(fields, "adapter")
fields["version"] = json.RawMessage(`1`)
raw, _ = json.Marshal(fields)
legacy, err := decodeGooglevideoProof(string(raw))
if err != nil || legacy.validate(c) != nil {
t.Fatal("trusted v1 contract invalid", err)
}
tx, err := db.Begin()
if err != nil {
t.Fatal(err)
}
defer tx.Rollback()
id, err := insertStrategyCandidate(tx, c.Group, c.Endpoints, c.Args, nil, c.Mode)
if err != nil {
t.Fatal(err)
}
if _, err := tx.Exec("INSERT INTO googlevideo_scope_evidence(candidate_id,proof) VALUES (?,?)", id, string(raw)); err != nil {
t.Fatal(err)
}
if err := tx.Commit(); err != nil {
t.Fatal(err)
}
return id, legacy
}
func expireLegacyYoutubeV1(t *testing.T, db *sql.DB, id int64, proof GooglevideoQualificationProof) {
t.Helper()
proof.Attestation.CheckedAt = time.Now().Add(-25 * time.Hour)
raw, _ := json.Marshal(proof)
if _, err := db.Exec("UPDATE googlevideo_scope_evidence SET proof=? WHERE candidate_id=?", string(raw), id); err != nil {
t.Fatal(err)
}
}
func TestLegacyYoutubeV1FreshApplyEligibility(t *testing.T) {
db := testStore(t)
id, proof := legacyYoutubeV1Fixture(t, db)
c, err := readStrategyCandidate(db, id)
if err != nil || !c.Qualified {
t.Fatal("fresh stored v1 lost qualification", err)
}
saved, err := listQualifiedCandidates(db, "googlevideo", 10)
if err != nil || len(saved) != 1 || saved[0].ID != id {
t.Fatal("fresh stored v1 disappeared from shortlist", err)
}
front := managedCandidateFixture(t, db, "frontend", "www.youtube.com", "--lua-desync=multisplit", true)
ids := []int64{front, id} // Native suffix still does not require assets.
m, reloads := managedFixture(t)
if err := m.Apply(db, ids, GooglevideoScopeSuffix); err != nil {
t.Fatal("fresh v1 apply rejected", err)
}
config, err := m.read(m.Name)
if err != nil {
t.Fatal(err)
}
expireLegacyYoutubeV1(t, db, id, proof)
c, err = readStrategyCandidate(db, id)
if err != nil || c.Qualified {
t.Fatal("expired v1 retained fresh qualification", err)
}
before := *reloads
if err := m.Apply(db, ids, GooglevideoScopeSuffix); err == nil || *reloads != before {
t.Fatal("expired v1 activated")
}
rendered, err := renderStoredManagedConfigScope(db, ids, GooglevideoScopeSuffix)
if err != nil || !bytes.Equal(config, rendered) {
t.Fatal("expired historical reconstruction changed", err)
}
}
func TestLegacyYoutubeV1PreparedRollback(t *testing.T) {
for _, point := range []string{"staged", "backup", "prepared", "replaced", "reloaded", "healthy"} {
t.Run(point, func(t *testing.T) {
db := testStore(t)
id, proof := legacyYoutubeV1Fixture(t, db)
front := managedCandidateFixture(t, db, "frontend", "www.youtube.com", "--lua-desync=multisplit", true)
ids := []int64{front, id}
m, reloads := managedFixture(t)
if err := m.Apply(db, ids, GooglevideoScopeSuffix); err != nil {
t.Fatal(err)
}
before, err := m.load()
if err != nil {
t.Fatal(err)
}
journal, err := m.read(managedJournalName)
if err != nil {
t.Fatal(err)
}
config, err := m.read(m.Name)
if err != nil {
t.Fatal(err)
}
nextFront := managedCandidateFixture(t, db, "frontend", "www.youtube.com", "--lua-desync=fake", true)
m.fault = func(stage string) error {
if stage == point {
return errors.New("fixture crash")
}
return nil
}
if err := m.Apply(db, []int64{nextFront, id}, GooglevideoScopeSuffix); err == nil {
t.Fatal("fault missed")
}
if point != "staged" {
backup, err := m.read(managedBackupName)
if err != nil || !bytes.Equal(backup, config) {
t.Fatal("legacy backup changed", err)
}
}
expireLegacyYoutubeV1(t, db, id, proof)
m.fault = nil
priorReloads := *reloads
if err := m.Reconcile(db); err != nil {
t.Fatal("expired v1 prepared recovery failed", err)
}
after, err := m.load()
if err != nil {
t.Fatal(err)
}
wantGeneration, wantReloads := before.Generation+1, priorReloads+1
if point == "staged" || point == "backup" {
wantGeneration, wantReloads = before.Generation, priorReloads
}
if after.State != "committed" || after.Hash != before.Hash || after.Scope != before.Scope || !reflect.DeepEqual(after.Candidates, before.Candidates) || len(after.PendingCandidates) != 0 || after.PendingScope != "" || after.Generation != wantGeneration || *reloads != wantReloads {
t.Fatal("legacy rollback contract changed", after, *reloads)
}
restored, err := m.read(m.Name)
if err != nil || !bytes.Equal(restored, config) {
t.Fatal("rollback config bytes changed", err)
}
if point == "staged" || point == "backup" {
afterJournal, err := m.read(managedJournalName)
if err != nil || !bytes.Equal(journal, afterJournal) {
t.Fatal("pre-prepare journal changed", err)
}
}
assertActiveCandidates(t, m, db, ids)
t.Logf("legacy restored config SHA256=%s", after.Hash)
})
}
}
@@ -0,0 +1,133 @@
package main
// This corpus also runs unmodified against archived d324b41. It uses only
// pre-extraction APIs, with explicit expected normalized facts, not wrappers.
import (
"bytes"
"context"
"encoding/json"
"fmt"
"strings"
"testing"
"time"
)
func TestYoutubeLegacyParserParity(t *testing.T) {
good := "https://rr1---sn-alpha.googlevideo.com/videoplayback?expire=1800000000&sig=private-secret"
format := func(raw, mime string) map[string]string { return map[string]string{"url": raw, "mimeType": mime} }
for _, tc := range []struct {
name string
formats, adaptive []map[string]string
want string
}{
{"ordinary-first", []map[string]string{format(good, "audio/mp4; codecs=mp4a")}, []map[string]string{format(good+"&second=1", "video/mp4")}, "audio/mp4"},
{"nonmp4-fallback", []map[string]string{format(good, "video/webm")}, []map[string]string{format(good, "video/mp4")}, "video/mp4"},
{"userinfo", []map[string]string{format(strings.Replace(good, "https://", "https://user@", 1), "video/mp4")}, nil, ""},
{"fragment", []map[string]string{format(good+"#secret", "video/mp4")}, nil, ""},
{"http", []map[string]string{format(strings.Replace(good, "https:", "http:", 1), "video/mp4")}, nil, ""},
{"invalid-dns", []map[string]string{format(strings.Replace(good, "rr1---sn-alpha", "bad_host", 1), "video/mp4")}, nil, ""},
{"sabr-only", nil, nil, ""},
} {
t.Run(tc.name, func(t *testing.T) {
body, _ := json.Marshal(map[string]interface{}{"playabilityStatus": map[string]string{"status": "OK"}, "streamingData": map[string]interface{}{"formats": tc.formats, "adaptiveFormats": tc.adaptive, "serverAbrStreamingUrl": good}})
r, capability, err := playerMediaResource(body)
if err != nil || r.kind != tc.want || capability.OrdinaryURL != (tc.want != "") || capability.SABRSupported {
t.Fatal(r.kind, capability, err)
}
if tc.want != "" && (r.url != good || r.host != "rr1---sn-alpha.googlevideo.com") {
t.Fatal("normalized resource changed")
}
})
}
for _, body := range [][]byte{[]byte(`{"secret":`), bytes.Repeat([]byte("x"), playerResponseLimit+1)} {
if _, _, err := playerMediaResource(body); err == nil || err.Error() != "invalid playable metadata" {
t.Fatal("metadata error contract changed", err)
}
}
for _, delta := range []time.Duration{-time.Hour, 19 * time.Minute, 21 * time.Minute} {
r := mediaResource{fmt.Sprintf("https://rr1---sn-alpha.googlevideo.com/videoplayback?expire=%d&lsig=secret", time.Now().Add(delta).Unix()), "rr1---sn-alpha.googlevideo.com", "video/mp4"}
if freshGooglevideoSample(r) != (delta > managedGooglevideoSampleTTL) {
t.Fatal("inventory freshness changed", delta)
}
}
}
func TestYoutubeLegacyJournalParity(t *testing.T) {
r, c, resources, _ := googlevideoRuntimeFixture(t)
p, err := r.verifyGooglevideo(context.Background(), c, resources)
if err != nil {
t.Fatal(err)
}
db := testStore(t)
tx, err := db.Begin()
if err != nil {
t.Fatal(err)
}
defer tx.Rollback()
id, err := insertStrategyCandidate(tx, c.Group, c.Endpoints, c.Args, nil, c.Mode)
if err != nil {
t.Fatal(err)
}
if err := saveAdaptiveGooglevideoEvidence(tx, id, p); err != nil {
t.Fatal(err)
}
if err := tx.Commit(); err != nil {
t.Fatal(err)
}
front := managedCandidateFixture(t, db, "frontend", "www.youtube.com", "--lua-desync=multisplit", true)
m, _ := managedFixture(t)
ids := []int64{front, id} // No new asset requirement for native suffix policy.
if err := m.Apply(db, ids, GooglevideoScopeSuffix); err != nil {
t.Fatal(err)
}
before, err := m.load()
if err != nil {
t.Fatal(err)
}
journalBytes, err := m.read(managedJournalName)
if err != nil {
t.Fatal(err)
}
config, err := m.read(m.Name)
if err != nil {
t.Fatal(err)
}
// Convert the actual producer facts to the exact historical v1 wire shape.
p.Attestation.CheckedAt = time.Now().Add(-25 * time.Hour)
raw, _ := json.Marshal(p)
var fields map[string]json.RawMessage
if err := json.Unmarshal(raw, &fields); err != nil {
t.Fatal(err)
}
delete(fields, "adapter")
fields["version"] = json.RawMessage(`1`)
raw, _ = json.Marshal(fields)
if _, err := db.Exec("UPDATE googlevideo_scope_evidence SET proof=? WHERE candidate_id=?", string(raw), id); err != nil {
t.Fatal(err)
}
rendered, err := renderStoredManagedConfigScope(db, ids, GooglevideoScopeSuffix)
if err != nil || !bytes.Equal(config, rendered) || managedHash(rendered) != before.Hash {
t.Fatal("historical render/hash changed", err)
}
if err := m.Reconcile(db); err != nil {
t.Fatal(err)
}
active, err := m.ActiveCandidates(db)
if err != nil || len(active) != 2 || active[0] != front || active[1] != id {
t.Fatal(active, err)
}
after, err := m.load()
if err != nil {
t.Fatal(err)
}
a, _ := json.Marshal(before)
b, _ := json.Marshal(after)
if !bytes.Equal(a, b) {
t.Fatal("historical journal changed")
}
afterBytes, err := m.read(managedJournalName)
if err != nil || !bytes.Equal(journalBytes, afterBytes) {
t.Fatal("historical journal bytes changed", err)
}
t.Logf("historical config SHA256=%s", before.Hash)
}