Cualquier desarrollador backend que diseñe endpoints HTTP públicos tiene la obligación de proteger el servidor contra ataques de denegación de servicio (Denial of Service). Si tu handler llama a ciegas a io.ReadAll(r.Body) o pasa el flujo entrante directo a json.NewDecoder(r.Body), a un atacante le basta con enviar un HTTP POST con un cuerpo de 5 gigabytes para que el servidor asigne toda la RAM disponible y caiga por Out of Memory (OOM).
La defensa parece obvia: limitar la cantidad máxima de bytes que el servidor acepta leer del cuerpo de la petición. Pero justo en ese paso miles de desarrolladores en Go cometen un error de base: echan mano de la utilidad estándar io.LimitReader.
A primera vista, io.LimitReader encaja como un guante. Sin embargo, en producción real ese wrapper ingenuo se convierte en una mina de acción retardada.
Anatomía del error: por qué io.LimitReader oculta el exceso de límite
Echemos un vistazo a cómo funciona io.LimitReader en la biblioteca estándar de Go. Este lector es extremadamente simple: envuelve un io.Reader subyacente y lee de él como máximo N bytes. En cuanto se alcanza el límite, cualquier llamada posterior a Read() devuelve 0, io.EOF.
¿Notas dónde está el truco?
Para un decodificador como json.NewDecoder o una función como io.ReadAll, recibir io.EOF significa el fin normal y esperado del flujo de datos.
Imagina que un cliente envía un JSON de 2 megabytes cuando el límite es de 1 megabyte:
io.LimitReaderlee obedientemente el primer megabyte y se detiene.- El decodificador JSON intenta seguir leyendo el objeto, tropieza con
io.EOFjusto en mitad de la estructura y devuelve un error banal de sintaxis:unexpected EOFosyntax error. - Tu handler captura ese error y devuelve al cliente un estado
HTTP 400 Bad Request.
El resultado es un doble fallo de lógica:
- El servidor no se entera de que ha sufrido un ataque o ha recibido un archivo demasiado grande, y registra falsos errores de sintaxis en los logs.
- El cliente legítimo recibe un mensaje engañoso de «JSON mal formado» en lugar del código honesto
HTTP 413 Payload Too Large. - Y lo peor de todo: si el cuerpo se cortó justo en el límite de un campo anidado válido, el parser podría tragarse el objeto truncado y el servidor acabaría guardando un registro mutilado en la base de datos.
La herramienta adecuada: net/http.MaxBytesReader
Para resolver esto como es debido, la biblioteca estándar de Go ofrece la función especializada http.MaxBytesReader.
A diferencia del primitivo io.LimitReader, http.MaxBytesReader está diseñada expresamente para trabajar junto con http.ResponseWriter:
- Si se supera el límite establecido aunque sea por un solo byte, la siguiente llamada a
Read()devuelve un error tipado*http.MaxBytesError. - La función activa automáticamente una marca interna en la conexión de red del servidor, impidiendo que el handler siga leyendo del socket.
- El servidor cierra la conexión correctamente o envía la cabecera
Connection: close, evitando que el cliente siga volcando bytes inútiles en el canal.
Aquí tienes un handler de referencia para recibir JSON de forma segura:
package main
import (
"encoding/json"
"errors"
"fmt"
"net/http"
)
type UserPayload struct {
Name string `json:"name"`
Email string `json:"email"`
}
func handleUserRegistration(w http.ResponseWriter, r *http.Request) {
// Límite estricto del tamaño del cuerpo: máximo 1 MB
const maxUploadSize = 1024 * 1024
r.Body = http.MaxBytesReader(w, r.Body, maxUploadSize)
var payload UserPayload
decoder := json.NewDecoder(r.Body)
decoder.DisallowUnknownFields()
if err := decoder.Decode(&payload); err != nil {
var maxBytesErr *http.MaxBytesError
if errors.As(err, &maxBytesErr) {
// Aviso honesto de que se ha superado el tamaño permitido
http.Error(w, fmt.Sprintf("El cuerpo de la petición supera el límite permitido de %d bytes", maxBytesErr.Limit), http.StatusRequestEntityTooLarge)
return
}
http.Error(w, fmt.Sprintf("Sintaxis JSON incorrecta: %v", err), http.StatusBadRequest)
return
}
w.WriteHeader(http.StatusOK)
w.Write([]byte(`{"status":"success"}`))
}
Fíjate en la comprobación errors.As(err, &maxBytesErr): te permite distinguir con precisión un exceso de cuota de un fallo real de sintaxis en el JSON.
Creación de un HTTP Middleware universal
Si tu servicio tiene decenas de endpoints, repetir la configuración del límite en cada handler resulta pesado y fácil de olvidar. Es mucho más fiable extraer esa lógica a un HTTP Middleware global:
package main
import (
"net/http"
)
// LimitBodySizeMiddleware limita el tamaño de los cuerpos de petición entrantes en todas las rutas
func LimitBodySizeMiddleware(maxBytes int64) func(http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// Limitamos la lectura solo en métodos que transportan carga útil
if r.Method == http.MethodPost || r.Method == http.MethodPut || r.Method == http.MethodPatch {
r.Body = http.MaxBytesReader(w, r.Body, maxBytes)
}
next.ServeHTTP(w, r)
})
}
}
Ya analizamos matices de sistema en el manejo de memoria en el artículo el problema de los major page faults en Go: por qué la llamada al sistema mmap puede ralentizar un programa, y controlar los búferes de red es otra pieza fundamental para la estabilidad del servicio.
Usa las herramientas especializadas de la plataforma para lo que fueron hechas: cambiar una sola línea de código librará a tu servicio de errores fantasma ocultos y hará que tu API sea predecible para los clientes externos.

