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

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

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

一、Java内存马简介

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

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

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

二、整体思路

无论是以上哪种攻击方式，从防守方的角度来说，检测的方式都是通过java instrumentation机制，将检测jar包attach到tomcat jvm，检查加载到jvm中的类是否异常。

整体检测思路为：

获取tomcat jvm中所有加载的类

遍历每个类，判断是否为风险类。我们把可能被攻击方新增/修改内存中的类，标记为风险类(比如实现了filter/servlet的类)

遍历风险类，检查是否为webshell：

检查高风险类的class文件是否存在；

反编译风险类字节码，检查java文件中包含恶意代码

三、获取jvm中所有加载的类

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

通过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 descriptor，传到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();

}

四、风险类识别

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

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

对于内存中的每一个类，递归检查其父类，然后将命中特征的类标记为风险类。

public static List> findAllSuspiciousClass (Instrumentation ins, Class>[] loadedClasses){

// 结果

List> suspiciousClassList = new ArrayList>();

List loadedClassesNames = new ArrayList();

// 获取所有风险类

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 riskInterface = new ArrayList();

// filter型

riskInterface.add("javax.servlet.Filter");

// servlet型

riskInterface.add("javax.servlet.Servlet");

// listener型

riskInterface.add("javax.servlet.ServletRequestListener");

try {

// 获取类实现的interface

List clazzInterfaces = new ArrayList();

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 riskSuperClassesName = new ArrayList();

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 riskAnnotations = new ArrayList();

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 riskClassName = new ArrayList();

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 riskPackage = new ArrayList();

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 catlina = (Map)((Map)domainTb).get("Catalina");

for (Map.Entry 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中配置，会引起误报，因此仅可作为一个查找风险类参考条件。

五、检测是否为内存马

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

1.内存马，对应的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;

}

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

public static Boolean checkFileContentIsRisk(File dumpPath){

List riskKeyword = new ArrayList();

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;

}

六、小结

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

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

感谢 fnmsd、c0ny1、LandGrey 师傅们的支持。

七、参考文章

本文由 Seebug Paper 发布，如需转载请注明来源。本文地址：https://paper.seebug.org/1381/