Skip to content

armgit / fider

Public Imported from GitHub
0

Open platform to collect and prioritize feedback

Add SSRF_GUARD_USE_PROXY option for the guarded HTTP client

Matt Roberts376c1ec5c5bd
diff --git a/.example.env b/.example.env
index 5214e3965..b9cff1b7a 100644
--- a/.example.env
+++ b/.example.env
@@ -6,6 +6,11 @@ JWT_SECRET=hsjl]W;&ZcHxT&FK;s%bgIQF:#ch=~#Al4:5]N;7V<qPZ3e9lT4'%;go;LIkc%k
# Relaxes the SSRF guard so webhooks and OAuth token/profile URLs may target
# private/internal network addresses (LAN, loopback, link-local). Self-hosted only.
# ALLOW_PRIVATE_NETWORK_TARGETS=true
+# By default, webhook and custom OAuth requests ignore HTTP_PROXY/HTTPS_PROXY so
+# the SSRF guard can check every connection. Set this to send them through the
+# proxy instead; proxied requests then rely only on the URL preflight check
+# (requests matching NO_PROXY are still fully checked).
+# SSRF_GUARD_USE_PROXY=true
LOG_LEVEL=DEBUG
LOG_CONSOLE=true
diff --git a/app/pkg/env/env.go b/app/pkg/env/env.go
index 39b113ed4..55b61aaa3 100644
--- a/app/pkg/env/env.go
+++ b/app/pkg/env/env.go
@@ -57,6 +57,7 @@ type config struct {
PostCreationWithTagsEnabled bool `env:"POST_CREATION_WITH_TAGS_ENABLED,default=false"`
AllowAllowedSchemes bool `env:"ALLOW_ALLOWED_SCHEMES,default=true"`
AllowPrivateNetworkTargets bool `env:"ALLOW_PRIVATE_NETWORK_TARGETS,default=false"`
+ SSRFGuardUseProxy bool `env:"SSRF_GUARD_USE_PROXY,default=false"`
Stripe struct {
SecretKey string `env:"STRIPE_SECRET_KEY"`
WebhookSecret string `env:"STRIPE_WEBHOOK_SECRET"`
diff --git a/app/pkg/netguard/netguard.go b/app/pkg/netguard/netguard.go
index 94de4c6aa..5553b87be 100644
--- a/app/pkg/netguard/netguard.go
+++ b/app/pkg/netguard/netguard.go
@@ -5,18 +5,23 @@
// There are two layers:
// - validate.WebhookURL performs a friendly preflight check (it resolves the
// hostname and rejects private targets with a readable message).
-// - The client returned by NewClient enforces the same IsBlockedIP check at
-// dial time, on the exact IP address being connected to. This is the real
-// enforcement: it cannot be bypassed by DNS rebinding (a hostname that
-// resolves to a public IP during validation and to a private IP when the
-// request is made).
+// - The client returned by Client/ClientFor enforces the same IsBlockedIP
+// check at dial time, on the exact IP address being connected to. This is
+// the real enforcement: it cannot be bypassed by DNS rebinding (a hostname
+// that resolves to a public IP during validation and to a private IP when
+// the request is made). The exception is requests sent through an HTTP(S)
+// proxy when SSRF_GUARD_USE_PROXY=true; see NewClient.
package netguard
import (
+ "context"
"errors"
"fmt"
"net"
"net/http"
+ "net/url"
+ "strings"
+ "sync"
"syscall"
"time"
@@ -146,47 +151,134 @@ func dialControl(network, address string, _ syscall.RawConn) error {
return nil
}
+// ProxyFunc selects the proxy for a request, like http.Transport.Proxy.
+// A nil ProxyFunc means requests are always sent directly.
+type ProxyFunc func(*http.Request) (*url.URL, error)
+
+// proxyAddrKey is the context key under which guardedTransport stores the
+// "host:port" of the proxy chosen for a request.
+type proxyAddrKey struct{}
+
+// guardedTransport wraps the real transport to tell the dialer which address,
+// if any, is the proxy for this particular request.
+//
+// With a proxy, net/http dials the proxy rather than the target, so a
+// dial-time check can only ever see the proxy's address. The proxy itself is
+// operator-configured and may well live on a private network, so that one
+// connection must be allowed. Everything else, in particular requests for
+// which the proxy func returns nil (NO_PROXY match, loopback targets, or no
+// proxy configured), must still be checked. To do that without guessing, the
+// wrapper evaluates the proxy func itself and stores the resulting proxy
+// address in the request context; the dialer skips the IP check only when the
+// address it is asked to dial equals that value exactly. If the two ever
+// disagree (e.g. the proxy environment changed between calls), the dial is
+// checked as normal, i.e. the guard fails closed.
+type guardedTransport struct {
+ proxy ProxyFunc
+ base *http.Transport
+}
+
+func (t *guardedTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+ if t.proxy != nil {
+ proxyURL, err := t.proxy(req)
+ if err != nil {
+ return nil, err
+ }
+ if proxyURL != nil {
+ ctx := context.WithValue(req.Context(), proxyAddrKey{}, proxyDialAddr(proxyURL))
+ req = req.WithContext(ctx)
+ }
+ }
+ return t.base.RoundTrip(req)
+}
+
+// proxyDialAddr returns the address net/http dials for proxyURL (mirrors
+// net/http's canonicalAddr: default port by scheme).
+func proxyDialAddr(proxyURL *url.URL) string {
+ port := proxyURL.Port()
+ if port == "" {
+ switch strings.ToLower(proxyURL.Scheme) {
+ case "https":
+ port = "443"
+ case "socks5", "socks5h":
+ port = "1080"
+ default:
+ port = "80"
+ }
+ }
+ return net.JoinHostPort(proxyURL.Hostname(), port)
+}
+
// NewClient returns an http.Client that refuses to connect to any address for
// which IsBlockedIP returns true. It mirrors Fider's default client settings:
// 30s timeout and redirects are not followed.
//
-// Proxies are intentionally disabled (Proxy: nil, i.e. HTTP(S)_PROXY is
-// ignored). With a proxy, the dial would go to the proxy rather than to the
-// target, so the dial-time check would inspect the proxy's address and either
-// block every request (proxy on a private network) or protect nothing (the
-// proxy resolves and connects to the target itself). Guarded requests are
-// therefore always sent directly.
-func NewClient() *http.Client {
- dialer := &net.Dialer{
+// If proxy is nil, requests are always sent directly and every connection is
+// checked. If proxy is set, requests it routes through a proxy are NOT covered
+// by the dial-time check (the proxy resolves and connects to the target), so
+// for those only the validate.WebhookURL preflight applies; this is weaker
+// against DNS rebinding. Requests the proxy func sends directly are still
+// fully checked. See guardedTransport.
+func NewClient(proxy ProxyFunc) *http.Client {
+ guarded := &net.Dialer{
Timeout: 30 * time.Second,
KeepAlive: 30 * time.Second,
Control: dialControl,
}
+ toProxy := &net.Dialer{
+ Timeout: 30 * time.Second,
+ KeepAlive: 30 * time.Second,
+ }
- transport := http.DefaultTransport.(*http.Transport).Clone()
- transport.Proxy = nil
- transport.DialContext = dialer.DialContext
+ base := http.DefaultTransport.(*http.Transport).Clone()
+ base.Proxy = proxy
+ base.DialContext = func(ctx context.Context, network, addr string) (net.Conn, error) {
+ if proxyAddr, _ := ctx.Value(proxyAddrKey{}).(string); proxyAddr != "" && addr == proxyAddr {
+ return toProxy.DialContext(ctx, network, addr)
+ }
+ return guarded.DialContext(ctx, network, addr)
+ }
return &http.Client{
Timeout: 30 * time.Second,
- Transport: transport,
+ Transport: &guardedTransport{proxy: proxy, base: base},
CheckRedirect: func(req *http.Request, via []*http.Request) error {
return http.ErrUseLastResponse
},
}
}
-// Client is a shared guarded client, safe for concurrent use.
-var Client = NewClient()
+var (
+ directOnce sync.Once
+ directClient *http.Client
+ proxiedOnce sync.Once
+ proxiedClient *http.Client
+)
+
+// Client returns the shared guarded client (safe for concurrent use).
+// It is chosen when called, not at package init, so it reflects the loaded
+// env config:
+// - SSRF_GUARD_USE_PROXY=false (default): HTTP(S)_PROXY is ignored and every
+// connection is checked at dial time.
+// - SSRF_GUARD_USE_PROXY=true: http.ProxyFromEnvironment is used; proxied
+// requests rely on the preflight only, direct ones are checked at dial time.
+func Client() *http.Client {
+ if env.Config.SSRFGuardUseProxy {
+ proxiedOnce.Do(func() { proxiedClient = NewClient(http.ProxyFromEnvironment) })
+ return proxiedClient
+ }
+ directOnce.Do(func() { directClient = NewClient(nil) })
+ return directClient
+}
// ClientFor returns the HTTP client to use for an outbound request. When
-// blockPrivateNetworkTargets is true it returns the guarded Client, unless the
-// instance opted out via ALLOW_PRIVATE_NETWORK_TARGETS=true, in which case (and
-// when blockPrivateNetworkTargets is false) it returns http.DefaultClient.
+// blockPrivateNetworkTargets is true it returns the guarded Client(), unless
+// the instance opted out via ALLOW_PRIVATE_NETWORK_TARGETS=true, in which case
+// (and when blockPrivateNetworkTargets is false) it returns http.DefaultClient.
// This is the single place where the escape hatch is applied.
func ClientFor(blockPrivateNetworkTargets bool) *http.Client {
if blockPrivateNetworkTargets && !env.Config.AllowPrivateNetworkTargets {
- return Client
+ return Client()
}
return http.DefaultClient
}
diff --git a/app/pkg/netguard/netguard_test.go b/app/pkg/netguard/netguard_test.go
index 9ccd4fbec..6eb1e21b1 100644
--- a/app/pkg/netguard/netguard_test.go
+++ b/app/pkg/netguard/netguard_test.go
@@ -3,14 +3,17 @@ package netguard_test
import (
"context"
"errors"
+ "io"
"net"
"net/http"
"net/http/httptest"
+ "net/url"
"testing"
. "github.com/getfider/fider/app/pkg/assert"
"github.com/getfider/fider/app/pkg/env"
"github.com/getfider/fider/app/pkg/netguard"
+ "golang.org/x/net/http/httpproxy"
)
func TestIsBlockedIP(t *testing.T) {
@@ -131,7 +134,7 @@ func TestClient_RejectsBlockedTargetsAtDialTime(t *testing.T) {
"http://localhost:" + port + "/", // hostname resolving to loopback
} {
req, _ := http.NewRequestWithContext(context.Background(), "GET", rawurl, nil)
- res, err := netguard.Client.Do(req)
+ res, err := netguard.Client().Do(req)
if res != nil {
_ = res.Body.Close()
}
@@ -148,10 +151,109 @@ func TestClientFor(t *testing.T) {
t.Cleanup(func() { env.Config.AllowPrivateNetworkTargets = original })
env.Config.AllowPrivateNetworkTargets = false
- Expect(netguard.ClientFor(true) == netguard.Client).IsTrue()
+ Expect(netguard.ClientFor(true) == netguard.Client()).IsTrue()
Expect(netguard.ClientFor(false) == http.DefaultClient).IsTrue()
env.Config.AllowPrivateNetworkTargets = true
Expect(netguard.ClientFor(true) == http.DefaultClient).IsTrue()
Expect(netguard.ClientFor(false) == http.DefaultClient).IsTrue()
}
+
+// newTestProxy starts a local forward-proxy stand-in on 127.0.0.1 that answers
+// every request itself and records the absolute request URLs it received.
+func newTestProxy(t *testing.T) (*httptest.Server, *[]string) {
+ seen := make([]string, 0)
+ proxy := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ seen = append(seen, r.URL.String())
+ _, _ = w.Write([]byte("via proxy"))
+ }))
+ t.Cleanup(proxy.Close)
+ return proxy, &seen
+}
+
+// proxyFuncFor builds a deterministic proxy func (http.ProxyFromEnvironment
+// caches the environment on first use, so it can't be driven from tests).
+func proxyFuncFor(cfg *httpproxy.Config) netguard.ProxyFunc {
+ fn := cfg.ProxyFunc()
+ return func(req *http.Request) (*url.URL, error) {
+ return fn(req.URL)
+ }
+}
+
+func get(client *http.Client, rawurl string) (*http.Response, []byte, error) {
+ req, _ := http.NewRequestWithContext(context.Background(), "GET", rawurl, nil)
+ res, err := client.Do(req)
+ if err != nil {
+ return nil, nil, err
+ }
+ defer func() { _ = res.Body.Close() }()
+ body, err := io.ReadAll(res.Body)
+ return res, body, err
+}
+
+func TestNewClient_WithProxy(t *testing.T) {
+ RegisterT(t)
+
+ proxy, seen := newTestProxy(t)
+ target := newLocalServer(t)
+ client := netguard.NewClient(proxyFuncFor(&httpproxy.Config{
+ HTTPProxy: proxy.URL,
+ NoProxy: "10.0.0.0/8",
+ }))
+
+ // Proxied request: the dial goes to the proxy on 127.0.0.1, which must not
+ // be blocked. The target itself is only covered by the preflight check.
+ res, body, err := get(client, "http://203.0.113.10/hook")
+ Expect(err).IsNil()
+ Expect(res.StatusCode).Equals(http.StatusOK)
+ Expect(string(body)).Equals("via proxy")
+ Expect(*seen).Equals([]string{"http://203.0.113.10/hook"})
+
+ // NO_PROXY match: sent directly, so the dial-time guard still applies.
+ _, _, err = get(client, "http://10.1.2.3/hook")
+ Expect(errors.Is(err, netguard.ErrBlockedAddress)).IsTrue()
+
+ // Loopback targets are never proxied by httpproxy / ProxyFromEnvironment:
+ // also direct, also blocked, even though the proxy address is loopback too.
+ _, _, err = get(client, target.URL)
+ Expect(errors.Is(err, netguard.ErrBlockedAddress)).IsTrue()
+
+ Expect(*seen).HasLen(1)
+}
+
+func TestNewClient_WithoutProxyIgnoresProxyEnv(t *testing.T) {
+ RegisterT(t)
+
+ proxy, seen := newTestProxy(t)
+ t.Setenv("HTTP_PROXY", proxy.URL)
+ t.Setenv("http_proxy", proxy.URL)
+
+ // 10.1.2.3 is rejected by the dial guard before any packet is sent. Had a
+ // proxy been used, the local proxy would have answered with 200.
+ _, _, err := get(netguard.NewClient(nil), "http://10.1.2.3/hook")
+ Expect(errors.Is(err, netguard.ErrBlockedAddress)).IsTrue()
+ Expect(*seen).HasLen(0)
+}
+
+func TestClient_ReflectsSSRFGuardUseProxy(t *testing.T) {
+ RegisterT(t)
+
+ original := env.Config.SSRFGuardUseProxy
+ t.Cleanup(func() { env.Config.SSRFGuardUseProxy = original })
+
+ env.Config.SSRFGuardUseProxy = false
+ direct := netguard.Client()
+ Expect(netguard.Client() == direct).IsTrue()
+
+ env.Config.SSRFGuardUseProxy = true
+ proxied := netguard.Client()
+ Expect(proxied == direct).IsFalse()
+ Expect(netguard.Client() == proxied).IsTrue()
+ Expect(netguard.ClientFor(true) == proxied).IsTrue()
+
+ // Whether or not a proxy is configured in this environment, loopback
+ // targets are never proxied, so they are still blocked at dial time.
+ target := newLocalServer(t)
+ _, _, err := get(proxied, target.URL)
+ Expect(errors.Is(err, netguard.ErrBlockedAddress)).IsTrue()
+}
diff --git a/app/services/oauth/guard_internal_test.go b/app/services/oauth/guard_internal_test.go
index 535522d35..7a858a362 100644
--- a/app/services/oauth/guard_internal_test.go
+++ b/app/services/oauth/guard_internal_test.go
@@ -24,7 +24,7 @@ func TestTokenExchangeContext(t *testing.T) {
expected *http.Client
}{
// Custom providers use the guarded client...
- {"_custom", false, netguard.Client},
+ {"_custom", false, netguard.Client()},
// ...unless the instance allows private network targets.
{"_custom", true, http.DefaultClient},
// Built-in providers leave the context untouched (oauth2 then uses its default).