185 lines
5.7 KiB
Go
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
|
|
}
|