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>
This commit is contained in:
Matthew Holt 2026-11-10 13:11:53 -07:00
parent a6af063626
commit 927eb48c21
3 changed files with 98 additions and 36 deletions

View file

@ -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)
}

View file

@ -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{

View file

@ -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