1 Java 基础 ¶

1.1 ClassLoader 机制 ¶

JVM 架构图 : Java 类均要经过 ClassLoader 加载后才能运行，AppClassLoader 是默认的类加载器，如果类加载时我们不指定类加载器的情况下，默认会使用 AppClassLoader 加载类，ClassLoader.getSystemClassLoader() 返回的系统类加载器也是 AppClassLoader。

Java 类加载方式 ¶

1. 隐式加载：当程序创建对象实例或使用 ClassName.MethodName() 时，如果该对象的类还没有被加载，JVM 会自动调用类加载器加载该类。
2. 显式加载：通过 Java 反射机制或 ClassLoader 来动态加载类。

// 反射加载TestHelloWorld示例
Class.forName("xxx.TestHelloWorld");

// ClassLoader加载TestHelloWorld示例
this.getClass().getClassLoader().loadClass("xxx.TestHelloWorld");

Class.forName("类名") 默认会初始化被加载类的静态属性和方法，如果不希望初始化类可以使用 Class.forName("类名", false, 类加载器)，而 ClassLoader.loadClass 默认不会初始化类方法。

1.2 Java 反射 ¶

Java 反射 ( Reflection ) 是 Java 非常重要的动态特性，通过使用反射我们不仅可以获取到任何类的成员方法 (Methods )、成员变量 (Fields )、构造方法 ( Constructors ) 等信息，还可以动态创建 Java 类实例、调用任意的类方法、修改任意的类成员变量值等。Java 反射机制是 Java 语言的动态性的重要体现，也是 Java 的各种框架底层实现的灵魂。

获取 Class 对象 ¶

Java 反射操作的是java.lang.Class对象，所以我们需要先想办法获取到 Class 对象，通常我们有如下几种方式获取一个类的 Class 对象：

1. 类名.class，如 :cc.classloader.TestHelloWorld.class。
2. Class.forName("cc.classloader.TestHelloWorld")。
3. classLoader.loadClass("cc.classloader.TestHelloWorld");

获取数组类型的 Class 对象需要特殊注意 , 需要使用 Java 类型的描述符方式，如下：

Class<?> doubleArray = Class.forName("[D");//相当于double[].class
Class<?> cStringArray = Class.forName("[[Ljava.lang.String;");// 相当于String[][].class

获取 Runtime 类 Class 对象代码片段：

String className     = "java.lang.Runtime";
Class  runtimeClass1 = Class.forName(className);
Class  runtimeClass2 = java.lang.Runtime.class;
Class  runtimeClass3 = ClassLoader.getSystemClassLoader().loadClass(className);

通过以上任意一种方式就可以获取java.lang.Runtime类的 Class 对象了，反射调用内部类的时候需要使用$来代替. , 如cc.Test类有一个叫做Hello的内部类，那么调用的时候就应该将类名写成：cc.Test$Hello。

反射 java.lang.Runtime ¶

java.lang.Runtime因为有一个exec方法可以执行本地命令，所以在很多的payload中我们都能看到反射调用Runtime类来执行本地系统命令，通过学习如何反射Runtime类也能让我们理解反射的一些基础用法。

// 输出命令执行结果
System.out.println(org.apache.commons.io.IOUtils.toString(Runtime.getRuntime().exec("whoami").getInputStream(), "UTF-8"));

// 获取Runtime类对象
Class runtimeClass1 = Class.forName("java.lang.Runtime");

// 获取构造方法
Constructor constructor = runtimeClass1.getDeclaredConstructor();
constructor.setAccessible(true);

// 创建Runtime类示例，等价于 Runtime rt = new Runtime();
Object runtimeInstance = constructor.newInstance();

// 获取Runtime的exec(String cmd)方法
Method runtimeMethod = runtimeClass1.getMethod("exec", String.class);

// 调用exec方法，等价于 rt.exec(cmd);
Process process = (Process) runtimeMethod.invoke(runtimeInstance, cmd);

// 获取命令执行结果
InputStream in = process.getInputStream();

// 输出命令执行结果
System.out.println(org.apache.commons.io.IOUtils.toString(in, "UTF-8"));

反射创建类实例 ¶

在 Java 的任何一个类都必须有一个或多个构造方法，如果代码中没有创建构造方法那么在类编译的时候会自动创建一个无参数的构造方法。

Runtime 类构造方法示例代码片段 :

public class Runtime {
   /** Don't let anyone else instantiate this class */
  private Runtime() {}

}

Runtime类的构造方法为 private，所以我们没办法new一个Runtime类实例，但示例中我们借助了反射机制，修改了方法访问权限从而间接的创建出了Runtime对象。

runtimeClass1.getDeclaredConstructor和runtimeClass1.getConstructor都可以获取到类构造方法，区别在于后者无法获取到私有方法，所以一般在获取某个类的构造方法时候我们会使用前者去获取构造方法。如果构造方法有一个或多个参数的情况下我们应该在获取构造方法时候传入对应的参数类型数组，如：clazz.getDeclaredConstructor(String.class, String.class)。

如果我们想获取类的所有构造方法可以使用：clazz.getDeclaredConstructors来获取一个Constructor数组。

获取到Constructor以后我们可以通过constructor.newInstance()来创建类实例 , 同理如果有参数的情况下我们应该传入对应的参数值，如 :constructor.newInstance("admin", "123456")。当我们没有访问构造方法权限时我们应该调用constructor.setAccessible(true)修改访问权限就可以成功的创建出类实例了。

反射调用类方法 ¶

Class对象提供了一个获取某个类的所有的成员方法的方法，也可以通过方法名和方法参数类型来获取指定成员方法。

获取当前类所有的成员方法：

Method[] methods = clazz.getDeclaredMethods()

获取当前类指定的成员方法：

Method method = clazz.getDeclaredMethod("方法名");
Method method = clazz.getDeclaredMethod("方法名", 参数类型如String.class，多个参数用","号隔开);

getMethod和getDeclaredMethod都能够获取到类成员方法，区别在于getMethod只能获取到当前类和父类的所有有权限的方法 ( 如：public)，而getDeclaredMethod能获取到当前类的所有成员方法 ( 不包含父类 )。

反射调用方法

获取到java.lang.reflect.Method对象以后我们可以通过Method的invoke方法来调用类方法。

调用类方法代码片段：

method.invoke(方法实例对象, 方法参数值，多个参数值用","隔开);

method.invoke的第一个参数必须是类实例对象，如果调用的是static方法那么第一个参数值可以传null，因为在 java 中调用静态方法是不需要有类实例的，因为可以直接类名.方法名(参数)的方式调用。

method.invoke的第二个参数不是必须的，如果当前调用的方法没有参数，那么第二个参数可以不传，如果有参数那么就必须严格的依次传入对应的参数类型。

反射调用成员变量 ¶

Java 反射不但可以获取类所有的成员变量名称，还可以无视权限修饰符实现修改对应的值。

获取当前类的所有成员变量：

Field fields = clazz.getDeclaredFields();

获取当前类指定的成员变量：

Field field  = clazz.getDeclaredField("变量名");

getField和getDeclaredField的区别同getMethod和getDeclaredMethod。

获取成员变量值：

Object obj = field.get(类实例对象);

修改成员变量值：

field.set(类实例对象, 修改后的值);

同理，当我们没有修改的成员变量权限时可以使用 : field.setAccessible(true)的方式修改为访问成员变量访问权限。

如果我们需要修改被final关键字修饰的成员变量，那么我们需要先修改方法

// 反射获取Field类的modifiers
Field modifiers = field.getClass().getDeclaredField("modifiers");

// 设置modifiers修改权限
modifiers.setAccessible(true);

// 修改成员变量的Field对象的modifiers值
modifiers.setInt(field, field.getModifiers() & ~Modifier.FINAL);

// 修改成员变量值
field.set(类实例对象, 修改后的值);

Java 反射机制总结 ¶

Java 反射机制是 Java 动态性中最为重要的体现，利用反射机制我们可以轻松的实现 Java 类的动态调用。Java 的大部分框架都是采用了反射机制来实现的 ( 如 :Spring MVC、ORM框架等 )，Java 反射在编写漏洞利用代码、代码审计、绕过 RASP 方法限制等中起到了至关重要的作用。

1.3 sun.misc.Unsafe¶

sun.misc.Unsafe是 Java 底层 API( 仅限 Java 内部使用 , 利用时可通过反射调用 ) 提供的一个神奇的 Java 类，Unsafe 提供了非常底层的内存、CAS、线程调度、类、对象等操作。

获取 Unsafe 对象 ¶

Unsafe 是 Java 内部 API，外部是禁止调用的，在编译 Java 类时如果检测到引用了 Unsafe 类也会有禁止使用的警告：Unsafe是内部专用 API, 可能会在未来发行版中删除。 可以使用反射的方式去获取Unsafe类实例:

// 获取Unsafe无参构造方法
Constructor constructor = Unsafe.class.getDeclaredConstructor();

// 修改构造方法访问权限
constructor.setAccessible(true);

// 反射创建Unsafe类实例，等价于 Unsafe unsafe1 = new Unsafe();
Unsafe unsafe1 = (Unsafe) constructor.newInstance();

// 反射获取Unsafe的theUnsafe成员变量
Field theUnsafeField = Unsafe.class.getDeclaredField("theUnsafe");

// 反射设置theUnsafe访问权限
theUnsafeField.setAccessible(true);

// 反射获取theUnsafe成员变量值
Unsafe unsafe = (Unsafe) theUnsafeField.get(null);

allocateInstance 无视构造方法创建类实例 ¶

Classname test = (Classname) unsafe1.allocateInstance(Classname.class);

Google 的 GSON 库在 JSON 反序列化的时候就使用这个方式来创建类实例，在渗透测试中也会经常遇到这样的限制，比如 RASP 限制了java.io.FileInputStream类的构造方法导致我们无法读文件或者限制了UNIXProcess/ProcessImpl类的构造方法导致我们无法执行本地命令等。

defineClass 直接调用 JVM 创建类对象 ¶

如果 ClassLoader 被限制，我们可以使用 Unsafe 的 defineClass 方法来实现通过字节码向 JVM 中注册类。

• public native Class defineClass(String var1, byte[] var2, int var3, int var4);
• public native Class<?> defineClass(String var1, byte[] var2, int var3, int var4, ClassLoader var5, ProtectionDomain var6);

// 使用Unsafe向JVM中注册cc.classloader.TestHelloWorld类
Class helloWorldClass = unsafe1.defineClass(TEST_CLASS_NAME, TEST_CLASS_BYTES, 0, TEST_CLASS_BYTES.length);

// 获取系统的类加载器
ClassLoader classLoader = ClassLoader.getSystemClassLoader();

// 创建默认的保护域
ProtectionDomain domain = new ProtectionDomain(
    new CodeSource(null, (Certificate[]) null), null, classLoader, null
);

// 使用Unsafe向JVM中注册cc.classloader.TestHelloWorld类
Class helloWorldClass = unsafe1.defineClass(
    TEST_CLASS_NAME, TEST_CLASS_BYTES, 0, TEST_CLASS_BYTES.length, classLoader, domain
);

1.4 Java 文件系统 ¶

在 Java SE 中内置了两类文件系统：java.io和java.nio，java.nio的实现是sun.nio，文件系统底层的 API 实现如下图：

java.io¶

Java 抽象出了一个叫做文件系统的对象 :java.io.FileSystem，不同的操作系统有不一样的文件系统 , 例如Windows和Unix就是两种不一样的文件系统： java.io.UnixFileSystem、java.io.WinNTFileSystem。

FileSystem 最终会通过 JNI 调用 native 方法来实现对文件的操作

java.nio¶

Java 7 提出了一个基于 NIO 的文件系统，这个 NIO 文件系统和阻塞 IO 文件系统两者是完全独立的。java.nio.file.spi.FileSystemProvider对文件的封装和java.io.FileSystem同理。

合理的利用 NIO 文件系统这一特性我们可以绕过某些只是防御了java.io.FileSystem的WAF /RASP

1.5 本地命令执行 ¶

Java 原生提供了对本地系统命令执行的支持，黑客通常会 RCE 或者 WebShell 来执行系统终端命令控制服务器

Runtime 命令执行 ¶

在 Java 中我们通常会使用 java.lang.Runtime 类的 exec 方法来执行本地系统命令。

Runtime.exec(xxx) 调用链如下 :

java.lang.UNIXProcess.<init>(UNIXProcess.java:247)
java.lang.ProcessImpl.start(ProcessImpl.java:134)
java.lang.ProcessBuilder.start(ProcessBuilder.java:1029)
java.lang.Runtime.exec(Runtime.java:620)
java.lang.Runtime.exec(Runtime.java:450)
java.lang.Runtime.exec(Runtime.java:347)
org.apache.jsp.runtime_002dexec2_jsp._jspService(runtime_002dexec2_jsp.java:118)

通过观察整个调用链我们可以清楚的看到 exec 方法并不是命令执行的最终点，执行逻辑大致是：

1. Runtime.exec(xxx)
2. java.lang.ProcessBuilder.start()
3. new java.lang.UNIXProcess(xxx)
4. UNIXProcess 构造方法中调用了 forkAndExec(xxx) native 方法。
5. forkAndExec 调用操作系统级别 fork->exec(*nix)/CreateProcess(Windows) 执行命令并返回 fork/CreateProcess 的 PID。

如果系统对 runtime 有相应检测防护机制，可以通过反射来绕过检测

ProcessBuilder 命令执行 ¶

注意到 Runtime.exec 会调用 ProcessBuilder.start()，所以我们可以直接使用 ProcessBuilder 来执行命令。

InputStream in = new ProcessBuilder(request.getParameterValues("cmd")).start().getInputStream();

UNIXProcess/ProcessImpl¶

UNIXProcess 和 ProcessImpl 可以理解本就是一个东西，因为在 JDK9 的时候把 UNIXProcess 合并到了 ProcessImpl 当中。ProcessImpl 其实就是最终调用 native 执行系统命令的类，这个类提供了一个叫 forkAndExec 的 native 方法，如方法名所述主要是通过 fork&exec 来执行本地系统命令。

JNI 命令执行 ¶

Java 可以通过 JNI 的方式调用动态链接库，只需要在动态链接库中写本地命令执行即可

1.7 URLConnection¶

Java 抽象出来了一个 URLConnection 类，它用来表示应用程序以及与 URL 建立通信连接的所有类的超类，通过 URL 类中的 openConnection 方法获取到 URLConnection 的类对象。

URLConnection 支持的协议可以在 sun.net.www.protocol 包下找到 (jdk_17.0.11)

其中每个协议都有一个 Handle, Handle 定义了这个协议如何去打开一个连接。

使用 URL 发起一个简单的请求 :

public class URLConnectionDemo {

    public static void main(String[] args) throws IOException {
        URL url = new URL("https://www.baidu.com");

        // 打开和url之间的连接
        URLConnection connection = url.openConnection();

        // 设置请求参数
        connection.setRequestProperty("user-agent", "javasec");
        connection.setConnectTimeout(1000);
        connection.setReadTimeout(1000);
        ...

        // 建立实际连接
        connection.connect();

        // 获取响应头字段信息列表
        connection.getHeaderFields();

        // 获取URL响应内容
        StringBuilder response = new StringBuilder();
        BufferedReader in = new BufferedReader(
                new InputStreamReader(connection.getInputStream()));
        String line;

        while ((line = in.readLine()) != null) {
            response.append("/n").append(line);
        }

        System.out.print(response.toString());
    }
}

SSRF¶

SSRF(Server-side Request Forge, 服务端请求伪造 )。 由攻击者构造的攻击链接传给服务端执行造成的漏洞，一般用来在外网探测或攻击内网服务。

服务端提供了可以从其他服务器获取资源的功能，然而并没有对用户的输入以及发起请求的 url 进行过滤 & 限制，形成了 SSRF 漏洞。 通常 ssrf 容易出现的功能点如下面几种场景:

• 抓取用户输入图片的地址并且本地化存储
• 从远程服务器请求资源
• 对外发起网络请求
• ...

Java 中 ssrf 漏洞对使用不同类发起的 url 请求有所区别，如果是 URLConnection|URL 发起的请求，那么对于上文中所提到的所有 protocol 都支持，但是如果经过二次包装或者其他的一些类发出的请求，比如 :

• HttpURLConnection
• HttpClient
• Request
• okhttp
• ...

那么只支持发起 http|https 协议，否则会抛出异常。 如果传入 url 端口存在，则会返回网页源码，如果端口提供非 web 服务，则会爆出 Invalid Http response 或 Connection reset 异常，通过对异常的捕获可以探测内网所有的端口服务。

java 中默认对 (http|https) 做了一些事情，比如 :

1. 《Ghidra 从 XXE 到 RCE》 (To be read)

默认跟随跳转 其中有一个坑点

它会对跟随跳转的 url 进行协议判断，所以 Java 的 SSRF 漏洞利用方式整体比较有限 :

• 利用 file 协议读取文件内容（仅限使用 URLConnection|URL 发起的请求）
• 利用 http 进行内网 web 服务端口探测
• 利用 http 进行内网非 web 服务端口探测 ( 如果将异常抛出来的情况下 )
• 利用 http 进行 ntlmrelay 攻击 ( 仅限 HttpURLConnection 或者二次包装 HttpURLConnection 并未复写 AuthenticationInfo 方法的对象 )

1.8 JNI 安全基础 ¶

Java Native Interface (JNI) 是 Java 与本地代码交互的一种技术。Java 语言是基于 C 语言实现的，Java 底层的很多 API 都是通过 JNI 来实现的。通过 JNI 接口 C/C++ 和 Java 可以互相调用 ( 存在跨平台问题 )。Java 可以通过 JNI 调用来弥补语言自身的不足 ( 代码安全性、内存操作等 )。

JNI- 定义 native 方法 ¶

首先在 Java 中如果想要调用 native 方法 , 那么需要在类中先定义一个 native 方法。

package cc.colemak;

public class TestJNI {
    public static native String exec(String cmd);
}

如上示例代码，我们使用 native 关键字定义一个类似于接口的方法

JNI- 生成类头文件 ¶

如上，我们已经编写好了 TestJNI.java，现在我们需要编译并生成 c 语言头文件。

javac -cp . TestJNI.java -h .

编译完成后会在当前目录下生成 TestJNI.class 和 cc_colemak_TestJNI.h。

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class cc_colemak_TestJNI */

#ifndef _Included_cc_colemak_TestJNI
#define _Included_cc_colemak_TestJNI
#ifdef __cplusplus
extern "C" {
#endif
/*
* Class:     cc_colemak_TestJNI
* Method:    exec
* Signature: (Ljava/lang/String;)Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL Java_cc_colemak_TestJNI_exec
(JNIEnv *, jclass, jstring);

#ifdef __cplusplus
}
#endif
#endif

JNI- 基础数据类型 ¶

需要特别注意的是 Java 和 JNI 定义的类型需要转换 (1) 才能相互使用

1. jni 中 java 与原生代码通信规则

参考如下类型对照表 :

JNI- 编写 C/C++ 本地命令执行实现 ¶

接下来使用 C/C++ 编写函数的最终实现代码。

#include <iostream>
#include <stdlib.h>
#include <cstring>
#include <string>
#include "cc_colemak_TestJNI.h"

using namespace std;

JNIEXPORT jstring

JNICALL Java_cc_colemak_TestJNI_exec
        (JNIEnv *env, jclass jclass, jstring str) {

    if (str != NULL) {
        jboolean jsCopy;
        // 将jstring参数转成char指针
        const char *cmd = env->GetStringUTFChars(str, &jsCopy);

        // 使用popen函数执行系统命令
        FILE *fd  = popen(cmd, "r");

        if (fd != NULL) {
            // 返回结果字符串
            string result;

            // 定义字符串数组
            char buf[128];

            // 读取popen函数的执行结果
            while (fgets(buf, sizeof(buf), fd) != NULL) {
                // 拼接读取到的结果到result
                result +=buf;
            }

            // 关闭popen
            pclose(fd);

            // 返回命令执行结果给Java
            return env->NewStringUTF(result.c_str());
        }

    }

    return NULL;
}

• Linux 编译： g++ -fPIC -I"$JAVA_HOME/include" -I"$JAVA_HOME/include/darwin" -shared -o libcmd.jnilib cc_colemak_TestJNI.cpp
• Windows 编译： g++ -I"%JAVA_HOME%\include" -I"%JAVA_HOME%\include\win32" -shared -o cmd.dll cc_colemak_TestJNI.cpp

编译参考 Java Programming Tutorial Java Native Interface (JNI)

package cc.colemak;

import java.io.File;
import java.lang.reflect.Method;

public class TestJNIcmd {

    private static final String COMMAND_CLASS_NAME = "cc.colemak.TestJNI";
    /**
     * JDK8u191 编译的cc.colemak.TestJNI 类字节码
     */
    private static final byte[] COMMAND_CLASS_BYTES = new byte[]{
            -54,-2,-70,-66,0,0,0,52,0,15,10,0,3,0,12,7,0,13,7,0,14,1,0,6,60,105,110,105,116,62,1,0,3,40,41,86,1,0,4,67,111,100,101,1,0,15,76,105,110,101,78,117,109,98,101,114,84,97,98,108,101,1,0,4,101,120,101,99,1,0,38,40,76,106,97,118,97,47,108,97,110,103,47,83,116,114,105,110,103,59,41,76,106,97,118,97,47,108,97,110,103,47,83,116,114,105,110,103,59,1,0,10,83,111,117,114,99,101,70,105,108,101,1,0,12,84,101,115,116,74,78,73,46,106,97,118,97,12,0,4,0,5,1,0,18,99,99,47,99,111,108,101,109,97,107,47,84,101,115,116,74,78,73,1,0,16,106,97,118,97,47,108,97,110,103,47,79,98,106,101,99,116,0,33,0,2,0,3,0,0,0,0,0,2,0,1,0,4,0,5,0,1,0,6,0,0,0,29,0,1,0,1,0,0,0,5,42,-73,0,1,-79,0,0,0,1,0,7,0,0,0,6,0,1,0,0,0,3,1,9,0,8,0,9,0,0,0,1,0,10,0,0,0,2,0,11
    };

    public static void main(String[] args) {
        String cmd = "ipconfig";// 定于需要执行的cmd

        try {
            ClassLoader loader = new ClassLoader(TestJNIcmd.class.getClassLoader()) {
                @Override
                protected Class<?> findClass(String name) throws ClassNotFoundException {
                    try {
                        return super.findClass(name);
                    } catch (ClassNotFoundException e) {
                        return defineClass(COMMAND_CLASS_NAME, COMMAND_CLASS_BYTES, 0, COMMAND_CLASS_BYTES.length);
                    }
                }
            };

            // 测试时候换成自己编译好的lib路径
            File libPath = new File("cmd.dll");

            // load命令执行类
            Class commandClass = loader.loadClass("cc.colemak.TestJNI");

            // 可以用System.load也加载lib也可以用反射ClassLoader加载,如果loadLibrary0
            // 也被拦截了可以换java.lang.ClassLoader$NativeLibrary类的load方法。
//          System.loadLibrary("D:\\work\\java\\TestJNI\\src\\main\\java\\cc\\colemak\\cmd");
            Method loadLibrary0Method = ClassLoader.class.getDeclaredMethod("loadLibrary0", Class.class, File.class);
            loadLibrary0Method.setAccessible(true);
            loadLibrary0Method.invoke(loader, commandClass, libPath);

            String content = (String) commandClass.getMethod("exec", String.class).invoke(null, cmd);
            System.out.println(content);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

编译运行结果如下：

1.9 Java 动态代理 ¶

Java 反射提供了一种类动态代理机制，可以通过代理接口实现类来完成程序无侵入式扩展。 Java动态代理主要使用场景：

• 统计方法执行所耗时间。
• 在方法执行前后添加日志。
• 检测方法的参数或返回值。
• 方法访问权限控制。
• 方法 Mock 测试。

动态代理 API ¶

在 java 的java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过这个类和接口可以生成动态代理类和动态代理对象。 Proxy类中定义的方法如下：

public class Proxy implements java.io.Serializable {
    ...
    //获取动态代理处理类对象
    public static InvocationHandler getInvocationHandler(Object proxy)

    //创建动态代理类实例
    public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

    //创建动态代理类
    public static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces)

    //检测某个类是否是动态代理类
    public static boolean isProxyClass(Class<?> cl)

    //向指定的类加载器中定义一个类对象
    private static native Class defineClass0(ClassLoader loader, String name, byte[] b, int off, int len)
}

java.lang.reflect.InvocationHandler接口用于调用Proxy类生成的代理类方法，该类只有一个invoke方法。

public interface InvocationHandler {
    //代理类调用方法时会调用该方法
   Object  invoke(Object  proxy, Method  method, Object [] args) throws Throwable 
}

使用 java.lang.reflect.Proxy 动态创建类对象 ¶

package cc.dynproxy;

import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import static cc.colemak.TestJNIcmd.COMMAND_CLASS_BYTES;
import static cc.colemak.TestJNIcmd.COMMAND_CLASS_NAME;

public class ProxyDefineClassTest {

    public static void main(String[] args) {
        // 获取系统的类加载器，可以根据具体情况换成一个存在的类加载器
        ClassLoader classLoader = ClassLoader.getSystemClassLoader();

        try {
            // 反射java.lang.reflect.Proxy类获取其中的defineClass0方法
            Method method = Proxy.class.getDeclaredMethod("defineClass0", new Class[]{
                    ClassLoader.class, String.class, byte[].class, int.class, int.class
            });

            // 修改方法的访问权限
            method.setAccessible(true);

            // 反射调用java.lang.reflect.Proxy.defineClass0()方法，动态向JVM注册
            // cc.classloader.TestHelloWorld类对象
            Class helloWorldClass = (Class) method.invoke(null, new Object[]{
                    classLoader, COMMAND_CLASS_NAME, COMMAND_CLASS_BYTES, 0, COMMAND_CLASS_BYTES.length
            });

            // 输出TestHelloWorld类对象
            System.out.println(helloWorldClass);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

创建代理类实例 ¶

// 创建UnixFileSystem类实例
FileSystem fileSystem = new UnixFileSystem();

// 使用JDK动态代理生成FileSystem动态代理类实例
FileSystem proxyInstance = (FileSystem) Proxy.newProxyInstance(
    FileSystem.class.getClassLoader(),// 指定动态代理类的类加载器
    new Class[]{FileSystem.class}, // 定义动态代理生成的类实现的接口
    new JDKInvocationHandler(fileSystem)// 动态代理处理类
);

// 创建UnixFileSystem类实例
FileSystem fileSystem = new UnixFileSystem();

// 创建动态代理处理类
InvocationHandler handler = new JDKInvocationHandler(fileSystem);

// 通过指定类加载器、类实现的接口数组生成一个动态代理类
Class proxyClass = Proxy.getProxyClass(
    FileSystem.class.getClassLoader(),// 指定动态代理类的类加载器
    new Class[]{FileSystem.class}// 定义动态代理生成的类实现的接口
);

// 使用反射获取Proxy类构造器并创建动态代理类实例
FileSystem proxyInstance = (FileSystem) proxyClass.getConstructor(
    new Class[]{InvocationHandler.class}).newInstance(new Object[]{handler}
);

动态代理添加方法调用日志 ¶

UnixFileSystem类实现了FileSystem接口，通过 JDK 动态代理的方式为FileSystem接口方法添加日志输出。

package cc.dynproxy;

import java.io.File;
import java.io.Serializable;

public interface FileSystem extends Serializable{
    String[] list(File file);
}

package cc.dynproxy;

import java.io.File;

public class UnixFileSystem implements FileSystem {
    public String[] list(File file){
        System.out.println("正在执行[" + this.getClass().getName() + "]类的list方法，参数:[" + file + "]");

        return file.list();
    }
}

package cc.dynproxy;

import java.io.Serializable;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class JDKInvocationHandler implements InvocationHandler, Serializable {
    private final Object target;
    public JDKInvocationHandler(final Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable {
        if ("toString".equals(method.getName())) {
            return method.invoke(target, args);
        }
        System.out.println("即将调用["+target.getClass().getName()+"."+method.getName()+"]");
        Object result = method.invoke(target, args);
        System.out.println("完成调用["+target.getClass().getName()+"."+method.getName()+"]");
        return result;
    }
}

package cc.dynproxy;

import java.io.File;
import java.lang.reflect.Proxy;
import java.util.Arrays;

public class FSProxyTest {
    public static void main(String[] args) {
        FileSystem fs=new UnixFileSystem();
        FileSystem proxyInstance = (FileSystem) Proxy.newProxyInstance(
                FileSystem.class.getClassLoader(),// 指定动态代理类的类加载器
                new Class[]{FileSystem.class}, // 定义动态代理生成的类实现的接口
                new JDKInvocationHandler(fs)// 动态代理处理类
        );

        System.out.println("动态代理生成的类名:" + proxyInstance.getClass());
        System.out.println("----------------------------------------------------------------------------------------");
        System.out.println("动态代理生成的类名toString:" + proxyInstance.toString());
        System.out.println("----------------------------------------------------------------------------------------");

        // 使用动态代理的方式UnixFileSystem方法
        String[] files = proxyInstance.list(new File("."));

        System.out.println("----------------------------------------------------------------------------------------");
        System.out.println("UnixFileSystem.list方法执行结果:" + Arrays.toString(files));
        System.out.println("----------------------------------------------------------------------------------------");

        boolean isFileSystem     = proxyInstance instanceof FileSystem;
        boolean isUnixFileSystem = proxyInstance instanceof UnixFileSystem;

        System.out.println("动态代理类[" + proxyInstance.getClass() + "]是否是FileSystem类的实例:" + isFileSystem);
        System.out.println("----------------------------------------------------------------------------------------");
        System.out.println("动态代理类[" + proxyInstance.getClass() + "]是否是UnixFileSystem类的实例:" + isUnixFileSystem);
        System.out.println("----------------------------------------------------------------------------------------");
    }
}

运行结果

动态代理生成的 $ProxyXXX 类代码分析 ¶

java.lang.reflect.Proxy 类通过创建一个新的 Java 类 ( 类名为 com.sun.proxy.$ProxyXXX) 实现无侵入的类方法代理功能。

动态代理生成出来的类有如下技术细节和特性：

1. 动态代理的必须是接口类，通过动态生成接口实现类来代理接口的方法调用 ( 反射机制 )。
2. 动态代理类由java.lang.reflect.Proxy.ProxyClassFactory创建。
3. ProxyClassFactory调用sun.misc.ProxyGenerator类生成该类的字节码，并调用java.lang.reflect.Proxy.defineClass0()方法将该类注册到 JVM。
4. 该类继承于java.lang.reflect.Proxy并实现了需要被代理的接口类，因为java.lang.reflect.Proxy类实现了java.io.Serializable接口，所以被代理的类支持序列化 / 反序列化。
5. 通过ProxyGenerator动态生成接口类的所有方法
6. 因为实现了代理的接口类，所以当前类是代理的接口类的实例 ( proxyInstance instanceof FileSystem为 true)，但不是代理接口类的实现类的实例 ( proxyInstance instanceof UnixFileSystem为 false)。
7. 该类方法中包含了被代理的接口类的所有方法，通过调用动态代理处理类 ( InvocationHandler ) 的 invoke 方法获取方法执行结果。
8. 该类代理的方式重写了java.lang.Object类的toString、hashCode、equals方法。
9. 如果动过动态代理生成了多个动态代理类，新生成的类名中的数字会自增，如com.sun.proxy.$Proxy0/$Proxy1/$Proxy2。

package com.sun.proxy.$Proxy0;

import java.io.File;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements FileSystem {

    private static Method m1;

// 实现的FileSystem接口方法，如果FileSystem里面有多个方法那么在这个类中将从m3开始n个成员变量
    private static Method m3;

    private static Method m0;

    private static Method m2;

    public $Proxy0(InvocationHandler var1) {
        super(var1);
    }

    public final boolean equals(Object var1) {
        try {
            return (Boolean) super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String[] list(File var1) {
        try {
            return (String[]) super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final int hashCode() {
        try {
            return (Integer) super.h.invoke(this, m0, (Object[]) null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() {
        try {
            return (String) super.h.invoke(this, m2, (Object[]) null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("cc.dynproxy.FileSystem").getMethod("list", Class.forName("java.io.File"));
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

动态代理类实例序列化 ¶

Dynamic Proxy Classes-Serialization

1.10 Java 类序列化 ¶

Java 序列化常被用于 Socket 传输。 在 RMI(Java 远程方法调用 -Java Remote Method Invocation) 和 JMX(Java 管理扩展 -Java Management Extensions) 服务中对象反序列化机制被强制性使用。在 Http 请求中也时常会被用到反序列化机制，如：直接接收序列化请求的后端服务、使用 Base 编码序列化字节字符串的方式传递等。

Java 类实现java.io.Serializable ( 内部序列化 ) 或java.io.Externalizable ( 外部序列化 ) 接口即可被序列化。

java.io.Serializablejava.io.Externalizable

java.io.Serializable是一个空接口，仅用于标记类可以被序列化。序列化机制会根据类的属性生成一个serialVersionUID，用于判断序列化对象是否一致。反序列化时如果serialVersionUID不一致会导致InvalidClassException 异常。如果未显式声明，则序列化运行时通过内置方法将计算默认 serialVersionUID值。

java.io.Serializable

    public interface Serializable {
    }

code

package cc.serial;

import java.io.*;
import java.util.Arrays;

public class DeserializationTest implements Serializable {

    private String username;

    private String email;

    public DeserializationTest() {
        System.out.println("init...");
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public static void main(String[] args) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        try {
            // 创建DeserializationTest类，并类设置属性值
            DeserializationTest t = new DeserializationTest();
            t.setUsername("colemak");
            t.setEmail("admin@javaweb.org");

            // 创建Java对象序列化输出流对象
            ObjectOutputStream out = new ObjectOutputStream(baos);

            // 序列化DeserializationTest类
            out.writeObject(t);
            out.flush();
            out.close();

            // 打印DeserializationTest类序列化以后的字节数组，我们可以将其存储到文件中或者通过Socket发送到远程服务地址
            System.out.println("DeserializationTest类序列化后的字节数组:" + Arrays.toString(baos.toByteArray()));

            // 利用DeserializationTest类生成的二进制数组创建二进制输入流对象用于反序列化操作
            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());

            // 通过反序列化输入流(bais),创建Java对象输入流(ObjectInputStream)对象
            ObjectInputStream in = new ObjectInputStream(bais);

            // 反序列化输入流数据为DeserializationTest对象
            DeserializationTest test = (DeserializationTest) in.readObject();
            System.out.println("用户名:" + test.getUsername() + ",邮箱:" + test.getEmail());

            // 关闭ObjectInputStream输入流
            in.close();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

}

程序执行结果如下：

ObjectOutputStream序列化类对象的主要流程是首先判断序列化的类是否重写了writeObject方法，如果重写了就调用对象自身的writeObject方法，序列化时会先写入类名信息，其次是写入成员变量信息 ( 通过反射获取所有不包含被transient修饰的变量和值 )。

java.io.Externalizable接口定义了writeExternal和readExternal方法需要序列化和反序列化的类实现，其余的和java.io.Serializable并无差别。

java.io.Externalizable

    public interface Externalizable extends java.io.Serializable {

    void writeExternal(ObjectOutput out) throws IOException;

    void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;

    }

code

package cc.serial;

import java.io.*;
import java.util.Arrays;

public class ExternalizableTest implements java.io.Externalizable {

    private String username;
    private String email;

    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(username);
        out.writeObject(email);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        this.username = (String) in.readObject();
        this.email = (String) in.readObject();
    }

    public static void main(String[] args) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        try {
            // 创建ExternalizableTest类，并类设置属性值
            ExternalizableTest t = new ExternalizableTest();
            t.setUsername("yz");
            t.setEmail("admin@javaweb.org");

            ObjectOutputStream out = new ObjectOutputStream(baos);
            out.writeObject(t);
            out.flush();
            out.close();

            // 打印ExternalizableTest类序列化以后的字节数组，我们可以将其存储到文件中或者通过Socket发送到远程服务地址
            System.out.println("ExternalizableTest类序列化后的字节数组:" + Arrays.toString(baos.toByteArray()));
            System.out.println("ExternalizableTest类反序列化后的字符串:" + new String(baos.toByteArray()));

            // 利用DeserializationTest类生成的二进制数组创建二进制输入流对象用于反序列化操作
            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());

            // 通过反序列化输入流创建Java对象输入流(ObjectInputStream)对象
            ObjectInputStream in = new ObjectInputStream(bais);

            // 反序列化输入流数据为ExternalizableTest对象
            ExternalizableTest test = (ExternalizableTest) in.readObject();
            System.out.println("用户名:" + test.getUsername() + ",邮箱:" + test.getEmail());

            // 关闭ObjectInputStream输入流
            in.close();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

}

程序执行结果如下：

反序列化类对象时有如下限制：

• 被反序列化的类必须存在。
• serialVersionUID值必须一致。

使用反序列化方式创建类实例

package cc.serial;

import sun.reflect.ReflectionFactory;
import java.lang.reflect.Constructor;

public class ReflectionFactoryTest {
    public static void main(String[] args) {
        try{
            // 获取sun.reflect.ReflectionFactory对象
            ReflectionFactory factory = ReflectionFactory.getReflectionFactory();

            // 使用反序列化方式获取DeserializationTest类的构造方法
            Constructor constructor = factory.newConstructorForSerialization(
                    DeserializationTest.class, Object.class.getConstructor()
            );

            // 实例化DeserializationTest对象
            System.out.println(constructor.newInstance());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

参考不用构造方法也能创建对象

自定义序列化 (writeObject) 和反序列化 (readObject) 方法 ¶

实现了java.io.Serializable接口的类，可以定义如下方法 ( 反序列化魔术方法 )，这些方法将会在类序列化或反序列化过程中调用：

1. private void writeObject(ObjectOutputStream oos), 自定义序列化。
2. private void readObject(ObjectInputStream ois)，自定义反序列化。
3. private void readObjectNoData()。
4. protected Object writeReplace()，写入时替换对象。
5. protected Object readResolve()。

具体的方法名定义在java.io.ObjectStreamClass#ObjectStreamClass(java.lang.Class<?>)，其中方法有详细的声明。

1.11 JNDI¶

JNDI(Java Naming and Directory Interface,Java 命名和目录接口 ) 是 SUN 公司提供的一种标准的 Java 命名系统接口，JNDI 提供统一的客户端 API，通过不同的访问提供者接口 JNDI 服务供应接口 (SPI) 的实现，由管理者将 JNDI API 映射为特定的命名服务和目录系统，使得 Java 应用程序可以和这些命名服务和目录服务之间进行交互。目录服务是命名服务的一种自然扩展。

JNDI(Java Naming and Directory Interface) 是一个应用程序设计的 API，为开发人员提供了查找和访问各种命名和目录服务的通用、统一的接口，类似 JDBC 都是构建在抽象层上。现在 JNDI 已经成为 J2EE 的标准之一，所有的 J2EE 容器都必须提供一个 JNDI 的服务。

JNDI 可访问的现有的目录及服务有： DNS、XNam 、Novell目录服务、LDAP(Lightweight Directory Access Protocol轻型目录访问协议)、 CORBA对象服务、文件系统、Windows XP/2000/NT/Me/9x的注册表、RMI、DSML v1&v2、NIS。

InitialContext¶

InitialContext() 
// 构建一个初始上下文。  
InitialContext(boolean lazy) 
// 构造一个初始上下文，并选择不初始化它。  
InitialContext(Hashtable<?,?> environment) 
// 使用提供的环境构建初始上下文。 

bind(Name name, Object obj) 
    // 将名称绑定到对象。 
list(String name) 
    // 枚举在命名上下文中绑定的名称以及绑定到它们的对象的类名。
lookup(String name) 
    // 检索命名对象。 
rebind(String name, Object obj) 
    // 将名称绑定到对象，覆盖任何现有绑定。 
unbind(String name) 
    // 取消绑定命名对象。 

Reference¶

该类表示对在命名 / 目录系统外部找到的对象的引用。提供了 JNDI 中类的引用功能，比如在某些目录服务中直接引用远程的 Java 对象。

Reference(String className) 
    // 为类名为“className”的对象构造一个新的引用。  
Reference(String className, RefAddr addr) 
    // 为类名为“className”的对象和地址构造一个新引用。  
Reference(String className, RefAddr addr, String factory, String factoryLocation) 
    // 为类名为“className”的对象，对象工厂的类名和位置以及对象的地址构造一个新引用。  
Reference(String className, String factory, String factoryLocation) 
    // 为类名为“className”的对象以及对象工厂的类名和位置构造一个新引用。  

void add(int posn, RefAddr addr) 
    将地址添加到索引posn的地址列表中。  
void add(RefAddr addr) 
    将地址添加到地址列表的末尾。  
void clear() 
    从此引用中删除所有地址。  
RefAddr get(int posn) 
    检索索引posn上的地址。  
RefAddr get(String addrType) 
    检索地址类型为“addrType”的第一个地址。  
Enumeration<RefAddr> getAll() 
    检索本参考文献中地址的列举。  
String getClassName() 
    检索引用引用的对象的类名。  
String getFactoryClassLocation() 
    检索此引用引用的对象的工厂位置。  
String getFactoryClassName() 
    检索此引用引用对象的工厂的类名。    
Object remove(int posn) 
    从地址列表中删除索引posn上的地址。  
int size() 
    检索此引用中的地址数。  
String toString() 
    生成此引用的字符串表示形式。  

package com.rmi.demo;

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 jndi {
    public static void main(String[] args) throws NamingException, RemoteException, AlreadyBoundException {
        String url = "http://127.0.0.1:8080"; 
        Registry registry = LocateRegistry.createRegistry(1099);
        Reference reference = new Reference("test", "test", url);
        ReferenceWrapper referenceWrapper = new ReferenceWrapper(reference);
        registry.bind("aa",referenceWrapper);


    }
}

JNDI 目录服务 ¶

访问 JNDI 目录服务时会通过预先设置好环境变量访问对应的服务， 如果创建 JNDI 上下文 (Context) 时未指定环境变量对象，JNDI 会自动搜索系统属性 (System.getProperty() )、applet 参数和应用程序资源文件 (jndi.properties )

// 创建环境变量对象
Hashtable env = new Hashtable();

// 设置JNDI初始化工厂类名
env.put(Context.INITIAL_CONTEXT_FACTORY, "类名");

// 设置JNDI提供服务的URL地址
env.put(Context.PROVIDER_URL, "url");

// 创建JNDI目录服务对象
DirContext context = new InitialDirContext(env);

Context.INITIAL_CONTEXT_FACTORY( 初始上下文工厂的环境属性名称 ) 指的是 JNDI 服务处理的具体类名称，如：DNS 服务可以使用com.sun.jndi.dns.DnsContextFactory类来处理，JNDI 上下文工厂类必须实现javax.naming.spi.InitialContextFactory接口，通过重写getInitialContext方法来创建服务。

1. JNDI DNS 服务： JNDI支持访问DNS服务，注册环境变量时设置JNDI服务处理的工厂类为com.sun.jndi.dns.DnsContextFactory即可。
2. JNDI-RMI 远程方法调用 RMI的服务处理工厂类是:com.sun.jndi.rmi.registry.RegistryContextFactory
3. JNDI-LDAP LDAP的服务处理工厂类是:com.sun.jndi.ldap.LdapCtxFactory
4. JNDI-DataSource JNDI连接数据源比较特殊，Java目前不提供内置的实现方法，提供数据源服务的多是Servlet容器，以Tomcat为例，参考Tomcat JNDI Datasource

JNDI- 协议转换

如果JNDI在lookup时没有指定初始化工厂名称，会自动根据协议类型动态查找内置的工厂类然后创建处理对应的服务请求。

JNDI默认支持自动转换的协议有：

RMI/LDAP 远程对象引用安全限制 ¶

在 RMI 服务中引用远程对象将受本地 Java 环境限制即本地的java.rmi.server.useCodebaseOnly配置必须为 false( 允许加载远程对象 )，如果该值为 true 则禁止引用远程对象。除此之外被引用的 ObjectFactory 对象还将受到com.sun.jndi.rmi.object.trustURLCodebase配置限制，如果该值为 false( 不信任远程引用对象 ) 一样无法调用远程的引用对象。

JDK 5 U45,JDK 6 U45,JDK 7u21,JDK 8u121 开始java.rmi.server.useCodebaseOnly默认配置已经改为了 true。 JDK 6u132, JDK 7u122, JDK 8u113开始com.sun.jndi.rmi.object.trustURLCodebase默认值已改为了false。 本地测试远程对象引用可以使用如下方式允许加载远程的引用对象：

System.setProperty("java.rmi.server.useCodebaseOnly", "false");
System.setProperty("com.sun.jndi.rmi.object.trustURLCodebase", "true");

LDAP 在 JDK 11.0.1、8u191、7u201、6u211 后也将默认的com.sun.jndi.ldap.object.trustURLCodebase设置为了 false。

高版本 JDK 可参考：如何绕过高版本 JDK 的限制进行 JNDI 注入利用

JNDI 注入漏洞参考：JNDI 注入漏洞

1.12 JShell¶

从 Java 9 开始提供了一个叫 jshell 的功能，jshell 是一个 REPL(Read-Eval-Print Loop) 命令行工具，提供了一个交互式命令行界面，在 jshell 中我们不再需要编写类也可以执行 Java 代码片段，开发者可以像 python 和 php 一样在命令行下愉快的写测试代码了。

命令行执行 jshell 即可进入 jshell 模式：

<%=jdk.jshell.JShell.builder().build().eval(request.getParameter("src"))%>

?src=new String(Runtime.getRuntime().exec("pwd").getInputStream().readAllBytes())

1.13 Java 字节码 ¶