Java安全之Java反射（一）

• Java安全大部分都是从反射开始，可以动态调用一些Payload而不出现相关特征。
  

类初始化代码执行顺序

• https://www.cnblogs.com/wugongzi/p/11849266.html
  
• 首先new一个类，加载的顺序是（父）静态变量->（父）静态代码块->（父）代码块->（父）构造方法。
  
• 如果初始化同一个类，静态变量、静态代码块只执行一次。
  

1. package Advance;
3. public class ExecutionOrder {
4.     public static void main(String[] args) {
5.         Student student = new Student();
6.     }
7. }
9. class Student extends Person {
10.     public Student() {
11.         System.out.println("学生构造函数");
12.     }
14.     {
15.         System.out.println("学生代码块");
16.     }
18.     static {
19.         System.out.println("学生静态代码块");
20.     }
21. }
24. class Person {
25.     public static String staticName = "Pan3a";
27.     public String name = "Forever";
29.     {
30.         System.out.println("人类代码块");
31.     }
33.     static {
34.         System.out.println("人类静态代码块");
35.     }
37.     public Person() {
38.         System.out.println("人类构造函数");
39.     }
41. }

复制代码

• 输出结果
  

1. 人类静态代码块
2. 学生静态代码块
3. 人类代码块
4. 人类构造函数
5. 学生代码块
6. 学生构造函数

复制代码

类加载器

• 这里暂时不去深究吧，后面学习参考文章
  
• 类加载器和Class.forName区别
  
• https://javasec.org/javase/ClassLoader/
  

环境

1. package Reflection;
3. public class ReflectData {
5.     public ReflectData() {
7.     }
8. }
10. class Person {
11.     private int age;
12.     private String name;
13.     public long id = 9527;
14.     public long grade;
15.     protected float score;
16.     protected int rank;
18.     public Person() {
19.     }
21.     protected Person(long id) {
22.         this(18, "Pan3a", id, 9, 9999, 31);
23.     }
25.     private Person(int age) {
26.         this(age, "Pan3a", 9527, 9, 9999, 30);
27.     }
29.     public Person(int age, String name, long id, long grade, float score, int rank) {
30.         this.age = age;
31.         this.name = name;
32.         this.id = id;
33.         this.grade = grade;
34.         this.score = score;
35.         this.rank = rank;
36.     }
38.     public int getAge() {
39.         return age;
40.     }
42.     public void setAge(int age) {
43.         this.age = age;
44.     }
46.     public String getName() {
47.         return name;
48.     }
50.     public void setName(String name) {
51.         this.name = name;
52.     }
54.     public long getId() {
55.         return id;
56.     }
58.     public void setId(long id) {
59.         this.id = id;
60.     }
62.     public long getGrade() {
63.         return grade;
64.     }
66.     public void setGrade(long grade) {
67.         this.grade = grade;
68.     }
70.     public float getScore() {
71.         return score;
72.     }
74.     public void setScore(float score) {
75.         this.score = score;
76.     }
78.     public int getRank() {
79.         return rank;
80.     }
82.     public void setRank(int rank) {
83.         this.rank = rank;
84.     }
86.     private static void sayHello() {
87.         System.out.println("Hello World");
88.     }
90.     private void sayHello(String name) {
91.         System.out.println("Hello " + name);
92.     }
94.     @Override
95.     public String toString() {
96.         final StringBuffer stringBuffer = new StringBuffer("Person{");
97.         stringBuffer.append("age=").append(age);
98.         stringBuffer.append(", name='").append(name).append('\'');
99.         stringBuffer.append(", id=").append(id);
100.         stringBuffer.append(", grade=").append(grade);
101.         stringBuffer.append(", score=").append(score);
102.         stringBuffer.append(", rank=").append(rank);
103.         stringBuffer.append('}');
104.         return stringBuffer.toString();
105.     }
106. }
108. class Teacher extends Person {
109.     private String role = "Teacher";
111.     public void sayHello() {
112.         System.out.println("Hello Teacher");
113.     }
114. }
116. class Student extends Teacher {
117.     private String role = "Student";
119.     static {
120.         System.out.println("run Student static codes!");
121.     }
123.     {
124.         System.out.println("run Student codes!");
125.     }
127.     @Override
128.     public void sayHello() {
129.         System.out.println("Hello Student");
130.     }
131.     public Student(){
133.     }
135.     public Student(String name){
136.         System.out.printf("hello %s", name);
137.     }
138. }

复制代码

获取对象

• 获取对象有三种方式，Class.forName(全类名)、对象.getclass()、类名.class。
  
• 这里的三种方式虽然作用都一样，但是都有各自的缺点。class.forName()需要知道类名的全路径。对象名.getclass()需要存在已经实例化的对象，类名.class需要提前在编译前知道类名。
  
• 这里都返回true了，说明这里返回的对象都是同一个，因此Person.class只加载了一次。用instanceof不但匹配指定类型，还匹配指定类型的子类。而用==判断class实例可以精确地判断数据类型，但不能作子类型比较。
  

1. package Reflection;
3. public class ReflectGetObject {
4.     public static void main(String[] args) throws ClassNotFoundException{
5.         compareReflectGetObject();
6.         
7.     }
9.     public static void compareReflectGetObject() throws ClassNotFoundException {
10.         Student student = new Student();
11.         Teacher teacher = new Teacher();
12.         Person person = new Person();
14.         if(student instanceof Person){
15.             System.out.println("Student 是Person子类");
16.         }
19.         Class<?> clazz1 = Class.forName("Reflection.Person");
20.         System.out.println(clazz1.getName());
22.         Class<?> clazz2 = person.getClass();
23.         System.out.println(clazz2.getName());
25.         Class<?> clazz3 = Person.class;
26.         System.out.println(clazz3.getName());
28.         System.out.println(clazz1 == clazz2);
29.         System.out.println(clazz1 == clazz3);
31.     }
32. }

复制代码

• 输出结果如下
  

1. run Student static codes!
2. run Student codes!
3. Student 是Person子类
4. Reflection.Person
5. Reflection.Person
6. Reflection.Person
7. true
8. true

复制代码

• 这里的Class.forName()有两个函数重载，我们可以跟进看看。第一个函数是我们平常用的，第二个有参数boolean initialize、ClassLoader loader，可以指定类是否在加载时初始化，和指定类加载器。
  
• 重点，这里的boolean initialize参数是控制是否初始化，而不是实例化，初始化会加载静态变量、静态代码块。
  

1. @CallerSensitive
2.     public static Class<?> forName(String className)
3.                 throws ClassNotFoundException {
4.         Class<?> caller = Reflection.getCallerClass();
5.         return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
6.     }

复制代码

1.     @CallerSensitive
2.     public static Class<?> forName(String name, boolean initialize,
3.                                    ClassLoader loader)
4.         throws ClassNotFoundException
5.     {
6.         Class<?> caller = null;
7.         SecurityManager sm = System.getSecurityManager();
8.         if (sm != null) {
9.             // Reflective call to get caller class is only needed if a security manager
10.             // is present.  Avoid the overhead of making this call otherwise.
11.             caller = Reflection.getCallerClass();
12.             if (sun.misc.VM.isSystemDomainLoader(loader)) {
13.                 ClassLoader ccl = ClassLoader.getClassLoader(caller);
14.                 if (!sun.misc.VM.isSystemDomainLoader(ccl)) {
15.                     sm.checkPermission(
16.                         SecurityConstants.GET_CLASSLOADER_PERMISSION);
17.                 }
18.             }
19.         }
20.         return forName0(name, initialize, loader, caller);
21.     }

复制代码

• 案例如下
  
• 输出结果如下，这里的静态代码块只执行了一次，后面没执行，是因为Student.class已经被前面加载到内存中了，
  

1. run Student static codes!
2. 0
3. ------------------
4. run Student codes!
5. ------------------
7. 0
8. ------------------
9. run Student codes!
10. ------------------

复制代码

• 若注释掉第一段39-47行，输出结果如下，可以看到静态代码块是在newInstance()实例化后再加载到，因此可以得出initialize参数控制的是是否初始化，而不是实例化。
  

1. 0
2. ------------------
3. run Student static codes!
4. run Student codes!
5. ------------------

复制代码

构造方法

• 有以下四种获取方法。getConstructor()、getConstructors()、getDeclaredConstructor()、getDeclaredConstructors()，若构造方法带参数，用对应的数据类型.class即可。
  
• 这里注意非public的构造方法需要使用getDeclaredConstructor()方法即可，然后如果需要实例化必须使用setAccessible(true)。
  

1. package Reflection;
3. import java.lang.reflect.Constructor;
4. import java.lang.reflect.Field;
5. import java.lang.reflect.InvocationTargetException;
6. import java.lang.reflect.Method;
8. public class ReflectGetObject {
9.     public static void main(String[] args) throws Exception{
10.         getConstructorsStudy();
11.     }
13.     public static void getConstructorsStudy() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
14.         Class<?> clazz = Class.forName("Reflection.Person");
17.         System.out.println("所有构造方法");
18.         Constructor<?>[] constructors = clazz.getDeclaredConstructors();
19.         for (Constructor<?> constructor:constructors){
20.             System.out.println(constructor);
21.         }
22.         System.out.println();
24.         System.out.println("public无参数构造方法");
25. //      默认当前类的无参数构造方法
26.         Constructor<?> constructor1 = clazz.getConstructor();
27.         System.out.println(constructor1);
29.         System.out.println("protected带参数构造方法");
30.         Constructor<?> constructor2 = clazz.getDeclaredConstructor(long.class);
31.         System.out.println(constructor2);
34.         System.out.println("private带参数构造方法");
35.         Constructor<?> constructor3 = clazz.getDeclaredConstructor(int.class);
36.         System.out.println(constructor3 + "\n");
39.         System.out.println("public无参数构造方法创建对象");
40.         Object person1 = constructor1.newInstance();
41.         System.out.println(person1);
44.         System.out.println("protected带参数构造方法创建对象");
45.         constructor2.setAccessible(true);
46.         Object person2 = constructor2.newInstance(9528);
47.         System.out.println(person2);
50.         System.out.println("private带参数构造方法创建对象");
51.         constructor3.setAccessible(true);
52.         Object person3 = constructor3.newInstance(18);
53.         System.out.println(person3);
56.         System.out.println("Person.class.newInstance()");
57.         Class<?> class1 = Reflection.Person.class;
58.         Object object = class1.newInstance();
59.         System.out.println(object);
60.     }
61. }

复制代码

• 输出结果展示
  

1. 所有构造方法
2. protected Reflection.Person(long)
3. private Reflection.Person(int)
4. public Reflection.Person(int,java.lang.String,long,long,float,int)
5. public Reflection.Person()
7. public无参数构造方法
8. public Reflection.Person()
9. protected带参数构造方法
10. protected Reflection.Person(long)
11. private带参数构造方法
12. private Reflection.Person(int)

复制代码

成员方法

• 获取成员方法，也有四个方法。getMethod()，getMethods()，getDeclaredMethod()，getDeclaredMethods()，invoke()，这里如果是继承，invoke()调用的方法根据实际传入的方法为准，不存在则向上父类寻找。
  
• 获取方法属性，getName()，getReturnType()，getParameterTypes()，getModifiers()。
  

1. package Reflection;
3. import java.lang.reflect.*;
4. import java.util.ArrayList;
5. import java.util.Arrays;
7. public class ReflectGetObject {
8.     public static void main(String[] args) throws Exception{
9.         getMethodStudy();
10.     }
12.     public static void getMethodStudy() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException {
13.         Class<?> clazz = Class.forName("Reflection.Person");
14.         Constructor<?> constructor = clazz.getDeclaredConstructor();
15.         constructor.setAccessible(true);
16.         Object person = constructor.newInstance();
17.         Method method = clazz.getMethod("setAge", int.class);
18.         method.invoke(person,18);
21.         // getDeclaredMethods学习
22.         System.out.println("所有方法");
23.         Method[] methods = clazz.getDeclaredMethods();
24.         for (Method methodTemp:methods){
25.             System.out.println(methodTemp.getName() + "\t" + Arrays.toString(methodTemp.getParameterTypes()));
26.         }
28.         // getMethod学习
29.         Method method1 = clazz.getMethod("getAge");
30.         method1.setAccessible(true);
31.         System.out.println(method1.invoke(person));;
33.         //  由于这里和方法为静态方法，因此object为null
34.         Method method2 = clazz.getDeclaredMethod("sayHello");
35.         method2.setAccessible(true);
36.         method2.invoke(null);
38.         //      多态，依旧根据传入的实例化对象为准，如果没有则向父类寻找
39.         Class<?> teacherClass = Class.forName("Reflection.Teacher");
40.         Method method3 = teacherClass.getMethod("sayHello");
41.         method3.invoke(new Reflection.Student());
42.     }
43. }

复制代码

• 输出结果
  

1. 所有方法
2. setAge        [int]
3. getAge        []
4. sayHello        [class java.lang.String]
5. sayHello        []
6. setId        [long]
7. getGrade        []
8. setGrade        [long]
9. getScore        []
10. setScore        [float]
11. getRank        []
12. setRank        [int]
13. toString        []
14. getName        []
15. setName        [class java.lang.String]
16. getId        []
17. 18
18. Hello World
19. run Student static codes!
20. run Student codes!
21. Hello Student

复制代码

成员变量

• 获取成员变量需要知道一下四个方法，getField，getFields，getDeclaredField，getDeclaredFields。
  
• 还可获取成员变量属性的三个方法，getType，getModifiers，getName。分别是获取变量类型，修饰符，成员名。
  
• 他们分别是获取单个成员，和获取所有成员，获取单个成员（忽略修饰服限制，不包括父类），获取多个成员（忽略修饰服限制，不包括父类）。需注意的是使用后面两个是需使用setAccessible(true)来忽略编译时的安全检查。
  

1. package Reflection;
3. import java.lang.reflect.*;
4. import java.util.ArrayList;
5. import java.util.Arrays;
7. public class ReflectGetObject {
8.     public static void main(String[] args) throws Exception{
9.         getFieldStudy();
10.     }
12.     public static void getFieldStudy() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
13.         Class<?> clazz = Class.forName("Reflection.Person");
14.         Constructor<?> constructor = clazz.getConstructor();
15.         Object person = constructor.newInstance();
16.         Method setAge = clazz.getMethod("setAge", int.class);
17.         setAge.invoke(person,18);
18.         Method getAge = clazz.getMethod("getAge");
19.         System.out.println(getAge.invoke(person) + "\n");
21.         // getgetDeclaredFields学习
22.         System.out.println("所有方法");
23.         Field[] fields = clazz.getDeclaredFields();
24.         for (Field field:fields){
25.             System.out.println(field.getName() + "\t" + field.getModifiers() + "\t" + field.getType());
26.         }
28.         // 反射修改私有成员值
29.         Field field = clazz.getDeclaredField("age");
30.         field.setAccessible(true);
31.         field.set(person,20);
32.         System.out.println(getAge.invoke(person));
33.     }
34. }

复制代码

• 输出结果
  

1. 18
3. 所有方法
4. age        2        int
5. name        2        class java.lang.String
6. id        1        long
7. grade        1        long
8. score        4        float
9. rank        4        int
10. 20

复制代码

反射Runtime执行命令

• 代码如下，依次来解释
  

1. package Reflection;
3. import java.lang.reflect.Method;
5. public class ReflectRuntimeExec {
6.     public static void main(String[] args) throws Exception{
7.         Class<?> clazz = Class.forName("java.lang.Runtime");
8.         Method getRuntime = clazz.getDeclaredMethod("getRuntime");
9.         Object runtime = getRuntime.invoke(null);
10.         Method exec = clazz.getDeclaredMethod("exec", String.class);
11.         exec.invoke(runtime,"open /System/Applications/Calculator.app");
12.     }
13. }

复制代码

• 这里为什么要获取两个方法呢，为什么没有实例化类就可以调用方法了。
  
• 跟进Runtime，发现它的构造方法是私有的，发现有一个getRuntime的静态方法，可以返回实例化的对象，就像P神说的，“单例模式 ”因此我们通过获取getRuntime方法来获取Runtime的实例，还可以反射构造方法来获取，只不过后者比前者麻烦。
  
• 疑问，这里为什么不可以获取字段来直接获取变量值。我觉得可能是这里只是获取的属性，并没有获取变量的值吧。这里发现可以通过Filed.get(clazz)来获取变量的值，问题解决。
  

getRuntime命令执行

1. package Reflection;
3. import java.lang.reflect.Constructor;
4. import java.lang.reflect.Field;
5. import java.lang.reflect.Method;
6. import java.lang.Runtime;
8. public class ReflectRuntimeExec {
9.     public static void main(String[] args) throws Exception {
10.         Class<?> clazz = Class.forName("java.lang.Runtime");
11.         Method getRuntime = clazz.getDeclaredMethod("getRuntime");
12.         Method exec = clazz.getDeclaredMethod("exec", String.class);
13.         Object runtime = getRuntime.invoke(null);
14.         exec.invoke(runtime, "open /System/Applications/Calculator.app");
15.     }
16. }

复制代码

Constructor命令执行

• 这里没有意外，直接反射操作即可。
  

1. package Reflection;
3. import java.lang.reflect.Constructor;
4. import java.lang.reflect.Field;
5. import java.lang.reflect.Method;
6. import java.lang.Runtime;
8. public class ReflectRuntimeExec {
9.     public static void main(String[] args) throws Exception {
10.         Class<?> clazz = Class.forName("java.lang.Runtime");
11.         Constructor<?> constructor = clazz.getDeclaredConstructor();
12.         constructor.setAccessible(true);
13.         Object runtime2 = constructor.newInstance();
14.         System.out.println(runtime2 instanceof Runtime);
15.         Method exec2 = clazz.getDeclaredMethod("exec", String.class);
16.         exec2.invoke(runtime2, "open /System/Applications/Calculator.app");
17.     }
18. }

复制代码

Filed命令执行

• 了解到field.get就可以获取变量值了
  

1. package Reflection;
3. import java.lang.reflect.Constructor;
4. import java.lang.reflect.Field;
5. import java.lang.reflect.Method;
6. import java.lang.Runtime;
8. public class ReflectRuntimeExec {
9.     public static void main(String[] args) throws Exception {
10.         Class<?> clazz = Class.forName("java.lang.Runtime");
11.         Field field = clazz.getDeclaredField("currentRuntime");
12.         field.setAccessible(true);
13.         Object runtime1 = field.get(clazz);
14.         System.out.println(runtime1 instanceof Runtime);
15.         Method exec1 = clazz.getDeclaredMethod("exec", String.class);
16.         exec1.invoke(runtime1, "open /System/Applications/Calculator.app");
17.     }
18. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！