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>
381 lines
12 KiB
Go
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"
|
|
}
|
|
}
|