From d9237166cc4cb618818d2e65e62f820f1cc03f24 Mon Sep 17 00:00:00 2001 From: LuckVd Date: Fri, 9 Oct 2026 10:26:21 +0800 Subject: [PATCH] fix(im/wecom): accept custom wss long-connection endpoints behind SSRF host checks MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit validateEndpointURL pinned the scheme to wss for long-connection endpoints and then passed the URL to ValidateURLForSSRF, whose scheme allowlist only accepts http/https — so every custom ws/wss endpoint failed with "invalid scheme: wss (only http/https allowed)" and SSRF_WHITELIST could not help because the whitelist is only consulted after the scheme check. The default endpoint worked only because it short-circuits validation. Validate ws/wss endpoints under an https mask instead: the scheme is already pinned, and every host-level guard (restricted hostnames, private/metadata IPs, DNS rebinding, port blocklist, whitelist and whitelist-only mode) still applies unchanged. Same approach as qqbot.validateGatewayURL. --- internal/im/wecom/endpoint_test.go | 71 ++++++++++++++++++++++++++++ internal/im/wecom/webhook_adapter.go | 14 +++++- 2 files changed, 84 insertions(+), 1 deletion(-) create mode 100644 internal/im/wecom/endpoint_test.go diff --git a/internal/im/wecom/endpoint_test.go b/internal/im/wecom/endpoint_test.go new file mode 100644 index 00000000..ae0d3f54 --- /dev/null +++ b/internal/im/wecom/endpoint_test.go @@ -0,0 +1,71 @@ +package wecom + +import ( + "os" + "strings" + "testing" + + secutils "github.com/Tencent/WeKnora/internal/utils" +) + +// setWhitelistForTest swaps the SSRF whitelist singleton for the duration of +// the test, following the pattern in internal/utils/security_test.go. +func setWhitelistForTest(t *testing.T, entries string) { + t.Helper() + secutils.ResetSSRFWhitelistForTest() + os.Setenv("SSRF_WHITELIST", entries) + t.Cleanup(func() { + os.Unsetenv("SSRF_WHITELIST") + secutils.ResetSSRFWhitelistForTest() + }) +} + +// A custom wss:// endpoint whose host is on the SSRF whitelist must be +// accepted. Before the https-mask validation every custom ws/wss endpoint +// failed with "invalid scheme: wss (only http/https allowed)" (#4047). +func TestValidateEndpointURLAcceptsWhitelistedCustomWssEndpoint(t *testing.T) { + setWhitelistForTest(t, "im.example.com") + + err := validateEndpointURL("wss://im.example.com/im_open/longconn", defaultWSEndpoint, "wss") + if err != nil { + t.Fatalf("whitelisted custom wss endpoint should be accepted, got: %v", err) + } +} + +// The scheme pin is untouched: an https:// URL is still rejected where a wss +// endpoint is required, and vice versa. +func TestValidateEndpointURLSchemePinUnchanged(t *testing.T) { + if err := validateEndpointURL("https://im.example.com", defaultWSEndpoint, "wss"); err == nil || !strings.Contains(err.Error(), "wss://") { + t.Fatalf("https endpoint must be rejected for a wss slot, got: %v", err) + } + if err := validateEndpointURL("wss://api.example.com", defaultAPIBaseURL, "https"); err == nil || !strings.Contains(err.Error(), "https://") { + t.Fatalf("wss endpoint must be rejected for an https slot, got: %v", err) + } +} + +// The https mask must not weaken host-level guards: private-IP endpoints stay +// blocked. +func TestValidateEndpointURLStillBlocksPrivateIPWssEndpoint(t *testing.T) { + setWhitelistForTest(t, "") + + err := validateEndpointURL("wss://192.168.1.10/ws", defaultWSEndpoint, "wss") + if err == nil { + t.Fatal("private-IP wss endpoint must stay blocked") + } +} + +// The default endpoint keeps its short-circuit (no validation, no DNS). +func TestValidateEndpointURLDefaultWSEndpointShortCircuits(t *testing.T) { + if err := validateEndpointURL(defaultWSEndpoint, defaultWSEndpoint, "wss"); err != nil { + t.Fatalf("default endpoint should short-circuit, got: %v", err) + } +} + +// The https path (API base URL) keeps its original behavior end to end. +func TestValidateEndpointURLHttpsPathUnchanged(t *testing.T) { + setWhitelistForTest(t, "api.example.com") + + if err := validateEndpointURL("https://api.example.com", defaultAPIBaseURL, "https"); err != nil { + t.Fatalf("whitelisted https base URL should keep working, got: %v", err) + } +} diff --git a/internal/im/wecom/webhook_adapter.go b/internal/im/wecom/webhook_adapter.go index 963f62a8..634559f7 100644 --- a/internal/im/wecom/webhook_adapter.go +++ b/internal/im/wecom/webhook_adapter.go @@ -74,7 +74,19 @@ func validateEndpointURL(endpoint, defaultEndpoint, requiredScheme string) error if u.Scheme != requiredScheme { return fmt.Errorf("endpoint must use %s:// scheme, got %s://", requiredScheme, u.Scheme) } - if err := secutils.ValidateURLForSSRF(endpoint); err != nil { + // ValidateURLForSSRF only accepts http/https, which made every custom + // ws/wss endpoint fail with "invalid scheme: wss". Validate WebSocket + // endpoints under an https mask instead: the scheme itself was already + // pinned above, and every host-level guard (restricted hostnames, + // private/metadata IPs, DNS rebinding, port blocklist, SSRF_WHITELIST) + // still applies unchanged. Same approach as qqbot.validateGatewayURL. + ssrfTarget := endpoint + if u.Scheme == "ws" || u.Scheme == "wss" { + masked := *u + masked.Scheme = "https" + ssrfTarget = masked.String() + } + if err := secutils.ValidateURLForSSRF(ssrfTarget); err != nil { return fmt.Errorf("%w (for private deployments on internal networks, add the hostname to SSRF_WHITELIST)", err) } return nil