Java Filter 型内存马调试系列 (三)——一种Tomcat全版本获取StandardContext的新方法（全网首次发布，精调无错版）_standardcontext获取

最新推荐文章于 2024-06-25 17:38:23 发布
最新推荐文章于 2024-06-25 17:38:23 发布
阅读量438 收藏 8
点赞数 3
分类专栏： 程序员 文章标签： java tomcat 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84968882/article/details/138982112
版权

0x01 具体实现

参考了这篇文章的思路：

Java内存马：一种Tomcat全版本获取StandardContext的新方法 - 先知社区​​​​​​，但文中的代码和逻辑均有错误。

我改进优化的代码：

2.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="org.apache.catalina.core.StandardEngine" %>
<%@ page import="org.apache.catalina.core.StandardHost" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="java.util.HashMap" %>
<%@ page import="java.util.Iterator" %>
<%@ page import="java.util.logging.Logger" %>
<%!
    String uri;
    String serverName;
    StandardContext standardContext;

    public Object getField(Object object, String fieldName) {
        Logger log3 = Logger.getLogger("113");
        Field declaredField;
        Class clazz = object.getClass();
        while (clazz != Object.class) {
            try {
                declaredField = clazz.getDeclaredField(fieldName);   // 取得这个类自己定义的所有公开的私有的字段,但是不包括继承的字段
                declaredField.setAccessible(true);
                return declaredField.get(object);
            } catch (NoSuchFieldException e) {
                //log3.info(e.toString()); //java.lang.NoSuchFieldException
            } catch (IllegalAccessException e) {
                log3.info(e.toString());
            }
            clazz = clazz.getSuperclass();
        }
        return null;
    }


    public void getStandardContext() {
        String ANSI_YELLOW = "\u001B[33m";
        String ANSI_GREEN = "\u001B[32m";
        String ANSI_RESET = "\u001B[0m";
        Logger log2 = Logger.getLogger("113");
        log2.info(ANSI_YELLOW + "getStandardContext method ing..." + ANSI_RESET);
        Thread[] threads = (Thread[]) this.getField(Thread.currentThread().getThreadGroup(), "threads");
        //log2.info(String.valueOf(threads.length));  //32

        for (Thread thread : threads) {
            // 过滤掉不相关的线程
            if (thread == null || thread.getName().contains("exec")) {
                continue;
            }

            if ((thread.getName().contains("Acceptor") || thread.getName().contains("Poller")) && (thread.getName().contains("http"))) {  // thread  http-nio-8080-Acceptor
                log2.info("thread: " + thread.getName());
                Object target = this.getField(thread, "target"); //target org.apache.tomcat.util.net.Acceptor@6698f6ae
                log2.info("target: " + target.toString());
                HashMap children;
                Object jioEndPoint = null;

                // Poller 线程
                if (thread.getName().contains("Poller")) {
                    try {
                        jioEndPoint = getField(target, "this$0");  //等价于  thread.getClass().getDeclaredField("this$0");  // Poller 线程
                        log2.info("jioEndPoint: " + jioEndPoint.toString());
                    } catch (Exception e) {
                        //log2.info(e.toString());  //java.lang.NullPointerException
                    }
                } else
                    // Acceptor 线程
                    if (thread.getName().contains("Acceptor")) {
                        //if (jioEndPoint == null) {
                        try {
                            jioEndPoint = getField(target, "endpoint");  // org.apache.tomcat.util.net.NioEndpoint@4eaaa9
                            log2.info("jioEndPoint: " + jioEndPoint.toString());
                        } catch (Exception e) {
                            log2.warning("异常，准备return " + e.toString());
                            return;
                        }
                    }
                Object service = getField(getField(getField(getField(getField(jioEndPoint, "handler"), "proto"), "adapter"), "connector"), "service");
                log2.info("service: " + service.toString());   // StandardService[Catalina]
                StandardEngine engine = null;
                try {
                    // tomcat 6,7,8
                    engine = (StandardEngine) getField(service, "container");
                    log2.info("engine: " + engine.toString());
                } catch (Exception e) {
                    //log2.info(e.toString());  //java.lang.NullPointerException
                }
                if (engine == null) {
                    // tomcat 9
                    engine = (StandardEngine) getField(service, "engine");  // StandardEngine[Catalina]
                    log2.info("engine: " + engine.toString());
                }

                children = (HashMap) getField(engine, "children");  //{localhost=StandardEngine[Catalina].StandardHost[localhost]}
                log2.info("children: " + children.toString());
                try {
                    // 这里使用ip会有问题会走catch的逻辑，也可以都用catch的逻辑代替
                    StandardHost standardHost = (StandardHost) children.get(this.serverName);
                    children = (HashMap) getField(standardHost, "children");
                    log2.info("standardHost: " + standardHost.toString());
                    Iterator iterator = children.keySet().iterator();
                    while (iterator.hasNext()) {
                        String contextKey = (String) iterator.next();
                        if (!(this.uri.startsWith(contextKey))) {
                            continue;
                        }
                        StandardContext standardContext = (StandardContext) children.get(contextKey);
                        this.standardContext = standardContext;
                        return;
                    }
                } catch (Exception e) {
                    // 不管是用 ip 还是 localhost 访问 最终都是走这个逻辑   children.get("localhost");
                    //log2.info(e.toString());  // java.lang.NullPointerException

                    StandardHost standardHost = (StandardHost) children.get("localhost");
                    log2.info("standardHost: " + standardHost.toString());
                    try {
                        children = (HashMap) getField(standardHost, "children");
                        Iterator iterator = children.keySet().iterator();
                        while (iterator.hasNext()) {
                            String contextKey = (String) iterator.next();
                            if (this.uri.startsWith(contextKey) && contextKey != "") {
                                StandardContext standardContext = (StandardContext) children.get(contextKey);
                                this.standardContext = standardContext; // StandardEngine[Catalina].StandardHost[localhost].StandardContext[/untitled3_war_exploded]
                                log2.warning(ANSI_GREEN + "standardContext: " + standardContext.toString() + ANSI_RESET);
                                return;
                            }
                        }
                    } catch (Exception e2) {
                        //log2.info(e2.toString()); //java.lang.NoSuchFieldException: children
                    }
                }
            }
        }
    }

    public StandardContext getSTC() {
        return this.standardContext;
    }

%>
<%
    String ANSI_RESET = "\u001B[0m";
    String ANSI_RED = "\u001B[31m";
    String ANSI_GREEN = "\u001B[32m";
    String ANSI_YELLOW = "\u001B[33m";
    Logger log = Logger.getLogger("main");

    Thread[] threads = (Thread[]) this.getField(Thread.currentThread().getThreadGroup(), "threads"); // tomcat 线程
    Object object;
    for (Thread thread : threads) {
        if (thread == null || thread.getName().contains("exec")) {
            continue;
        }
        log.info(ANSI_RED + "main_thread: " + thread + ANSI_RESET);        // 打印 线程  // Thread[main,5,main]  // Thread[Monitor Ctrl-Break,5,main]
        if (thread.getName().contains("Acceptor") || thread.getName().contains("Poller")) {
            Object target = this.getField(thread, "target");  //! target instanceof Runnable
            log.info("main_target: " + target);
            log.info(String.valueOf(target instanceof Runnable));
            if (!(target instanceof Runnable)) {
                continue;
            }

            try {
                object = getField(getField(getField(target, "this$0"), "handler"), "global");
            } catch (Exception e) {
                //log.warning(ANSI_RED+e.toString()+ANSI_RESET); // java.lang.NoSuchFieldException
                continue;
            }
            if (object == null) {
                continue;
            }
            java.util.ArrayList processors = (java.util.ArrayList) getField(object, "processors");
            Iterator iterator = processors.iterator();
            while (iterator.hasNext()) {
                Object next = iterator.next();
                Object req = getField(next, "req");   // 获取 req 对象
                // 过滤 // req: R( null)
                Object serverPort = getField(req, "serverPort");
                if (serverPort.equals(-1)) {   // 不是对应的请求时，serverPort = -1
                    continue;
                }
                log.info("req: " + req.toString());  // req: R( /untitled3_war_exploded/2.jsp)

                org.apache.tomcat.util.buf.MessageBytes serverNameMB = (org.apache.tomcat.util.buf.MessageBytes) getField(req, "serverNameMB");
                this.serverName = (String) getField(serverNameMB, "strValue");
                if (this.serverName == null) {
                    this.serverName = serverNameMB.toString();
                }
                if (this.serverName == null) {
                    this.serverName = serverNameMB.getString();
                }
                log.info(this.serverName.toString());  // 10.10.40.65
                org.apache.tomcat.util.buf.MessageBytes uriMB = (org.apache.tomcat.util.buf.MessageBytes) getField(req, "uriMB");
                this.uri = (String) getField(uriMB, "strValue");
                if (this.uri == null) {
                    this.uri = uriMB.toString();
                }
                if (this.uri == null) {
                    this.uri = uriMB.getString();
                }
                log.info(this.uri.toString());
                this.getStandardContext();
            }
        }
    }
%>

0x02 复盘总结

getField(jioEndPoint, "handler").proto.endpoint.poller.selector.keys[0]


(threads[6].target.endpoint.poller.selector.keys).toArray()[0].channel.toString()
## 最后

**自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。**

**深知大多数网络安全工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**

**因此收集整理了一份《2024年网络安全全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。**

![img](https://img-blog.csdnimg.cn/img_convert/d9f6991881adcb1e3e690bd10fd6d297.png)

![img](https://img-blog.csdnimg.cn/img_convert/942e4bf13dfbd6b296b82c51e451d126.png)

![img](https://img-blog.csdnimg.cn/img_convert/706cee8dc3aed9a06e8ce3bd2c0d68d5.png)

![img](https://img-blog.csdnimg.cn/img_convert/071c505e799aa5bfde69812ec7997b33.png)

![img](https://img-blog.csdnimg.cn/img_convert/3b249039edaf525253ef37741c16db7f.png)

 

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上网络安全知识点！真正的体系化！**

[**如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！**](https://bbs.csdn.net/topics/618653875)

**由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！**

..(img-IYkdmKW1-1715881543180)]

 

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上网络安全知识点！真正的体系化！**

[**如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！**](https://bbs.csdn.net/topics/618653875)

**由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！**
2401_84968882
关注
专栏目录
Java内存马攻防实战——攻击基础篇
JavaMonsterr的博客
05-23 3320
在红蓝对抗中，攻击方广泛应用webshell等技术在防守方提供的服务中植入后门，防守方也发展出各种技术来应对攻击，传统的落地型webshell很容易被攻击方检测和绞杀。而内存马技术则是通过在运行的服务中直接插入运行攻击者的webshell逻辑，利用中间件的进程执行某些恶意代码，而不依赖实体文件的存在实现的服务后门，因此具有更好的隐蔽性，也更容易躲避传统安全监测设备的检测。 本文以Java语言为基础讨论内存马技术的攻防，分为两个篇章，分别是攻击基础篇和防护应用篇。本篇攻击基础篇介绍了Java Servlet
【安全记录】基于Tomcat的Java内存马初探
君行路的博客
08-22 479
文章目录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
Spring Boot启动过程（六）之内嵌Tomcat中StandardHost、StandardContext和StandardWrapper的启动教程详解
08-30
主要介绍了Spring Boot启动过程（六）之内嵌Tomcat中StandardHost、StandardContext和StandardWrapper的启动教程详解,需要的朋友可以参考下
AAA-------网安的一种管理机制--认证授权计费
2401_84970893的博客
05-12 478
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数网络安全工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！因此收集整理了一份《2024年网络安全全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上网络安全知识点！真正的体系化！
17,tomcat中StandardContext
老男人
11-15 199
一个上下文容器（Context）代表一个web应用，每一个上下文包括多个包装器（Wrapper），每个包装器代表一个Servlet上下文还需要其它的一些组件如加载器和管理器Context接口的标准实现，org.apache.catalina.core.StandardContext类 StandardContext配置创建一个StandardContext实例之后，必须调用它的start方法，这...
tomcat源码研读笔记—tomcat的接收请求之四 StandardContext接收请求
plkkoko的专栏
03-22 408
StandardContext继承关系：根据继承关系，我们可以知道，跟之前处理请求的机制基本是一致的。只是standardContext重写了父类的invoke方法： public void invoke(Request request, Response response)       throws IOException, ServletException {        // Wait i...
S04-tomcat之Filter内存马1
08-03
【标题】："S04-tomcat之Filter内存马1" 【描述】："理解Tomcat中的Filter内存马，涉及servlet-api以及Tomcat组件动态注册的实现，关注Filter的生命周期和内存马的创建思路。" 在Java Web开发中，Tomcat作为常用的...
shiro 内存马_Tomcat 内存马检测
weixin_39637921的博客
12-22 1530
随着HW、攻防对抗的强度越来越高，各大厂商对于webshell的检测技术愈发成熟，对于攻击方来说，传统的文件落地webshell的生存空间越来越小，无文件webshell已经逐步成为新的研究趋势。三月底针对tomcat内存马的检测写了一个demo，但由于对Maven打包理解不深，整个项目结构比较糟糕。国庆前偶然发现LandGrey师傅的copagent项目，在该项目基础上进行了重构，并于本文中记录...
内存马初探-Filter
qq_31065143的博客
04-18 1238
内存马初探-Filter Tomcat简介 tomcat其实质上就是一个大点的servlet容器，那什么是容器呢，我觉得其实就是一个类。在tomcat中各个容器之间嵌套。而这些容器都是有生命周期的java类，都继承了共同的接口Lifecycle，所以Lifecycle就是这些容器的顶层接口。下面来谈谈存在哪些容器。 容器 init()方法：初始化容器组件，它必须在启动容器之前调用。它会创建许多对象。 start():启动容器，比如启动一个Server。 stop()：停止执行 destroy()：销毁这个
tomcat源码阅读之StandardContext
weixin_30522183的博客
12-18 168
Context实例表示一个具体的web应用程序，其中包含一个或者多个Wrapper实例，每个Wrapper表示一个具体的servlet定义。StandardContext类是Context接口的标准实现。 一、相关类 UML图： 1、StandardContext是一个相当复杂的容器类，他实现了Context接口，类的很多功能是依赖于其他对象完成的，因此在start启动Context时会...
Tomcat 9 源码解析 -- StandardContext
gaohaicheng123的博客
05-07 1223
StandardContext 类介绍 StandardContext 和其他 Container 一样，也是重写了 startInternal 方法。由于涉及到 webapp 的启动流程，需要很多准备工作，比如使用 WebResourceRoot 加载资源文件、利用 Loader 加载 class、使用 JarScanner 扫描 jar 包，等等。因此StandardContex...
Tomcat启动流程之StandardContext启动
一场梦的博客
03-12 1093
StandardContext启动 对一些启动过程进行详细分析一下这个分析不是完整的完整的请看我的收藏这里只是对一些不清楚的地方补充了一下 protected void deployApps() { File appBase = host.getAppBaseFile(); File configBase = host.getConfigBaseFile(); ...
Tomcat 运行报错:StandardContext......
weixin_30587927的博客
12-22 247
2009-12-22 11:05:19 StandardContext[/balancer]org.apache.webapp.balancer.BalancerFilter: init(): ruleChain: [org.apache.webapp.balancer.RuleChain: [org.apache.webapp.balancer.rules.URLStringMatchRule:...
Tomcat原理学习---StandardContext
zcm482的专栏
06-12 479
在前面的章节中已经看到，一个上下文容器（Context）代表一个web应用，每一个上下文包括多个包装器（Wrapper），每个包装器代表一个Servlet。但是，上下文还需要其它的一些组件如加载器和管理器。本章要介绍 Catalina中Context接口的标准实现，org.apache.catalina.core.StandardContext类. 我们首先介绍StandardConte
tomcat解析(十三)StandardContext
holly2k的专栏
02-02 2721
在一个tomcat服务器的生命周期内可以会创建一个或多个StandardContext对象，StandardContext对象代表的是一个具体的工程项目，对应的可以是server.xml里的标签或webapps文件夹下的某一个工程文件夹或war包，也可以对应于conf/Catalina/localhost文件夹下的任一个xml文件里的Context配置，在tomcat中，这些context代表的是
深入剖析Tomcat(十二) 详解StandardContext
最新发布
咖啡煮码
06-25 1169
Tomcat中Context容器的标准实现：StandardContext。类加载、会话管理、uri映射…
从零开始手写Tomcat的教程12节----StandardContext
m0_53157173的博客
03-21 723
从零开始手写Tomcat的教程12节----StandardContextStandardContext的配置StandardContext类的构造函数启动StandardContext类的实例invoke方法StandardContextMapper类对重载的支持backgroundProcess()方法小结 StandardContext的配置 StandardContext类的构造函数 /** * Create a new StandardContext compon
StandardContext分析-tomcat6.x源码阅读
weixin_33724046的博客
10-20 133
2019独角兽企业重金招聘Python工程师标准>>> ...
Tomcat监听器揭秘：内存马利用与Java.util.EventListener应用
在Apache Tomcat中，Listener是一个关键的概念，它主要用于监控服务器的行为和管理应用程序的生命周期。Tomcat中的Listener主要分为两类：org.apache.catalina.LifecycleListener和Java原生的Java.util.Event...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值