Validação de Entrada e Tratamento Seguro de HTML/JSON

Todo manipulador HTTP e gRPC que aceita entrada do usuário deve validar a estrutura, o tamanho e a semântica antes de acessar bancos de dados, shells ou saída HTML.

Os parsers do Go ajudam com a sintaxe, mas não impõem sua política de segurança.

Resumo

A validação de entrada em Go começa na borda do transporte (limites de tamanho do corpo, tipos de conteúdo) e continua através da decodificação tipada (encoding/json, json.Decoder, protobuf) e verificações explícitas de regras (comprimento, formato, listas de permissão).

A codificação de saída segura depende do contexto: HTML requer html/template, APIs JSON precisam de Content-Type correto e sem HTML embutido em campos de string sem codificação.

Falhas de injeção (SQL, comando, template, log) compartilham uma causa raiz: tratar dados não confiáveis como código ou estrutura.

Valide cedo, parametrize consultas e falhe com mensagens de erro seguras.

Receita

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

type CreateUser struct {
    Email string `json:"email"`
    Age   int    `json:"age"`
}
 
func decodeCreateUser(r *http.Request) (CreateUser, error) {
    r.Body = http.MaxBytesReader(nil, r.Body, 1<<20)
    dec := json.NewDecoder(r.Body)
    dec.DisallowUnknownFields()
    var u CreateUser
    if err := dec.Decode(&u); err != nil {
        return u, err
    }
    if !strings.Contains(u.Email, "@") || u.Age < 0 || u.Age > 150 {
        return u, errors.New("invalid user")
    }
    return u, nil
}

Quando usar isso:

• Manipuladores REST que aceitam corpos JSON de navegadores ou terceiros.
• Formulários de administração renderizados como HTML com nomes de exibição fornecidos pelo usuário.
• Manipuladores gRPC após a decodificação protobuf, quando os invariantes de negócio ainda precisam de verificações.
• Receptores de Webhook que devem rejeitar payloads malformados ou excessivamente grandes rapidamente.

Exemplo de Trabalho

package main
 
import (
    "database/sql"
    "encoding/json"
    "errors"
    "html/template"
    "net/http"
    "regexp"
    "strings"
 
    _ "modernc.org/sqlite"
)
 
var emailRe = regexp.MustCompile(`^[^@\s]+@[^@\s]+\.[^@\s]+$`)
 
type Profile struct {
    DisplayName string `json:"display_name"`
    Email       string `json:"email"`
}
 
func validateProfile(p Profile) error {
    p.DisplayName = strings.TrimSpace(p.DisplayName)
    if len(p.DisplayName) == 0 || len(p.DisplayName) > 64 {
        return errors.New("invalid display name")
    }
    if !emailRe.MatchString(p.Email) {
        return errors.New("invalid email")
    }
    return nil
}
 
func createProfileHandler(db *sql.DB) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        r.Body = http.MaxBytesReader(w, r.Body, 64<<10)
        dec := json.NewDecoder(r.Body)
        dec.DisallowUnknownFields()
        var p Profile
        if err := dec.Decode(&p); err != nil {
            http.Error(w, "bad request", http.StatusBadRequest)
            return
        }
        if err := validateProfile(p); err != nil {
            http.Error(w, "bad request", http.StatusBadRequest)
            return
        }
        _, err := db.Exec(
            "INSERT INTO profiles (display_name, email) VALUES (?, ?)",
            p.DisplayName, p.Email,
        )
        if err != nil {
            http.Error(w, "internal error", http.StatusInternalServerError)
            return
        }
        w.WriteHeader(http.StatusCreated)
    }
}
 
func renderProfileHandler() http.HandlerFunc {
    tmpl := template.Must(template.New("page").Parse(`<h1>{{.}}</h1>`))
    return func(w http.ResponseWriter, r *http.Request) {
        name := r.URL.Query().Get("name")
        if len(name) > 64 {
            http.Error(w, "bad request", http.StatusBadRequest)
            return
        }
        w.Header().Set("Content-Type", "text/html; charset=utf-8")
        tmpl.Execute(w, name)
    }
}
 
func main() {
    db, _ := sql.Open("sqlite", ":memory:")
    mux := http.NewServeMux()
    mux.HandleFunc("POST /profiles", createProfileHandler(db))
    mux.HandleFunc("GET /view", renderProfileHandler())
    http.ListenAndServe(":8080", mux)
}

O que isso demonstra:

• Limite de tamanho do corpo antes da decodificação JSON.
• DisallowUnknownFields para contratos de API estritos.
• Função de validação separada para regras de negócio após a análise sintática.
• SQL parametrizado com placeholders ?, não formatação de string.
• html/template com escape automático para exibição de parâmetros de consulta.

Mergulho Profundo

Como Funciona

• json.Unmarshal e json.Decoder mapeiam JSON para tipos Go; valores zero preenchem campos ausentes, a menos que você use ponteiros para detecção opcional.
• Bibliotecas de validação (go-playground/validator, funções personalizadas) são executadas após a decodificação para impor formatos, intervalos e regras entre campos.
• DisallowUnknownFields rejeita chaves JSON extras - útil para APIs públicas; às vezes relaxado para APIs internas compatíveis com versões futuras.
• O contexto HTML requer codificação ciente do contexto; html/template lida com o texto do elemento, enquanto contextos JavaScript ou URL precisam de regras mais rigorosas ou CSP.
• A segurança SQL é inteiramente sobre placeholders: db.Query("SELECT * FROM users WHERE id = ?", id) nunca interpola strings do usuário no texto da consulta.

Camadas de Validação

Notas do Go

// Evite atribuição em massa: use DTOs separados para criar vs. atualizar
type PublicCreateOrder struct {
    SKU      string `json:"sku"`
    Quantity int    `json:"quantity"`
    // sem Status, sem UserID - o servidor define esses
}

Armadilhas

• Confiar no JSON apenas após a descompactação - JSON válido ainda pode conter Age: -1 impossível ou Role: "admin". Sempre execute validação semântica.
• Atribuição em massa de JSON do cliente - Vincular diretamente a modelos de banco de dados expõe campos que os clientes não devem definir (is_admin, owner_id). Use DTOs de entrada.
• text/template para HTML - Renderiza entrada bruta do usuário e permite XSS. Use html/template ou retorne apenas JSON.
• fmt.Sprintf SQL - fmt.Sprintf("SELECT * FROM t WHERE id = %s", id) é injetável. Use placeholders sempre.
• Refletir erros internos - Retornar err.Error() de drivers de banco de dados vaza dicas de esquema. Registre internamente; responda com mensagens genéricas.
• Ignorar string vazia vs. ausente - JSON "" e campo omitido ambos se tornam "" em campos string. Use ponteiros ou sql.NullString quando a distinção for importante.
• Injeção de log - Escrever entrada do usuário literalmente em logs pode forjar linhas de log falsas. Limpe ou registre estruturalmente com escape.

Alternativas

FAQs

Relacionados

• Noções Básicas de Segurança em Go - limites de corpo e introdução a html/template
• Padrões de Autenticação e Autorização - autorização após validação
• Cookies Seguros e CSRF para Aplicativos Web - riscos de entrada específicos do navegador
• Segurança para Serviços Go: Padrões e Lacunas - validação como uma lacuna de aplicação
• Resumo das Melhores Práticas de Segurança - itens de verificação de validação

Versões da 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 (mais recente - verifique na compilação), gin (mais recente - verifique na compilação), echo (mais recente - verifique na compilação), google.golang.org/grpc (mais recente - verifique na compilação), sigs.k8s.io/controller-runtime (mais recente - verifique na compilação), kubebuilder (mais recente - verifique na compilação), tinygo (mais recente - verifique os alvos de placa na compilação), wazero (mais recente - verifique na compilação) e golangci-lint (mais recente - verifique na compilação).