llamaCVEVulnerability Intelligence
/
Advisory · GitHub · Go · github.com/seaweedfs/seaweedfs

GHSA-3J72-RGQ3-C2J7

SeaweedFS 4.42 inline GCS credentials allow unauthenticated SSRF with response read-back

Sin parche publicado
Descargar PNG JSON
CVSS 3.1
9.3
Crítica
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:L/A:N Fuente: GitHub
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
ParcheSin parcheEl fabricante no ha publicado corrección
Exposición63 dDesde la divulgación, 18 sept 2026, 3:00 p. m.
Detección62 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, automatizable e impacto técnico parcial. No hay versión corregida: aplique mitigaciones.
Algún pentester ya está tomando notas de esto.Te dejo mi extintor por si acaso.
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Explotación
Remediación
Monitoreo
Detectada +1
18 sept 26
20 nov 26
21 nov 26
18 sept 26
4 oct 26
20 oct 26
5 nov 26
21 nov 26
FechaFaseEventoDetalle
Divulgación Publicada GHSA-3J72-RGQ3-C2J7 divulgada · CVSS 9.3 (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

SeaweedFS 4.42 allows an unauthenticated caller with network access to the volume server gRPC port to bypass the endpoint SSRF protection in `VolumeServer.FetchAndWriteNeedle`. The caller can supply inline Google Cloud Storage credential JSON containing attacker-controlled `credential_source.url` and `token_url` destinations. SeaweedFS accepts the JSON and the Google authentication client sends requests to those destinations without applying SeaweedFS's loopback, private-network, link-local, or cloud-metadata address restrictions.

The bypass allows the volume server to make attacker-directed GET and POST requests to internal services and return their response bodies through the gRPC error. The attached local proof of concept reproduces both request paths through a real TCP gRPC server and client using SeaweedFS 4.42.

Details
Affected components
  • `weed/server/volume_grpc_remote.go`: `VolumeServer.FetchAndWriteNeedle`, `guardedRemoteClient`, and `gcsCredentialsArePath`
  • `weed/remote_storage/gcs/gcs_storage_client.go`: `gcsRemoteStorageMaker.Make`

`FetchAndWriteNeedle` accepts both a remote-storage configuration and a remote object location. When its default endpoint protection is enabled, explicit S3-compatible and Azure endpoints are validated and routed through a protected HTTP client. That client rejects internal destinations and revalidates the resolved address when connecting.

GCS follows a different path. The handler rejects a GCS credential value only when it is a non-empty filesystem path. A value beginning with `{` is accepted as inline JSON. GCS is then classified as a fixed-host backend, so it is constructed through the ordinary remote-storage client path rather than the protected HTTP client.

The accepted JSON is passed to the Google credential parser without validating the credential type or URLs embedded in it. A valid `external_account` credential document supports attacker-controlled values including:

  • `credential_source.url`, fetched with an HTTP GET when the token source obtains a subject token;
  • `credential_source.headers`, attached to that GET;
  • `token_url`, which receives an HTTP POST containing the retrieved subject token.

The Google authentication client performs these requests before accessing the normal GCS object endpoint. When either destination returns an error, its response body is included in the authentication error. `FetchAndWriteNeedle` wraps that error and returns it to the gRPC caller, creating response read-back.

The exploitable data flow is:

gRPC caller
  -> FetchAndWriteNeedle.remote_conf
  -> inline GCS external_account JSON accepted
  -> GCS omitted from guardedRemoteClient
  -> credential_source.url GET with attacker-selected headers
  -> optional token_url POST carrying the retrieved subject token
  -> internal response body included in authentication error
  -> gRPC error returned to caller
Security boundary

This report does not claim that exposing an internal cluster port is itself a vulnerability. It demonstrates a bypass of the endpoint-validation control that SeaweedFS deliberately applies to `FetchAndWriteNeedle` when `volume.allowUntrustedRemoteEndpoints` is disabled, which is the default.

With that protection enabled, an equivalent direct S3 request targeting loopback is rejected before any connection is made. The inline-GCS input reaches the same prohibited destination because the actual URLs are nested in credential JSON and are dialed by the OAuth token source outside the guarded transport. Restrictive network policy, mTLS, or a non-empty admin whitelist can prevent an attacker from reaching the RPC, but they do not correct this validation bypass.

Deployment and attacker starting position

The minimal affected configuration is:

  • a SeaweedFS 4.42 volume server with an existing local volume;
  • the volume server gRPC port reachable by the attacker;
  • `volume.allowUntrustedRemoteEndpoints=false`, the secure default;
  • no gRPC mTLS; and
  • an empty admin whitelist, which accepts all peer addresses.

The attacker starts as an unauthenticated network client with access to that gRPC port. The attacker does not need filesystem access, Google credentials, control of a GCS bucket, or access to a master, filer, S3 gateway, or admin UI. The attacker must know or identify an existing volume ID because the handler resolves the volume before creating the remote client.

Expected behavior

When endpoint protection is enabled, every network destination derived from caller-supplied remote configuration should be validated with the same address policy and connection-time protections. Inline GCS credentials containing loopback, private, link-local, or metadata-service URLs should be rejected before any connection occurs.

Actual behavior

SeaweedFS checks whether the GCS credential value is a file path but does not inspect accepted inline JSON. The Google OAuth token source therefore connects to the embedded URLs through its own HTTP client. A direct S3 loopback endpoint is blocked, while the same loopback destination supplied as `credential_source.url` or `token_url` is contacted and its response body is returned to the caller.

PoC

The attached test uses only loopback services and a disposable local volume. It registers the real SeaweedFS `VolumeServer` implementation on a TCP gRPC listener and invokes `FetchAndWriteNeedle` through the generated gRPC client. No external or third-party service is contacted.

  1. Download and extract the SeaweedFS 4.42 source release.
  2. Copy `fetch_and_write_gcs_ssrf_test.go` into `weed/server/`.
  3. From the SeaweedFS source root, run:

```bash
go test ./weed/server -run '^TestPoCGCSInlineCredentialsSSRF$' -count=1 -v
```

  1. A vulnerable result passes all three subtests. The direct-S3 negative control is rejected before dialing, while the two inline-GCS subtests print errors containing:

```text
SEAWEEDFS_POC_GET_RESPONSE_4a7d
SEAWEEDFS_POC_POST_RESPONSE_8b3a
```

The direct-S3 subtest proves that the endpoint guard is enabled and blocks an equivalent loopback destination before any request reaches it.

The GET subtest proves that the RPC sends a request with an attacker-selected header to `credential_source.url` and returns that endpoint's response marker.

The POST subtest proves that the RPC retrieves an attacker-controlled subject token, forwards it in a form-encoded request to `token_url`, and returns the token endpoint's response marker. Request counters and unique markers ensure the result is attributable to the real RPC path rather than test setup.

Impact

This is server-side request forgery with response read-back. An unauthenticated attacker who can reach the affected volume server gRPC port can:

  • read error responses from services bound only to loopback or a private network;
  • access cloud instance-metadata endpoints and potentially disclose workload or IAM credentials;
  • send attacker-selected headers to an internal GET endpoint;
  • make a form-encoded POST to an attacker-selected internal endpoint;
  • forward data obtained from the first internal endpoint as the POST's subject token; and
  • enumerate internal services using returned response bodies and connection errors.

The practical impact depends on which internal services the volume server can reach. Network isolation, gRPC mTLS, or a restrictive admin whitelist reduces exploitability. Deployments in which an untrusted client can reach the default unauthenticated gRPC plane have the highest exposure.

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

Rangos afectados

Afectada Corregida
github.com/seaweedfs/seaweedfstodas
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
Gogithub.com/seaweedfs/seaweedfs
Sin parche — — —
Explotación

Arsenal público

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

Referencias
Advisoryhttps://github.com/seaweedfs/seaweedfs/security/advisories/GHSA-3j72-rgq3-c2j7

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