Validación de Entradas y Manejo Seguro de HTML/JSON

Cada manejador HTTP y gRPC que acepta entradas de usuario debe validar la estructura, el tamaño y la semántica antes de tocar bases de datos, shells o salidas HTML.

Los analizadores de Go ayudan con la sintaxis, pero no imponen tu política de seguridad.

Resumen

La validación de entradas en Go comienza en el borde del transporte (límites de tamaño del cuerpo, tipos de contenido) y continúa a través de la decodificación tipada (encoding/json, json.Decoder, protobuf) y verificaciones explícitas de reglas (longitud, formato, listas de permitidos).

La codificación de salida segura depende del contexto: HTML necesita html/template, las API JSON necesitan un Content-Type correcto y ningún HTML incrustado en campos de cadena sin codificar.

Las vulnerabilidades de inyección (SQL, comandos, plantillas, logs) comparten una causa raíz: tratar datos no confiables como código o estructura.

Valida temprano, parametriza consultas y falla con mensajes de error seguros.

Receta

Tarjeta de receta de referencia rápida - lista para copiar y pegar.

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
}

Cuándo usar esto:

• Manejadores REST que aceptan cuerpos JSON de navegadores o terceros.
• Formularios de administración renderizados como HTML con nombres de visualización proporcionados por el usuario.
• Manejadores gRPC después de la decodificación protobuf, cuando las invariantes de negocio aún necesitan verificaciones.
• Receptores de Webhook que deben rechazar rápidamente cargas útiles mal formadas o sobredimensionadas.

Ejemplo de Trabajo

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)
}

Lo que esto demuestra:

• Límite de tamaño del cuerpo antes de la decodificación JSON.
• DisallowUnknownFields para contratos de API estrictos.
• Función de validación separada para reglas de negocio después del análisis sintáctico.
• SQL parametrizado con marcadores de posición ?, no formato de cadena.
• html/template auto-escapado para la visualización de parámetros de consulta.

Inmersión Profunda

Cómo Funciona

• json.Unmarshal y json.Decoder mapean JSON a tipos Go; los valores cero rellenan los campos faltantes a menos que uses punteros para la detección opcional.
• Las bibliotecas de validación (go-playground/validator, funciones personalizadas) se ejecutan después de la decodificación para forzar formatos, rangos y reglas entre campos.
• DisallowUnknownFields rechaza claves JSON adicionales; útil para API públicas; a veces se relaja para API internas compatibles con versiones futuras.
• El contexto HTML requiere codificación consciente del contexto; html/template maneja el texto de los elementos, mientras que los contextos JavaScript o URL necesitan reglas más estrictas o CSP.
• La seguridad SQL se basa completamente en marcadores de posición: db.Query("SELECT * FROM users WHERE id = ?", id) nunca interpola cadenas de usuario en el texto de la consulta.

Capas de Validación

Notas de Go

// Evita la asignación masiva: usa DTOs separados para crear vs. actualizar
type PublicCreateOrder struct {
    SKU      string `json:"sku"`
    Quantity int    `json:"quantity"`
    // no Status, no UserID - el servidor los establece
}

Errores Comunes

• Confiar solo en JSON después de la deserialización - Un JSON válido aún puede contener Age: -1 imposible o Role: "admin". Ejecuta siempre la validación semántica.
• Asignación masiva desde JSON del cliente - Vincular directamente a modelos de base de datos expone campos que los clientes no deben establecer (is_admin, owner_id). Usa DTOs de entrada.
• text/template para HTML - Renderiza entrada de usuario sin procesar y habilita XSS. Usa html/template o devuelve solo JSON.
• fmt.Sprintf SQL - fmt.Sprintf("SELECT * FROM t WHERE id = %s", id) es inyectable. Usa siempre marcadores de posición.
• Reflejar errores internos - Devolver err.Error() de los controladores de base de datos filtra pistas del esquema. Registra internamente; responde con mensajes genéricos.
• Omitir cadena vacía vs. faltante - JSON "" y campo omitido ambos se convierten en "" en campos string. Usa punteros o sql.NullString cuando la distinción sea importante.
• Inyección de logs - Escribir la entrada del usuario textualmente en los logs puede falsificar líneas de log. Sanea o registra estructuradamente con escape.

Alternativas

Preguntas Frecuentes

Relacionado

• Conceptos Básicos de Seguridad en Go - límites del cuerpo e introducción a html/template
• Patrones de Autenticación y Autorización - autorización después de la validación
• Cookies Seguras y CSRF para Aplicaciones Web - riesgos de entrada específicos del navegador
• Seguridad para Servicios Go: Valores Predeterminados y Brechas - validación como brecha de aplicación
• Resumen de Mejores Prácticas de Seguridad - elementos de la lista de verificación de validación

Versiones de Stack: Esta página fue escrita para Go 1.26.x (GC predeterminado de Green Tea, go fix modernizers - verificar parche en la compilación), chi (última versión - verificar en la compilación), gin (última versión - verificar en la compilación), echo (última versión - verificar en la compilación), google.golang.org/grpc (última versión - verificar en la compilación), sigs.k8s.io/controller-runtime (última versión - verificar en la compilación), kubebuilder (última versión - verificar en la compilación), tinygo (última versión - verificar objetivos de placa en la compilación), wazero (última versión - verificar en la compilación) y golangci-lint (última versión - verificar en la compilación).