fix(security): harden outbound requests and file previews

This commit is contained in:
wizardchen
2026-07-02 18:17:51 +08:00
committed by lyingbug
parent 7099a7e181
commit 663d13eb58
16 changed files with 546 additions and 110 deletions
@@ -25,6 +25,13 @@ const embedWebhookTimeout = 5 * time.Second
// ErrEmbedWebhookURLInvalid is returned when a webhook URL fails format or SSRF checks.
var ErrEmbedWebhookURLInvalid = errors.New("invalid embed webhook URL")
func newEmbedWebhookHTTPClient() *http.Client {
return secutils.NewSSRFSafeHTTPClient(secutils.SSRFSafeHTTPClientConfig{
Timeout: embedWebhookTimeout,
MaxRedirects: 5,
})
}
// ValidateEmbedWebhookURL checks an optional outbound webhook URL. Empty is allowed.
func ValidateEmbedWebhookURL(raw string) error {
trimmed := strings.TrimSpace(raw)
@@ -90,7 +97,7 @@ func DispatchEmbedWebhook(ch *types.EmbedChannel, eventType, sessionID string, p
_, _ = mac.Write(raw)
req.Header.Set("X-WeKnora-Signature", "sha256="+hex.EncodeToString(mac.Sum(nil)))
}
resp, err := http.DefaultClient.Do(req)
resp, err := newEmbedWebhookHTTPClient().Do(req)
if err != nil {
logger.Warnf(context.Background(), "[embed_webhook] dispatch %s failed: %v", eventType, err)
return
@@ -1,6 +1,13 @@
package service
import "testing"
import (
stderrors "errors"
"net/http"
"net/http/httptest"
"testing"
secutils "github.com/Tencent/WeKnora/internal/utils"
)
func TestValidateEmbedWebhookURL(t *testing.T) {
withSSRFWhitelist(t, "*.example.com,127.0.0.1")
@@ -33,3 +40,27 @@ func TestSignEmbedWebhookBody(t *testing.T) {
t.Fatal("signature not deterministic")
}
}
func TestEmbedWebhookHTTPClientBlocksRedirectToInternalURL(t *testing.T) {
withSSRFWhitelist(t, "127.0.0.1")
origin := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, "http://169.254.169.254/latest/meta-data/", http.StatusFound)
}))
defer origin.Close()
req, err := http.NewRequest(http.MethodPost, origin.URL, nil)
if err != nil {
t.Fatalf("NewRequest: %v", err)
}
resp, err := newEmbedWebhookHTTPClient().Do(req)
if resp != nil && resp.Body != nil {
_ = resp.Body.Close()
}
if err == nil {
t.Fatal("expected redirect to link-local metadata endpoint to be blocked")
}
if !stderrors.Is(err, secutils.ErrSSRFRedirectBlocked) {
t.Fatalf("error = %v, want ErrSSRFRedirectBlocked", err)
}
}
+53 -9
View File
@@ -1051,6 +1051,39 @@ type oidcTokenResponse struct {
TokenType string `json:"token_type"`
}
func newOIDCHTTPClient() *http.Client {
cfg := secutils.DefaultSSRFSafeHTTPClientConfig()
cfg.Timeout = 30 * time.Second
return secutils.NewSSRFSafeHTTPClient(cfg)
}
func validateOIDCEndpoint(label, endpoint string, required bool) error {
endpoint = strings.TrimSpace(endpoint)
if endpoint == "" {
if required {
return fmt.Errorf("OIDC %s endpoint is required", label)
}
return nil
}
if err := secutils.ValidateURLForSSRF(endpoint); err != nil {
return fmt.Errorf("OIDC %s endpoint failed SSRF validation: %w", label, err)
}
return nil
}
func validateOIDCEndpoints(cfg *config.OIDCAuthConfig) error {
if err := validateOIDCEndpoint("authorization", cfg.AuthorizationEndpoint, true); err != nil {
return err
}
if err := validateOIDCEndpoint("token", cfg.TokenEndpoint, true); err != nil {
return err
}
if err := validateOIDCEndpoint("userinfo", cfg.UserInfoEndpoint, false); err != nil {
return err
}
return nil
}
func (s *userService) getOIDCConfig(ctx context.Context) (*config.OIDCAuthConfig, error) {
if s.config == nil || s.config.OIDCAuth == nil || !s.config.OIDCAuth.Enable {
return nil, errors.New("OIDC login is disabled")
@@ -1067,18 +1100,21 @@ func (s *userService) getOIDCConfig(ctx context.Context) (*config.OIDCAuthConfig
func (s *userService) populateOIDCEndpoints(ctx context.Context, cfg *config.OIDCAuthConfig) error {
if strings.TrimSpace(cfg.AuthorizationEndpoint) != "" && strings.TrimSpace(cfg.TokenEndpoint) != "" {
return nil
return validateOIDCEndpoints(cfg)
}
if strings.TrimSpace(cfg.DiscoveryURL) == "" {
return errors.New("OIDC discovery_url or explicit endpoints are required")
}
if err := validateOIDCEndpoint("discovery", cfg.DiscoveryURL, true); err != nil {
return err
}
req, err := http.NewRequestWithContext(ctx, http.MethodGet, cfg.DiscoveryURL, nil)
if err != nil {
return fmt.Errorf("failed to create OIDC discovery request: %w", err)
}
resp, err := http.DefaultClient.Do(req)
resp, err := newOIDCHTTPClient().Do(req)
if err != nil {
return fmt.Errorf("failed to load OIDC discovery document: %w", err)
}
@@ -1104,10 +1140,14 @@ func (s *userService) populateOIDCEndpoints(ctx context.Context, cfg *config.OID
if cfg.AuthorizationEndpoint == "" || cfg.TokenEndpoint == "" {
return errors.New("OIDC discovery document missing required endpoints")
}
return nil
return validateOIDCEndpoints(cfg)
}
func (s *userService) exchangeOIDCCode(ctx context.Context, cfg *config.OIDCAuthConfig, code, redirectURI string) (*oidcTokenResponse, error) {
if err := validateOIDCEndpoint("token", cfg.TokenEndpoint, true); err != nil {
return nil, err
}
form := url.Values{}
form.Set("grant_type", "authorization_code")
form.Set("code", code)
@@ -1122,14 +1162,14 @@ func (s *userService) exchangeOIDCCode(ctx context.Context, cfg *config.OIDCAuth
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
req.Header.Set("Accept", "application/json")
resp, err := http.DefaultClient.Do(req)
resp, err := newOIDCHTTPClient().Do(req)
if err != nil {
return nil, fmt.Errorf("failed to exchange OIDC code: %w", err)
}
defer resp.Body.Close()
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
body, _ := io.ReadAll(io.LimitReader(resp.Body, 2048))
return nil, fmt.Errorf("OIDC token exchange failed: status=%d body=%s", resp.StatusCode, strings.TrimSpace(string(body)))
_, _ = io.Copy(io.Discard, io.LimitReader(resp.Body, 2048))
return nil, fmt.Errorf("OIDC token exchange failed: status=%d", resp.StatusCode)
}
var tokenResp oidcTokenResponse
@@ -1186,6 +1226,10 @@ func (s *userService) resolveOIDCUserInfo(ctx context.Context, cfg *config.OIDCA
}
func (s *userService) fetchOIDCUserInfo(ctx context.Context, endpoint, accessToken string) (map[string]interface{}, error) {
if err := validateOIDCEndpoint("userinfo", endpoint, true); err != nil {
return nil, err
}
req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
if err != nil {
return nil, err
@@ -1193,14 +1237,14 @@ func (s *userService) fetchOIDCUserInfo(ctx context.Context, endpoint, accessTok
req.Header.Set("Authorization", "Bearer "+accessToken)
req.Header.Set("Accept", "application/json")
resp, err := http.DefaultClient.Do(req)
resp, err := newOIDCHTTPClient().Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
body, _ := io.ReadAll(io.LimitReader(resp.Body, 2048))
return nil, fmt.Errorf("userinfo request failed: status=%d body=%s", resp.StatusCode, strings.TrimSpace(string(body)))
_, _ = io.Copy(io.Discard, io.LimitReader(resp.Body, 2048))
return nil, fmt.Errorf("userinfo request failed: status=%d", resp.StatusCode)
}
var claims map[string]interface{}
@@ -0,0 +1,87 @@
package service
import (
"context"
"encoding/json"
"net/http"
"net/http/httptest"
"strings"
"testing"
"github.com/Tencent/WeKnora/internal/config"
secutils "github.com/Tencent/WeKnora/internal/utils"
)
func withOIDCSSRFWhitelist(t *testing.T, raw string) {
t.Helper()
t.Setenv("SSRF_WHITELIST", raw)
secutils.ResetSSRFWhitelistForTest()
t.Cleanup(secutils.ResetSSRFWhitelistForTest)
}
func TestOIDCDiscoveryRejectsInternalDiscoveredEndpoint(t *testing.T) {
withOIDCSSRFWhitelist(t, "127.0.0.1")
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
_ = json.NewEncoder(w).Encode(oidcDiscoveryDocument{
AuthorizationEndpoint: serverURL(r, "/authorize"),
TokenEndpoint: "http://169.254.169.254/latest/meta-data/",
})
}))
defer server.Close()
svc := &userService{}
cfg := &config.OIDCAuthConfig{DiscoveryURL: server.URL}
err := svc.populateOIDCEndpoints(context.Background(), cfg)
if err == nil || !strings.Contains(err.Error(), "OIDC token endpoint failed SSRF validation") {
t.Fatalf("populateOIDCEndpoints error = %v, want token SSRF validation failure", err)
}
}
func TestOIDCTokenExchangeBlocksRedirectToInternalURL(t *testing.T) {
withOIDCSSRFWhitelist(t, "127.0.0.1")
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, "http://169.254.169.254/latest/meta-data/", http.StatusFound)
}))
defer server.Close()
svc := &userService{}
cfg := &config.OIDCAuthConfig{TokenEndpoint: server.URL, ClientID: "client-id", ClientSecret: "client-secret"}
_, err := svc.exchangeOIDCCode(context.Background(), cfg, "code", "https://app.example/callback")
if err == nil || !strings.Contains(err.Error(), secutils.ErrSSRFRedirectBlocked.Error()) {
t.Fatalf("exchangeOIDCCode error = %v, want redirect SSRF block", err)
}
}
func TestOIDCErrorsDoNotEchoSecrets(t *testing.T) {
withOIDCSSRFWhitelist(t, "127.0.0.1")
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
w.WriteHeader(http.StatusBadRequest)
_, _ = w.Write([]byte("client-secret bearer-token"))
}))
defer server.Close()
svc := &userService{}
cfg := &config.OIDCAuthConfig{TokenEndpoint: server.URL, ClientID: "client-id", ClientSecret: "client-secret"}
_, err := svc.exchangeOIDCCode(context.Background(), cfg, "code", "https://app.example/callback")
if err == nil {
t.Fatalf("exchangeOIDCCode returned nil error")
}
if strings.Contains(err.Error(), "client-secret") {
t.Fatalf("exchangeOIDCCode error leaked secret: %v", err)
}
_, err = svc.fetchOIDCUserInfo(context.Background(), server.URL, "bearer-token")
if err == nil {
t.Fatalf("fetchOIDCUserInfo returned nil error")
}
if strings.Contains(err.Error(), "bearer-token") {
t.Fatalf("fetchOIDCUserInfo error leaked bearer token: %v", err)
}
}
func serverURL(r *http.Request, path string) string {
return "http://" + r.Host + path
}