La trampa de httputil.ReverseProxy en Go: por qué Director pierde las cabecerasArtículo · digest del 20 de octubre
Corte arquitectónico de un API Gateway en isometría de 45°: un filtro estricto descarta las cabeceras de tránsito antes de reenviar la petición al microservicio en Go.
Artículo2 secciones≈ 4 min

La trampa de httputil.ReverseProxy en Go: por qué Director pierde las cabeceras

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:

  1. El proxy llama a tu función Director(req) y tú añades req.Header.Set("X-App-User", "authorized-user-id").
  2. 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:

  1. El proxy clona la petición entrante r.In en la saliente r.Out.
  2. Todas las cabeceras hop-by-hop y los campos listados en Connection se eliminan de r.Out antes de llamar a tu código.
  3. Se eliminan campos de tránsito como Forwarded y X-Forwarded-* para proteger contra el spoofing de IP.
  4. 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()
        },
    }
}
Trampas durante la migración

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.

Quiero un análisis detalladoLos votos ayudan a elegir qué analizar a fondo. Este material tiene 0 votos.
Fuentes · 2