Files
zapret-autotune/cmd/zapret-autotune/render.go
T
2026-10-09 20:59:51 +03:00

185 lines
5.7 KiB
Go

package main
import (
"bytes"
"encoding/json"
"fmt"
"io"
"math"
"regexp"
"sort"
"strings"
)
type candidate struct {
Group string `json:"group"`
Domains []string `json:"domains"`
Args string `json:"args"`
SuccessRate float64 `json:"success_rate"`
Coverage float64 `json:"coverage"`
PassesOK int `json:"passes_ok"`
PassesTotal int `json:"passes_total"`
MedianLatency float64 `json:"median_latency_ms"`
MedianSpeed float64 `json:"median_speed_kbps"`
}
// renderResults consumes normalized measurements only; it never runs probes or applies options.
func renderResults(r io.Reader) (string, error) {
decoder := json.NewDecoder(r)
var records []json.RawMessage
if err := decoder.Decode(&records); err != nil {
return "", err
}
if err := decoder.Decode(new(json.RawMessage)); err != io.EOF {
return "", fmt.Errorf("expected exactly one JSON array")
}
best := make(map[string]candidate)
for i, record := range records {
var fields map[string]json.RawMessage
if err := json.Unmarshal(record, &fields); err != nil {
return "", err
}
for _, key := range []string{"group", "domains", "args", "success_rate", "coverage", "passes_ok", "passes_total", "median_latency_ms", "median_speed_kbps"} {
if value, ok := fields[key]; !ok || bytes.Equal(bytes.TrimSpace(value), []byte("null")) {
return "", fmt.Errorf("candidate %d: missing or null %s", i, key)
}
}
var c candidate
d := json.NewDecoder(bytes.NewReader(record))
d.DisallowUnknownFields()
if err := d.Decode(&c); err != nil {
return "", fmt.Errorf("candidate %d: %w", i, err)
}
if err := c.validate(); err != nil {
return "", fmt.Errorf("candidate %d: %w", i, err)
}
if !fullyPassing(c) {
continue
}
if old, ok := best[c.Group]; !ok || better(c, old) {
best[c.Group] = c
}
}
var profiles []string
for _, group := range []string{"frontend", "googlevideo"} {
c, ok := best[group]
if !ok {
return "", fmt.Errorf("no fully passing candidate for %s", group)
}
profiles = append(profiles, "--filter-tcp=443 --filter-l7=tls --hostlist-domains="+strings.Join(c.Domains, ",")+" "+c.Args)
}
return "NFQWS2_OPT='" + strings.Join(profiles, " --new ") + "'", nil
}
func (c *candidate) validate() error {
if err := c.validateMeasurements(); err != nil {
return err
}
return c.validateArgs()
}
func (c *candidate) validateMeasurements() error {
if c.Group != "frontend" && c.Group != "googlevideo" {
return fmt.Errorf("unknown group")
}
if len(c.Domains) == 0 {
return fmt.Errorf("domains must not be empty")
}
for i, domain := range c.Domains {
if !validDomain(domain) {
return fmt.Errorf("invalid DNS hostname")
}
c.Domains[i] = strings.ToLower(domain)
}
sort.Strings(c.Domains)
for _, metric := range []float64{c.SuccessRate, c.Coverage, c.MedianLatency, c.MedianSpeed} {
if math.IsNaN(metric) || math.IsInf(metric, 0) || metric < 0 {
return fmt.Errorf("invalid metric")
}
}
if c.SuccessRate > 1 || c.Coverage > 1 || c.PassesOK < 0 || c.PassesTotal < 0 || c.PassesOK > c.PassesTotal {
return fmt.Errorf("invalid success/coverage/pass counts")
}
if len(strings.Fields(c.Args)) == 0 {
return fmt.Errorf("args must not be empty")
}
return nil
}
func (c *candidate) validateArgs() error {
// Only shell-inert, unquoted option values can be rendered verbatim.
for _, ch := range c.Args {
if !(ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z' || ch >= '0' && ch <= '9' || strings.ContainsRune(" _-=:,./+@%", ch)) {
return fmt.Errorf("unsafe args character")
}
}
for _, arg := range strings.Fields(c.Args) {
option, value, ok := strings.Cut(arg, "=")
valid := false
if ok {
switch option {
case "--lua-desync":
valid = validStage(value)
case "--payload":
valid = payloadValue.MatchString(value)
case "--in-range", "--out-range":
valid = rangeValue.MatchString(value)
case "--lua-init":
// ponytail: file-based init only; inline Lua needs a separate,
// non-shell output contract and is deliberately rejected.
valid = initValue.MatchString(value) && !strings.Contains(value, "..")
}
}
if !valid {
return fmt.Errorf("unknown or invalid args option/value: %q", arg)
}
}
return nil
}
var (
stageValue = regexp.MustCompile(`^[A-Za-z_][A-Za-z_0-9]*(:[A-Za-z_][A-Za-z_0-9]*(=[A-Za-z0-9_.,/+@%-]+)?)*$`)
payloadValue = regexp.MustCompile(`^(all|unknown|empty|known|tls_client_hello|tls_server_hello)(,(all|unknown|empty|known|tls_client_hello|tls_server_hello))*$`)
rangeValue = regexp.MustCompile(`^([nbsd]?[0-9]+|-[nbsd]?[0-9]+|[nbsd]?[0-9]+-[nbsd]?[0-9]+)$`)
initValue = regexp.MustCompile(`^@/opt/zapret2/lua/[A-Za-z0-9_./-]+\.lua(\.gz)?$`)
)
func validStage(stage string) bool { return stageValue.MatchString(stage) }
func validDomain(domain string) bool {
if len(domain) == 0 || len(domain) > 253 {
return false
}
for _, label := range strings.Split(domain, ".") {
if len(label) == 0 || len(label) > 63 || label[0] == '-' || label[len(label)-1] == '-' {
return false
}
for _, ch := range label {
if !(ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z' || ch >= '0' && ch <= '9' || ch == '-') {
return false
}
}
}
return true
}
func better(a, b candidate) bool {
if a.MedianSpeed != b.MedianSpeed {
return a.MedianSpeed > b.MedianSpeed
}
if a.MedianLatency != b.MedianLatency {
return a.MedianLatency < b.MedianLatency
}
if len(strings.Fields(a.Args)) != len(strings.Fields(b.Args)) {
return len(strings.Fields(a.Args)) < len(strings.Fields(b.Args))
}
if a.Args != b.Args {
return a.Args < b.Args
}
return strings.Join(a.Domains, ",") < strings.Join(b.Domains, ",")
}
func fullyPassing(c candidate) bool {
return c.SuccessRate == 1 && c.Coverage == 1 && c.PassesOK == c.PassesTotal && c.PassesTotal > 0
}