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
Ferramentas/GitHubGitHub/certbn/cve-2026-97229-gitlab-ci-cd
Análise de VulnerabilidadesAnálise de CódigoExploraçãoExploração de Aplicações WebDevSecOpsInteligência de AmeaçasPapers e PesquisaAprendizado e EducaçãoResposta a Incidentes
GitHubcertbn/cve-2026-97229-gitlab-ci-cd

CVE-2026-97229-GitLab-CI-CD

Aviso e análise técnica da CVE-2026-97229, um estouro de inteiro em regex do GitLab CI/CD que permite RCE não autenticado, com causa raiz, diff de correção, regras de detecção e IoCs.

Ver Repositório
há 15 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.

    936
  • 2

    ghostlock-app

    yukonga/ghostlock-app

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

    555
  • 3

    redforge

    cybersecurity91/redforge

    Kit de ferramentas de red team do lado do navegador com 102 ferramentas offline para reconhecimento, geração de payloads, ataques a credenciais, criptografia, codificação e relatórios de engajamento.

    353
  • 4

    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.

    348
  • 5

    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.

    336
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    O sistema de ação para cibersegurança nativa em IA—onde a intenção se torna execução governada, a evidência se torna memória operacional, e cada operação melhora a próxima.

    288

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →
Compartilhar

CVE-2026-97229: Execução remota de código não autenticada (RCE) causada por estouro de inteiro no compilador de expressões regulares do GitLab CI/CD

CVSS Type KEV Auth

📌 TL;DR

  • Trata-se de um estouro de inteiro (integer overflow, CWE-190) que ocorre no processamento de expressões regulares (regular expression) do CI/CD do GitLab CE/EE, permitindo execução de código arbitrário (RCE) no servidor GitLab por meio de expressões regulares manipuladas. CVSS v3.1 10.0 (valor máximo).
  • A causa raiz não está no próprio GitLab, mas no Onigmo, o motor de expressões regulares embutido no Ruby, e é alcançável pelo caminho em que o GitLab compila expressões regulares fornecidas pelo usuário com Regexp.new.
  • O alvo são instâncias auto-hospedadas (self-managed). O GitLab.com e o Dedicated já estão corrigidos. Foi incluído no CISA KEV em 2026-10-29, confirmando exploração real — é necessário aplicar o patch imediatamente.

📋 Informações básicas

ItemConteúdo
CVE IDCVE-2026-97229
Data de divulgação2026-10-12 (publicação do aviso do GitLab) / publicação do registro CVE em 2026-10-13
Produtos afetadosGitLab Community Edition (CE) e Enterprise Edition (EE), auto-hospedados
Versões afetadas19.2 (< 19.2.8), 19.3 (< 19.3.5), 19.4 (< 19.4.2)
Versões corrigidas19.2.8, 19.3.5, 19.4.2 ou superior (ver "Atenção" abaixo)
CVSS v3.110.0 (Critical) — CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H
CVSS v4.0Vetor v4.0 não fornecido no aviso oficial do fornecedor (GitLab) nem no registro CVE (nenhum valor confirmado)
CWECWE-190 (Integer Overflow or Wraparound)
Relatorjoaxcar (Johan Carlsson), bug bounty do GitLab no HackerOne
Exploração realIncluído no CISA KEV (2026-10-29, prazo de ação para agências federais em 2026-11-01). PoC público existente (Rapid7, 2026-10-13). Tentativas de exploração contra instâncias Alpine Linux observadas (2026-10-20~21)

⚠️ Atenção importante sobre as versões corrigidas (fato confirmado)

  • 19.3.4 não é uma correção válida. O aviso inicial indicava a correção do branch 19.3 como 19.3.4, mas a 19.3.4 continha um bug que afetava a página de merge request quando a integração com o Ona estava ativada, e por isso foi substituída pela 19.3.5. Alguns materiais secundários ainda indicam erroneamente a 19.3.4 como versão corrigida. Segundo a versão mais recente do aviso do fornecedor, a correção do branch 19.3 é a 19.3.5.
  • Builds próprios (source) ou imagens de contêiner que usam um Ruby próprio continuam vulneráveis mesmo que apenas o GitLab seja atualizado. Isso porque esta correção aplica patch no Ruby embutido nos pacotes Omnibus oficiais/imagens CNG do GitLab. Nesses ambientes, é necessário atualizar o Ruby para 3.3.13 / 3.4.12 / 4.0.9 ou superior (lançamentos de 2026-10-22~23). Isso foi de fato um problema no caso do Alpine Linux.

🔍 Análise da causa da vulnerabilidade (Root Cause)

1) Localização e funcionamento do código vulnerável

O GitLab faz a correspondência de expressões regulares fornecidas pelo usuário com o caminho do repositório (repository path) em rules:exists:regexp, rules:changes:regexp, etc. das configurações de CI/CD. Essa expressão regular é finalmente compilada pelo Regexp.new do Ruby, e o motor interno Onigmo (motor de expressões regulares embutido no Ruby, escrito em C) a converte em bytecode (pcode).

O defeito fundamental está no cálculo do tamanho de expansão de repetição (quantifier) do compilador do Onigmo. Como o tamanho do programa compilado é acumulado usando um inteiro de 32 bits com sinal, e os deslocamentos de salto são armazenados em um RelAddrType de 32 bits com sinal, quando o resultado da compilação ultrapassa INT_MAX, tanto o cálculo de comprimento quanto os deslocamentos de salto sofrem wraparound.

A verificação de tamanho em compile_quantifier_node() do regcomp.c do Ruby 3.3.12 é o ponto central (com base na análise da Rapid7 e nos commits do Ruby):

/* regcomp.c: compile_quantifier_node() — 취약 로직 */
else if (!infinite && qn->greedy &&
         (qn->upper == 1 || (tlen + SIZE_OP_PUSH) * qn->upper
                                <= QUANTIFIER_EXPAND_LIMIT_SIZE)) { // 부호 있는 곱셈 → 오버플로
    ...
    r = compile_tree_n_times(qn->target, qn->lower, reg); // 모든 복사본을 인라인 확장
}

Se o produto entre o tamanho do corpo repetido (tlen) e o número de repetições (qn->upper) exceder INT_MAX, o resultado sofre wrap para um valor negativo e passa na verificação de que "é suficientemente pequeno, então pode ser expandido inline". Como resultado, o Onigmo gera um pcode gigante, e os deslocamentos de salto calculados posteriormente com o comprimento já com wrap enviam o fluxo de execução para posições incorretas.

2) Por que isso é um problema — as defesas do GitLab e o bypass

O GitLab mantém várias defesas para expressões regulares, mas elas são contornadas da seguinte forma (com base no caminho ponta a ponta divulgado pela Rapid7):

  • Verificação do comprimento da fonte: considera apenas o comprimento da fonte antes da expansão.
  • Scanner de limite de repetição (REPEAT_BOUND, limite 1.000): reconhece apenas dígitos consecutivos. O PoC engana o scanner inserindo um comentário inline de regex (?#) no meio, como em {5(?#)7805}. O Onigmo ignora (?#) e lê o limite como 57.805, mas o scanner não enxerga a ultrapassagem de 1.000.
  • Verificação do tamanho de compilação (limite de cerca de 1MB): é verificada apenas no momento da compilação inicial em US-ASCII. No entanto, se o caminho alvo da correspondência contiver caracteres UTF-8 de 4 bytes, o Ruby recompila em codificação UTF-8 em rb_reg_prepare_re(). Nesse momento, classes de caracteres POSIX como [[:word:]] se expandem para grandes tabelas de intervalos Unicode, e o GitLab não verifica o tamanho resultante dessa recompilação. Além disso, essa recompilação ocorre fora do timeout de correspondência (Regexp.timeout), portanto não é impedida nem pelo timeout.

Ou seja, uma expressão regular pequena (na casa de 986 bytes) passa nas verificações e, somente na recompilação UTF-8 no momento da correspondência, torna-se um programa grande que provoca o overflow.

Nota (estimativa): o caminho analisado e divulgado pela Rapid7 pressupõe "enviar primeiro (push) um .gitlab-ci.yml manipulado e um caminho especial para um projeto público (requer permissão de escrita)". Isso entra em conflito com a avaliação PR:N (sem necessidade de privilégios) do GitLab; como o relatório original no HackerOne é privado, não foi confirmado publicamente como o ataque relatado evita a etapa de escrita (a própria Rapid7 declara não saber). Portanto, o caminho exato do relatório original que fundamenta a avaliação de "totalmente não autenticado" é atualmente uma área de estimativa.

3) Comparação do diff do patch (Antes / Depois)

Com base no Ruby PR #19020 (commit cf35145fc4, backport 2d1859ffa6) + commit subsequente 366f5fdc00. O GitLab fez backport desse patch do Ruby para o Ruby empacotado (omnibus-gitlab MR !9845).

(a) Substituição de multiplicação com sinal por verificação baseada em divisão (tornando o overflow impossível)

/* Before: (tlen + SIZE_OP_PUSH) * qn->upper <= QUANTIFIER_EXPAND_LIMIT_SIZE  → 곱셈이 오버플로 */

/* After: regcomp.c */
#define IS_EXPAND_LIMIT_OK(tlen, n) \
  ((n) <= 0 || (tlen) <= QUANTIFIER_EXPAND_LIMIT_SIZE / (n))

(b) Introdução de um limite máximo (hard cap) para o tamanho do programa compilado

/* After: regint.h */
#define MAX_COMPILED_PROGRAM_SIZE  ((unsigned int)(INT_MAX_LIMIT / 4))
Baixar ferramenta