Rate Limiting, CORS & Security Headers

Middleware de borda em serviços Go reduz abusos, define a política cross-origin do navegador e define cabeçalhos de resposta que endurecem clientes contra ataques web comuns.

Nenhum desses substitui autenticação ou validação de entrada, mas eles reduzem o raio de explosão quando algo mais está mal configurado.

Resumo

Rate limiting (limitação de taxa) limita quantas requisições um cliente pode fazer em uma janela de tempo, protegendo CPU, conexões de banco de dados e quotas downstream.

CORS informa aos navegadores quais JavaScripts cross-origin podem ler respostas - ele não bloqueia clientes não-navegadores.

Security headers (cabeçalhos de segurança) instruem os navegadores a impor HTTPS, restringir framing e limitar o carregamento de scripts e recursos.

Implemente os três como wrappers http.Handler que você aplica consistentemente, inclusive em caminhos de erro.

Receita

Cartão de receita de referência rápida - pronto para copiar e colar.

func securityHeaders(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("X-Content-Type-Options", "nosniff")
        w.Header().Set("X-Frame-Options", "DENY")
        w.Header().Set("Referrer-Policy", "strict-origin-when-cross-origin")
        w.Header().Set("Content-Security-Policy", "default-src 'self'")
        next.ServeHTTP(w, r)
    })
}

Quando usar isso:

• APIs HTTP públicas expostas à internet ou integrações de parceiros.
• Backends Go voltados para o navegador servindo SPAs ou envios de formulário.
• Serviços atrás de um balanceador de carga onde o aplicativo ainda é responsável por CORS e cabeçalhos de segurança.
• Endpoints vulneráveis a credential stuffing, scraping ou computação cara por requisição.

Exemplo de Trabalho

package main
 
import (
    "net/http"
    "strings"
    "sync"
    "time"
)
 
var allowedOrigins = map[string]bool{
    "https://app.example.com": true,
}
 
func cors(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        origin := r.Header.Get("Origin")
        if allowedOrigins[origin] {
            w.Header().Set("Access-Control-Allow-Origin", origin)
            w.Header().Set("Vary", "Origin")
            w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
            w.Header().Set("Access-Control-Allow-Headers", "Authorization, Content-Type")
            w.Header().Set("Access-Control-Max-Age", "600")
        }
        if r.Method == http.MethodOptions {
            w.WriteHeader(http.StatusNoContent)
            return
        }
        next.ServeHTTP(w, r)
    })
}
 
type ipLimiter struct {
    mu      sync.Mutex
    buckets map[string]*tokenBucket
}
 
type tokenBucket struct {
    tokens float64
    last   time.Time
}
 
func (l *ipLimiter) allow(key string, rate float64, burst float64) bool {
    l.mu.Lock()
    defer l.mu.Unlock()
    b, ok := l.buckets[key]
    now := time.Now()
    if !ok {
        b = &tokenBucket{tokens: burst, last: now}
        l.buckets[key] = b
    }
    elapsed := now.Sub(b.last).Seconds()
    b.tokens = min(burst, b.tokens+elapsed*rate)
    b.last = now
    if b.tokens < 1 {
        return false
    }
    b.tokens--
    return true
}
 
func rateLimit(l *ipLimiter, next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ip := strings.Split(r.RemoteAddr, ":")[0]
        if !l.allow(ip, 5, 10) {
            w.Header().Set("Retry-After", "1")
            http.Error(w, "too many requests", http.StatusTooManyRequests)
            return
        }
        next.ServeHTTP(w, r)
    })
}
 
func securityHeaders(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Strict-Transport-Security", "max-age=31536000; includeSubDomains")
        w.Header().Set("X-Content-Type-Options", "nosniff")
        w.Header().Set("X-Frame-Options", "DENY")
        w.Header().Set("Referrer-Policy", "strict-origin-when-cross-origin")
        w.Header().Set("Content-Security-Policy", "default-src 'self'; frame-ancestors 'none'")
        next.ServeHTTP(w, r)
    })
}
 
func main() {
    limiter := &ipLimiter{buckets: make(map[string]*tokenBucket)}
    mux := http.NewServeMux()
    mux.HandleFunc("/api/data", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte(`{"ok":true}`))
    })
    handler := securityHeaders(cors(rateLimit(limiter, mux)))
    http.ListenAndServe(":8080", handler)
}
 
func min(a, b float64) float64 {
    if a < b {
        return a
    }
    return b
}

O que isso demonstra:

• Lista de permissões explícita de CORS com Vary: Origin e tratamento de preflight OPTIONS.
• Limitador de taxa de bucket de tokens em memória com chave pelo IP do cliente.
• Cabeçalhos de segurança incluindo HSTS e CSP em todos os caminhos de resposta.
• Ordem de composição de middleware: limite de taxa dentro do CORS dentro dos cabeçalhos de segurança (ajuste por implantação).

Aprofundamento

Como Funciona

• Limitadores de taxa rastreiam o consumo por chave (IP, chave de API, ID de usuário).

O bucket de tokens permite rajadas enquanto mantém a taxa média.

Implantações distribuídas precisam de limites em nível de Redis ou gateway - mapas em memória são apenas por processo.

• CORS se aplica apenas quando os navegadores enviam um cabeçalho Origin.

Permitir * com credenciais é inválido.

Refletir valores de Origin arbitrários permite roubo de dados cross-site com credenciais.

• Cabeçalhos de segurança são consultivos, exceto HSTS (após a primeira visita HTTPS).

CSP reduz o impacto do XSS bloqueando scripts inline, a menos que sejam nonced.

X-Content-Type-Options: nosniff impede ataques de MIME sniffing.

Referência de Cabeçalhos

Posicionamento do Rate Limit

Notas Go

// Atrás de proxy reverso: confie em X-Forwarded-For apenas de IPs de LB conhecidos
func clientIP(r *http.Request, trusted bool) string {
    if trusted {
        if xff := r.Header.Get("X-Forwarded-For"); xff != "" {
            return strings.TrimSpace(strings.Split(xff, ",")[0])
        }
    }
    host, _, _ := net.SplitHostPort(r.RemoteAddr)
    return host
}

Armadilhas

• Curinga CORS com credenciais - Access-Control-Allow-Origin: * não pode ser usado com Allow-Credentials: true. Use origens explícitas.
• Refletindo cabeçalho Origin - Allow-Origin: r.Header.Get("Origin") dinâmico sem lista de permissões é igual a CORS aberto. Sempre mapeie contra um conjunto.
• Rate limit por RemoteAddr bruto atrás de LB - Todo o tráfego aparece como um único IP. Analise X-Forwarded-For apenas quando o proxy remover valores de cliente não confiáveis.
• Pular cabeçalhos em erros - http.Error ignora o middleware se você o chamar antes do wrapper. Garanta que o middleware de cabeçalhos envolva toda a árvore de handlers.
• HSTS em desenvolvimento apenas HTTP - HSTS em http://localhost pode confundir testes locais. Habilite HSTS apenas em listeners TLS de produção.
• CSP quebrando ativos de SPA - default-src 'self' bloqueia scripts de CDN. Ajuste CSP por implantação ou use nonces para scripts inline.
• OPTIONS sem rate limit - Atacantes podem inundar preflights. Aplique limites a OPTIONS ou trate CORS no gateway.

Alternativas

FAQs

Relacionado

• Noções Básicas de Segurança Go - timeouts de servidor complementam limites de taxa
• Cookies Seguros & CSRF para Aplicativos Web - endurecimento de sessão do navegador
• Padrões de Autenticação & Autorização - limites de taxa por usuário após autenticação
• Segurança para Serviços Go: Padrões e Lacunas - camada de borda em defesa em profundidade
• Resumo das Melhores Práticas de Segurança - itens de checklist de cabeçalhos e CORS

Versões de Stack: Esta página foi escrita para Go 1.26.x (GC padrão Green Tea, go fix modernizers - verifique o patch na compilação), chi (última versão - verifique na compilação), gin (última versão - verifique na compilação), echo (última versão - verifique na compilação), google.golang.org/grpc (última versão - verifique na compilação), sigs.k8s.io/controller-runtime (última versão - verifique na compilação), kubebuilder (última versão - verifique na compilação), tinygo (última versão - verifique os alvos de placa na compilação), wazero (última versão - verifique na compilação) e golangci-lint (última versão - verifique na compilação).