GHSA-3J72-RGQ3-C2J7
SeaweedFS 4.42 inline GCS credentials allow unauthenticated SSRF with response read-back
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:L/A:N
Fuente: GitHub
Ciclo de vida de la vulnerabilidad
| Fecha | Fase | Evento | Detalle |
|---|---|---|---|
| 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 |
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 callerSecurity 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.
- Download and extract the SeaweedFS 4.42 source release.
- Copy `fetch_and_write_gcs_ssrf_test.go` into `weed/server/`.
- From the SeaweedFS source root, run:
```bash
go test ./weed/server -run '^TestPoCGCSInlineCredentialsSSRF$' -count=1 -v
```
- 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.
Desglose de métricas
Rangos afectados
Estado del parche por paquete
| Paquete / producto | Estado | Corregida en | Desde divulgación | Última versión |
|---|---|---|---|---|
Gogithub.com/seaweedfs/seaweedfs |
Sin parche | — | — | — |
Arsenal público
Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.
https://github.com/seaweedfs/seaweedfs/security/advisories/GHSA-3j72-rgq3-c2j7Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.
