Files
archie/internal/infrastructure/egress/policy.go
T
sam f92c5b4536
ci/woodpecker/pr/quality Pipeline was successful
Quality / check (pull_request) Canceled after 7m39s
chore(runtime): delete Kit and external agent harness support (#1877)
Archie runs its own agent loop only. Removes Kit resolution and launch,
the harness runner and adapters, the setup terminal and sandbox view,
harness secrets and OAuth capture (table dropped in migration 0075), the
task-tools contract that only Kit containers reached, and the
sandbox-kit-spec dependency. Agent profiles carry image and tools only.
The egress proxy keeps the model-session path; the sandbox relay code
stays for #1867.
2026-11-12 21:29:05 +11:00

91 lines
2.0 KiB
Go

package egress
import (
"net"
"strconv"
"strings"
)
// pattern is one allow-list entry: an exact host, a host on one port,
// a single-label wildcard, or everything.
type pattern struct {
everything bool
suffix string // ".example.com" for "*.example.com"
host string
port int // 0 means any port
}
// rules is a compiled allow list. An empty one allows nothing.
type rules struct {
allow []pattern
}
func compilePatterns(entries []string) []pattern {
out := make([]pattern, 0, len(entries))
for _, e := range entries {
out = append(out, compilePattern(e))
}
return out
}
func compilePattern(entry string) pattern {
entry = strings.TrimSpace(entry)
if entry == "*" || entry == "**" {
return pattern{everything: true}
}
var p pattern
if h, portText, err := net.SplitHostPort(entry); err == nil {
if port, err := strconv.Atoi(portText); err == nil {
entry, p.port = h, port
}
}
entry = normalizeHost(entry)
if rest, ok := strings.CutPrefix(entry, "*."); ok {
p.suffix = "." + rest
return p
}
p.host = entry
return p
}
func normalizeHost(host string) string {
return strings.TrimSuffix(strings.ToLower(host), ".")
}
func (p pattern) matches(host string, port int) bool {
if p.everything {
return true
}
if p.port != 0 && p.port != port {
return false
}
if p.suffix != "" {
label, ok := strings.CutSuffix(host, p.suffix)
return ok && label != "" && !strings.Contains(label, ".") && net.ParseIP(host) == nil
}
return host == p.host
}
func (r rules) allows(host string, port int) bool {
host = normalizeHost(host)
for _, p := range r.allow {
if p.matches(host, port) {
return true
}
}
return false
}
// namesIP reports whether an allow entry names ip exactly. Only an explicit
// IP entry opens an internal address; a wildcard or everything never does.
func (r rules) namesIP(ip net.IP) bool {
for _, p := range r.allow {
if !p.everything && p.suffix == "" {
if named := net.ParseIP(p.host); named != nil && named.Equal(ip) {
return true
}
}
}
return false
}