
Exploit proof-of-concept in Python e Go e un laboratorio Docker per CVE-2026-57967, dirottamento di sessione non autenticato di ActiveMQ Artemis tramite SESSION_REATTACH.
Dirottamento remoto non autenticato di una sessione autenticata del protocollo CORE in
Apache ActiveMQ Artemis 2.50.0 – 2.56.0 (e negli artefatti org.apache.activemq
1.0.0 – 2.44.0). Un attaccante in grado di aprire una connessione TCP verso l'acceptor CORE
(predefinito 0.0.0.0:61616) e che conosce il nome di sessione di una vittima può inviare
un pacchetto SESSION_REATTACH artigianale, e il broker trasferisce la sessione
pienamente autenticata della vittima — il suo contesto di sicurezza, i consumer, le consegne
in sospeso — sulla connessione dell'attaccante. Nessun nome utente, nessuna password, nessuna identità
client TLS viene mai verificata su questo percorso.
Questo repository contiene un exploit Python funzionante e senza dipendenze, oltre a un client "vittima" Java, e un laboratorio docker con due broker (2.56.0 vulnerabile e 2.57.0 corretto) per riprodurre l'attacco end-to-end.
[!CAUTION] Questo materiale è fornito esclusivamente per ricerca di sicurezza autorizzata e test difensivi (vedere la dichiarazione di esclusione di responsabilità in fondo). Attaccare sistemi di cui non si è proprietari o che non si gestiscono senza autorizzazione scritta è illegale.
Il protocollo CORE multiplexa i canali su un'unica connessione TCP. Il canale 1 è
il canale di gestione delle sessioni (CoreProtocolManager lo crea per ogni
connessione in ingresso) e — nella 2.56.0 — non richiede alcun handshake di alcun tipo
prima dell'uso. ActiveMQPacketHandler vi distribuisce quattro tipi di pacchetto,
incluso 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);
}
...
}
L'handler non consulta mai il SecurityStore — si confronti il percorso
legittimo di creazione della sessione (CREATESESSION), che chiama server.validateUser(...).
ReattachSessionMessage trasporta solo un nome di sessione e un int. Il nome
è la chiave di CoreProtocolManager.sessionHandlers, quindi chi lo conosce diventa il
proprietario della sessione: ServerSessionPacketHandler.transferConnection(...) riassocia il
canale lato server della vittima alla connessione TCP dell'attaccante, riproduce
la cache dei comandi non confermati del canale all'attaccante e, da quel momento, ogni
pacchetto SESS_* che l'attaccante invia su quel canale viene eseguito con il
contesto di sicurezza autenticato della vittima (browse/consume/send/ack, gestione di code e
indirizzi entro i permessi della vittima). Le consegne dei messaggi per
i consumer della vittima vanno al socket dell'attaccante; la connessione della vittima stessa
diventa muta — il suo canale non esiste più su di essa.
Corretto in 2.57.0 tramite ARTEMIS-6245,
commit
26ce5813
("Reattachment should be disabled"). L'handler lato server è stato eliminato; il
caso REATTACH ora risponde sempre ReattachSessionResponseMessage(-1, false),
e l'autenticazione a livello di connessione è stata introdotta con il nuovo pacchetto
CONNECT (commit 51b06748, "Improve Core connection handshake").
org.apache.artemis:artemis-server 2.50.0 – 2.56.0org.apache.activemq:artemis-server 1.0.0 – 2.44.0Annuncio: OSS Security mirror · testo dell'advisory ASF
Il formato wire CORE è minimale, quindi exploit.py lo parla usando nient'altro che
la libreria standard di 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)
ARTEMIS + un pacchetto
REATTACH_SESSION (tipo 32, canale 1). Il payload è il nome della sessione
della vittima (codifica stringa Artemis: int32 lunghezza caratteri + short lunghezza byte UTF-8 +
byte) seguito da int32 lastConfirmedCommandID = -1.reattached=true significa che la sessione
autenticata ora risiede sulla connessione dell'attaccante. (reattached=false è un
oracolo di esistenza per i nomi di sessione; contro la 2.57.0 è il comportamento
fisso.)SimpleIDGenerator
conta a partire da USER(10)).SESS_START (tipo 67) sul canale della vittima: le consegne per i
consumer della vittima ora arrivano all'attaccante. Il PoC stampa i corpi dei messaggi
VICTIM-SECRET-* intercettati come prova.Oltre a ricevere messaggi, l'attaccante può eseguire operazioni SESS_* arbitrarie
(creare consumer/producer, inviare, confermare, chiudere — vedere le costanti di tipo
PacketImpl in exploit.py) sotto l'identità della vittima.
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
Requisiti: Docker, Python 3, JDK (javac/java). Go 1.21+ per l'exploit 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 &