Files
ARTEX/egress/pace.go
T
BaaRai 2e55615713 feat(traffic): pace Bash requests at the capture proxy
With traffic capture on, the Bash proxy URL carries a marker userinfo. The recording proxy drops Proxy-Authorization from every request before it is forwarded or recorded; when the value is the marker it marks the client connection, and every later request on it, including those inside its CONNECT tunnel, waits for the per-host token and jitter of the current noise profile (egress.Wait) and is counted, with a bounded wait. WebFetch, the http custom tools and enrich keep the unmarked URL, which egress already paces, so nothing is paced twice. Off paces nothing. Best effort: only clients that honour the proxy are covered, with capture on.
2026-11-15 00:57:13 +01:00

68 lines
2.3 KiB
Go

package egress
import (
"context"
"encoding/base64"
"net/url"
"strings"
)
// Bash commands reach targets through the recording proxy, outside the clients
// this package governs. With traffic capture on, the proxy URL in their
// environment carries a marker userinfo (MarkProxyURL). The proxy paces each
// request of a marked client connection with Wait, and leaves unmarked
// connections alone: WebFetch, the http custom tools and the enrich probe use
// the plain proxy URL and are already paced by their governor, so no request
// is paced twice. Best effort, not a security boundary: a command that ignores
// the proxy, or drops the marker, is not paced.
// PaceUser is the user and password of the marker userinfo.
const PaceUser = "artex-pace"
// MarkProxyURL returns raw with the marker userinfo. raw is returned unchanged
// when it does not parse or already carries a userinfo.
func MarkProxyURL(raw string) string {
u, err := url.Parse(raw)
if err != nil || u.Host == "" || u.User != nil {
return raw
}
u.User = url.UserPassword(PaceUser, PaceUser)
return u.String()
}
// IsPaceMarker reports whether a Proxy-Authorization value is Basic
// credentials for PaceUser.
func IsPaceMarker(proxyAuthorization string) bool {
scheme, enc, ok := strings.Cut(strings.TrimSpace(proxyAuthorization), " ")
if !ok || !strings.EqualFold(scheme, "Basic") {
return false
}
dec, err := base64.StdEncoding.DecodeString(strings.TrimSpace(enc))
if err != nil {
return false
}
user, _, _ := strings.Cut(string(dec), ":")
return user == PaceUser
}
// Wait paces one request to hostKey under the current profile. See
// Governor.Wait.
func Wait(ctx context.Context, hostKey string) error { return Current().Wait(ctx, hostKey) }
// Wait takes a token of the host's bucket plus the jitter, as a governed request
// does, and counts the request in the host's noise counter. It takes no
// in-flight slot, and nothing is cached, coalesced or retried. Off, it returns
// at once and counts nothing. An error means ctx ended first; the request is
// counted either way, since the caller sends it regardless.
func (g *Governor) Wait(ctx context.Context, hostKey string) error {
if g.off() {
return nil
}
h := g.host(hostKey)
err := sleep(ctx, g.reserve(h)+g.jitter())
g.mu.Lock()
h.sent++
g.mu.Unlock()
return err
}