llamaCVEVulnerability Intelligence
/
Advisory · GitHub · Go · github.com/gotenberg/gotenberg/v8

GHSA-8G49-V2H4-F554

The WebSocket handshake path evaluates the operator's outbound deny list against the pinning proxy's authority-only CONNECT URL, so a rule that anchors on a path or on the wss:// scheme does not match a tunnel that the same rule refuses as an ordinary request

Parche disponible
Descargar PNG JSON
CVSS 3.1
7.2
Alta
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:L/I:L/A:N Fuente: GitHub
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
Parche2 versionesPrimer parche a -16 d de la divulgación
Exposición10 dDesde la divulgación, 11 nov 2026, 2:18 a. m.
Detección7 dDesde la divulgación hasta su ingreso al índice
Decisión estimadaSeguir
Remediar en la ventana regular de mantenimiento
Estimación de Llama con el árbol SSVC de CISA a partir de vector CVSS 3.1 y la evidencia de explotación (sin evaluación oficial): sin explotación conocida, automatizable e impacto técnico parcial. Hay versiones corregidas disponibles.
Hoy es tranquila, pero podría madrugarte.Seguimiento de cerca: yo sé de mirar de cerca.
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Explotación
Remediación
Parche v8.39.0
Monitoreo
Detectada +1
26 oct 26
11 nov 26
18 nov 26
21 nov 26
26 oct 26
1 nov 26
8 nov 26
14 nov 26
21 nov 26
FechaFaseEventoDetalle
Remediación Parche v8.39.0 github.com/gotenberg/gotenberg/v8 · -16 d desde divulgación
Divulgación Publicada GHSA-8G49-V2H4-F554 divulgada · CVSS 7.2 (GitHub)
Monitoreo Detectada Ingresó al índice
Monitoreo Verificada Última verificación contra las fuentes
Resumen
Descripción del advisory
Texto original · GitHub · en inglés
Summary

Gotenberg's Chromium pinning proxy is the enforcement point for the operator's --chromium-allow-list / --chromium-deny-list. Its two paths evaluate that policy against different URL shapes for the same destination:

  • the forward path validates the full absolute URI (pkg/modules/chromium/pinning_proxy.go:462);
  • the CONNECT path -- which every HTTPS sub-resource and every TLS WebSocket traverses -- validates an authority-only URL, "https://" + req.Host (pkg/modules/chromium/pinning_proxy.go:241).

A deny rule that terminates on a path (^https?://host/ or ^https?://host/path) is therefore enforced for plain requests and silently not applied to WebSocket handshakes, because Chromium never surfaces a handshake as a fetch.EventRequestPaused (pkg/modules/chromium/events.go:56-68) and the WebSocket listener can only record a warning (pkg/modules/chromium/events.go:85-91). For handshakes, the proxy's CONNECT verdict is the only enforcement point.

A rendered page can open a wss:// tunnel to a host the operator's deny list names, and read the response through it.

Severity: high (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:L/I:L/A:N, 7.2).

Relationship to GHSA-73vq-mh8c-27wg: that advisory (medium, 2026-10-15) covered WebSocket handshakes bypassing the outbound allow-list entirely, and was fixed in 8.38.0 by routing loopback handshakes through the pinning proxy and filtering handshakes against the policy. This report is the residual rule-shape gap in the enforcement point that advisory relies on: the CONNECT verdict still evaluates an authority-only URL, so rule shapes that URL cannot express remain unenforceable on the handshake path. The two defects are distinct, and the fix for GHSA-73vq does not address this one.

Details

Same-version behavioural divergence

pkg/modules/chromium/events.go:132
err := gotenberg.FilterOutboundURL(ctx, e.Request.URL, options.allowList, options.denyList, deadline, ...)
if err != nil { allow = false }
pkg/modules/chromium/events.go:168
req := fetch.FailRequest(e.RequestID, network.ErrorReasonAccessDenied)

The CDP Fetch layer evaluates the operator's lists against the FULL request URL and refuses the request with net::ERR_ACCESS_DENIED. fetch.Enable() is unconditional and the listener is registered per conversion, so every ordinary page load and every HTTP(S) sub-resource is refused before the browser issues the CONNECT.

pkg/modules/chromium/events.go:56-68
Chromium never surfaces a WebSocket handshake as a fetch.EventRequestPaused, so without this
listener a page could open a WebSocket to an address the outbound filter would otherwise block.

pkg/modules/chromium/events.go:85-91
err := gotenberg.FilterOutboundURL(ctx, e.URL, options.allowList, options.denyList, deadline, ...)
if err != nil { logger.WarnContext(ctx, err.Error()) }

The WebSocket listener evaluates the same lists but only records a warning: a handshake cannot be aborted through the CDP Network domain. Its own comment states that "the connection is severed by the pinning proxy, which every WebSocket handshake traverses" - so for a handshake, the proxy's CONNECT verdict is the enforcement point by design.

pkg/modules/chromium/pinning_proxy.go:241
decision, err := p.decide(req.Context(), "https://"+req.Host, p.allowList, p.denyList, deadline)

The CONNECT verdict is computed on an authority-only URL, so a rule that anchors on a path cannot match it.

The consequence is a divergence between the two enforcement layers of the same control in the same version: the same destination, under the same deny rule, is refused when it is fetched as an ordinary request and admitted when it is reached as a WebSocket handshake.

Which rule shapes are affected:

  • AFFECTED: rules that require a path or a query, e.g. ^https?://host/ or ^https?://host/path. The authority-only URL "https://host:443" cannot match them.
  • AFFECTED: rules anchored on the wss:// scheme, e.g. ^wss://host/ - CONNECT forces the https:// scheme, so the pattern cannot match.
  • NOT AFFECTED: host-terminated rules of the documented form, e.g. ^https?://host(:|/|$) - the authority-only URL still matches those, and the flag help teaches exactly that form for the allow list (pkg/modules/chromium/chromium.go:482).
  • NOT AFFECTED: the IP-class flags --chromium-deny-private-ips / --chromium-deny-public-ips, which inspect the resolved address rather than the URL. The observable blind spot is therefore the list-only configuration described in GHSA-73vq-mh8c-27wg.

The shipped default --chromium-deny-list entry is ^file:(?!//\/tmp/).* (pkg/modules/chromium/chromium.go:100-102), which covers file:// URLs only and can never match a CONNECT target. On the factory defaults there is no HTTP(S) egress policy, so the asymmetry has nothing to act on; it becomes observable as soon as an operator adds an HTTP(S) deny rule, which is the documented purpose of the flag.

Proof of concept

Reproduction, performed locally against the unmodified source at e4ee0f29 (v8.38.1). The two halves of the chain were verified separately, each with a discriminator that shows the traffic passed through the component under test; the end-to-end run that joins them is the reproduction for a real deployment, given in the last step.

Configuration

--chromium-deny-list "^https?://denied\\.example/"
# --chromium-deny-private-ips and --chromium-deny-public-ips left at their default false
# (a path-terminated rule: the shape the authority-only CONNECT URL cannot match)

HALF 1 - the proxy side, with the real code

The pinning proxy's CONNECT handler was driven with the production gotenberg.DecideOutbound and the real handleConnect, against a local listener standing in for the denied host. The same deny rule was applied to both paths:

forward status = 403 (the deny rule blocked the plain-HTTP request)
CONNECT status = "HTTP/1.1 200 OK" (the tunnel to the same host and port was admitted)
upstream reached through the tunnel: "HT" (the denied host's own response bytes came back)

The two inputs differ only in shape: the forward path validates the full absolute URI (pinning_proxy.go:462), the CONNECT path validates "https://"+req.Host (pinning_proxy.go:241). The negative control: a host-terminated rule of the documented form refuses the CONNECT target as well, so the gap is specific to the rule shapes the authority-only URL cannot express.

HALF 2 - the browser side, with a real Chromium

A real Chromium 151 was driven through the real pinning proxy and the real Gotenberg Fetch listener, with the proxy's own dialer instrumented so that a dial to the denied host's port can only be produced by the proxy:

CDP fetch.requestPaused URLs = [https://denied.example/secret] (the ordinary request reached the Fetch layer)
CDP network.webSocketCreated = [wss://denied.example/ws] (the handshake only reached the Network domain)
denied host: http hits=0 (the ordinary request never arrived)

So the handshake does not surface as a fetch.EventRequestPaused, the Fetch layer never sees it, and the deny rule is never applied to it. The Fetch layer did apply the rule to the ordinary request, and the denied host confirms it: it received nothing.

WHAT WAS NOT JOINED ON THE AUDIT HOST, AND HOW TO JOIN IT

On the audit host the two halves could not be observed in a single run: the handshake was never delivered to the proxy there, so the run showed the proxy dialling no port at all. That is an environment limitation of the audit host (a loopback target is reachable by the browser directly, and the host allows neither a non-loopback target nor a host alias), not a property of the defect. The step below therefore joins the two halves on a real deployment.

REPRODUCTION ON A REAL DEPLOYMENT

  1. Configure the deny list as above and start Gotenberg with the Chromium module enabled. The default deny-list entry only covers file:// URLs, so the path-terminated rule has to be added explicitly.
  2. Serve a page that opens a TLS WebSocket to the denied host and, in the same page, fetches an ordinary HTTPS resource from it:

<script>
new WebSocket("wss://denied.example/ws");
fetch("https://denied.example/secret");
</script>

  1. Convert that page with POST /forms/chromium/convert/html.
  2. Observe: the ordinary fetch is refused (the request never leaves the host), while the WebSocket handshake is established and the page can read the response.

To confirm the handshake really went through the pinning proxy rather than around it, look for the CONNECT on the proxy side - the proxy logs a refusal with "CONNECT blocked for '<host>:<port>'" when a rule matches, and the proxy's own dial of the denied host's port is the discriminator that separates a proxied tunnel from a direct connection. A plain-HTTP request to the same host is the control: it is refused, and the host logs no request.

Impact

An unauthenticated caller who can submit a Chromium conversion request controls the HTML that is rendered, and therefore controls the WebSocket handshake. The operator's outbound deny list -- the control they rely on to keep a rendered page away from internal services, a cloud instance metadata endpoint, or any other host their policy names -- is not applied to that handshake.

The response body travels back through the tunnel to the rendered page and is therefore readable by the caller, so this is a readable SSRF primitive rather than a blind one. What it yields depends on the deployment: an internal service, a cloud instance metadata endpoint, or an otherwise unreachable host.

Scope of the bypass:

  • It only affects rule shapes the authority-only CONNECT URL cannot match: path-terminated rules (^https?://host/, ^https?://host/path) and rules anchored on the wss:// scheme. Host-terminated rules of the documented (:|/|$) form are unaffected.
  • It only affects the WebSocket handshake path. Ordinary page loads and HTTP(S) sub-resources are refused by the CDP Fetch layer with net::ERR_ACCESS_DENIED before the pinning proxy is involved.
  • The IP-class flags (--chromium-deny-private-ips / --chromium-deny-public-ips), when enabled, still refuse a private destination, because they inspect the resolved address rather than the URL. The gap is observable in the list-only configuration, which is the configuration described in GHSA-73vq-mh8c-27wg.

The attacker holds no privilege: basic-auth and OIDC are opt-in and default off, so the conversion request is normally anonymous.

Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.

Vector CVSS 3.1

Desglose de métricas

Opción resaltada = valor del vector · izquierda = peor caso · GitHub
Vector de ataqueAV:N
RedAdyacenteLocalFísica
ComplejidadAC:L
BajaAlta
PrivilegiosPR:N
NingunoBajosAltos
InteracciónUI:N
NingunaRequerida
AlcanceS:C
CambiadoSin cambio
ConfidencialidadC:L
AltoBajoNinguno
IntegridadI:L
AltoBajoNinguno
DisponibilidadA:N
AltoBajoNinguno
Score de explotaciónQué tan fácil y probable es que la exploten
10.0/ 10Muy alto
Vector 10.0 (muy fácil) · sin evidencia de explotación.
Versiones

Rangos afectados

Afectada Corregida Última
github.com/gotenberg/gotenberg/v8≥ 8.32.0 < 8.39.0
8.32.0
8.39.0
v8.40.0
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
gogithub.com/gotenberg/gotenberg/v8
Corregida v8.39.0 -16 d v8.40.0 no afectada
Versiones corregidas8.39.0v8.39.0
Explotación

Arsenal público

Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.

Referencias
Advisoryhttps://github.com/gotenberg/gotenberg/security/advisories/GHSA-8g49-v2h4-f554

Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.