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

GHSA-F27V-HGJ3-G9XG

Low-privileged S3 user can determine existence of other tenants' S3Tables buckets via a 403 vs 404 oracle

Sin parche publicado
Descargar PNG JSON
CVSS 3.1
4.3
Media
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:N 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:50 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, no automatizable e impacto técnico parcial. No hay versión corregida: aplique mitigaciones.
Paso a paso, como subiendo al Cotopaxi.Sin drama: ventana de mantenimiento y listo.
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada +1
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-F27V-HGJ3-G9XG divulgada · CVSS 4.3 (GitHub)
Divulgación Modificada Última actualización del registro
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 routes requests signed with SigV4 service `s3tables` to the S3Tables management API, where the point-lookup handler `handleGetTableBucket` in `weed/s3api/s3tables/handler_bucket_get_list_delete.go` discloses whether a table bucket exists by returning distinguishable responses. An authenticated low-privileged S3 identity, holding ordinary S3 credentials and no S3Tables permission, receives HTTP 403 `AccessDenied` when it probes a table bucket that exists but is owned by another account, and HTTP 404 `NoSuchBucket` when the probed name does not exist. This response discrepancy is a cross-tenant existence oracle: by supplying candidate names one at a time, the low-privileged caller confirms the presence of administrator-owned or other-tenant table bucket names across the ownership boundary, without any read of contents.

Root Cause

The handler loads the target resource before it evaluates authorization, and then reports the two failure conditions with different, attacker-distinguishable results. The absence check runs first: a missing bucket produces `filer_pb.ErrNotFound` and a 404 response, emitted independently of any authorization decision. Only if the bucket exists does the handler evaluate `CheckPermissionWithContext`, and a denial there produces a 403 response. Because the two outcomes differ, the response itself reveals existence to a caller who is not authorized to know it.

The sibling read handlers in the same package enforce the opposite, existence-hiding convention: on an authorization denial they return 404 while internally recording access-denied, so a denied caller cannot distinguish "present but forbidden" from "absent." `handleGetTableBucket` was omitted from that convention, so it leaks where the siblings do not.

Affected component: S3Tables / Iceberg REST management API point-lookup handler
Primary function: github.com/seaweedfs/seaweedfs/weed/s3api/s3tables.(*S3TablesHandler).handleGetTableBucket
Source: weed/s3api/s3tables/handler_bucket_get_list_delete.go
  - absent bucket -> HTTP 404 NoSuchBucket (line 61-62), before any authorization
  - present + denied -> HTTP 403 AccessDenied (line 76-78), terminal
Existence-hiding convention observed in siblings (deny masked as 404):
  - handleGetTable: weed/s3api/s3tables/handler_table.go:446-448 (404 NoSuchTable on deny)
  - handleGetNamespace: weed/s3api/s3tables/handler_namespace.go:263-266 (404 NoSuchNamespace on deny)

Impact

An authenticated attacker who holds only ordinary low-privileged S3 credentials on a filer that runs the S3 API with IAM enabled and at least two identities can determine the existence of table bucket names owned by other accounts, including an administrator. The demonstrated capability is confidentiality only, and limited to the existence of a name that the attacker supplies or guesses on each request; no bucket contents, metadata, ARNs beyond the supplied name, or policy are returned, and there is no integrity or availability impact. This is the same low-privileged-to-management boundary and threat model as the seed advisory, but the primitive here is weaker than the seed's bulk inventory listing: the attacker must probe candidate names individually rather than receive a full inventory. In shared or multi-tenant deployments this still discloses tenant naming and operational structure across the ownership boundary.

Proof of Concept

`Requires a running SeaweedFS S3 endpoint with IAM enabled, an administrator-owned (or other-tenant) table bucket, and low-privileged attacker S3 credentials with no S3Tables permission. A boto3 s3tables client signs requests with SERVICE=s3tables, satisfying the route selector.`

  1. Configure the attacker's low-privileged credentials in the environment.
  2. Call `get_table_bucket` for a name known to exist and owned by another account; observe HTTP 403 `AccessDenied`.
  3. Call `get_table_bucket` for a name known not to exist; observe HTTP 404 `NoSuchBucket`.
  4. The differing status codes distinguish present-but-forbidden from absent, confirming the oracle.
import boto3
from botocore.exceptions import ClientError

# Attacker holds only low-privileged S3 credentials; no S3Tables permission.
client = boto3.client(
    "s3tables",
    endpoint_url="http://TARGET:8333",
    aws_access_key_id="ATTACKER_KEY",
    aws_secret_access_key="ATTACKER_SECRET",
    region_name="us-east-1",
)

def probe(name):
    arn = f"arn:aws:s3tables:us-east-1:000000000000:bucket/{name}"
    try:
        client.get_table_bucket(tableBucketARN=arn)
        return "ACCESSIBLE (200)"
    except ClientError as e:
        code = e.response["ResponseMetadata"]["HTTPStatusCode"]
        if code == 403:
            return "EXISTS (403, present but not authorized)"
        if code == 404:
            return "ABSENT (404)"
        return f"OTHER ({code})"

for candidate in ["admin-analytics", "does-not-exist-xyz"]:
    print(candidate, "->", probe(candidate))
admin-analytics -> EXISTS (403, present but not authorized)
does-not-exist-xyz -> ABSENT (404)

Attack Chain

  1. Exposure: The S3Tables route ships and is active whenever the S3 API runs. `isS3TablesSignedRequest` in `weed/s3api/s3api_tables.go` selects the route on the raw credential scope containing `/s3tables/`; any client can sign with `SERVICE=s3tables`, so this is a routing signal, not an authorization gate.
  2. Control: The attacker fully controls the probed bucket name in the request body ARN. `parseBucketNameFromARN` extracts only the bucket name; the account and region ARN segments are never compared to the caller or the bucket owner.
  3. Path: `authenticateS3Tables` in `weed/s3api/s3api_tables.go` performs signature-only authentication with no per-action gate, then invokes `handleGetTableBucket`. The handler reads the bucket metadata through a raw filer lookup before evaluating authorization.
  4. Guard: The one guard that could collapse the two outcomes, `defaultAllowFor`, fails closed for a named identity, and the prior fix keeps a low-privileged account-less identity from collapsing into the administrator account. So a named non-owner is deterministically denied on an existing foreign bucket, and there is no existence-hiding mask on this handler.
  5. Primitive: The handler emits HTTP 404 `NoSuchBucket` for an absent name (before authorization) and HTTP 403 `AccessDenied` for a present-but-forbidden name (terminal). The two branches are mutually exclusive and observable.
  6. Result: Repeating with different candidate names yields a per-name cross-tenant existence oracle for table bucket names, disclosing the existence of administrator-owned or other-tenant buckets with no access to their contents.

Bypass Evidence

The prior advisory for CVE-2026-55873 hardened the list path: it removed the failed-open authorization that collapsed account-less identities into a shared administrator account and allowed by default, and it removed the tautological ListTableBuckets gate. That fix is present in the analyzed source and correctly denies a low-privileged caller. It does not address the point-lookup's 403-versus-404 response semantics; in fact the fix is the mechanism that now denies the caller and thereby produces the distinguishable 403. The list-path per-item filter (`weed/s3api/s3tables/handler_bucket_get_list_delete.go` around line 194, which drops unauthorized buckets from the listing) and the administrator-collapse fix (`weed/s3api/s3tables/handler.go` around line 266) are on different code paths from the point lookup and leave its error semantics unchanged.

Strongest attempts to disprove the finding:

  • AWS parity. AWS S3 Tables control-plane authorization for `GetTableBucket` is evaluated from the caller's identity policy against the ARN independently of whether the resource exists, so a denied caller receives `AccessDenied` for both existing and absent buckets and no existence oracle results. SeaweedFS instead loads the resource first (404 if absent) and checks permission second (403 if present); that ordering is a genuine deviation that manufactures the oracle, so parity does not excuse it.
  • Sibling handlers as the anomaly. The read handlers `handleGetTable` (`weed/s3api/s3tables/handler_table.go:446-448`) and `handleGetNamespace` (`weed/s3api/s3tables/handler_namespace.go:263-266`) return 404 while internally recording access-denied. Writing 404 while recording denial is a deliberate existence-hiding convention, which identifies `handleGetTableBucket` as the outlier that leaks.
  • Precondition realism. The IAM-enabled, multi-identity deployment is the same threat model and privilege level as the seed advisory, so the precondition is not an added obstacle.
  • Deny masking or an authorization gate blocking the probe. The 403 write is terminal, and there is no per-action gate before the handler; neither neutralizes the oracle.

Affected Versions

  • `Ecosystem: go`
  • `Package: github.com/seaweedfs/seaweedfs`
  • `Confirmed affected range: >= 4.34`
  • `Latest release checked: 4.47 (release tag; analyzed source is 40 commits past 4.47, and the Go proxy resolves @latest to pseudo-version v0.0.0-20260916232503-0eb638f5034e)`
  • `Fix status: not fixed (no release addresses the 403/404 differential on this handler)`

The lower bound is 4.34 because before 4.34 the same low-privileged caller was allowed (a failed-open response returning full bucket details), which is the separate and worse behavior fixed by the prior advisory. From 4.34 onward the caller is correctly denied, and the denial on the point lookup is existence-revealing. The differential is verified present in the analyzed source, which maps to the 4.47 release tag; no released version removes it, so the range is open-ended. The 4.34 lower bound is a reasoned inference tied to the prior fix version; the shallow analysis clone could not inspect the 4.34 artifact directly, and that residual uncertainty is noted.

Suggested Fix

Enforce the existing existence-hiding convention on `handleGetTableBucket` so that an authorization denial does not reveal resource existence. Return the same response for a present-but-forbidden bucket as for an absent one (for example, mask the denial as 404 `NoSuchBucket`, matching `handleGetTable` and `handleGetNamespace`), or alternatively evaluate authorization against the requested ARN before loading the resource so that a denied caller receives an identical result regardless of existence. Apply the same treatment to the other point-lookup and mutating handlers that share the pattern (`handleDeleteTableBucket`, `handleDeleteTable`, `handleUpdateTable`, `handleUpdateNamespace`), preferably through a shared helper so the convention cannot drift again. As an interim mitigation, deployments can avoid granting distinct low-privileged S3 identities on filers that also host administrator-owned table buckets, since the oracle requires a multi-identity IAM configuration.

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

Rangos afectados

Afectada Corregida
github.com/seaweedfs/seaweedfs≥ 4.34
4.34
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-f27v-hgj3-g9xg

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