Files
zapret-autotune/cmd/zapret-autotune/managed_asset_runtime.go
T
ZeusinaandGPT-6 Bot e9a28c8cd3 fix: keep rejected image payloads recoverable across verification
Type decoder payload rejections once and share the image nonpass classifier across live health and owned verification. Retain strict qualification, malformed metadata, source-kind separation and mixed safety vetoes; exercise seed fallback, joined workers, fresh evidence and durable absence cooldown.

Co-authored-by: GPT-6 <gpt-6@openai.com>
2026-10-12 22:09:11 +03:00

381 lines
12 KiB
Go

package main
import (
"context"
"errors"
"fmt"
"io"
"os"
"os/exec"
"strconv"
"strings"
"syscall"
"time"
)
const managedAssetQueue = 200 // Serialized recovery never runs blockcheck concurrently.
const managedAssetTable = "zapret_autotune_asset_probe"
type managedAssetWorker struct {
pid int
done <-chan error
stop func() error
}
type managedAssetRuntime struct {
guard func() error
nft func(context.Context, string) (string, error)
start func([]string) (managedAssetWorker, error)
queue func(int) (bool, error)
curl subprocessRunner
proxy string
}
type managedAssetCleanupFailure struct{ Err error }
func (e *managedAssetCleanupFailure) Error() string { return "owned asset runtime cleanup failed" }
func (e *managedAssetCleanupFailure) Unwrap() error { return e.Err }
func newManagedAssetVerifier(target managedDeps) func(context.Context, storedCandidate, managedServiceInventory) ([]assetMeasurement, error) {
return newManagedAssetRuntime(target).verify
}
func newManagedAssetRuntime(target managedDeps) managedAssetRuntime {
proxy, _ := target.lookup("ZAPRET_AUTOTUNE_SOCKS_PROXY")
r := managedAssetRuntime{proxy: proxy, curl: runResourceCurl}
r.guard = func() error {
if _, err := managedRuntimeGuard(target); err != nil {
return err
}
status, err := os.ReadFile("/proc/self/status")
if err != nil {
return err
}
return managedAssetCapabilityGuard(string(status))
}
r.nft = func(ctx context.Context, input string) (string, error) {
cmd := exec.CommandContext(ctx, "nft", "-f", "-")
cmd.Stdin = strings.NewReader(input)
var out strings.Builder
cmd.Stdout, cmd.Stderr = &out, io.Discard
err := cmd.Run()
return out.String(), err
}
r.start = func(args []string) (managedAssetWorker, error) {
// No daemon or Setpgid: retain monitor session ownership.
cmd := exec.Command("/opt/zapret2/nfq2/nfqws2", args...)
cmd.Stdout, cmd.Stderr = io.Discard, io.Discard
if err := cmd.Start(); err != nil {
return managedAssetWorker{}, err
}
done := make(chan error, 1)
go func() { done <- cmd.Wait() }()
return managedAssetWorker{pid: cmd.Process.Pid, done: done, stop: func() error {
err := cmd.Process.Kill()
if errors.Is(err, os.ErrProcessDone) {
return errors.New("asset worker exited before owned stop")
}
return err
}}, nil
}
r.queue = managedAssetQueueReady
return r
}
func managedAssetCapabilityGuard(status string) error {
const required = 1<<5 | 1<<12 | 1<<19 // KILL, NET_ADMIN, SYS_PTRACE
for _, line := range strings.Split(status, "\n") {
if strings.HasPrefix(line, "CapEff:") {
bits, err := strconv.ParseUint(strings.TrimSpace(strings.TrimPrefix(line, "CapEff:")), 16, 64)
if err == nil && bits&required == required {
return nil
}
}
}
return errors.New("asset verifier requires CAP_KILL, CAP_NET_ADMIN and CAP_SYS_PTRACE")
}
// Queue peer portid is a netlink socket id, not necessarily a process id.
func managedAssetQueueReady(pid int) (bool, error) {
queues, err := os.ReadFile("/proc/net/netfilter/nfnetlink_queue")
if errors.Is(err, os.ErrNotExist) {
return false, nil
}
if err != nil {
return false, err
}
peer := ""
for _, line := range strings.Split(string(queues), "\n") {
f := strings.Fields(line)
if len(f) >= 2 && f[0] == strconv.Itoa(managedAssetQueue) {
peer = f[1]
}
}
if peer == "" {
return false, nil
}
if pid == 0 {
return true, nil
}
if err := syscall.Kill(pid, 0); err != nil {
return false, err
}
netlink, err := os.ReadFile("/proc/net/netlink")
if err != nil {
return false, err
}
inodes := map[string]bool{}
for _, line := range strings.Split(string(netlink), "\n") {
f := strings.Fields(line)
if len(f) >= 10 && f[1] == "12" && f[2] == peer {
inodes["socket:["+f[9]+"]"] = true
}
}
return managedAssetQueueFDReady(fmt.Sprintf("/proc/%d/fd", pid), inodes, os.Readlink)
}
func managedAssetQueueFDReady(dir string, inodes map[string]bool, readlink func(string) (string, error)) (bool, error) {
fds, err := os.ReadDir(dir)
if err != nil {
return false, err
}
denied := false
for _, fd := range fds {
link, err := readlink(dir + "/" + fd.Name())
if err == nil && inodes[link] {
return true, nil
}
if errors.Is(err, os.ErrPermission) {
denied = true
} else if err != nil && !errors.Is(err, os.ErrNotExist) {
return false, err
}
}
if denied {
return false, errors.New("asset queue ownership inspection denied")
}
return false, errors.New("asset queue belongs to another process")
}
const managedAssetRules = `create table inet zapret_autotune_asset_probe
add chain inet zapret_autotune_asset_probe output { type filter hook output priority -151; policy accept; }
add chain inet zapret_autotune_asset_probe input { type filter hook input priority -151; policy accept; }
add rule inet zapret_autotune_asset_probe output meta mark & 0x10000000 == 0 tcp dport 443 queue num 200
add rule inet zapret_autotune_asset_probe input meta mark & 0x10000000 == 0 tcp sport 443 queue num 200
`
func (r managedAssetRuntime) verify(ctx context.Context, c storedCandidate, inventory managedServiceInventory) (measurements []assetMeasurement, err error) {
if c.Group != "assets" || len(c.Endpoints) == 0 || len(c.Endpoints) > 2 || strings.TrimSpace(c.Args) == "" {
return nil, &managedRecoveryFatal{Err: errors.New("invalid asset candidate")}
}
if e := (&candidate{Args: c.Args}).validateArgs(); e != nil {
return nil, &managedRecoveryFatal{Err: e}
}
for _, arg := range strings.Fields(c.Args) {
if strings.HasPrefix(arg, "--lua-init=") && arg != "--lua-init=@/opt/zapret2/lua/zapret-lib.lua" && arg != "--lua-init=@/opt/zapret2/lua/zapret-antidpi.lua" {
return nil, &managedRecoveryFatal{Err: errors.New("asset verifier only permits fixed Lua init files")}
}
}
seen := map[string]bool{}
for _, host := range c.Endpoints {
if !assetEndpoint(host) || seen[host] {
return nil, &managedRecoveryFatal{Err: errors.New("invalid asset endpoints")}
}
seen[host] = true
if _, e := privateResourceURL(inventory.images[host], host); e != nil {
return nil, e
}
}
if e := ctx.Err(); e != nil {
return nil, e
}
err = r.withOwnedWorker(ctx, c.Endpoints, c.Args, func(probeCtx context.Context) error {
for _, host := range c.Endpoints {
for _, protocol := range []string{"tls12", "tls13"} {
m, e := collectAssetMeasurement(probeCtx, r.proxy, inventory.images[host], host, protocol, c.Args, r.curl)
if e != nil {
if ctx.Err() != nil {
return ctx.Err()
}
if managedAssetTransferNonpass(e) {
return errCandidateNonpass
}
return e
}
measurements = append(measurements, m)
}
}
return nil
})
if err != nil {
return nil, err
}
return measurements, nil
}
// Shared, serialized session lifecycle: only an atomically created table is
// owned, and success is returned only after queue removal and worker join.
func (r managedAssetRuntime) withOwnedWorker(ctx context.Context, endpoints []string, strategyArgs string, capture func(context.Context) error) (err error) {
if err := ctx.Err(); err != nil {
return err
}
if e := r.guard(); e != nil {
return &managedRecoveryFatal{Err: e}
}
tables, e := r.nft(ctx, "list tables\n")
if e != nil {
return &managedRecoveryFatal{Err: e}
}
if strings.Contains(tables, "table inet "+managedAssetTable) {
return &managedRecoveryFatal{Err: errors.New("asset nft table already exists")}
}
occupied, e := r.queue(0)
if e != nil || occupied {
return &managedRecoveryFatal{Err: errors.Join(e, errors.New("asset queue unavailable"))}
}
args := managedProbeWorkerArgs(endpoints, strategyArgs)
worker, e := r.start(args)
if e != nil {
return &managedRecoveryFatal{Err: e}
}
joined, table := false, false
defer func() {
cleanup, cancel := context.WithTimeout(context.WithoutCancel(ctx), 30*time.Second)
defer cancel()
var cleanupErr error
// Remove queues before killing the consumer.
if table {
_, cleanupErr = r.nft(cleanup, "delete table inet "+managedAssetTable+"\n")
}
if !joined {
select {
case e := <-worker.done:
joined = true
cleanupErr = errors.Join(cleanupErr, e, errors.New("asset worker exited unexpectedly"))
default:
}
}
if !joined {
cleanupErr = errors.Join(cleanupErr, worker.stop())
select {
case e := <-worker.done:
joined = true
if e != nil {
var exit *exec.ExitError
if !errors.As(e, &exit) || !exit.ProcessState.Sys().(syscall.WaitStatus).Signaled() || exit.ProcessState.Sys().(syscall.WaitStatus).Signal() != syscall.SIGKILL {
cleanupErr = errors.Join(cleanupErr, e)
}
}
case <-cleanup.Done():
cleanupErr = errors.Join(cleanupErr, errors.New("asset worker join timeout"))
}
}
if cleanupErr != nil {
err = &managedRecoveryFatal{Err: errors.Join(err, &managedAssetCleanupFailure{Err: cleanupErr})}
}
}()
readyCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
tick := time.NewTicker(25 * time.Millisecond)
defer tick.Stop()
for {
select {
case e := <-worker.done:
joined = true
return &managedRecoveryFatal{Err: errors.Join(e, errors.New("asset worker exited before READY"))}
default:
}
ready, e := r.queue(worker.pid)
if e != nil {
return &managedRecoveryFatal{Err: e}
}
if ready {
break
}
select {
case <-readyCtx.Done():
if ctx.Err() != nil {
return ctx.Err()
}
return &managedRecoveryFatal{Err: errors.New("asset queue READY timeout")}
case <-tick.C:
}
}
// nft's transaction is atomic; failed creation owns no state to delete.
if _, e := r.nft(ctx, managedAssetRules); e != nil {
return &managedRecoveryFatal{Err: e}
}
table = true
// Recheck ownership after installing the queue and before the first capture.
if ready, e := r.queue(worker.pid); e != nil || !ready {
return &managedRecoveryFatal{Err: errors.Join(e, errors.New("owned queue lost before capture"))}
}
probeCtx, stopProbe := context.WithCancel(ctx)
watchDone := make(chan struct{})
exited := make(chan error, 1)
go func() {
defer close(watchDone)
select {
case e := <-worker.done:
exited <- errors.Join(e, errors.New("asset worker exited during probe"))
stopProbe()
case <-probeCtx.Done():
}
}()
defer func() {
stopProbe()
<-watchDone
select {
case e := <-exited:
joined = true
err = &managedRecoveryFatal{Err: errors.Join(err, e)}
default:
}
}()
return capture(probeCtx)
}
func managedProbeWorkerArgs(endpoints []string, strategyArgs string) []string {
args := []string{"--qnum=200", "--fwmark=0x10000000", "--lua-init=@/opt/zapret2/lua/zapret-lib.lua", "--lua-init=@/opt/zapret2/lua/zapret-antidpi.lua", "--filter-tcp=443", "--hostlist-domains=" + strings.Join(endpoints, ",")}
return append(args, strings.Fields(strategyArgs)...)
}
// Collector errors conservatively carry a fatal wrapper. Only known transport
// failures and genuine rejected responses are nonpasses; malformed evidence,
// missing executables, unknown errors and worker failures remain infrastructure.
func managedAssetTransferNonpass(err error) bool {
if err == nil {
return false
}
switch e := err.(type) {
case *managedRecoveryFatal:
return false
case *resourceError:
return managedResourceTransferNonpass(e, false, true)
case imageBodyRejection:
return true
case *resourcePeerTLSRejection:
return true
case *exec.ExitError:
switch e.ExitCode() {
case 6, 28, 35, 51, 52, 55, 56, 60:
return true
}
return false
case interface{ Unwrap() []error }:
children := e.Unwrap()
if len(children) == 0 {
return false
}
for _, child := range children {
if !managedAssetTransferNonpass(child) {
return false
}
}
return true
case interface{ Unwrap() error }:
return managedAssetTransferNonpass(e.Unwrap())
default:
return err == context.DeadlineExceeded || err.Error() == "resource origin verification failed" || err.Error() == "image HTTP status"
}
}