Tomcat 内存马检测-安全客

随着HW、攻防对抗的强度越来越高，各大厂商对于webshell的检测技术愈发成熟，对于攻击方来说，传统的文件落地webshell的生存空间越来越小，无文件webshell已经逐步成为新的研究趋势。

三月底针对tomcat内存马的检测写了一个demo，但由于对Maven打包理解不深，整个项目结构比较糟糕。

国庆前研究了LandGrey师傅的copagent项目，在该项目基础上进行了重构，并于本文中记录了检测思路，以及部分核心代码。

作者： jweny @360云安全

0x01 Java内存马简介

关于JAVA内存马的发展历史，这里引用下 c0ny1师傅的总结。早在17年n1nty师傅的《Tomcat源码调试笔记-看不见的shell》中已初见端倪，但一直不温不火。后经过rebeyond师傅使用agent技术)加持后，拓展了内存马的使用场景，然终停留在奇技淫巧上。在各类hw洗礼之后，文件shell明显气数已尽。内存马以救命稻草的身份重回大众视野。特别是今年在shiro的回显研究之后，引发了无数安全研究员对内存webshell的研究，其中涌现出了LandGrey师傅构造的Spring controller内存马。

从攻击对象来说，可以将Java内存马分为以下几类：

为方便学习，webshell demo已整理至github。

0x02 整体思路

无论是以上哪种攻击方式，影响的均为加载到tomcat jvm中的类。

从防守方的角度来说，可以通过java instrumentation机制，将检测jar包attach到tomcat jvm，检查加载到jvm中的类是否异常。

整体检测思路为：

1.获取tomcat jvm中所有加载的类
2.遍历每个类，判断是否为风险类。这里把可能被攻击方新增/修改内存中的类，标记为风险类（比如实现了filter/servlet的类）
3.遍历风险类，检查是否为webshell：
- 检查高风险类的class文件是否存在；
- 反编译风险类字节码，检查java文件中包含恶意代码

0x03 获取jvm中所有加载的类

1.遍历java jvm，查找所有的tomcat jvm

2.通过java instrumentation，将agent attach到每个tomcat jvm。由于可能存在多个tomcat进程的场景，因此每个tomcat jvm均检测一遍

// 应对存在多个 tomcat 进程的情况
public static void attach(String agent_jar_path) throws Exception {
    VirtualMachine virtualMachine = null;
    for (VirtualMachineDescriptor descriptor : VirtualMachine.list()) {
        if (descriptor.displayName().contains("catalina") || descriptor.displayName().equals("")) {
            try {
                virtualMachine = VirtualMachine.attach(descriptor);
                Properties targetSystemProperties = virtualMachine.getSystemProperties();
                if (descriptor.displayName().equals("") && !targetSystemProperties.containsKey("catalina.home"))
                    continue;
                // 将当前tomcat pid，传到agent，作为检测结果的文件名，用来区分多个tomcat进程。
                String currentJvmName = "tomcat_" + descriptor.id();
                Thread.sleep(1000);
                javaInfoWarning(targetSystemProperties);
                virtualMachine.loadAgent(agent_jar_path, currentJvmName);
            } catch (Throwable t) {
                t.printStackTrace();
            } finally {
                    // detach
                if (null != virtualMachine)
                    virtualMachine.detach();
            }
        }
    }
}

3.遍历tomcat jvm 加载过的类

private static synchronized void detectMemShell(String currentJvmName, Instrumentation ins) {
    // 获取所有加载的类
    Class<?>[] loadedClasses = ins.getAllLoadedClasses();
}

0x04 风险类识别

最理想的做法是把所有加载的类都认定为风险类。但在绝大多数情况下jvm加载的都是正常的类，每次检查时，都dump所有加载的类，对于tomcat来说开销有点大。

比较实际的做法是，根据已知内存马要新增/修改的类生成特征。

对于内存中的每一个类，检查其自身，并递归检查其父类，如果命中特征，就标记为风险类。

public static List<Class<?>> findAllSuspiciousClass (Instrumentation ins, Class<?>[] loadedClasses){
    // 结果
    List<Class<?>> suspiciousClassList = new ArrayList<Class<?>>();
    List<String> loadedClassesNames = new ArrayList<String>();
    // 获取所有风险类
    for (Class<?> clazz : loadedClasses) {
        loadedClassesNames.add(clazz.getName());
        // 递归 检查class的父类 空或java.lang.Object退出
        while (clazz != null && !clazz.getName().equals("java.lang.Object")) {
            if (
                    ClassUtils.lsContainRiskPackage(clazz) ||
                            ClassUtils.isUseAnnotations(clazz) ||
                            ClassUtils.lsHasRiskSuperClass(clazz) ||
                            ClassUtils.lsRiskClassName(clazz) ||
                            ClassUtils.lsReleaseRiskInterfaces(clazz)
            ){
                if (loadedClassesNames.contains(clazz.getName())) {
                    suspiciousClassList.add(clazz);
                    ClassUtils.dumpClass(ins, clazz.getName(), false,
                            Integer.toHexString(clazz.getClassLoader().hashCode()));
                    break;
                }
                LogUtils.logToFile("cannot find " + clazz.getName() + " classes in instrumentation");
                break;
            }
            clazz = clazz.getSuperclass();
        }
    }
    return suspiciousClassList;
}

这里借鉴了LandGrey师傅的黑名单，将内存马的目标类的类名、继承类、实现类、所属的包、使用的注解均设置黑名单。

1. 实现类黑名单

检测类是否实现javax.servlet.Filter / javax.servlet.Servlet / javax.servlet.ServletRequestListener接口类。

// 检测类是否实现高风险接口，如servlet/filter/Listener
public static Boolean lsReleaseRiskInterfaces(Class<?> clazz){
    // 高风险的接口
    List<String> riskInterface = new ArrayList<String>();
    // filter型
    riskInterface.add("javax.servlet.Filter");
    // servlet型
    riskInterface.add("javax.servlet.Servlet");
    // listener型
    riskInterface.add("javax.servlet.ServletRequestListener");
    try {
        // 获取类实现的interface
        List<String> clazzInterfaces = new ArrayList<String>();
        for (Class<?> cls : clazz.getInterfaces())
            clazzInterfaces.add(cls.getName());
        // 两个list有交集 返回true
        clazzInterfaces.retainAll(riskInterface);
        if(clazzInterfaces.size()>0){
            return Boolean.TRUE;
        }
    } catch (Throwable ignored) {}
    return Boolean.FALSE;
}

2. 继承类黑名单

// 检测父类是否属于高风险
public static Boolean lsHasRiskSuperClass(Class<?> clazz) {
    // 高风险的父类
    List<String> riskSuperClassesName = new ArrayList<String>();
    riskSuperClassesName.add("javax.servlet.http.HttpServlet");
    try {
        if ((clazz.getSuperclass() != null
                && riskSuperClassesName.contains(clazz.getSuperclass().getName())
        )){
            return Boolean.TRUE;
        }
    }catch (Throwable ignored) {}
    return Boolean.FALSE;
}

3. 注解黑名单

通过clazz.getDeclaredAnnotations() 获取所有注解，如果类使用了spring注册路由的注解，则标记为高风险。

public static Boolean isUseAnnotations(Class<?> clazz) {
    // 针对spring注册路由的一些注解
    List<String> riskAnnotations = new ArrayList<String>();
    riskAnnotations.add("org.springframework.stereotype.Controller");
    riskAnnotations.add("org.springframework.web.bind.annotation.RestController");
    riskAnnotations.add("org.springframework.web.bind.annotation.RequestMapping");
    riskAnnotations.add("org.springframework.web.bind.annotation.GetMapping");
    riskAnnotations.add("org.springframework.web.bind.annotation.PostMapping");
    riskAnnotations.add("org.springframework.web.bind.annotation.PatchMapping");
    riskAnnotations.add("org.springframework.web.bind.annotation.PutMapping");
    riskAnnotations.add("org.springframework.web.bind.annotation.Mapping");
    try {
        // 获取所有注解
        Annotation[] da = clazz.getDeclaredAnnotations();
        if (da.length > 0)
            for (Annotation _da : da) {
                // 比较 注解 && 高风险注解 如果有交集 返回True
                for (String _annotation : riskAnnotations) {
                    if (_da.annotationType().getName().equals(_annotation))
                        return Boolean.TRUE;
                }
            }
    } catch (Throwable ignored) {}
    return Boolean.FALSE;
}

4. 类名黑名单

// 高风险的类名
public static Boolean lsRiskClassName(Class<?> clazz){
    List<String> riskClassName = new ArrayList<String>();
    riskClassName.add("org.springframework.web.servlet.handler.AbstractHandlerMapping");
    try {
        if (riskClassName.contains(clazz.getName())){
            return Boolean.TRUE;
        }
    }catch (Throwable ignored) {}
    return Boolean.FALSE;
}

5. 包名黑名单

// 检测是否属于高风险的包
public static Boolean lsContainRiskPackage(Class<?> clazz){
    // 高风险的包
    List<String> riskPackage = new ArrayList<String>();
    riskPackage.add("net.rebeyond.");
    riskPackage.add("com.metasploit.");
    try {
        for (String packageName : riskPackage) {
            if (clazz.getName().startsWith(packageName)) {
                return Boolean.TRUE;
            }
        }
    }catch (Throwable ignored) {}
    return Boolean.FALSE;
}

6. 基于mbean的filter/servlet风险类识别

这里分享另一种filter/servlet的检测，检测思路是通过mbean获取sevlet/filter列表，内存马的filter是动态注册的，所以web.xml中肯定没有相应配置，因此通过对比可以发现异常的filter。

MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
Object mbsInte = getFieldValue(mbs, "mbsInterceptor");
Object repository = getFieldValue(mbsInte, "repository");
Object domainTb = getFieldValue(repository, "domainTb");
Map<String, Object> catlina = (Map<String, Object>)((Map<String,Object>)domainTb).get("Catalina");
for (Map.Entry<String, Object> entry : catlina.entrySet()) {
  String key = entry.getKey();
  // servlet
  if (key.contains("j2eeType=Servlet")){...}
  // filter 
  if (key.contains("j2eeType=Servlet") && key.contains("name=jsp")){
    Object value = entry.getValue();
    Object obj = getFieldValue(value,"object");
    Object res = getResourceValue(obj);
    Object instance = getFieldValue(res,"instance");
    Object rctxt = getFieldValue(instance, "rctxt");
    Object context = getFieldValue(instance, "context");
    Object appContext = getFieldValue(context,"context");
    Object standardContext = getFieldValue(appContext,"context");
    Object filterConfigs = getFieldValue(standardContext,"filterConfigs");
    ...

不过这种方式有较大的缺陷。首先，mbean只是资源管理，并不影响功能，所以在植入内存马后再卸载掉注册的mbean即可绕过；其次，servlet 3.0引入了 @WebFilter 可以动态注册，这种也没有在web.xml中配置，会引起误报，因此仅可作为一个查找风险类的参考条件。

0x05 检测是否为内存马

遍历风险类列表，并检测以下规则：

内存马，对应的ClassLoader目录下没有对应的class文件

public static Boolean checkClassIsNotExists(Class<?> clazz){
    String className = clazz.getName();
    String classNamePath = className.replace(".","/") + ".class";
    URL isExists = clazz.getClassLoader().getResource(classNamePath);
    if (isExists == null){
        return Boolean.TRUE;
    }
    return Boolean.FALSE;
}

反编译该类的字节码，检查是否存在危险函数

public static Boolean checkFileContentIsRisk(File dumpPath){
    List<String> riskKeyword = new ArrayList<String>();
    riskKeyword.add("javax.crypto.");
    riskKeyword.add("ProcessBuilder");
    riskKeyword.add("getRuntime");
    riskKeyword.add("ProcessImpl");
    riskKeyword.add("shell");
    String content = PathUtils.getFileContent(dumpPath);
    for (String keyword : riskKeyword) {
        if (content.contains(keyword)) {
            return Boolean.TRUE;
        }
    }

结果输出参考：如果没有class文件，可将该类风险等级标为high。如果包含恶意代码，将该类风险等级调至最高级。

// 输出结果
public static String getClassRiskLevel(Class<?> clazz, File dumpPath) {
    String riskLevel = "Low";
    // 检测 Classloader目录下是否存在class文件
    if (AnalysisUtils.checkClassIsNotExists(clazz)){
        riskLevel = "high";
    }
    // 反编译  检测java文件是否包含执行命令的危险函数
    if (AnalysisUtils.checkFileContentIsRisk(dumpPath)){
        riskLevel = "Absolutely";
    }
    return riskLevel;
}

0x06 小结

本文仅对Tomcat内存马的检测提供了一些思路，但并未提及查杀，查杀将在下一篇详细分享。

以上所有方法的黑名单列表仅供参考，可自行更改、扩充。

再次感谢 fnmsd、c0ny1、LandGrey 师傅们的大力支持。

Tomcat 内存马检测

译文声明

0x01 Java内存马简介

0x02 整体思路

0x03 获取jvm中所有加载的类

0x04 风险类识别

1. 实现类黑名单

2. 继承类黑名单

3. 注解黑名单

4. 类名黑名单

5. 包名黑名单

6. 基于mbean的filter/servlet风险类识别

0x05 检测是否为内存马

0x06 小结

0x07 参考文章

发表评论

TA的文章

从RFC规范看如何绕过waf上传表单下篇

pocassist——全新的开源在线poc测试框架

从RFC规范看如何绕过waf上传表单上篇

Java反序列化机制拒绝服务的利用与防御

从TemplatesImpl类Gadget中提取bytecode

相关文章

HelloKitty 勒索软件更名并重新投入运营

“Kapeka”和“Fuxnet”：俄乌对攻使用的 ICS 恶意软件

SteganoAmor：超过300家公司差点陷入复杂的“爱情陷阱”

Bing 广告冒充 NordVPN 旨在传播 SecTopRAT 恶意软件

新型Latrodectus病毒：由IcedID进化

Byakugan：针对葡语国家的恶意软件

“TheMoon”恶意软件尾大不掉，机器人数量 40000个，来自88个国家

热门推荐