From 927eb48c218abbc7ed50e1d03eb3c668e559bd2c Mon Sep 17 00:00:00 2001 From: Matthew Holt Date: Tue, 10 Nov 2026 13:11:53 -0700 Subject: [PATCH] headers: compile dynamic replacement regexes once per operation A placeholder-dependent search_regexp was recompiled for every matching header value. Compile it once per replacement operation, keep skipping invalid expanded expressions, and merge the duplicated "*" code path. Addresses scan report 6c26a7b4c2e5ddc3. Code written by GitHub Copilot (GPT-6.1 Sol, Claude Opus 5.5); reviewed by mholt. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- modules/caddyhttp/headers/headers.go | 49 ++++----------- .../caddyhttp/headers/headers_bench_test.go | 26 ++++++++ modules/caddyhttp/headers/headers_test.go | 59 +++++++++++++++++++ 3 files changed, 98 insertions(+), 36 deletions(-) diff --git a/modules/caddyhttp/headers/headers.go b/modules/caddyhttp/headers/headers.go index 1c396b799..2a0de7a9c 100644 --- a/modules/caddyhttp/headers/headers.go +++ b/modules/caddyhttp/headers/headers.go @@ -205,7 +205,8 @@ type Replacement struct { // The substring to search for. Search string `json:"search,omitempty"` - // The regular expression to search with. + // The regular expression to search with. Placeholder-dependent expressions + // are compiled once per operation; invalid expanded expressions are skipped. SearchRegexp string `json:"search_regexp,omitempty"` // The string with which to replace matches. @@ -307,49 +308,25 @@ func (ops *HeaderOps) ApplyTo(hdr http.Header, repl *caddy.Replacer) { for fieldName, replacements := range ops.Replace { fieldName = http.CanonicalHeaderKey(repl.ReplaceKnown(fieldName, "")) - // all fields... - if fieldName == "*" { - for _, r := range replacements { - search := repl.ReplaceKnown(r.Search, "") - replace := repl.ReplaceKnown(r.Replace, "") - for fieldName, vals := range hdr { - for i := range vals { - if r.re != nil { - // Use precompiled regular expressions - hdr[fieldName][i] = r.re.ReplaceAllString(hdr[fieldName][i], replace) - } else if r.SearchRegexp != "" { - // Runtime compilation of regular expressions - searchRegexp := repl.ReplaceKnown(r.SearchRegexp, "") - if re, err := regexp.Compile(searchRegexp); err == nil { - hdr[fieldName][i] = re.ReplaceAllString(hdr[fieldName][i], replace) - } - // If compilation fails, skip this replacement - } else { - hdr[fieldName][i] = strings.ReplaceAll(hdr[fieldName][i], search, replace) - } - } - } - } - continue - } - - // ...or only with the named field for _, r := range replacements { search := repl.ReplaceKnown(r.Search, "") replace := repl.ReplaceKnown(r.Replace, "") + re := r.re + if re == nil && r.SearchRegexp != "" { + var err error + re, err = regexp.Compile(repl.ReplaceKnown(r.SearchRegexp, "")) + if err != nil { + continue + } + } for hdrFieldName, vals := range hdr { // see issue #4330 for why we don't simply use hdr[fieldName] - if http.CanonicalHeaderKey(hdrFieldName) != fieldName { + if fieldName != "*" && http.CanonicalHeaderKey(hdrFieldName) != fieldName { continue } for i := range vals { - if r.re != nil { - hdr[hdrFieldName][i] = r.re.ReplaceAllString(hdr[hdrFieldName][i], replace) - } else if r.SearchRegexp != "" { - searchRegexp := repl.ReplaceKnown(r.SearchRegexp, "") - if re, err := regexp.Compile(searchRegexp); err == nil { - hdr[hdrFieldName][i] = re.ReplaceAllString(hdr[hdrFieldName][i], replace) - } + if re != nil { + hdr[hdrFieldName][i] = re.ReplaceAllString(hdr[hdrFieldName][i], replace) } else { hdr[hdrFieldName][i] = strings.ReplaceAll(hdr[hdrFieldName][i], search, replace) } diff --git a/modules/caddyhttp/headers/headers_bench_test.go b/modules/caddyhttp/headers/headers_bench_test.go index e75ca6b46..44ef3f98b 100644 --- a/modules/caddyhttp/headers/headers_bench_test.go +++ b/modules/caddyhttp/headers/headers_bench_test.go @@ -15,12 +15,38 @@ package headers import ( + "fmt" "net/http" "testing" "github.com/caddyserver/caddy/v2" ) +func BenchmarkDynamicHeaderReplacement(b *testing.B) { + for _, field := range []string{"Referer", "*"} { + for _, count := range []int{1, 150} { + b.Run(fmt.Sprintf("%s/values=%d", field, count), func(b *testing.B) { + ops := &HeaderOps{Replace: map[string][]Replacement{ + field: {{SearchRegexp: "^https?://{host}/", Replace: "/"}}, + }} + if err := ops.Provision(caddy.Context{}); err != nil { + b.Fatal(err) + } + repl := caddy.NewReplacer() + repl.Set("host", "example.test") + hdr := http.Header{"Referer": make([]string, count)} + b.ReportAllocs() + for b.Loop() { + for i := range hdr["Referer"] { + hdr["Referer"][i] = "https://example.test/path" + } + ops.ApplyTo(hdr, repl) + } + }) + } + } +} + func BenchmarkHeaderOpsApplyToSet(b *testing.B) { ops := &HeaderOps{ Set: http.Header{ diff --git a/modules/caddyhttp/headers/headers_test.go b/modules/caddyhttp/headers/headers_test.go index f74cf4ac9..72c689123 100644 --- a/modules/caddyhttp/headers/headers_test.go +++ b/modules/caddyhttp/headers/headers_test.go @@ -26,6 +26,65 @@ import ( "github.com/caddyserver/caddy/v2/modules/caddyhttp" ) +func TestDynamicReplacementExpandedOnce(t *testing.T) { + for _, field := range []string{"X-Test", "*"} { + for _, invalid := range []bool{false, true} { + t.Run(fmt.Sprintf("%s/invalid=%t", field, invalid), func(t *testing.T) { + ops := &HeaderOps{Replace: map[string][]Replacement{ + field: {{SearchRegexp: "^foo{pattern}$", Replace: "replaced"}}, + }} + if err := ops.Provision(caddy.Context{}); err != nil { + t.Fatal(err) + } + if ops.Replace[field][0].re != nil { + t.Fatal("dynamic pattern was precompiled") + } + pattern := "bar" + if invalid { + pattern = "[" + } + expansions := 0 + repl := caddy.NewReplacer() + repl.Map(func(key string) (any, bool) { + if key == "pattern" { + expansions++ + return pattern, true + } + return nil, false + }) + for _, value := range []string{"foobar", "foobaz"} { + if value == "foobaz" && !invalid { + pattern = "baz" + } + hdr := http.Header{ + "X-Test": {"foobar", value}, + "x-test": {value}, + "Other": {value}, + } + before := expansions + ops.ApplyTo(hdr, repl) + if got := expansions - before; got != 1 { + t.Fatalf("expanded pattern %d times, want once", got) + } + want := value + if !invalid { + want = "replaced" + } + if hdr["X-Test"][1] != want || hdr["x-test"][0] != want { + t.Fatalf("unexpected named-field replacement: %v", hdr) + } + if field != "*" { + want = value + } + if hdr["Other"][0] != want { + t.Fatalf("unexpected other-field replacement: %v", hdr) + } + } + }) + } + } +} + func TestHandler(t *testing.T) { for i, tc := range []struct { handler Handler