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

GHSA-QPCW-W62H-6QFR

Unauthenticated SSRF port oracle and remote crash via unvalidated source address in volume server copy/tail gRPC handlers

Sin parche publicado
Descargar PNG JSON
CVSS 3.1
8.2
Alta
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:H Fuente: GitHub
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
ParcheSin parcheEl fabricante no ha publicado corrección
Exposición11 dDesde la divulgación, 9 nov 2026, 2:51 p. m.
Detección10 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.
Más vale un parche a tiempo que un incidente de madrugada.Las PoC crecen rápido, como las llamas bebé.
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Explotación
Remediación
Monitoreo
Detectada +1
9 nov 26
20 nov 26
21 nov 26
9 nov 26
12 nov 26
15 nov 26
18 nov 26
21 nov 26
FechaFaseEventoDetalle
Divulgación Publicada GHSA-QPCW-W62H-6QFR divulgada · CVSS 8.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 SeaweedFS volume server exposes a gRPC control plane that, in the default configuration, performs no effective authentication: the only gate on its administrative handlers is an IP whitelist that is empty by default and therefore allows every caller. Three of these handlers, `VolumeCopy`, `VolumeEcShardsCopy`, and `VolumeTailReceiver`, take a caller-supplied source address (`SourceDataNode` / `SourceVolumeServer`) and dial it without any endpoint validation. An unauthenticated remote attacker can point that address at arbitrary internal or cloud-metadata hosts and use the resulting connection behavior as a network connectivity and port oracle, or supply a malformed address that reaches a fatal parse path and terminates the volume server process with a single request.

Root Cause

The volume server's gRPC admin handlers are guarded only by `checkGrpcAdminAuth`, which consults `Guard.IsWhiteListed`. When no IP whitelist is configured (the default), `IsWhiteListed` returns true for every caller, so the handlers are unauthenticated by default; configuring a JWT signing key does not activate the whitelist gate. Past fixes for this service (the guarded dialer and endpoint validation added for `FetchAndWriteNeedle`, and the target check added to the `Ping` handler) constrained the destinations that a caller may cause the server to contact. Those protections were never applied to the copy and tail handlers, which pass the attacker-controlled source address straight into a gRPC dial. A second defect compounds this: the address-to-gRPC-address transform accepts an unusual `host:0.port` form that yields full attacker control over the destination port, and a malformed address form triggers a fatal logging call that exits the process.

Affected functions (repository-relative):
- weed/server/volume_grpc_copy.go            (*VolumeServer).VolumeCopy           dials pb.ServerAddress(req.SourceDataNode) with no target validation
- weed/server/volume_grpc_erasure_coding.go  (*VolumeServer).VolumeEcShardsCopy   dials pb.ServerAddress(req.SourceDataNode) with no target validation
- weed/server/volume_grpc_tail.go            (*VolumeServer).VolumeTailReceiver   dials pb.ServerAddress(req.SourceVolumeServer) with no target validation
- weed/pb/server_address.go                  ServerAddress.ToGrpcAddress          host:0.port form grants arbitrary destination port
- weed/pb/grpc_client_server.go              ServerToGrpcAddress                  glog.Fatalf on malformed address reaches os.Exit synchronously in the serving goroutine

Impact

An unauthenticated attacker with network access to the volume server gRPC port (default 18080) gains two capabilities against a default deployment. First, a connectivity and port oracle: by setting the source address to an arbitrary internal or link-local host and port and observing the returned dial or copy-stage error, the attacker can distinguish reachable from unreachable services across the server's internal network vantage, including cloud instance-metadata endpoints. No HTTP response body is read back on this path, so this is an oracle rather than full response exfiltration. Second, a reliable denial of service: a source address whose port component is non-numeric reaches a fatal parse path that calls `os.Exit`, terminating the entire volume server process. A single unauthenticated request crashes the server, and the crash is unrecoverable because it is invoked synchronously in the request-serving goroutine.

Proof of Concept

Preconditions: a stock volume server reachable on its gRPC port, with no -whiteList
configured (the default). No credentials are attached to the request.
  1. Start a default volume server (for example the shipped container image) and reach its gRPC port.
  2. Send an anonymous `VolumeCopy` request whose `SourceDataNode` names an internal target, using the `host:0.port` form to control the exact destination port; observe the dial/stage error to learn whether the target port is open (oracle bit).
  3. To crash the process, send an anonymous `VolumeCopy` request whose `SourceDataNode` has a non-numeric port component.
// Minimal anonymous gRPC client (no token attached).
// Oracle probe: SourceDataNode "169.254.169.254:0.80" dials 169.254.169.254:80.
// Crash:        SourceDataNode "target:notaport" reaches glog.Fatalf -> os.Exit(255).
client := volume_server_pb.NewVolumeServerClient(conn)
stream, _ := client.VolumeCopy(ctx, &volume_server_pb.VolumeCopyRequest{
    VolumeId:       1,
    SourceDataNode: "169.254.169.254:0.80", // or "target:notaport" for the crash
})
_, err := stream.Recv() // dial/stage error is the oracle bit
Address transform trace (verified against ServerAddress.ToGrpcAddress):
  "169.254.169.254:0.80" -> dial "169.254.169.254:80"   (arbitrary port)
  "10.0.0.5:0.6379"      -> dial "10.0.0.5:6379"         (arbitrary port)
  "target:notaport"      -> parse error -> glog.Fatalf -> os.Exit(255)  (process exit)

Attack Chain

  1. Exposure: The volume server gRPC service listens on its default port and, with no whitelist configured, accepts requests from any network peer.
  2. Control: The attacker fully controls the `SourceDataNode` (or `SourceVolumeServer`) string field of the copy/tail request.
  3. Path: `VolumeCopy` calls `checkGrpcAdminAuth` (allow-all by default) and `CheckMaintenanceMode` (nil by default), reads a boolean for whether the volume exists locally without returning, then reaches the dial.
  4. Guard: No endpoint validation exists on this path; the guarded dialer and target checks added for other handlers are absent here, so the attacker-controlled address flows directly into the gRPC dial.
  5. Primitive: `operation.WithVolumeServerClient` evaluates `ToGrpcAddress()` synchronously and dials the attacker-named host and port; a malformed port instead reaches `ServerToGrpcAddress` and its fatal parse call.
  6. Result: Either a connectivity/port oracle across the server's internal and metadata vantage, or an unauthenticated one-request crash of the volume server process.

Bypass Evidence

The relevant prior protections are the endpoint validation and guarded dialer introduced for the `FetchAndWriteNeedle` SSRF (advisories GHSA-87fv-vqqr-m4jr / CVE-2026-73080 and its follow-up GHSA-939f-xh28-2q48), and the target check on the `Ping` handler. A source-level search of `volume_grpc_copy.go`, `volume_grpc_erasure_coding.go`, and `volume_grpc_tail.go` for those validation routines returns nothing, at both the current tree and the latest released tag; the routines live only in the remote-needle handler and the `Ping` handler. The copy and tail handlers therefore have no guard to bypass: the attacker-controlled address reaches the dial unvalidated. The authentication gate was tested and found to be allow-all by default: `IsWhiteListed` returns true when the whitelist is empty, which is the shipped default, and this matches the unauthenticated posture already demonstrated by the two published advisories on the sibling handler. Attempts to disprove reachability failed: the dial in `VolumeCopy`/`VolumeEcShardsCopy` precedes any local-volume existence gate, so it fires regardless of whether the named volume exists; the fatal exit is reached synchronously in the serving goroutine and cannot be recovered; and the source address is an arbitrary protobuf string with no transport-layer validation. This path performs only a gRPC dial and does not read back an HTTP response body, so the finding is scoped as an oracle plus crash rather than full response exfiltration.

Affected Versions

  • `Ecosystem: go`
  • `Package: github.com/seaweedfs/seaweedfs`
  • `Confirmed affected range: <= 4.47`
  • `Latest release checked: 4.47 (GitHub release tags)`
  • `Fix status: not fixed`

The vulnerable dial is present in the latest released tag (4.47) and in current development, and no fix has been applied to the copy or tail handlers, so no fixed release exists. The introduction boundary could not be pinned from the available shallow, tagless checkout; the affected code predates the related SSRF advisories, so the lower bound is left open rather than asserted. The Go module proxy publishes only pseudo-versions for this module, so the affected boundary is expressed against GitHub release tags.

Suggested Fix

Enforce the same destination-validation invariant already applied to `FetchAndWriteNeedle` and `Ping` on every handler that dials a caller-supplied address. `VolumeCopy`, `VolumeEcShardsCopy`, and `VolumeTailReceiver` should validate `SourceDataNode` / `SourceVolumeServer` against an allowed set of cluster peers (or the existing guarded-dialer / endpoint-validation path) before dialing, rejecting loopback, link-local, and other unintended destinations. Separately, the address parsing should not terminate the process on malformed caller input: the fatal parse call reached through `ToGrpcAddress` / `ServerToGrpcAddress` should return an error to the handler instead of calling a fatal logger that exits, and the `host:0.port` form that grants arbitrary port control should be rejected or normalized. As an interim mitigation, operators can configure an IP whitelist so the volume server gRPC control plane is not reachable by untrusted peers, and restrict network access to the gRPC port to trusted cluster members only.

---

Reported by zx (GitHub: @manus-pi).

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:U
CambiadoSin cambio
ConfidencialidadC:L
AltoBajoNinguno
IntegridadI:N
AltoBajoNinguno
DisponibilidadA:H
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.47
4.47
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-qpcw-w62h-6qfr

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