Open-source LLM knowledge platform: turn raw documents into a queryable RAG, an autonomous reasoning agent, and a self-maintaining Wiki.
Go agentagenticaichatbotdsh-pluginembeddingsevaluationgenerative-aigolangknowledge-basellmmulti-tenantollamaopenaiquestion-answeringragrerankingsemantic-searchvector-searchwiki
fix(im/wecom): accept custom wss long-connection endpoints behind SSRF host checks
LuckVdd9237166cc4c
diff --git a/internal/im/wecom/endpoint_test.go b/internal/im/wecom/endpoint_test.gonew file mode 100644index 000000000..ae0d3f548--- /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.goindex 963f62a8e..634559f74 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) errorif 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