From 08eb4ec2446ed782a70879a80ffa0d3687bed07a Mon Sep 17 00:00:00 2001 From: protonmatter Date: Tue, 17 Nov 2026 13:04:37 -0500 Subject: [PATCH] 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 26f0cab..d9227a3 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 fd10097..f9dcd8a 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