原来Java反序列化远程执行漏洞这么简单

释放双眼,带上耳机,听听看~!

在这里我们对Java中反序列化问题引发的远程代码执行漏洞的原理进行介绍。为了简化说明,在不引入第3方库的前提下进行操作,希望能起到抛砖引玉的效果。

主要有3个部分组成:

Java的反省机制

Java的序列化处理

Java的远程代码执行

Java的反射与代码执行

我们先看1个简单的例子,使用Java调用计算器程序:

  1. import java.io.IOException; import java.lang.Runtime; public class Test { public static void main(String[] args) {
  2. Runtime env = Runtime.getRuntime();
  3. String cmd = "calc.exe"; try {
  4. env.exec(cmd);
  5. } catch (IOException e) {
  6. e.printStackTrace();
  7. }
  8. }
  9. }

我们从java.lang包中导入Runtime类,之后调用其getRuntime方法得到1个Runtime对象,该对象可以用于JVM虚拟机运行状态的处理。接着我们调用其exec方法,传入1个字符串作为参数。

此时,将启动本地计算机上的计算器程序。

下面我们通过Java的反省机制对上述的代码进行重写。通过Java的反省机制可以动态的调用代码,而逃过一些服务端黑名单的处理:

  1. import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method;
  2.  
  3. public class Test {
  4.  
  5. public static void main(String[] args) { try {
  6. Class<?> cls = Class.forName("java.lang.Runtime"); String cmd = "calc.exe"; try {
  7. Method getRuntime = cls.getMethod("getRuntime", new Class[] {}); Object runtime = getRuntime.invoke(null);
  8. Method exec = cls.getMethod("exec", String.class);
  9. exec.invoke(runtime, cmd);
  10. } catch (NoSuchMethodException e) {
  11. e.printStackTrace();
  12. } catch (SecurityException e) {
  13. e.printStackTrace();
  14. } catch (IllegalAccessException e) {
  15. e.printStackTrace();
  16. } catch (IllegalArgumentException e) {
  17. e.printStackTrace();
  18. } catch (InvocationTargetException e) {
  19. e.printStackTrace();
  20. }
  21. } catch (ClassNotFoundException e1) {
  22. e1.printStackTrace();
  23. }
  24. }
  25. }

上述代码看起来很繁琐,实际上并不是很难。首先,通过Class.forName传入1个字符串作为参数,其返回1个Class的实例。而其作用是根据对应的名称找到对应的类。

接着我们使用Class实例的getMethod方法获取对应类的getRuntime方法,由于该类没有参数,因此可以将其设置为null或使用匿名类来处理。

  1. Method getRuntime = cls.getMethod("getRuntime", new Class[] {});

之后通过得到的方法的实例的invoke方法调用对应的类方法,由于没有参数则传入null即可。同理,我们再获取到exec方法。

Java序列化处理

对于Java中的序列化处理,对应的类需要实现Serializable接口,例如:

  1. import java.io.Serializable; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; public class Reader implements Serializable { private static final long serialVersionUID = 10L; private void readObject(ObjectInputStream stream) {
  2. System.out.println("foo...bar...");
  3. } public static byte[] serialize(Object obj) { //序列化对象 ByteArrayOutputStream out = new ByteArrayOutputStream();
  4. ObjectOutputStream output = null; try {
  5. output = new ObjectOutputStream(out);
  6. output.writeObject(obj);
  7. output.flush();
  8. output.close();
  9.  
  10. } catch (IOException e) {
  11. e.printStackTrace();
  12. } return out.toByteArray();
  13.  
  14. } public static Object deserialize(byte[] bytes) { //反序列化处理 ByteArrayInputStream in = new ByteArrayInputStream(bytes);
  15. ObjectInputStream input;
  16. Object obj = null; try {
  17. input = new ObjectInputStream(in);
  18. obj = input.readObject();
  19. } catch (IOException e) {
  20. e.printStackTrace();
  21. } catch (ClassNotFoundException e) {
  22. e.printStackTrace();
  23. } return obj;
  24.  
  25. } public static void main(String[] args) { byte[] data = serialize(new Reader()); //对类自身进行序列化 Object response = deserialize(data);
  26. System.out.println(response);
  27. }
  28. }

在这里我们重写了该类的readObject方法,用于读取对象用于测试。其中比较重要的2个函数是serialize和deserialize,分别用于序列化和反序列化处理。

其中,serialize方法需要传入1个对象作为参数,其输出结果为1个字节数组。在该类中,其中的对象输出流ObjectOutputStream主要用于ByteArrayOutputStream进行包装,之后使用其writeObject方法将对象写入进去,最后我们通过ByteArrayOutputStream实例的toByteArray方法得到字节数组。

而在deserialize方法中,需要传入1个字节数组,而返回值为1个Object对象。与之前的序列化serialize函数类似,此时我们使用ByteArrayInputStream接收字节数组,之后使用ObjectInputStream对ByteArrayInputStream进行包装,接着调用其readObject方法得到1个Object对象,并将其返回。

当我们运行该类时,将得到如下的结果:

  1. foo...bar...

Java远程通信与传输

为了实现Java代码的远程传输及远程代码执行,我们可以借助RMI、RPC等方式。而在这里我们使用Socket进行服务端及客户端处理。

首先是服务器端,监听本地的8888端口,其代码为:

  1. import java.net.Socket; import java.io.IOException; import java.io.InputStream; import java.net.ServerSocket; public class Server { public static void main(String[] args) throws ClassNotFoundException { int port = 8888; try {
  2. ServerSocket server = new ServerSocket(port);
  3. System.out.println("Server is waiting for connect");
  4. Socket socket = server.accept();
  5. InputStream input = socket.getInputStream(); byte[] bytes = new byte[1024]; int length = 0; while((length=input.read(bytes))!=-1) {
  6. String out = new String(bytes, 0, length, "UTF-8");
  7. System.out.println(out);
  8. }
  9. input.close();
  10. socket.close();
  11. server.close();
  12. } catch (IOException e) {
  13. e.printStackTrace();
  14. }
  15. }
  16. }

我们通过传入1个端口来实例化ServerSocket类,此时得到1个服务器的socket,之后调用其accept方法接收客户端的请求。此时,得到了1个socket对象,而通过socket对象的getInputStream方法获取输入流,并指定1个长度为1024的字节数组。接着调用socket的read方法读取那么指定长度的字节序列,之后通过String构造器将字节数组转换为字符串并输出。这样我们就得到了客户端传输的内容。

而对于客户端器,其代码类似如下:

  1. import java.io.IOException; import java.net.Socket; import java.io.OutputStream; public class Client { public static void main(String[] args) {
  2. String host = "192.168.1.108"; int port = 8888; try {
  3. Socket socket = new Socket(host, port);
  4. OutputStream output = socket.getOutputStream();
  5. String message = "Hello,Java Socket Server";
  6. output.write(message.getBytes("UTF-8"));
  7. output.close();
  8. socket.close();
  9. } catch (IOException e) {
  10. e.printStackTrace();
  11. }
  12. }
  13. }

在客户端,我们通过Socket对象传递要连接的IP地址和端口,之后通过socket对象的getOutputStream方法获取到输出流,用于往服务器端发送输出。由于这里只是演示,使用的是本地的主机IP。而在实际应用中,如果我们知道某个外网主机的IP及开放的端口,如果当前主机存在对应的漏洞,也是可以利用类似的方式来实现的。

这里我们设置要传输的内容为UTF-8编码的字符串,俄日在输出流的write方法中通过字符串的getBytes指定其编码,从而将其转换为对应的字节数组进行发送。

正常情况下,我们运行服务器后再运行客户端,在服务器端可以得到如下输出:

  1. Server is waiting for connect
  2. Hello,Java Socket Server

Java反序列化与远程代码执行

下面我们通过Java反序列化的问题来实现远程代码执行,为了实现远程代码执行,我们首先在Reader类中添加1个malicious方法,其代码为:

  1. ... public Object malicious() throws IOException {
  2. Runtime.getRuntime().exec("calc.exe");
  3. System.out.println("Hacked the Server..."); return this;
  4. }

在该方法中我们使用之前的介绍调用宿主机器上的计算器程序,然后输出1个相关信息,最后返回当前类。

之后是对服务器端的代码进行如下的修改:

  1. ... while((length=input.read(bytes))!=-1) {
  2. Reader obj = (Reader) Reader.deserialize(bytes);
  3. obj.malicious();
  4. }

我们在接收到客户端对应的字符串后对其进行反序列处理,之后调用某个指定的函数,从而实现远程代码的执行。

而在客户端,我们需要对其进行序列化处理:

  1. Reader reader = new Reader();
  2. byte[] bytes = Reader.serialize(reader); String message = new String(bytes);
  3. output.write(message.getBytes());

下面我们在宿主机器上运行服务器端程序,之后在本地机器上运行客户端程序,当客户端程序执行时,可以看到类似如下的结果:原来Java反序列化远程执行漏洞这么简单-路人娱乐网

可以看到,我们成功的在宿主机器上执行了对应的命令执行。

总结

为了实现通过Java的反序列问题来实现远程代码执行的漏洞,我们需要编写1个有恶意代码注入的序列化类。之后在客户端将恶意代码序列化后发送给服务器端,而服务器端需要调用我们期望的方法,从而触发远程代码执行。

为了避免服务器端进行一些安全处理,我们可以采用反射的方式来逃逸其处理。

这里只是1个简化的过程,更加实用的过程可以参考Apache Common Collections的问题导致的Weblogic漏洞CVE-2015-4852及Jboss的漏洞CVE-2015-7501。

人已赞赏
论天地

有偿招收优质文章创作者

2020-12-18 23:06:19

论天地

分享一些短信轰炸接口

2021-1-5 9:19:03

0 条回复 A文章作者 M管理员
    暂无讨论,说说你的看法吧
个人中心
购物车
优惠劵
今日签到
有新私信 私信列表
搜索