From 48641fd35a1a0266e8f6636a3de0e8d6493341c1 Mon Sep 17 00:00:00 2001 From: Georgios Konstantopoulos Date: Wed, 28 Oct 2026 14:33:33 -0700 Subject: [PATCH 1/2] feat(proxy): add an mTLS reverse listener for clients that cannot trust the MITM CA --- README.md | 55 +++++++ cmd/iron-proxy/main.go | 17 ++- internal/config/config.go | 23 +++ internal/config/config_test.go | 31 ++++ internal/proxy/proxy.go | 67 +++++++-- internal/proxy/reverse.go | 119 +++++++++++++++ internal/proxy/reverse_test.go | 268 +++++++++++++++++++++++++++++++++ iron-proxy.example.yaml | 9 ++ 8 files changed, 576 insertions(+), 13 deletions(-) create mode 100644 internal/proxy/reverse.go create mode 100644 internal/proxy/reverse_test.go diff --git a/README.md b/README.md index 23e99b0..a12205d 100644 --- a/README.md +++ b/README.md @@ -244,6 +244,11 @@ proxy: http_listen: ":80" https_listen: ":443" tunnel_listen: ":8080" # Optional CONNECT/SOCKS5 listener + reverse: # Optional mTLS listener for clients that name the upstream in the path + listen: ":8444" + cert: "/etc/iron-proxy/server.crt" + key: "/etc/iron-proxy/server.key" + client_ca: "/etc/iron-proxy/clients.crt" max_request_body_bytes: 1048576 # 1 MiB (default) max_response_body_bytes: 0 # uncapped (default) @@ -766,6 +771,56 @@ export ALL_PROXY=socks5h://172.20.0.2:8080 The SOCKS5 implementation supports no-auth only and accepts IPv4, IPv6, and domain name address types. +### Reverse listener (mTLS) + +Some clients can neither trust iron-proxy's CA nor route through its DNS or a +`HTTPS_PROXY`: a Cloudflare Worker's `fetch` only trusts public certificate +authorities and offers no proxy setting. The reverse listener serves them +under iron-proxy's own name. The client names the upstream host in the first +path segment, and iron-proxy sends the request there over TLS through the same +transform pipeline: + +``` +https://proxy.example.com/api.anthropic.com/v1/messages -> https://api.anthropic.com/v1/messages +``` + +Anyone who can send it a request gets the credentials your transforms inject, +so the listener requires a client certificate issued by `client_ca`. `cert` +and `key` are iron-proxy's own certificate, which clients must trust, such as a +public certificate for the proxy's hostname: + +```yaml +proxy: + reverse: + listen: ":8444" + cert: "/etc/iron-proxy/server.crt" + key: "/etc/iron-proxy/server.key" + client_ca: "/etc/iron-proxy/clients.crt" +``` + +The allowlist, secrets and every other transform see the upstream host, path +and query, exactly as for requests on the other listeners. WebSocket upgrades +are relayed to `wss://` upstreams. Paths with dot segments and a first segment +that is not a hostname or IP address, with an optional port, are rejected with +400. The listener removes `Cf-*` and `Cdn-Loop` request headers: Cloudflare +adds `CF-Worker` to every Worker subrequest, and some upstreams refuse +requests that carry it. iron-proxy reads `cert` and `key` at startup, so +restart it after renewing the certificate. + +A Worker presents its client certificate through an `mtls_certificates` +binding. Upload the certificate and key with +`wrangler mtls-certificate upload --cert client.crt --key client.key`, bind +the returned ID in `wrangler.jsonc`, and send requests with the binding's +`fetch`: + +```jsonc +"mtls_certificates": [{ "binding": "IRON_PROXY", "certificate_id": "" }] +``` + +```js +await env.IRON_PROXY.fetch('https://proxy.example.com/api.anthropic.com/v1/messages', init) +``` + ### TLS iron-proxy generates leaf certificates on the fly, signed by the CA you provide. diff --git a/cmd/iron-proxy/main.go b/cmd/iron-proxy/main.go index a06534a..e235805 100644 --- a/cmd/iron-proxy/main.go +++ b/cmd/iron-proxy/main.go @@ -3,6 +3,7 @@ package main import ( "context" + "crypto/tls" "encoding/json" "errors" "flag" @@ -228,6 +229,15 @@ func main() { logger.Info("response retry handler enabled", slog.Any("statuses", responseRetryStatuses)) } + var reverseTLS *tls.Config + if r := cfg.Proxy.Reverse; r.Listen != "" { + reverseTLS, err = proxy.ReverseTLSConfig(r.Cert, r.Key, r.ClientCA) + if err != nil { + logger.Error("initializing reverse listener", slog.String("error", err.Error())) + os.Exit(1) + } + } + // Initialize proxy. p := proxy.New(proxy.Options{ HTTPAddr: cfg.Proxy.HTTPListen, @@ -247,7 +257,9 @@ func main() { // Managed proxies fail closed until the first control-plane config // has been applied; an un-synced pipeline would otherwise pass // requests through with placeholder credentials intact. - Ready: managedReady(poller), + Ready: managedReady(poller), + ReverseAddr: cfg.Proxy.Reverse.Listen, + ReverseTLS: reverseTLS, }) // Initialize metrics server. @@ -296,6 +308,9 @@ func main() { if cfg.Proxy.TunnelListen != "" { startAttrs = append(startAttrs, slog.String("tunnel_listen", cfg.Proxy.TunnelListen)) } + if cfg.Proxy.Reverse.Listen != "" { + startAttrs = append(startAttrs, slog.String("reverse_listen", cfg.Proxy.Reverse.Listen)) + } logger.Info("iron-proxy starting", startAttrs...) if pipeline := holder.Load(); !pipeline.Empty() { logger.Info("transform pipeline", slog.String("transforms", pipeline.Names())) diff --git a/internal/config/config.go b/internal/config/config.go index 31d7d1c..20059b6 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -115,6 +115,20 @@ type Proxy struct { // upstream SOCKS5/HTTP CONNECT proxy. The standard HTTP_PROXY/HTTPS_PROXY/ // NO_PROXY environment variables override these fields when set. UpstreamProxy UpstreamProxy `yaml:"upstream_proxy"` + // Reverse configures the reverse listener, for clients that can neither + // trust the MITM CA nor route through the proxy's DNS. + Reverse Reverse `yaml:"reverse"` +} + +// Reverse configures the reverse listener. Clients reach it under the proxy's +// own name, authenticate with a certificate issued by ClientCA, and name the +// upstream host in the first path segment: https://// is +// sent to https:///. +type Reverse struct { + Listen string `yaml:"listen"` + Cert string `yaml:"cert"` + Key string `yaml:"key"` + ClientCA string `yaml:"client_ca"` } // CIDRList is a list of CIDR strings whose presence in YAML is distinguishable @@ -316,6 +330,15 @@ func Validate(cfg *Config) error { return fmt.Errorf("proxy.upstream_deny_cidrs: %w", err) } + if r := cfg.Proxy.Reverse; r.Listen != "" { + if r.Cert == "" || r.Key == "" { + return fmt.Errorf("proxy.reverse.cert and proxy.reverse.key are required when proxy.reverse.listen is set") + } + if r.ClientCA == "" { + return fmt.Errorf("proxy.reverse.client_ca is required when proxy.reverse.listen is set: the listener only serves clients with a certificate") + } + } + if cfg.Management.Listen != "" { if cfg.Management.APIKeyEnv == "" { return fmt.Errorf("management.api_key_env is required when management.listen is set") diff --git a/internal/config/config_test.go b/internal/config/config_test.go index b7c4910..f1593f3 100644 --- a/internal/config/config_test.go +++ b/internal/config/config_test.go @@ -123,6 +123,37 @@ tls: `, wantErr: "tls.ca_key is required", }, + { + name: "reverse listener without a certificate", + yaml: ` +dns: + proxy_ip: "10.0.0.1" +tls: + ca_cert: "/tmp/ca.crt" + ca_key: "/tmp/ca.key" +proxy: + reverse: + listen: ":8444" + client_ca: "/tmp/clients.crt" +`, + wantErr: "proxy.reverse.cert and proxy.reverse.key are required", + }, + { + name: "reverse listener without client_ca", + yaml: ` +dns: + proxy_ip: "10.0.0.1" +tls: + ca_cert: "/tmp/ca.crt" + ca_key: "/tmp/ca.key" +proxy: + reverse: + listen: ":8444" + cert: "/tmp/server.crt" + key: "/tmp/server.key" +`, + wantErr: "proxy.reverse.client_ca is required", + }, { name: "invalid log level", yaml: ` diff --git a/internal/proxy/proxy.go b/internal/proxy/proxy.go index 463a748..0cc4113 100644 --- a/internal/proxy/proxy.go +++ b/internal/proxy/proxy.go @@ -42,6 +42,7 @@ type Proxy struct { tunnelAddr string tunnelListener net.Listener tunnelDone chan struct{} + reverseServer *http.Server certCache *certcache.Cache pipeline *transform.PipelineHolder transport *http.Transport @@ -96,6 +97,11 @@ type Options struct { // requests can never pass through un-transformed (leaking placeholder // credentials upstream) during startup. Ready func() bool + + // ReverseAddr, when set, serves the reverse listener with ReverseTLS, + // which must require client certificates (see ReverseTLSConfig). + ReverseAddr string + ReverseTLS *tls.Config } // New creates a new Proxy. In TLSModeMITM, certCache must be non-nil. In @@ -144,6 +150,15 @@ func New(opts Options) *Proxy { // negotiated conns through the existing handler); zero config never errors. _ = http2.ConfigureServer(p.httpsServer, &http2.Server{}) + if opts.ReverseAddr != "" { + p.reverseServer = &http.Server{ + Addr: opts.ReverseAddr, + Handler: http.HandlerFunc(p.handleReverse), + TLSConfig: opts.ReverseTLS, + } + _ = http2.ConfigureServer(p.reverseServer, &http2.Server{}) // Zero config never errors. + } + return p } @@ -152,7 +167,10 @@ func New(opts Options) *Proxy { func (p *Proxy) ListenAndServe() error { n := 2 if p.tunnelAddr != "" { - n = 3 + n++ + } + if p.reverseServer != nil { + n++ } errc := make(chan error, n) @@ -180,6 +198,12 @@ func (p *Proxy) ListenAndServe() error { }() } + if p.reverseServer != nil { + go func() { + errc <- p.serveReverse() + }() + } + return <-errc } @@ -227,6 +251,11 @@ func (p *Proxy) Shutdown(ctx context.Context) error { errHTTP := p.httpServer.Shutdown(ctx) + var errReverse error + if p.reverseServer != nil { + errReverse = p.reverseServer.Shutdown(ctx) + } + var errHTTPS error if p.tlsMode == config.TLSModeSNIOnly { if p.tlsListener != nil { @@ -245,7 +274,10 @@ func (p *Proxy) Shutdown(ctx context.Context) error { if errHTTP != nil { return errHTTP } - return errHTTPS + if errHTTPS != nil { + return errHTTPS + } + return errReverse } func (p *Proxy) getCertificate(hello *tls.ClientHelloInfo) (*tls.Certificate, error) { @@ -324,14 +356,16 @@ func (p *Proxy) handleHTTP(w http.ResponseWriter, r *http.Request, tunnelInfo *t } // Validate SNI matches Host header on TLS connections + sni := "" if r.TLS != nil { + sni = r.TLS.ServerName hostOnly := r.Host if h, _, err := net.SplitHostPort(hostOnly); err == nil { hostOnly = h } - if r.TLS.ServerName != hostOnly { + if sni != hostOnly { p.logger.Warn("SNI/Host mismatch", - slog.String("sni", r.TLS.ServerName), + slog.String("sni", sni), slog.String("host", r.Host), ) http.Error(w, "SNI and Host header mismatch", http.StatusBadRequest) @@ -339,15 +373,19 @@ func (p *Proxy) handleHTTP(w http.ResponseWriter, r *http.Request, tunnelInfo *t } } + p.proxyRequest(w, r, tunnelInfo, scheme, host, sni) +} + +// proxyRequest runs a request that the listener has already validated through +// the transform pipeline and sends it to scheme://host. +func (p *Proxy) proxyRequest(w http.ResponseWriter, r *http.Request, tunnelInfo *transform.TunnelInfo, scheme, host, sni string) { // Clone tunnelInfo so a transform that mutates the annotations map can't // leak state into sibling requests that share the same tunnel. tctx := &transform.TransformContext{ Logger: p.logger, Mode: transform.ModeMITM, Tunnel: cloneTunnelInfo(tunnelInfo), - } - if r.TLS != nil { - tctx.SNI = r.TLS.ServerName + SNI: sni, } result := &transform.PipelineResult{ @@ -773,11 +811,7 @@ func (p *Proxy) handleWebSocket(w http.ResponseWriter, r *http.Request, scheme, Control: p.guard.DialControl, } if upstreamScheme == "wss" { - upstreamConn, err = tls.DialWithDialer( - dialer, - "tcp", upstreamHost, - &tls.Config{MinVersion: tls.VersionTLS12}, - ) + upstreamConn, err = tls.DialWithDialer(dialer, "tcp", upstreamHost, p.upstreamTLSConfig()) } else { upstreamConn, err = dialer.DialContext(r.Context(), "tcp", upstreamHost) } @@ -932,6 +966,15 @@ func buildTransport(resolver *net.Resolver, guard *dnsguard.Guard, responseHeade } } +// upstreamTLSConfig is the TLS configuration of upstream connections, so +// WebSockets verify upstreams as HTTP requests do. +func (p *Proxy) upstreamTLSConfig() *tls.Config { + if p.transport.TLSClientConfig == nil { + return &tls.Config{MinVersion: tls.VersionTLS12} + } + return p.transport.TLSClientConfig.Clone() +} + func (p *Proxy) doUpstream(req *http.Request) (*http.Response, error) { return p.transport.RoundTrip(req) } diff --git a/internal/proxy/reverse.go b/internal/proxy/reverse.go new file mode 100644 index 0000000..ffc2603 --- /dev/null +++ b/internal/proxy/reverse.go @@ -0,0 +1,119 @@ +package proxy + +import ( + "crypto/tls" + "crypto/x509" + "fmt" + "log/slog" + "net" + "net/http" + "net/url" + "os" + "regexp" + "strconv" + "strings" +) + +// ReverseTLSConfig returns the TLS configuration of the reverse listener: the +// proxy's own certificate, with client certificates required and verified +// against the PEM certificates in clientCAFile. +func ReverseTLSConfig(certFile, keyFile, clientCAFile string) (*tls.Config, error) { + cert, err := tls.LoadX509KeyPair(certFile, keyFile) + if err != nil { + return nil, fmt.Errorf("loading reverse listener certificate: %w", err) + } + pem, err := os.ReadFile(clientCAFile) + if err != nil { + return nil, fmt.Errorf("reading reverse listener client CA: %w", err) + } + pool := x509.NewCertPool() + if !pool.AppendCertsFromPEM(pem) { + return nil, fmt.Errorf("reverse listener client CA %s holds no PEM certificates", clientCAFile) + } + return &tls.Config{ + MinVersion: tls.VersionTLS12, + Certificates: []tls.Certificate{cert}, + ClientAuth: tls.RequireAndVerifyClientCert, + ClientCAs: pool, + }, nil +} + +// serveReverse serves the reverse listener until it is shut down. +func (p *Proxy) serveReverse() error { + ln, err := net.Listen("tcp", p.reverseServer.Addr) + if err != nil { + return fmt.Errorf("reverse listen: %w", err) + } + p.logger.Info("reverse proxy starting", slog.String("addr", ln.Addr().String())) + return fmt.Errorf("reverse: %w", p.reverseServer.Serve(tls.NewListener(ln, p.reverseServer.TLSConfig))) +} + +// handleReverse serves a request of the reverse listener, whose TLS layer has +// verified the client's certificate. The first path segment names the +// upstream host: // goes to https:/// through the +// transform pipeline. +func (p *Proxy) handleReverse(w http.ResponseWriter, r *http.Request) { + // A request-target such as //host/path parses as an authority; only an + // origin-form path names the upstream. + host, rest, ok := reverseTarget(r.URL.EscapedPath()) + if !ok || r.URL.Host != "" || r.URL.Opaque != "" { + http.Error(w, "the path must start with the upstream host: //", http.StatusBadRequest) + return + } + target, err := url.ParseRequestURI(rest) + if err != nil { + http.Error(w, "invalid upstream path", http.StatusBadRequest) + return + } + if containsDotSegments(target.Path) { + http.Error(w, "path contains dot segments", http.StatusBadRequest) + return + } + r.Host = host + r.URL.Host = host + r.URL.Path = target.Path + r.URL.RawPath = target.RawPath + // Cloudflare adds CF-Worker and other Cf-* headers to every Worker + // subrequest. They describe the hop to iron-proxy, not the client's + // request, and some upstreams refuse requests that carry them. + for name := range r.Header { + if strings.HasPrefix(name, "Cf-") || name == "Cdn-Loop" { + r.Header.Del(name) + } + } + p.proxyRequest(w, r, nil, "https", host, "") +} + +var hostnamePattern = regexp.MustCompile(`^[A-Za-z0-9]([A-Za-z0-9-]*[A-Za-z0-9])?(\.[A-Za-z0-9]([A-Za-z0-9-]*[A-Za-z0-9])?)*$`) + +// reverseTarget splits an escaped request path into the upstream host named +// by its first segment and the rest of the path. +func reverseTarget(escapedPath string) (host, rest string, ok bool) { + trimmed, found := strings.CutPrefix(escapedPath, "/") + if !found { + return "", "", false + } + host, rest, _ = strings.Cut(trimmed, "/") + if !validUpstreamHost(host) { + return "", "", false + } + return host, "/" + rest, true +} + +// validUpstreamHost reports whether host is a hostname or IP address, with an +// optional port. +func validUpstreamHost(host string) bool { + name := host + if strings.Contains(host, ":") { + h, port, err := net.SplitHostPort(host) + if err != nil { + return false + } + n, err := strconv.Atoi(port) + if err != nil || n < 1 || n > 65535 { + return false + } + name = h + } + return net.ParseIP(name) != nil || hostnamePattern.MatchString(name) +} diff --git a/internal/proxy/reverse_test.go b/internal/proxy/reverse_test.go new file mode 100644 index 0000000..d08cab2 --- /dev/null +++ b/internal/proxy/reverse_test.go @@ -0,0 +1,268 @@ +package proxy + +import ( + "bufio" + "context" + "crypto/ecdsa" + "crypto/elliptic" + "crypto/rand" + "crypto/tls" + "crypto/x509" + "crypto/x509/pkix" + "encoding/pem" + "fmt" + "io" + "math/big" + "net" + "net/http" + "net/http/httptest" + "os" + "path/filepath" + "testing" + "time" + + "github.com/stretchr/testify/require" + + "github.com/ironsh/iron-proxy/internal/certcache" + "github.com/ironsh/iron-proxy/internal/transform" +) + +// issueCert returns a certificate for name signed by the CA, for a server or a client. +func issueCert(t *testing.T, caCert *x509.Certificate, caKey *ecdsa.PrivateKey, name string, usage x509.ExtKeyUsage) tls.Certificate { + t.Helper() + key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader) + require.NoError(t, err) + template := &x509.Certificate{ + SerialNumber: big.NewInt(time.Now().UnixNano()), + Subject: pkix.Name{CommonName: name}, + DNSNames: []string{name}, + NotBefore: time.Now().Add(-time.Hour), + NotAfter: time.Now().Add(time.Hour), + KeyUsage: x509.KeyUsageDigitalSignature, + ExtKeyUsage: []x509.ExtKeyUsage{usage}, + } + der, err := x509.CreateCertificate(rand.Reader, template, caCert, &key.PublicKey, caKey) + require.NoError(t, err) + return tls.Certificate{Certificate: [][]byte{der}, PrivateKey: key} +} + +func writePEM(t *testing.T, path, kind string, der []byte) { + t.Helper() + require.NoError(t, os.WriteFile(path, pem.EncodeToMemory(&pem.Block{Type: kind, Bytes: der}), 0o600)) +} + +type reverseFixture struct { + addr string + serverCAs *x509.CertPool + client tls.Certificate + stranger tls.Certificate +} + +// startReverseProxy starts a proxy whose reverse listener serves "proxy.test" +// and trusts one client CA. Upstream TLS certificates are not verified, so +// tests can use httptest upstreams. +func startReverseProxy(t *testing.T, transforms []transform.Transformer) reverseFixture { + t.Helper() + dir := t.TempDir() + + serverCA, serverCAKey := generateTestCA(t) + server := issueCert(t, serverCA, serverCAKey, "proxy.test", x509.ExtKeyUsageServerAuth) + writePEM(t, filepath.Join(dir, "server.crt"), "CERTIFICATE", server.Certificate[0]) + serverKey, err := x509.MarshalECPrivateKey(server.PrivateKey.(*ecdsa.PrivateKey)) + require.NoError(t, err) + writePEM(t, filepath.Join(dir, "server.key"), "EC PRIVATE KEY", serverKey) + + clientCA, clientCAKey := generateTestCA(t) + writePEM(t, filepath.Join(dir, "clients.crt"), "CERTIFICATE", clientCA.Raw) + strangerCA, strangerCAKey := generateTestCA(t) + + reverseTLS, err := ReverseTLSConfig(filepath.Join(dir, "server.crt"), filepath.Join(dir, "server.key"), filepath.Join(dir, "clients.crt")) + require.NoError(t, err) + + mitmCA, mitmKey := generateTestCA(t) + cache, err := certcache.NewFromCA(mitmCA, mitmKey, 100, 72*time.Hour) + require.NoError(t, err) + p := New(Options{ + HTTPAddr: "127.0.0.1:0", + HTTPSAddr: "127.0.0.1:0", + ReverseAddr: "127.0.0.1:0", + ReverseTLS: reverseTLS, + CertCache: cache, + Pipeline: transform.NewPipelineHolder(transform.NewPipeline(transforms, transform.BodyLimits{}, testLogger())), + Logger: testLogger(), + }) + p.transport = &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: true}} + + ln, err := net.Listen("tcp", "127.0.0.1:0") + require.NoError(t, err) + go func() { _ = p.reverseServer.Serve(tls.NewListener(ln, p.reverseServer.TLSConfig)) }() + t.Cleanup(func() { _ = p.reverseServer.Close() }) + + serverCAs := x509.NewCertPool() + serverCAs.AddCert(serverCA) + return reverseFixture{ + addr: ln.Addr().String(), + serverCAs: serverCAs, + client: issueCert(t, clientCA, clientCAKey, "worker", x509.ExtKeyUsageClientAuth), + stranger: issueCert(t, strangerCA, strangerCAKey, "stranger", x509.ExtKeyUsageClientAuth), + } +} + +func (f reverseFixture) tlsConfig(certs ...tls.Certificate) *tls.Config { + return &tls.Config{RootCAs: f.serverCAs, ServerName: "proxy.test", Certificates: certs} +} + +func (f reverseFixture) httpClient(certs ...tls.Certificate) *http.Client { + return &http.Client{Transport: &http.Transport{ + TLSClientConfig: f.tlsConfig(certs...), + DialContext: func(ctx context.Context, network, _ string) (net.Conn, error) { + return (&net.Dialer{Timeout: 5 * time.Second}).DialContext(ctx, network, f.addr) + }, + }} +} + +func TestReverse_ForwardsToNamedUpstream(t *testing.T) { + type seen struct { + host, path, query string + header http.Header + } + got := make(chan seen, 1) + upstream := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + got <- seen{r.Host, r.URL.Path, r.URL.RawQuery, r.Header.Clone()} + _, _ = fmt.Fprint(w, "hello from upstream") + })) + defer upstream.Close() + upstreamHost := upstream.Listener.Addr().String() + + injector := &replacerTransform{reqHeaders: http.Header{"Authorization": {"Bearer real"}}} + f := startReverseProxy(t, []transform.Transformer{injector}) + + req, err := http.NewRequest("POST", fmt.Sprintf("https://proxy.test/%s/v1/things?x=1", upstreamHost), nil) + require.NoError(t, err) + req.Header.Set("Cf-Worker", "example.com") + req.Header.Set("Cf-Connecting-Ip", "203.0.113.1") + req.Header.Set("Cdn-Loop", "cloudflare") + req.Header.Set("X-Keep", "yes") + resp, err := f.httpClient(f.client).Do(req) + require.NoError(t, err) + defer resp.Body.Close() + body, err := io.ReadAll(resp.Body) + require.NoError(t, err) + + require.Equal(t, http.StatusOK, resp.StatusCode) + require.Equal(t, "hello from upstream", string(body)) + upstreamSaw := <-got + require.Equal(t, upstreamHost, upstreamSaw.host) + require.Equal(t, "/v1/things", upstreamSaw.path) + require.Equal(t, "x=1", upstreamSaw.query) + require.Equal(t, "Bearer real", upstreamSaw.header.Get("Authorization")) + require.Equal(t, "yes", upstreamSaw.header.Get("X-Keep")) + require.Empty(t, upstreamSaw.header.Get("Cf-Worker")) + require.Empty(t, upstreamSaw.header.Get("Cf-Connecting-Ip")) + require.Empty(t, upstreamSaw.header.Get("Cdn-Loop")) +} + +func TestReverse_RequiresClientCertificate(t *testing.T) { + f := startReverseProxy(t, nil) + cases := []struct { + name string + certs []tls.Certificate + }{ + {name: "no certificate"}, + {name: "certificate from another CA", certs: []tls.Certificate{f.stranger}}, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + resp, err := f.httpClient(tc.certs...).Get("https://proxy.test/example.com/") + if resp != nil { + _ = resp.Body.Close() + } + require.Error(t, err) + }) + } +} + +func TestReverse_RejectsPathsWithoutUpstream(t *testing.T) { + f := startReverseProxy(t, nil) + cases := []struct { + name string + path string + }{ + {name: "no host", path: "/"}, + {name: "empty host", path: "//example.com/x"}, + {name: "encoded host", path: "/%65xample.com/x"}, + {name: "userinfo", path: "/user@example.com/x"}, + {name: "port out of range", path: "/example.com:99999/x"}, + {name: "dot segments after the host", path: "/example.com/a/%2E%2E/b"}, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + req, err := http.NewRequest("GET", "https://proxy.test/", nil) + require.NoError(t, err) + req.URL.Opaque = tc.path + resp, err := f.httpClient(f.client).Do(req) + require.NoError(t, err) + defer resp.Body.Close() + require.Equal(t, http.StatusBadRequest, resp.StatusCode) + }) + } +} + +func TestReverse_TransformsCanReject(t *testing.T) { + f := startReverseProxy(t, []transform.Transformer{&rejectTransform{}}) + resp, err := f.httpClient(f.client).Get("https://proxy.test/example.com/") + require.NoError(t, err) + defer resp.Body.Close() + require.Equal(t, http.StatusForbidden, resp.StatusCode) +} + +func TestReverse_WebSocketToTLSUpstream(t *testing.T) { + upstreamCA, upstreamCAKey := generateTestCA(t) + upstreamCert := issueCert(t, upstreamCA, upstreamCAKey, "127.0.0.1", x509.ExtKeyUsageServerAuth) + ln, err := tls.Listen("tcp", "127.0.0.1:0", &tls.Config{Certificates: []tls.Certificate{upstreamCert}}) + require.NoError(t, err) + t.Cleanup(func() { _ = ln.Close() }) + paths := make(chan string, 1) + go func() { + conn, err := ln.Accept() + if err != nil { + return + } + defer conn.Close() + br := bufio.NewReader(conn) + req, err := http.ReadRequest(br) + if err != nil { + return + } + paths <- req.URL.Path + if _, err := io.WriteString(conn, "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n\r\n"); err != nil { + return + } + _, _ = io.Copy(conn, br) // Echo until the client closes. + }() + + f := startReverseProxy(t, nil) + conn, err := tls.Dial("tcp", f.addr, f.tlsConfig(f.client)) + require.NoError(t, err) + defer conn.Close() + br := bufio.NewReader(conn) + _, err = fmt.Fprintf(conn, "GET /%s/v1/responses HTTP/1.1\r\n"+ + "Host: proxy.test\r\n"+ + "Upgrade: websocket\r\n"+ + "Connection: Upgrade\r\n"+ + "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"+ + "Sec-WebSocket-Version: 13\r\n\r\n", ln.Addr().String()) + require.NoError(t, err) + require.NoError(t, conn.SetReadDeadline(time.Now().Add(5*time.Second))) + resp, err := http.ReadResponse(br, nil) + require.NoError(t, err) + require.Equal(t, http.StatusSwitchingProtocols, resp.StatusCode) + require.Equal(t, "/v1/responses", <-paths) + + _, err = conn.Write([]byte("hello websocket")) + require.NoError(t, err) + buf := make([]byte, 64) + n, err := br.Read(buf) + require.NoError(t, err) + require.Equal(t, "hello websocket", string(buf[:n])) +} diff --git a/iron-proxy.example.yaml b/iron-proxy.example.yaml index 3140e30..ae8b9ef 100644 --- a/iron-proxy.example.yaml +++ b/iron-proxy.example.yaml @@ -29,6 +29,15 @@ dns: proxy: http_listen: ":80" https_listen: ":443" + # Optional reverse listener for clients that can neither trust the MITM CA + # nor route through the proxy, such as Cloudflare Workers: they reach it under + # the proxy's own name with a client certificate issued by client_ca, and name + # the upstream in the path (https:////). + # reverse: + # listen: ":8444" + # cert: "/etc/iron-proxy/server.crt" + # key: "/etc/iron-proxy/server.key" + # client_ca: "/etc/iron-proxy/clients.crt" # Global body buffer limits for transforms. max_request_body_bytes: 1048576 # default: 1 MiB # max_response_body_bytes: 0 # default: 0 (uncapped) From 0ea33827e569dcebfd6fc34d02293328671f78f7 Mon Sep 17 00:00:00 2001 From: Georgios Konstantopoulos Date: Wed, 28 Oct 2026 14:49:47 -0700 Subject: [PATCH 2/2] fix(proxy): offer only HTTP/1.1 when dialing WebSocket upstreams --- internal/proxy/proxy.go | 19 ++++++++++++------- internal/proxy/reverse_test.go | 17 ++++++++++++++++- 2 files changed, 28 insertions(+), 8 deletions(-) diff --git a/internal/proxy/proxy.go b/internal/proxy/proxy.go index 0cc4113..f5e9b36 100644 --- a/internal/proxy/proxy.go +++ b/internal/proxy/proxy.go @@ -811,7 +811,7 @@ func (p *Proxy) handleWebSocket(w http.ResponseWriter, r *http.Request, scheme, Control: p.guard.DialControl, } if upstreamScheme == "wss" { - upstreamConn, err = tls.DialWithDialer(dialer, "tcp", upstreamHost, p.upstreamTLSConfig()) + upstreamConn, err = tls.DialWithDialer(dialer, "tcp", upstreamHost, p.websocketTLSConfig()) } else { upstreamConn, err = dialer.DialContext(r.Context(), "tcp", upstreamHost) } @@ -966,13 +966,18 @@ func buildTransport(resolver *net.Resolver, guard *dnsguard.Guard, responseHeade } } -// upstreamTLSConfig is the TLS configuration of upstream connections, so -// WebSockets verify upstreams as HTTP requests do. -func (p *Proxy) upstreamTLSConfig() *tls.Config { - if p.transport.TLSClientConfig == nil { - return &tls.Config{MinVersion: tls.VersionTLS12} +// websocketTLSConfig is the TLS configuration of upstream WebSocket +// connections: the upstream transport's, so WebSockets verify upstreams as +// HTTP requests do, offering only HTTP/1.1. The transport adds h2 to its +// NextProtos once it has served a request, and an upstream that negotiates h2 +// would not understand the HTTP/1.1 upgrade the proxy writes. +func (p *Proxy) websocketTLSConfig() *tls.Config { + cfg := &tls.Config{MinVersion: tls.VersionTLS12} + if p.transport.TLSClientConfig != nil { + cfg = p.transport.TLSClientConfig.Clone() } - return p.transport.TLSClientConfig.Clone() + cfg.NextProtos = []string{"http/1.1"} + return cfg } func (p *Proxy) doUpstream(req *http.Request) (*http.Response, error) { diff --git a/internal/proxy/reverse_test.go b/internal/proxy/reverse_test.go index d08cab2..5ff10a5 100644 --- a/internal/proxy/reverse_test.go +++ b/internal/proxy/reverse_test.go @@ -52,6 +52,7 @@ func writePEM(t *testing.T, path, kind string, der []byte) { } type reverseFixture struct { + proxy *Proxy addr string serverCAs *x509.CertPool client tls.Certificate @@ -101,6 +102,7 @@ func startReverseProxy(t *testing.T, transforms []transform.Transformer) reverse serverCAs := x509.NewCertPool() serverCAs.AddCert(serverCA) return reverseFixture{ + proxy: p, addr: ln.Addr().String(), serverCAs: serverCAs, client: issueCert(t, clientCA, clientCAKey, "worker", x509.ExtKeyUsageClientAuth), @@ -219,16 +221,25 @@ func TestReverse_TransformsCanReject(t *testing.T) { func TestReverse_WebSocketToTLSUpstream(t *testing.T) { upstreamCA, upstreamCAKey := generateTestCA(t) upstreamCert := issueCert(t, upstreamCA, upstreamCAKey, "127.0.0.1", x509.ExtKeyUsageServerAuth) - ln, err := tls.Listen("tcp", "127.0.0.1:0", &tls.Config{Certificates: []tls.Certificate{upstreamCert}}) + ln, err := tls.Listen("tcp", "127.0.0.1:0", &tls.Config{ + Certificates: []tls.Certificate{upstreamCert}, + NextProtos: []string{"h2", "http/1.1"}, + }) require.NoError(t, err) t.Cleanup(func() { _ = ln.Close() }) paths := make(chan string, 1) + protocols := make(chan string, 1) go func() { conn, err := ln.Accept() if err != nil { return } defer conn.Close() + tlsConn := conn.(*tls.Conn) + if err := tlsConn.Handshake(); err != nil { + return + } + protocols <- tlsConn.ConnectionState().NegotiatedProtocol br := bufio.NewReader(conn) req, err := http.ReadRequest(br) if err != nil { @@ -242,6 +253,9 @@ func TestReverse_WebSocketToTLSUpstream(t *testing.T) { }() f := startReverseProxy(t, nil) + // The upstream transport offers h2 once it has served a request; the + // WebSocket dial must still negotiate HTTP/1.1. + f.proxy.transport.TLSClientConfig.NextProtos = []string{"h2", "http/1.1"} conn, err := tls.Dial("tcp", f.addr, f.tlsConfig(f.client)) require.NoError(t, err) defer conn.Close() @@ -257,6 +271,7 @@ func TestReverse_WebSocketToTLSUpstream(t *testing.T) { resp, err := http.ReadResponse(br, nil) require.NoError(t, err) require.Equal(t, http.StatusSwitchingProtocols, resp.StatusCode) + require.Equal(t, "http/1.1", <-protocols) require.Equal(t, "/v1/responses", <-paths) _, err = conn.Write([]byte("hello websocket"))