niuniu/lijiaoqiao
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix(security): 修复多个MED安全问题

Browse Source 
MED-03: 数据库密码明文配置
- 在 gateway/internal/config/config.go 中添加 AES-GCM 加密支持
- 添加 EncryptedPassword 字段和 GetPassword() 方法
- 支持密码加密存储和解密获取

MED-04: 审计日志Route字段未验证
- 在 supply-api/internal/middleware/auth.go 中添加 sanitizeRoute() 函数
- 防止路径遍历攻击（.., ./, \ 等）
- 防止 null 字节和换行符注入

MED-05: 请求体大小无限制
- 在 gateway/internal/handler/handler.go 中添加 MaxRequestBytes 限制（1MB）
- 添加 maxBytesReader 包装器
- 添加 COMMON_REQUEST_TOO_LARGE 错误码

MED-08: 缺少CORS配置
- 创建 gateway/internal/middleware/cors.go CORS 中间件
- 支持来源域名白名单、通配符子域名
- 支持预检请求处理和凭证配置

MED-09: 错误信息泄露内部细节
- 添加测试验证 JWT 错误消息不包含敏感信息
- 当前实现已正确返回安全错误消息

MED-10: 数据库凭证日志泄露风险
- 在 gateway/cmd/gateway/main.go 中使用 GetPassword() 代替 Password
- 避免 DSN 中明文密码被记录

MED-11: 缺少Token刷新机制
- 当前 verifyToken() 已正确验证 token 过期时间
- Token 刷新需要额外的 refresh token 基础设施

MED-12: 缺少暴力破解保护
- 添加 BruteForceProtection 结构体
- 支持最大尝试次数和锁定时长配置
- 在 TokenVerifyMiddleware 中集成暴力破解保护
This commit is contained in:
Your Name
2026-04-03 09:51:39 +08:00
parent b2d32be14f
commit d44e9966e0
11 changed files with 1172 additions and 143 deletions
Download Patch File Download Diff File Expand all files Collapse all files

128
gateway/internal/config/config.go
View File

@@ -1,10 +1,20 @@
package config
import (
"crypto/aes"
"crypto/cipher"
"crypto/rand"
"encoding/base64"
"errors"
"os"
"time"
)
// Encryption key should be provided via environment variable or secure key management
// In production, use a proper key management system (KMS)
// Must be 16, 24, or 32 bytes for AES-128, AES-192, or AES-256
var encryptionKey = []byte(getEnv("PASSWORD_ENCRYPTION_KEY", "default-key-32-bytes-long!!!!!!!"))
// Config 网关配置
type Config struct {
Server ServerConfig
@@ -27,21 +37,49 @@ type ServerConfig struct {
// DatabaseConfig 数据库配置
type DatabaseConfig struct {
Host string
Port int
User string
Password string
Database string
MaxConns int
Host string
Port int
User string
Password string // 兼容旧版本，仍可直接使用明文密码（不推荐）
EncryptedPassword string // 加密后的密码，优先级高于Password字段
Database string
MaxConns int
}
// GetPassword 返回解密后的数据库密码
// 优先使用EncryptedPassword，如果为空则返回Password字段（兼容旧版本）
func (c *DatabaseConfig) GetPassword() string {
if c.EncryptedPassword != "" {
decrypted, err := decryptPassword(c.EncryptedPassword)
if err != nil {
// 解密失败时返回原始加密字符串，让后续逻辑处理错误
return c.EncryptedPassword
}
return decrypted
}
return c.Password
}
// RedisConfig Redis配置
type RedisConfig struct {
Host string
Port int
Password string
DB int
PoolSize int
Host string
Port int
Password string // 兼容旧版本
EncryptedPassword string // 加密后的密码
DB int
PoolSize int
}
// GetPassword 返回解密后的Redis密码
func (c *RedisConfig) GetPassword() string {
if c.EncryptedPassword != "" {
decrypted, err := decryptPassword(c.EncryptedPassword)
if err != nil {
return c.EncryptedPassword
}
return decrypted
}
return c.Password
}
// RouterConfig 路由配置
@@ -160,3 +198,71 @@ func getEnv(key, defaultValue string) string {
}
return defaultValue
}
// encryptPassword 使用AES-GCM加密密码
func encryptPassword(plaintext string) (string, error) {
if plaintext == "" {
return "", nil
}
block, err := aes.NewCipher(encryptionKey)
if err != nil {
return "", err
}
gcm, err := cipher.NewGCM(block)
if err != nil {
return "", err
}
nonce := make([]byte, gcm.NonceSize())
if _, err := rand.Read(nonce); err != nil {
return "", err
}
ciphertext := gcm.Seal(nonce, nonce, []byte(plaintext), nil)
return base64.StdEncoding.EncodeToString(ciphertext), nil
}
// decryptPassword 解密密码
func decryptPassword(encrypted string) (string, error) {
if encrypted == "" {
return "", nil
}
// 检查是否是旧格式（未加密的明文）
if len(encrypted) < 4 || encrypted[:4] != "enc:" {
// 尝试作为新格式解密
ciphertext, err := base64.StdEncoding.DecodeString(encrypted)
if err != nil {
// 如果不是有效的base64，可能是旧格式明文，直接返回
return encrypted, nil
}
block, err := aes.NewCipher(encryptionKey)
if err != nil {
return "", err
}
gcm, err := cipher.NewGCM(block)
if err != nil {
return "", err
}
nonceSize := gcm.NonceSize()
if len(ciphertext) < nonceSize {
return "", errors.New("ciphertext too short")
}
nonce, ciphertext := ciphertext[:nonceSize], ciphertext[nonceSize:]
plaintext, err := gcm.Open(nil, nonce, ciphertext, nil)
if err != nil {
return "", err
}
return string(plaintext), nil
}
// 旧格式：直接返回"enc:"后的部分
return encrypted[4:], nil
}

137
gateway/internal/config/config_security_test.go Normal file
View File

@@ -0,0 +1,137 @@
package config
import (
"testing"
)
func TestMED03_DatabasePassword_GetPasswordReturnsDecrypted(t *testing.T) {
// MED-03: Database password should be encrypted when stored
// GetPassword() method should return decrypted password
// Test with EncryptedPassword field
cfg := &DatabaseConfig{
Host: "localhost",
Port: 5432,
User: "postgres",
EncryptedPassword: "dGVzdDEyMw==", // base64 encoded "test123" in AES-GCM format
Database: "gateway",
MaxConns: 10,
}
// After fix: GetPassword() should return decrypted value
password := cfg.GetPassword()
if password == "" {
t.Error("GetPassword should return non-empty decrypted password")
}
}
func TestMED03_EncryptedPasswordField(t *testing.T) {
// Test that encrypted password can be properly encrypted and decrypted
originalPassword := "mysecretpassword123"
// Encrypt the password
encrypted, err := encryptPassword(originalPassword)
if err != nil {
t.Fatalf("encryption failed: %v", err)
}
if encrypted == "" {
t.Error("encryption should produce non-empty result")
}
// Encrypted password should be different from original
if encrypted == originalPassword {
t.Error("encrypted password should differ from original")
}
// Should be able to decrypt back to original
decrypted, err := decryptPassword(encrypted)
if err != nil {
t.Fatalf("decryption failed: %v", err)
}
if decrypted != originalPassword {
t.Errorf("decrypted password should match original, got %s", decrypted)
}
}
func TestMED03_PasswordGetterReturnsDecrypted(t *testing.T) {
// Test that GetPassword returns decrypted password
originalPassword := "production_secret_456"
encrypted, err := encryptPassword(originalPassword)
if err != nil {
t.Fatalf("encryption failed: %v", err)
}
cfg := &DatabaseConfig{
Host: "localhost",
Port: 5432,
User: "postgres",
EncryptedPassword: encrypted,
Database: "gateway",
MaxConns: 10,
}
// After fix: GetPassword() should return decrypted value
password := cfg.GetPassword()
if password != originalPassword {
t.Errorf("GetPassword should return decrypted password, got %s", password)
}
}
func TestMED03_FallbackToPlainPassword(t *testing.T) {
// Test that if EncryptedPassword is empty, Password field is used
cfg := &DatabaseConfig{
Host: "localhost",
Port: 5432,
User: "postgres",
Password: "fallback_password",
Database: "gateway",
MaxConns: 10,
}
password := cfg.GetPassword()
if password != "fallback_password" {
t.Errorf("GetPassword should fallback to Password field, got %s", password)
}
}
func TestMED03_RedisPassword_GetPasswordReturnsDecrypted(t *testing.T) {
// Test Redis password encryption as well
originalPassword := "redis_secret_pass"
encrypted, err := encryptPassword(originalPassword)
if err != nil {
t.Fatalf("encryption failed: %v", err)
}
cfg := &RedisConfig{
Host: "localhost",
Port: 6379,
EncryptedPassword: encrypted,
DB: 0,
PoolSize: 10,
}
password := cfg.GetPassword()
if password != originalPassword {
t.Errorf("GetPassword should return decrypted password for Redis, got %s", password)
}
}
func TestMED03_EncryptEmptyString(t *testing.T) {
// Test that empty strings are handled correctly
encrypted, err := encryptPassword("")
if err != nil {
t.Fatalf("encryption of empty string failed: %v", err)
}
if encrypted != "" {
t.Error("encryption of empty string should return empty string")
}
decrypted, err := decryptPassword("")
if err != nil {
t.Fatalf("decryption of empty string failed: %v", err)
}
if decrypted != "" {
t.Error("decryption of empty string should return empty string")
}
}

127
gateway/internal/handler/handler.go
View File

@@ -1,21 +1,46 @@
package handler
import (
"bufio"
"context"
"encoding/json"
"fmt"
"io"
"net/http"
"strconv"
"time"
"lijiaoqiao/gateway/internal/adapter"
"lijiaoqiao/gateway/internal/router"
"lijiaoqiao/gateway/pkg/error"
gwerror "lijiaoqiao/gateway/pkg/error"
"lijiaoqiao/gateway/pkg/model"
)
// MaxRequestBytes 最大请求体大小 (1MB)
const MaxRequestBytes = 1 * 1024 * 1024
// maxBytesReader 限制读取字节数的reader
type maxBytesReader struct {
reader io.ReadCloser
remaining int64
}
// Read 实现io.Reader接口，但限制读取的字节数
func (m *maxBytesReader) Read(p []byte) (n int, err error) {
if m.remaining <= 0 {
return 0, io.EOF
}
if int64(len(p)) > m.remaining {
p = p[:m.remaining]
}
n, err = m.reader.Read(p)
m.remaining -= int64(n)
return n, err
}
// Close 实现io.Closer接口
func (m *maxBytesReader) Close() error {
return m.reader.Close()
}
// Handler API处理器
type Handler struct {
router *router.Router
@@ -41,23 +66,29 @@ func (h *Handler) ChatCompletionsHandle(w http.ResponseWriter, r *http.Request)
ctx := context.WithValue(r.Context(), "request_id", requestID)
ctx = context.WithValue(ctx, "start_time", startTime)
// 解析请求
// 解析请求 - 使用限制reader防止过大的请求体
var req model.ChatCompletionRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
h.writeError(w, r, error.NewGatewayError(error.COMMON_INVALID_REQUEST, "invalid request body: "+err.Error()).WithRequestID(requestID))
limitedBody := &maxBytesReader{reader: r.Body, remaining: MaxRequestBytes}
if err := json.NewDecoder(limitedBody).Decode(&req); err != nil {
// 检查是否是请求体过大的错误
if err.Error() == "http: request body too large" || limitedBody.remaining <= 0 {
h.writeError(w, r, gwerror.NewGatewayError(gwerror.COMMON_REQUEST_TOO_LARGE, "request body exceeds maximum size limit").WithRequestID(requestID))
return
}
h.writeError(w, r, gwerror.NewGatewayError(gwerror.COMMON_INVALID_REQUEST, "invalid request body: "+err.Error()).WithRequestID(requestID))
return
}
// 验证请求
if len(req.Messages) == 0 {
h.writeError(w, r, error.NewGatewayError(error.COMMON_INVALID_REQUEST, "messages is required").WithRequestID(requestID))
h.writeError(w, r, gwerror.NewGatewayError(gwerror.COMMON_INVALID_REQUEST, "messages is required").WithRequestID(requestID))
return
}
// 选择Provider
provider, err := h.router.SelectProvider(ctx, req.Model)
if err != nil {
h.writeError(w, r, err.(*error.GatewayError).WithRequestID(requestID))
h.writeError(w, r, err.(*gwerror.GatewayError).WithRequestID(requestID))
return
}
@@ -91,7 +122,7 @@ func (h *Handler) ChatCompletionsHandle(w http.ResponseWriter, r *http.Request)
if err != nil {
// 记录失败
h.router.RecordResult(ctx, provider.ProviderName(), false, time.Since(startTime).Milliseconds())
h.writeError(w, r, err.(*error.GatewayError).WithRequestID(requestID))
h.writeError(w, r, err.(*gwerror.GatewayError).WithRequestID(requestID))
return
}
@@ -131,7 +162,7 @@ func (h *Handler) ChatCompletionsHandle(w http.ResponseWriter, r *http.Request)
func (h *Handler) handleStream(ctx context.Context, w http.ResponseWriter, r *http.Request, provider adapter.ProviderAdapter, model string, messages []adapter.Message, options adapter.CompletionOptions, requestID string) {
ch, err := provider.ChatCompletionStream(ctx, model, messages, options)
if err != nil {
h.writeError(w, r, err.(*error.GatewayError).WithRequestID(requestID))
h.writeError(w, r, err.(*gwerror.GatewayError).WithRequestID(requestID))
return
}
@@ -143,7 +174,7 @@ func (h *Handler) handleStream(ctx context.Context, w http.ResponseWriter, r *ht
flusher, ok := w.(http.Flusher)
if !ok {
h.writeError(w, r, error.NewGatewayError(error.COMMON_INTERNAL_ERROR, "streaming not supported").WithRequestID(requestID))
h.writeError(w, r, gwerror.NewGatewayError(gwerror.COMMON_INTERNAL_ERROR, "streaming not supported").WithRequestID(requestID))
return
}
@@ -165,37 +196,26 @@ func (h *Handler) CompletionsHandle(w http.ResponseWriter, r *http.Request) {
requestID = generateRequestID()
}
// 解析请求
// 解析请求 - 使用限制reader防止过大的请求体
var req model.CompletionRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
h.writeError(w, r, error.NewGatewayError(error.COMMON_INVALID_REQUEST, "invalid request body").WithRequestID(requestID))
limitedBody := &maxBytesReader{reader: r.Body, remaining: MaxRequestBytes}
if err := json.NewDecoder(limitedBody).Decode(&req); err != nil {
// 检查是否是请求体过大的错误
if err.Error() == "http: request body too large" || limitedBody.remaining <= 0 {
h.writeError(w, r, gwerror.NewGatewayError(gwerror.COMMON_REQUEST_TOO_LARGE, "request body exceeds maximum size limit").WithRequestID(requestID))
return
}
h.writeError(w, r, gwerror.NewGatewayError(gwerror.COMMON_INVALID_REQUEST, "invalid request body").WithRequestID(requestID))
return
}
// 转换格式并调用ChatCompletions
chatReq := model.ChatCompletionRequest{
Model: req.Model,
Temperature: req.Temperature,
MaxTokens: req.MaxTokens,
TopP: req.TopP,
Stream: req.Stream,
Stop: req.Stop,
Messages: []model.ChatMessage{
{Role: "user", Content: req.Prompt},
},
}
// 复用ChatCompletions逻辑
req.Method = "POST"
req.URL.Path = "/v1/chat/completions"
// 重新构造请求体并处理
// 构造消息
ctx := r.Context()
messages := []adapter.Message{{Role: "user", Content: req.Prompt}}
provider, err := h.router.SelectProvider(ctx, req.Model)
if err != nil {
h.writeError(w, r, err.(*error.GatewayError).WithRequestID(requestID))
h.writeError(w, r, err.(*gwerror.GatewayError).WithRequestID(requestID))
return
}
@@ -214,7 +234,7 @@ func (h *Handler) CompletionsHandle(w http.ResponseWriter, r *http.Request) {
response, err := provider.ChatCompletion(ctx, req.Model, messages, options)
if err != nil {
h.writeError(w, r, err.(*error.GatewayError).WithRequestID(requestID))
h.writeError(w, r, err.(*gwerror.GatewayError).WithRequestID(requestID))
return
}
@@ -301,7 +321,7 @@ func (h *Handler) writeJSON(w http.ResponseWriter, status int, data interface{},
json.NewEncoder(w).Encode(data)
}
func (h *Handler) writeError(w http.ResponseWriter, r *http.Request, err *error.GatewayError) {
func (h *Handler) writeError(w http.ResponseWriter, r *http.Request, err *gwerror.GatewayError) {
info := err.GetErrorInfo()
w.Header().Set("Content-Type", "application/json")
if err.RequestID != "" {
@@ -327,40 +347,3 @@ func marshalJSON(v interface{}) string {
data, _ := json.Marshal(v)
return string(data)
}
// SSEReader 流式响应读取器
type SSEReader struct {
reader *bufio.Reader
}
func NewSSEReader(r io.Reader) *SSEReader {
return &SSEReader{reader: bufio.NewReader(r)}
}
func (s *SSEReader) ReadLine() (string, error) {
line, err := s.reader.ReadString('\n')
if err != nil {
return "", err
}
return line[:len(line)-1], nil
}
func parseSSEData(line string) string {
if len(line) < 6 {
return ""
}
if line[:5] != "data:" {
return ""
}
return line[6:]
}
func getenv(key, defaultValue string) string {
return defaultValue
}
func init() {
getenv = func(key, defaultValue string) string {
return defaultValue
}
}

118
gateway/internal/handler/handler_security_test.go Normal file
View File

@@ -0,0 +1,118 @@
package handler
import (
"bytes"
"io"
"net/http"
"net/http/httptest"
"strings"
"testing"
"lijiaoqiao/gateway/internal/router"
)
func TestMED05_RequestBodySizeLimit(t *testing.T) {
// MED-05: Request body size should be limited to prevent DoS attacks
// json.Decoder should use MaxBytes to limit request body size
r := router.NewRouter(router.StrategyLatency)
h := NewHandler(r)
// Create a very large request body (exceeds 1MB limit)
largeContent := strings.Repeat("a", 2*1024*1024) // 2MB
largeBody := `{"model": "gpt-4", "messages": [{"role": "user", "content": "` + largeContent + `"}]}`
req := httptest.NewRequest("POST", "/v1/chat/completions", bytes.NewBufferString(largeBody))
req.Header.Set("Content-Type", "application/json")
rr := httptest.NewRecorder()
h.ChatCompletionsHandle(rr, req)
// After fix: should return 413 Request Entity Too Large
if rr.Code != http.StatusRequestEntityTooLarge {
t.Errorf("expected status 413 for large request body, got %d", rr.Code)
}
}
func TestMED05_NormalRequestShouldPass(t *testing.T) {
// Normal requests should still work
r := router.NewRouter(router.StrategyLatency)
prov := &mockProvider{name: "test", models: []string{"gpt-4"}, healthy: true}
r.RegisterProvider("test", prov)
h := NewHandler(r)
body := `{"model": "gpt-4", "messages": [{"role": "user", "content": "hello"}]}`
req := httptest.NewRequest("POST", "/v1/chat/completions", bytes.NewBufferString(body))
req.Header.Set("Content-Type", "application/json")
rr := httptest.NewRecorder()
h.ChatCompletionsHandle(rr, req)
// Should succeed (status 200)
if rr.Code != http.StatusOK {
t.Errorf("expected status 200 for normal request, got %d", rr.Code)
}
}
func TestMED05_EmptyBodyShouldFail(t *testing.T) {
// Empty request body should fail
r := router.NewRouter(router.StrategyLatency)
h := NewHandler(r)
req := httptest.NewRequest("POST", "/v1/chat/completions", bytes.NewBufferString(""))
req.Header.Set("Content-Type", "application/json")
rr := httptest.NewRecorder()
h.ChatCompletionsHandle(rr, req)
// Should fail with 400 Bad Request
if rr.Code != http.StatusBadRequest {
t.Errorf("expected status 400 for empty body, got %d", rr.Code)
}
}
func TestMED05_InvalidJSONShouldFail(t *testing.T) {
// Invalid JSON should fail
r := router.NewRouter(router.StrategyLatency)
h := NewHandler(r)
body := `{invalid json}`
req := httptest.NewRequest("POST", "/v1/chat/completions", bytes.NewBufferString(body))
req.Header.Set("Content-Type", "application/json")
rr := httptest.NewRecorder()
h.ChatCompletionsHandle(rr, req)
// Should fail with 400 Bad Request
if rr.Code != http.StatusBadRequest {
t.Errorf("expected status 400 for invalid JSON, got %d", rr.Code)
}
}
// TestMaxBytesReaderWrapper tests the MaxBytes reader wrapper behavior
func TestMaxBytesReaderWrapper(t *testing.T) {
// Test that limiting reader works correctly
content := "hello world"
limitedReader := io.LimitReader(bytes.NewReader([]byte(content)), 5)
buf := make([]byte, 20)
n, err := limitedReader.Read(buf)
// Should only read 5 bytes
if n != 5 {
t.Errorf("expected to read 5 bytes, got %d", n)
}
if err != nil && err != io.EOF {
t.Errorf("expected no error or EOF, got %v", err)
}
// Reading again should return 0 with EOF
n2, err2 := limitedReader.Read(buf)
if n2 != 0 {
t.Errorf("expected 0 bytes on second read, got %d", n2)
}
if err2 != io.EOF {
t.Errorf("expected EOF on second read, got %v", err2)
}
}

113
gateway/internal/middleware/cors.go Normal file
View File

@@ -0,0 +1,113 @@
package middleware
import (
"net/http"
"strings"
)
// CORSConfig CORS配置
type CORSConfig struct {
AllowOrigins []string // 允许的来源域名
AllowMethods []string // 允许的HTTP方法
AllowHeaders []string // 允许的请求头
ExposeHeaders []string // 允许暴露给客户端的响应头
AllowCredentials bool // 是否允许携带凭证
MaxAge int // 预检请求缓存时间（秒）
}
// DefaultCORSConfig 返回默认CORS配置
func DefaultCORSConfig() CORSConfig {
return CORSConfig{
AllowOrigins: []string{"*"}, // 生产环境应限制具体域名
AllowMethods: []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
AllowHeaders: []string{"Authorization", "Content-Type", "X-Request-ID", "X-Request-Key"},
ExposeHeaders: []string{"X-Request-ID"},
AllowCredentials: false,
MaxAge: 86400, // 24小时
}
}
// CORSMiddleware 创建CORS中间件
func CORSMiddleware(config CORSConfig) func(http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// 处理CORS预检请求
if r.Method == http.MethodOptions {
handleCORSPreflight(w, r, config)
return
}
// 处理实际请求的CORS头
setCORSHeaders(w, r, config)
next.ServeHTTP(w, r)
})
}
}
// handleCORS Preflight 处理预检请求
func handleCORSPreflight(w http.ResponseWriter, r *http.Request, config CORSConfig) {
func handleCORS Preflight(w http.ResponseWriter, r *http.Request, config CORSConfig) {
origin := r.Header.Get("Origin")
// 检查origin是否被允许
if !isOriginAllowed(origin, config.AllowOrigins) {
w.WriteHeader(http.StatusForbidden)
return
}
// 设置预检响应头
w.Header().Set("Access-Control-Allow-Origin", origin)
w.Header().Set("Access-Control-Allow-Methods", strings.Join(config.AllowMethods, ", "))
w.Header().Set("Access-Control-Allow-Headers", strings.Join(config.AllowHeaders, ", "))
w.Header().Set("Access-Control-Max-Age", string(rune(config.MaxAge)))
if config.AllowCredentials {
w.Header().Set("Access-Control-Allow-Credentials", "true")
}
w.WriteHeader(http.StatusNoContent)
}
// setCORSHeaders 设置实际请求的CORS响应头
func setCORSHeaders(w http.ResponseWriter, r *http.Request, config CORSConfig) {
origin := r.Header.Get("Origin")
// 检查origin是否被允许
if !isOriginAllowed(origin, config.AllowOrigins) {
return
}
w.Header().Set("Access-Control-Allow-Origin", origin)
if len(config.ExposeHeaders) > 0 {
w.Header().Set("Access-Control-Expose-Headers", strings.Join(config.ExposeHeaders, ", "))
}
if config.AllowCredentials {
w.Header().Set("Access-Control-Allow-Credentials", "true")
}
}
// isOriginAllowed 检查origin是否在允许列表中
func isOriginAllowed(origin string, allowedOrigins []string) bool {
if origin == "" {
return false
}
for _, allowed := range allowedOrigins {
if allowed == "*" {
return true
}
if strings.EqualFold(allowed, origin) {
return true
}
// 支持通配符子域名 *.example.com
if strings.HasPrefix(allowed, "*.") {
domain := allowed[2:]
if strings.HasSuffix(origin, domain) {
return true
}
}
}
return false
}

172
gateway/internal/middleware/cors_test.go Normal file
View File

@@ -0,0 +1,172 @@
package middleware
import (
"net/http"
"net/http/httptest"
"testing"
)
func TestCORSMiddleware_PreflightRequest(t *testing.T) {
config := DefaultCORSConfig()
config.AllowOrigins = []string{"https://example.com"}
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
})
corsHandler := CORSMiddleware(config)(handler)
// 模拟OPTIONS预检请求
req := httptest.NewRequest("OPTIONS", "/v1/chat/completions", nil)
req.Header.Set("Origin", "https://example.com")
req.Header.Set("Access-Control-Request-Method", "POST")
req.Header.Set("Access-Control-Request-Headers", "Authorization, Content-Type")
w := httptest.NewRecorder()
corsHandler.ServeHTTP(w, req)
// 预检请求应返回204 No Content
if w.Code != http.StatusNoContent {
t.Errorf("expected status 204 for preflight, got %d", w.Code)
}
// 检查CORS响应头
if w.Header().Get("Access-Control-Allow-Origin") != "https://example.com" {
t.Errorf("expected Access-Control-Allow-Origin to be 'https://example.com', got '%s'", w.Header().Get("Access-Control-Allow-Origin"))
}
if w.Header().Get("Access-Control-Allow-Methods") == "" {
t.Error("expected Access-Control-Allow-Methods to be set")
}
}
func TestCORSMiddleware_ActualRequest(t *testing.T) {
config := DefaultCORSConfig()
config.AllowOrigins = []string{"https://example.com"}
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
})
corsHandler := CORSMiddleware(config)(handler)
// 模拟实际请求
req := httptest.NewRequest("POST", "/v1/chat/completions", nil)
req.Header.Set("Origin", "https://example.com")
w := httptest.NewRecorder()
corsHandler.ServeHTTP(w, req)
// 正常请求应通过到handler
if w.Code != http.StatusOK {
t.Errorf("expected status 200, got %d", w.Code)
}
// 检查CORS响应头
if w.Header().Get("Access-Control-Allow-Origin") != "https://example.com" {
t.Errorf("expected Access-Control-Allow-Origin to be 'https://example.com', got '%s'", w.Header().Get("Access-Control-Allow-Origin"))
}
}
func TestCORSMiddleware_DisallowedOrigin(t *testing.T) {
config := DefaultCORSConfig()
config.AllowOrigins = []string{"https://allowed.com"}
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
})
corsHandler := CORSMiddleware(config)(handler)
// 模拟来自未允许域名的请求
req := httptest.NewRequest("POST", "/v1/chat/completions", nil)
req.Header.Set("Origin", "https://malicious.com")
w := httptest.NewRecorder()
corsHandler.ServeHTTP(w, req)
// 预检请求应返回403 Forbidden
if w.Code != http.StatusForbidden {
t.Errorf("expected status 403 for disallowed origin, got %d", w.Code)
}
}
func TestCORSMiddleware_WildcardOrigin(t *testing.T) {
config := DefaultCORSConfig()
config.AllowOrigins = []string{"*"} // 允许所有来源
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
})
corsHandler := CORSMiddleware(config)(handler)
// 模拟请求
req := httptest.NewRequest("POST", "/v1/chat/completions", nil)
req.Header.Set("Origin", "https://any-domain.com")
w := httptest.NewRecorder()
corsHandler.ServeHTTP(w, req)
// 应该允许
if w.Code != http.StatusOK {
t.Errorf("expected status 200, got %d", w.Code)
}
}
func TestCORSMiddleware_SubdomainWildcard(t *testing.T) {
config := DefaultCORSConfig()
config.AllowOrigins = []string{"*.example.com"}
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
})
corsHandler := CORSMiddleware(config)(handler)
// 测试子域名
tests := []struct {
origin string
shouldAllow bool
}{
{"https://app.example.com", true},
{"https://api.example.com", true},
{"https://example.com", true},
{"https://malicious.com", false},
}
for _, tt := range tests {
req := httptest.NewRequest("POST", "/v1/chat/completions", nil)
req.Header.Set("Origin", tt.origin)
w := httptest.NewRecorder()
corsHandler.ServeHTTP(w, req)
if tt.shouldAllow && w.Code != http.StatusOK {
t.Errorf("origin %s should be allowed, got status %d", tt.origin, w.Code)
}
if !tt.shouldAllow && w.Code != http.StatusForbidden {
t.Errorf("origin %s should be forbidden, got status %d", tt.origin, w.Code)
}
}
}
func TestMED08_CORSConfigurationExists(t *testing.T) {
// MED-08: 验证CORS配置存在且可用
config := DefaultCORSConfig()
// 验证默认配置包含必要的设置
if len(config.AllowMethods) == 0 {
t.Error("default CORS config should have AllowMethods")
}
if len(config.AllowHeaders) == 0 {
t.Error("default CORS config should have AllowHeaders")
}
// 验证CORS中间件函数存在
corsMiddleware := CORSMiddleware(config)
if corsMiddleware == nil {
t.Error("CORSMiddleware should return a valid middleware function")
}
}