Imagina una tarea clásica: estás construyendo un API Gateway ligero en Go. El servicio recibe la petición del cliente, valida el token JWT y reenvía la petición a un microservicio interno. Para que el backend sepa quién está autorizado, el proxy adjunta una cabecera interna con el ID del usuario.
Durante años, muchos desarrolladores resolvieron esto de la misma forma: tomaban el confiable httputil.ReverseProxy de la biblioteca estándar y configuraban en él el campo Director. Pero si en tu entorno de producción sigue corriendo un código así, hay una grieta seria en la seguridad del sistema.
Así lucía este patrón habitual, pero vulnerable:
package main
import (
"net/http"
"net/http/httputil"
"net/url"
)
func NewLegacyProxy(target *url.URL) *httputil.ReverseProxy {
proxy := httputil.NewSingleHostReverseProxy(target)
originalDirector := proxy.Director
proxy.Director = func(req *http.Request) {
originalDirector(req)
// Pasamos el ID del usuario al servicio interno
req.Header.Set("X-App-User", "authorized-user-id")
}
return proxy
}
Parecería que aquí no puede fallar nada, ¿verdad? Fijamos explícitamente la cabecera antes de enviarla. Sin embargo, en cierto momento el servicio empieza a recibir valores vacíos y la autorización falla misteriosamente.
Anatomía del bug: la traicionera cabecera Connection
Para entender la causa, echemos un vistazo bajo el capó de httputil.ReverseProxy y recordemos los estándares HTTP (RFC 7230 y RFC 9110).
En el protocolo existe el concepto de cabeceras hop-by-hop (de salto a salto). Campos como Keep-Alive, Upgrade y Connection solo tienen sentido para una única conexión de red, y el proxy está obligado a limpiarlos antes de reenviar la petición.
Pero lo más interesante es que el estándar permite al cliente listar en Connection los nombres de cualquier otra cabecera, exigiendo que se consideren de tránsito.
Ahora mira el orden fatal de operaciones en el antiguo ReverseProxy:
- El proxy llama a tu función
Director(req)y tú añadesreq.Header.Set("X-App-User", "authorized-user-id"). - Después de esto, el código estándar de Go limpia los campos hop-by-hop: lee la cabecera
Connection, encuentra en ella los nombres de los campos y los recorta de la petición saliente.
Si un cliente externo envía una petición entrante con la cabecera:
GET /api/profile HTTP/1.1
Host: api.example.com
Connection: X-App-User
entonces Director añadirá fielmente la cabecera del usuario, pero el algoritmo interno de Go la borrará sin dejar rastro en el paso siguiente. El backend recibirá una petición anónima, abriendo la puerta a evadir la autenticación.
El esquema seguro con Rewrite
A partir de Go 1.20, el campo Director quedó obsoleto y en su lugar llegó la interfaz Rewrite.
En Rewrite invirtieron el orden:
- El proxy clona la petición entrante
r.Inen la salienter.Out. - Todas las cabeceras hop-by-hop y los campos listados en
Connectionse eliminan der.Outantes de llamar a tu código. - Se eliminan campos de tránsito como
ForwardedyX-Forwarded-*para proteger contra el spoofing de IP. - Se ejecuta tu callback
Rewrite(r).
Ahora la cabecera añadida en r.Out.Header llegará al backend con total garantía:
package main
import (
"net/http/httputil"
"net/url"
)
func NewSecureProxy(target *url.URL) *httputil.ReverseProxy {
return &httputil.ReverseProxy{
Rewrite: func(r *httputil.ProxyRequest) {
r.SetURL(target)
r.Out.Header.Set("X-App-User", "authorized-user-id")
r.SetXForwarded()
},
}
}
El método r.SetURL(target) sobrescribe r.Out.Host con la dirección de destino. Si el backend espera el host original, indica r.Out.Host = r.In.Host. Y nunca definas Director y Rewrite al mismo tiempo: Go responderá con un panic inmediato.
El objeto entrante r.In dentro de Rewrite es de solo lectura. Migrar a Rewrite lleva un par de líneas, pero cierra para siempre el problema de la pérdida silenciosa de cabeceras internas.

