说了这么多嗷，我分步拆开来写一下，会更清晰一些：

1
2
3
4
5
6
7
8
9
10

public void execute(String className, String methodName) throws Exception {
  		//首先找到类对象
  		Class clazz = Class.forName(className);
  		//根据类对象找到Method方法对象
      Method mtd = clazz.getMethod(methodName);
  		//动态生成类实例化对象obj
      Object obj = clazz.newInstance();
  		//调用类中方法mtd
      mtd.invoke(obj); 
  }

以下一步步使用反射机制实现 Runtime.getRuntime().exec("calc.exe"); 这个语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

package domain;

public class TrainPrint {
    //初始块
    {
        System.out.printf("Empty block initial %s\n", this.getClass());
    }
    //静态初始块
    static {
        System.out.printf("Static initial %s\n", TrainPrint.class);
    }
    //构造函数
    public TrainPrint() {
        System.out.printf("Initial %s\n", this.getClass());
    }
}

首先我写一个测试类，对于这个测试类，它有初始块，静态初始块，构造函数。

那么下面我来获取它的Class对象，想看看当这个 TrainPrint 测试类加载进内存之后，哪些部分执行了，好主意，说写就写：

首先 类的初始化 :

1
2
3
4
5
6
7
8
9
10

package reflect;

import java.io.IOException;
import domain.TrainPrint;

public class initTest {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Class.forName("domain.TrainPrint");
    }
}

执行结果： Static initial class domain.TrainPrint

这说明当类加载进了内存，只有 静态初始块 得到了执行。

那么 类的实例化 呢:

1
2
3
4
5
6
7
8
9
10

package reflect;

import java.io.IOException;
import domain.TrainPrint;

public class initTest {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        TrainPrint test= new TrainPrint();
    }
}

执行结果：

1
2
3

Static initial class domain.TrainPrint
Empty block initial class domain.TrainPrint
Initial class domain.TrainPrint

这也暴露了顺序： 静态初始块 -> 初始块 -> 构造函数

具有父类的类的实例化： 父类静态初始块 -> 子类静态初始块 -> 父类初始块 -> 父类构造函数 -> 子类初始块 -> 子类构造函数

以上对于类初始化的说明其实就是说，单独一个Class.forName()，在 类静态初始块可控的情况 下，可以执行恶意代码。

Class.forName("C1$C2") 可以调用这个内部类。

我们可以通过 Class.forName("java.lang.Runtime") 来获取类（java.lang.Runtime是Runtime类的完整路径）

由于我们的exec函数是一个普通方法，需要传入类对象，即 invoke(类对象，exec方法传入的参数) 。
之前说到Runtime的类对象不能通过newInstance()来获取对象（class.newInstance等于new class）,是因为Runtime的类构造函数是一个private构造函数，只能通过getRuntime方法返回一个对象。

获取类对象：

1
2
3
4
5
6
7
8
9
10

`invoke(Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.Runtime"))，"calc.exe")`

合并：

```java
Class.forName("java.lang.Runtime").getMethod("exec", String.class).
                invoke(
                        Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(
                                Class.forName("java.lang.Runtime")),"/Applications/Calculator.app/Contents/MacOS/Calculator");

再简化一下：

1
2

Class clazz = Class.forName("java.lang.Runtime"); 
clazz.getMethod("exec", String.class).invoke(clazz.getMethod("getRuntime").invoke(clazz), "/Applications/Calculator.app/Contents/MacOS/Calculator");

详细解读，这里是一个疯狂套娃的过程：

1
2
3
4

List<String> paramList = new ArrayList<>();
paramList.add("/Applications/Calculator.app/Contents/MacOS/Calculator");
ProcessBuilder pb = new ProcessBuilder(paramList);
pb.start();

可见，其构造函数是写入了一个字符串，不是无参构造方法，接下来我们会一步步进行转化。

ProcessBuilder有两个构造函数：

getConsturctor() 函数可以选定指定接口格式的构造函数(由于构造函数也可以根据参数来进行重载)， getConsturctor(参数类型)

选定后我们可以通过 newInstance() ,并传入构造函数的参数执行构造函数，即 newInstance(传入的构造函数参数) 。

start函数不是一个静态函数,需要传入类的实例，所以这里可以继续使用反射：

1
2

Class clazz = Class.forName("java.lang.ProcessBuilder"); 
clazz.getMethod("start").invoke(clazz.getConstructor(List.class).newInstance(Arrays.asList("/Applications/Calculator.app/Contents/MacOS/Calculator")));

这里还有一种方式：

1
2
3

//这个可以传入多个字符串
ProcessBuilder pb = new ProcessBuilder("/Applications/Calculator.app/Contents/MacOS/Calculator");
pb.start();

那么payload就这样写吧：

1
2

Class clazz = Class.forName("java.lang.ProcessBuilder"); 
((ProcessBuilder)clazz.getConstructor(String[].class).newInstance(new String[]{"/Applications/Calculator.app/Contents/MacOS/Calculator"})).start();

但是实际上我们这样调用是会报错的，因为newInstance函数接受参数是一个 Object.. 也就是Object数组，它会完美契合我们提供的String[]，剥去一层数组。

那就再套一层：

1
2

Class clazz = Class.forName("java.lang.ProcessBuilder"); 
((ProcessBuilder)clazz.getConstructor(String[].class).newInstance(new String[][]{{"/Applications/Calculator.app/Contents/MacOS/Calculator"}})).start();

之前说到Runtime的构造方式是一个私有方法，从而不能直接调用，那么接下来我就来调用Runtime的构造方法来获取一个实例来执行计算器弹出：

1
2
3
4

Class clazz = Class.forName("java.lang.Runtime"); 
Constructor m = clazz.getDeclaredConstructor(); 
m.setAccessible(true); //暴力反射
clazz.getMethod("exec", String.class).invoke(m.newInstance(), "/Applications/Calculator.app/Contents/MacOS/Calculator");

在获取到私有方法后，通过 setAccessible(true) 可以打破私有方法访问限制，从而进行调用。

1

Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.Runtime"))

但其实我们很容易忽略反射机制中调用的函数实际上可以在两个不同的class中调用， 就像好比有一个函数可以在两个class中调用 。

在Commons-Collections的环境中，我们是没法得到 Class.forName("java.lang.Runtime").getMethod(...) 的，但是可以得到 Class.forName("java.lang.Class").getMethod(...) 。

可以理解为我们可以抓到 Runtime 的父类，那么就可以得到以下途径进行变形：

继续看一下Class类中getMethod方法的接口：

1
2
3
4
5
6
7
8
9
10

@CallerSensitive
public Method getMethod(String name, Class<?>... parameterTypes)////<?>... 表示任意类型任意数量的Class数组
    throws NoSuchMethodException, SecurityException {
    checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), true);
    Method method = getMethod0(name, parameterTypes, true);
    if (method == null) {
        throw new NoSuchMethodException(getName() + "." + name + argumentTypesToString(parameterTypes));
    }
    return method;
}

那么我们传数组，来拿到 getmethod 这个方法不就行了么：

1
2

Method method1= Class.forName("java.lang.Class")
        .getMethod("getMethod", new Class[] {String.class, Class[].class });//根据getMethod方法接口进行封装

以下套娃警告！

这里的Class类，它有所有方法，我们就是先拿到 getmethod 这个方法，这里是为什么呢？因为对于想用反射来调用方法其他类的方法，你必须会用到 getmethod 方法（忘了的向上翻模板），这里就相当于我先把梯子拿到！

那么有了 getmethod 方法之后，我需要一个obj对象来调用呀，这个obj其实就是 java.lang.Runtime 。之前也说了，这个对象很有脾气，需要执行这个类下面的 Runtime 方法，才能实例化一个 Runtime 对象。

结合上面刚刚获取的 getmethod 梯子方法，继续写吧：

1
2
3
4

//以下语句执行结果等同于Class.forName("java.lang.Runtime").getMethod(getRunime)
method1.invoke(Class.forName("java.lang.Runtime"),"getRuntime",new Class[0]);
//用于对比：以下语句等同于Class.forName("java.lang.Class").getMethod(getRunime)
//method1.invoke(Class.forName("java.lang.Class"),"getRuntime",new Class[0]);

合起来就是：

1
2
3
4
5
6

// 1.正常的反射调用
Class.forName("java.lang.Runtime").getMethod("getRuntime")
// 2.经过变形的反射调用，需要绕一圈
Class.forName("java.lang.Class")
    .getMethod("getMethod", new Class[] {String.class, Class[].class })//得到getMethod方法
   .invoke(Class.forName("java.lang.Runtime"),"getRuntime",new Class[0]);//new Class[0]其实就是占位

new Class[0] 其实就是占位，因为阅读源码能看到invoke方法参数规范，是硬性标准需要两个参数的，第二个是一个 Object 类的数组：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

@CallerSensitive
public Object invoke(Object obj, Object... args)
    throws IllegalAccessException, IllegalArgumentException,
       InvocationTargetException
{
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, obj, modifiers);
        }
    }
    MethodAccessor ma = methodAccessor;             // read volatile
    if (ma == null) {
        ma = acquireMethodAccessor();
    }
    return ma.invoke(obj, args);
}

所以现在我们只是以 Class.forName("java.lang.Class") 开头获取到了Runtime类下的getRuntime方法。还没有执行。

invoke有一个非常神奇的特性，它不会那么严格地校验obj。回顾之前总结的invoke传参规则：

它的第一个参数是执行method的对象obj：

但是， 传入的第一个参数其实不一定要是正确的类或者类对象!

下面一个小例子：

1
2
3
4
5
6
7
8

//main函数
Class.forName("a").getMethod("print").invoke(null);
//内部类：
class a{
    public static void print(){
        System.out.println(1);
    }
}

按照规则，print函数是一个 静态方法 ，实际上我们应该invoke传入一个a的类。但是以上代码的执行结果却是成功的：

但是如果 print 方法不是静态防范时就会执行失败：

这是因为invoke函数null抛出报错的机制导致的：

1
2
3
4
5
6

* @exception NullPointerException      
* if the specified object is null and the method is an instance method. //obj为null，并且method是一个实例method
*/
@CallerSensitive
public Object invoke(Object obj, Object... args){
}

当method是一个普通函数时，传入obj不能为null，并且其类对象要与方法匹配；但是当method是一个静态函数时，就很随便了(可能是因为压根不会被用到吧)。

这里我迷茫了好久，知道我看到这样一句话才弄懂：

类实例 是其他类的实例， 类 实际上是Class.class这个类的实例。
这边之前的疑问是，getMethod不是静态方法而invoke中传入的是类而不是类实例。
实际上因为getMethod本来就是class类中的方法，而 Class.forName("java.lang.Runtime") 获取到的class类的实例
我们调用getMethod传入的不是之前的模糊类的概念，而是class类的实例（类实例），所以这里是没毛病的调用class类下的非静态方法，传入class类实例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

package java.lang.reflect;
public final class Method extends AccessibleObject implements GenericDeclaration,Member...
public Object invoke(Object obj, Object... args)
        throws IllegalAccessException, IllegalArgumentException,
           InvocationTargetException
{
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class<?> caller = Reflection.getCallerClass(1);

                checkAccess(caller, clazz, obj, modifiers);
            }
        }
        MethodAccessor ma = methodAccessor;             // read volatile
        if (ma == null) {
            ma = acquireMethodAccessor();
        }
        return ma.invoke(obj, args);
}

override参数

它是父类AccessibleObject的一个属性，AccessibleObject这个类有三个子类：构造函数、属性、方法。

override这个值默认是false，但是我们可以通过method.setAccessible(true)来改掉它的值。

Reflection.quickCheckMemberAccess(clazz, modifiers)

如果是override是默认值false，那么继续往下走。

我们这里假设： m.invoke(obj,args)

1

public static native Class<?> getCallerClass();

1
2
3
4
5
6

MethodAccessor ma = methodAccessor;             // read volatile
if (ma == null) {
	ma = acquireMethodAccessor();
}
return ma.invoke(obj, args);

这里我们以 NativeMethodAccessorImpl 本地实现为例：

每次调用其invoke时会做一个累加，判断是否到达阙值，如果没有则调用native的invoke0方法，当超过时则调用 MethodAccessorGenerator.generateMethod() ，并将其设置到 DelegatingMethodAccessorImpl 的delegate，这样下次就会直接调用到动态实现的位置。

m.invoke(o，args)

invoke0参数：

我们重点分析一下invoke0这个native方法：

1
2
3
4
5

JNIEXPORT jobject JNICALL Java_sun_reflect_NativeMethodAccessorImpl_invoke0
(JNIEnv *env, jclass unused, jobject m, jobject obj, jobjectArray args)
{
    return JVM_InvokeMethod(env, m, obj, args);
}

借用ruilin的图，继续看JVM_InvokeMethod方法：

发现提到了oop，简单写一下oop-klass理解：

JVM就是用这种方式，将一个对象的数据和对象模型进行分离。普遍意义上来说，我们说持有一个对象的引用，指的是图中的handle(存放在栈区)，它是oop(存放在堆区)的一个封装。

关键点是：

1

oop result = Reflection::invoke_method(method_handle(), receiver, args, CHECK_NULL);

跟进hotspot/src/share/vm/runtime/reflection.cpp

Reflection::invoke_method()中接受的method_mirror(oop)就是我们要反射调用的方法。然后代码调用了Reflection::invoke()，跟进之后最终到JavaCalls::call()执行

最后的 os_exception_wrapper 其实就是调用了 call_help ，也就是说本地实现的 反射最终的方法执行是通过 JavaCalls::call_helper 方法来完成的 。