From 08eb4ec2446ed782a70879a80ffa0d3687bed07a Mon Sep 17 00:00:00 2001 From: protonmatter Date: Tue, 17 Nov 2026 13:04:37 -0500 Subject: [PATCH 1/2] Expire a MITM passthrough mark after one minute. A host that cannot be intercepted is tunneled until the mark expires, then interception is tried again. --- traffic/passthrough_test.go | 20 ++++++++++++++++++++ traffic/traffic.go | 33 +++++++++++++++++++++++++++------ 2 files changed, 47 insertions(+), 6 deletions(-) diff --git a/traffic/passthrough_test.go b/traffic/passthrough_test.go index 26f0cabb..d9227a3b 100644 --- a/traffic/passthrough_test.go +++ b/traffic/passthrough_test.go @@ -4,6 +4,7 @@ import ( "errors" "net/url" "testing" + "time" mproxy "github.com/lqqyt2423/go-mitmproxy/proxy" ) @@ -65,4 +66,23 @@ func TestMaybePassthroughFlagsHostOnce(t *testing.T) { if _, tunnel := tr.pass.Load(hostOnly("target.test:443")); !tunnel { t.Fatal("flagged host must be recognized for the CONNECT form with port") } + if !tr.tunneling("target.test") { + t.Fatal("a fresh passthrough mark must tunnel") + } +} + +func TestPassthroughMarkExpires(t *testing.T) { + tr := &Traffic{} + host := "expired.example" + tr.pass.Store(host, time.Now().Add(-time.Second)) + if tr.tunneling(host) { + t.Fatal("expired passthrough mark still tunnels") + } + if _, ok := tr.pass.Load(host); ok { + t.Fatal("expired mark was kept") + } + tr.pass.Store(host, time.Now().Add(time.Minute)) + if !tr.tunneling(host) { + t.Fatal("fresh passthrough mark should tunnel") + } } diff --git a/traffic/traffic.go b/traffic/traffic.go index fd100978..f9dcd8ac 100644 --- a/traffic/traffic.go +++ b/traffic/traffic.go @@ -190,8 +190,9 @@ type Traffic struct { closeOnce sync.Once // pass is the set of hosts whose MITM interception failed for a proxy/protocol // reason; connections to them are tunneled transparently (fail-open) so the - // request still reaches the target — unrecorded — instead of being killed. - pass sync.Map // hostname(string) -> struct{} + // request still reaches the target, unrecorded, instead of being killed. + // The value is the time the mark expires. After that, interception is tried again. + pass sync.Map // hostname(string) -> time.Time // upstream is the global egress proxy every captured request is forwarded // through (nil = dial targets directly). Both the intercepted and the // transparent-passthrough paths honor it (go-mitmproxy's getUpstreamConn), @@ -253,8 +254,7 @@ func Open(dir, addr string) (*Traffic, error) { // can't intercept without breaking (see maybePassthrough). Those are tunneled // transparently so the request still reaches the target instead of being killed. p.SetShouldInterceptRule(func(req *http.Request) bool { - _, tunnel := t.pass.Load(hostOnly(req.Host)) - return !tunnel + return !t.tunneling(hostOnly(req.Host)) }) p.AddAddon(&sink{t: t}) t.proxy = p @@ -454,9 +454,30 @@ func (t *Traffic) maybePassthrough(f *mproxy.Flow, err error) { if host == "" { return } - if _, loaded := t.pass.LoadOrStore(host, struct{}{}); !loaded { - log.Printf("[traffic] MITM with %s failed, falling back to passthrough (this host now connects straight to the target and is no longer recorded, but requests proceed normally): %v", host, err) + if t.tunneling(host) { + return + } + until := time.Now().Add(passthroughTTL) + if _, loaded := t.pass.LoadOrStore(host, until); !loaded { + log.Printf("[traffic] MITM with %s failed, falling back to passthrough for %s (this host connects straight to the target and is not recorded until then; requests still proceed): %v", host, passthroughTTL, err) + } +} + +const passthroughTTL = time.Minute + +// tunneling reports whether host is inside an unexpired passthrough mark. +// An expired mark is removed so the next connection tries interception again. +func (t *Traffic) tunneling(host string) bool { + v, ok := t.pass.Load(host) + if !ok { + return false + } + until, ok := v.(time.Time) + if !ok || !time.Now().Before(until) { + t.pass.CompareAndDelete(host, v) + return false } + return true } // proxyCausedErr reports whether err indicates the interception layer (not the From 287cbb685cf1f008998d9ff34b340ea431a72b0f Mon Sep 17 00:00:00 2001 From: protonmatter Date: Tue, 17 Nov 2026 15:58:24 -0500 Subject: [PATCH 2/2] Treat an expired passthrough mark as intercepted again, and say what the window costs. Replay was still honoring a stale bypass, and a host whose interception always fails now loses one request per minute instead of one per process. --- traffic/replay.go | 3 +-- traffic/replay_test.go | 12 ++++++++++-- traffic/traffic.go | 12 +++++++++--- 3 files changed, 20 insertions(+), 7 deletions(-) diff --git a/traffic/replay.go b/traffic/replay.go index 75385d1b..4ed176a2 100644 --- a/traffic/replay.go +++ b/traffic/replay.go @@ -86,8 +86,7 @@ func (t *Traffic) replayRecorded(scheme, host string) bool { if scheme != "https" { return true } - _, tunneled := t.pass.Load(hostOnly(host)) - return !tunneled + return !t.tunneling(hostOnly(host)) } func replayInvalid(format string, args ...any) error { diff --git a/traffic/replay_test.go b/traffic/replay_test.go index 931569b5..d9dc1ae3 100644 --- a/traffic/replay_test.go +++ b/traffic/replay_test.go @@ -199,7 +199,10 @@ func TestReplayPassthroughHostIsNotIntercepted(t *testing.T) { tr, _, _ := startProxy(t) srv := httptest.NewTLSServer(http.HandlerFunc(echoHandler)) t.Cleanup(srv.Close) - tr.pass.Store("localhost", struct{}{}) + tr.pass.Store("localhost", time.Now().Add(passthroughTTL)) + if !tr.tunneling("localhost") { + t.Fatal("passthrough mark was not recognized before the replay") + } target := localhostURL(srv.URL) + "/tunneled" _, err := tr.Replay(t.Context(), ReplayRequest{Method: "GET", URL: target}) if err == nil || !strings.Contains(err.Error(), "certificate") { @@ -249,7 +252,11 @@ func TestReplayRejectsInvalidRequests(t *testing.T) { // Only an https host in passthrough is reported as not recorded. func TestReplayRecordedHelper(t *testing.T) { tr := &Traffic{} - tr.pass.Store("localhost", struct{}{}) + tr.pass.Store("localhost", time.Now().Add(passthroughTTL)) + if !tr.tunneling("localhost") { + t.Fatal("fresh passthrough mark was not tunneling") + } + tr.pass.Store("expired.example", time.Now().Add(-time.Second)) for _, c := range []struct { scheme, host string want bool @@ -257,6 +264,7 @@ func TestReplayRecordedHelper(t *testing.T) { {"https", "localhost:443", false}, {"https", "example.com:443", true}, {"http", "localhost:80", true}, + {"https", "expired.example:443", true}, } { if got := tr.replayRecorded(c.scheme, c.host); got != c.want { t.Errorf("replayRecorded(%s, %s) = %v, want %v", c.scheme, c.host, got, c.want) diff --git a/traffic/traffic.go b/traffic/traffic.go index f9dcd8ac..17b1c05e 100644 --- a/traffic/traffic.go +++ b/traffic/traffic.go @@ -439,8 +439,10 @@ func (s *sink) Response(f *mproxy.Flow) { // RequestError fires when a request through an established MITM tunnel fails. If // the failure looks proxy/protocol-caused (h2 quirks, HEAD-with-body, protocol -// errors) — not a plain target-unreachable error — we flag the host for -// transparent passthrough so future requests to it succeed instead of dying. +// errors) and not a plain target-unreachable error, the host is tunneled for +// passthroughTTL. This request has already failed. Later requests in the window +// connect straight through; the first request after the window tries +// interception again. func (s *sink) RequestError(f *mproxy.Flow, err error) { s.t.maybePassthrough(f, err) } // maybePassthrough marks a host to be tunneled transparently on the next @@ -459,10 +461,14 @@ func (t *Traffic) maybePassthrough(f *mproxy.Flow, err error) { } until := time.Now().Add(passthroughTTL) if _, loaded := t.pass.LoadOrStore(host, until); !loaded { - log.Printf("[traffic] MITM with %s failed, falling back to passthrough for %s (this host connects straight to the target and is not recorded until then; requests still proceed): %v", host, passthroughTTL, err) + log.Printf("[traffic] MITM with %s failed, falling back to passthrough for %s (this request failed; the host connects straight to the target and is not recorded until then; the first request after the window fails again if interception still cannot handle it): %v", host, passthroughTTL, err) } } +// passthroughTTL is how long a host stays tunneled after a proxy-caused MITM +// failure. A host whose interception always fails pays one lost request per +// window: one per host per minute, where a mark that never expired cost one +// per process. The window is what lets a stale bypass end. const passthroughTTL = time.Minute // tunneling reports whether host is inside an unexpired passthrough mark.