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/c0dem4sters/cve-2026-57967
Sniffing e Análise de PacotesScanners de VulnerabilidadesAnálise de VulnerabilidadesExploraçãoExploração de Aplicações WebTestes de PenetraçãoAutenticaçãoLabs e Prática
GitHubc0dem4sters/cve-2026-57967

CVE-2026-57967

Exploits proof-of-concept em Python e Go, além de um laboratório Docker para CVE-2026-57967, sequestro de sessão não autenticado no ActiveMQ Artemis via SESSION_REATTACH.

1há 1 mêsAinda não revisado
Ver Repositório
Compartilhar

CVE-2026-57967 — Sequestro de Sessão Não Autenticado no Apache ActiveMQ Artemis (SESSION_REATTACH)

CVE Severity Affected Fixed PoC Ethics

English | Русский | 中文

Sequestro remoto não autenticado de uma sessão autenticada do protocolo CORE no Apache ActiveMQ Artemis 2.50.0 – 2.56.0 (e artefatos org.apache.activemq 1.0.0 – 2.44.0). Um atacante que consiga abrir uma conexão TCP com o acceptor CORE (padrão 0.0.0.0:61616) e que conheça o nome de sessão da vítima pode enviar um pacote SESSION_REATTACH artesanal, e o broker transfere a sessão totalmente autenticada da vítima — seu contexto de segurança, consumidores, entregas pendentes — para a conexão do atacante. Nenhum nome de usuário, nenhuma senha, nenhuma identidade de cliente TLS é verificada nesse caminho.

Este repositório contém um exploit Python funcional e sem dependências, além de um cliente "vítima" em Java, e um laboratório docker com dois brokers (2.56.0 vulnerável e 2.57.0 corrigido) para reproduzir o ataque de ponta a ponta.

[!CAUTION] Este material é fornecido apenas para pesquisa de segurança autorizada e testes defensivos (consulte o aviso legal no final). Atacar sistemas que você não possui ou opera sem permissão por escrito é ilegal.

A vulnerabilidade

O protocolo CORE multiplexa canais sobre uma única conexão TCP. O canal 1 é o canal de gerenciamento de sessão (CoreProtocolManager o cria para cada conexão de entrada) e — na versão 2.56.0 — não requer nenhum handshake de qualquer tipo antes do uso. ActiveMQPacketHandler despacha quatro tipos de pacote ali, incluindo REATTACH_SESSION (tipo 32):

// artemis-server/.../ActiveMQPacketHandler.java, tag 2.56.0
private void handleReattachSession(final ReattachSessionMessage request) {
   ...
   ServerSessionPacketHandler sessionHandler = protocolManager.getSessionHandler(request.getName());  // by NAME only!
   if (sessionHandler == null) {
      response = new ReattachSessionResponseMessage(-1, false);
   } else if (sessionHandler.getChannel().getConfirmationWindowSize() == -1) {
      ... // DoS branch: the victim's session gets closed
   } else {
      // Reconnect the channel to the new connection
      int serverLastConfirmedCommandID = sessionHandler.transferConnection(connection, request.getLastConfirmedCommandID());
      response = new ReattachSessionResponseMessage(serverLastConfirmedCommandID, true);
   }
   ...
}

O handler nunca consulta o SecurityStore — compare com o caminho legítimo de criação de sessão (CREATESESSION), que chama server.validateUser(...). ReattachSessionMessage carrega apenas um nome de sessão e um int. O nome indexa CoreProtocolManager.sessionHandlers, portanto quem o conhece torna-se o dono da sessão: ServerSessionPacketHandler.transferConnection(...) reatribui o canal do lado do servidor da vítima à conexão TCP do atacante, reenvia o cache de comandos não confirmados do canal para o atacante e, a partir daí, cada pacote SESS_* que o atacante envia nesse canal é executado com o contexto de segurança autenticado da vítima (browse/consume/send/ack, gestão de filas e endereços dentro das permissões da vítima). As entregas de mensagens para os consumidores da vítima vão para o socket do atacante; a própria conexão da vítima fica muda — o seu canal já não existe nela.

A correção

Corrigido em 2.57.0 por ARTEMIS-6245, commit 26ce5813 ("Reattachment should be disabled"). O handler do servidor foi eliminado; o caso REATTACH agora responde sempre ReattachSessionResponseMessage(-1, false), e a autenticação ao nível da conexão foi introduzida com o novo pacote CONNECT (commit 51b06748, "Improve Core connection handshake").

Versões afetadas

  • org.apache.artemis:artemis-server 2.50.0 – 2.56.0
  • org.apache.activemq:artemis-server 1.0.0 – 2.44.0

Anúncio: OSS Security mirror · ASF advisory text

Como o exploit funciona

O formato de wire CORE é minimalista, por isso exploit.py comunica com ele usando apenas a biblioteca padrão do Python:

first frame of a connection is preceded by the 7-byte ASCII magic "ARTEMIS"
frame = [int32 BE length][byte type][int64 BE channelID][payload]   (length = frame size - 4)
  1. Conecte-se ao acceptor CORE, envie ARTEMIS + um pacote REATTACH_SESSION (tipo 32, canal 1). O payload é o nome da sessão da vítima (codificação de string Artemis: int32 comprimento de caracteres + short comprimento em bytes UTF-8 + bytes) seguido de int32 lastConfirmedCommandID = -1.
  2. Leia a resposta: tipo 33 com reattached=true significa que a sessão autenticada agora reside na conexão do atacante. (reattached=false é um oráculo de existência para nomes de sessão; contra a versão 2.57.0 é o comportamento fixo.)
  3. O servidor imediatamente reproduz o cache de comandos não confirmados do canal da vítima — o atacante descobre o id do canal da vítima a partir dos cabeçalhos do frame (primeira sessão de uma conexão de cliente = canal 10; SimpleIDGenerator conta a partir de USER(10)).
  4. Envie SESS_START (tipo 67) no canal da vítima: as entregas para os consumidores da vítima agora chegam ao atacante. O PoC imprime os corpos das mensagens VICTIM-SECRET-* interceptadas como prova.

Além de receber mensagens, o atacante pode executar operações SESS_* arbitrárias (criar consumidores/produtores, enviar, confirmar, fechar — consulte as constantes de tipo PacketImpl em exploit.py) sob a identidade da vítima.

Estrutura do repositório

exploit.py              Python exploit (stdlib only, zero dependencies)
go/main.go              Go exploit (single binary, zero dependencies)
tools/sniffer.py        passive CORE session name sniffer (scapy/tcpdump)
tools/check.sh          quick version check (bash + nc, no dependencies)
nuclei/                 Nuclei detection template (Project Discovery)
victim/Victim.java      legitimate authenticated client for demonstration
victim/run.sh           build & run the victim against a broker
demo.sh                 one-shot end-to-end demo: victim -> exploit -> patched check
stand/                  docker-compose lab: Artemis 2.56.0 (61616) and 2.57.0 (62616)
logs/                   captured outputs of the runs below

Reprodução

Requisitos: Docker, Python 3, JDK (javac/java). Go 1.21+ para o exploit em Go.

# 1. start the lab (vulnerable 2.56.0 on 61616, fixed 2.57.0 on 62616)
cd stand && docker compose up -d && cd ..

# 2. run everything at once
./demo.sh

# --- or step by step ----------------------------------------------- #
# victim: connects with artuser/artpass, prints SESSION_NAME=..., parks 60 s
./victim/run.sh --host localhost --port 61616 --duration-ms 60000 &

# attacker — Python (second terminal; NO credentials are used):
python3 exploit.py --host localhost --port 61616 \
    --session-name "$(cat victim/victim-session.txt)"

# attacker — Go:
cd go && go build -o exploit . && ./exploit \
    --host localhost --port 61616 \
    --session-name "$(cat ../victim/victim-session.txt)"
Baixar ferramenta

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

Sem dados de popularidade ainda.

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →