目录[ Hide ]
  1. 0x00：前言
  2. 0x01：反射机制概述
  3. 0x02：Java反射
    1. 使用getField方法获取成员变量
    2. 使用getDeclaredFields获取所有成员变量
    3. 使用getDeclaredField获取指定成员变量
    4. 获取构造方法
    5. 获取方法
    6. 获取所有public修饰方法
    7. 获取类名
  4. 0x03：反射调用Runtime
    1. 不利用反射执行命令
  5. 0x04：参考

0x00：前言

之前已经学习过反射了，大概概况就是可以通过Class 类将其他类的字节码加载到本类实现操作其他类的方法、变量等。

0x01：反射机制概述

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

0x02：Java反射

Java反射操作的是java.lang.Class对象，所以我们需要要先获取到Class对象。

获取Class对象的方式：

JAVA 反射
1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
         多用于配置文件，将类名定义在配置文件中。读取文件，加载类
    2. 类名.class：通过类名的属性class获取
         多用于参数的传递
    3. 对象.getClass()：getClass()方法在Object类中定义着。
         多用于对象的获取字节码的方式

代码实例：

方式一：
Class cls1 = Class.forName("Domain.Person");

        System.out.println(cls1);
方式二：
        Class cls2 = Person.class;
        System.out.println(cls2);
       
方式三：

        Person p = new Person();
        Class cls3 = p.getClass();
        System.out.println(cls3);

同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个。

class类方法：

获取成员变量方法：

1. 获取成员变量们
            * Field[] getFields() ：获取所有public修饰的成员变量
            * Field getField(String name)   获取指定名称的 public修饰的成员变量

            * Field[] getDeclaredFields()  获取所有的成员变量，不考虑修饰符
            * Field getDeclaredField(String name)

获取构造方法:

* Constructor<?>[] getConstructors()  
            * Constructor<T> getConstructor(类<?>... parameterTypes)  

            * Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)  
            * Constructor<?>[] getDeclaredConstructors()

获取成员方法:

* Method[] getMethods()  
            * Method getMethod(String name, 类<?>... parameterTypes)  

            * Method[] getDeclaredMethods()  
            * Method getDeclaredMethod(String name, 类<?>... parameterTypes)

获取全类名:



String getName()

成员变量设置：

Field：成员变量
    * 操作：
        1. 设置值
            * void set(Object obj, Object value)  
        2. 获取值
            * get(Object obj)

        3. 忽略访问权限修饰符的安全检查
            * setAccessible(true):暴力反射

构造方法:

创建对象：
        * T newInstance(Object... initargs)  

        * 如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法

方法对象：

执行方法：
        * Object invoke(Object obj, Object... args)  

    * 获取方法名称：
        * String getName:获取方法名

使用getField方法获取成员变量

我们现在这里编写一个person类。

person代码：

package com.pure.demo;

public class Person {
    private String name  ;
    private int age;
    public String a ;


    public Person() {
    }

    public void eat(){
        System.out.println("eat");
    }
    public void eat(String food){
        System.out.println("eat "+food);
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", a='" + a + '\'' +
                '}';
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

main类代码：

public static void main(String[] args) throws Exception {
        Class cls = Class.forName("com.pure.demo.Person");
        Field a = cls.getField("a"); //获取成员a变量
        Person person = new Person();
        Object o = a.get(person);  //获取成员变量的值
        System.out.println(o);
        a.set(person,"abc");  //修改成员a变量的值为abc
        System.out.println(person);

    }

使用getDeclaredFields获取所有成员变量

该方法不考虑修饰符

public static void main(String[] args) throws Exception {
        Class cls = Class.forName("com.pure.demo.Person");
        System.out.println(Person);
        Field[] declaredFields = cls.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);

        }
    }

使用getDeclaredField获取指定成员变量

public static void main(String[] args) throws Exception {
        Class cls = Class.forName("com.pure.demo.Person");
        Field b = cls.getDeclaredField("age");
        b.setAccessible(true);  //使用暴力反射机制，忽略访问权限修饰符的安全检测
        Person person = new Person();
        Object o1 = b.get(person);
        System.out.println(o1);
    }

这里person该类中的成员变量是被private修饰的，我们想要访问他的值必须使用暴力反射，暴力反射可以忽略访问权限修饰符的安全检测。

获取构造方法

public static void main(String[] args) throws Exception {
        Class cls = Class.forName("com.pure.demo.Person");

        Constructor constructor = cls.getConstructor(String.class,int.class);//获取构造器
        System.out.println(constructor);
        //有参构造
        Object o = constructor.newInstance("123", 18); //创建对象
        System.out.println(o);
        //无参构造
        Object o1 = constructor.newInstance();

        System.out.println(o1);
    }

获取方法

public static void main(String[] args) throws Exception {
        Class cls = Class.forName("com.pure.demo.Person");
        //无参数方法
        Method eat = cls.getMethod("eat");
        Person person = new Person();
        eat.invoke(person);   //调用eat方法
        //有参数方法
        Method eat1 = cls.getMethod("eat", String.class);  //获取eat方法并且设置参数
        eat1.invoke(person, "fish");
    }

获取所有public修饰方法

  public static void main(String[] args) throws Exception {
        Class cls = Class.forName("com.pure.demo.Person");
        Method[] methods = cls.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
    }

获取类名

public static void main(String[] args) throws Exception {
        Class cls = Class.forName("com.pure.demo.Person");
        String name = cls.getName();
        System.out.println(name);
    }

0x03：反射调用Runtime

Runtime这个函数有exec方法可以本地执行命令，大部分关于jsp命令执行的payload可能都是调用Runtime进行Runtime的exec方法进行命令执行的。

不利用反射执行命令

package com.pure.demo;

import org.apache.commons.io.IOUtils;

import java.io.IOException;
import java.io.InputStream;

public class Test {
    public static void main(String[] args) throws IOException {
        InputStream ipconfig = Runtime.getRuntime().exec("ipconfig").getInputStream();
        String s = IOUtils.toString(ipconfig,"gbk"); //使用IOUtils.toString静态方法将字节输入流转换为字符
        System.out.println(s);


    }
}

这样的代码基本都是固定死的，如果要多次传入参数执行命令的话，这样的写法肯定是不行的，那么这时候就可以用到反射。

package com.pure.demo;

import org.apache.commons.io.IOUtils;

import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class Test2 {
    public static void main(String[] args) throws Exception {
        String command = "ipconfig";
        Class cls = Class.forName("java.lang.Runtime"); //Runtime加载进内存
        Constructor declaredConstructor = cls.getDeclaredConstructor(); //获取构造方法
        declaredConstructor.setAccessible(true);  //暴力反射
        Object o = declaredConstructor.newInstance(); //创建Runtime类
        Method exec = cls.getMethod("exec", String.class); //获取exec方法，设置需要参数string类型参数
        Process process = (Process) exec.invoke(o,command);   //执行exec方法，并传入ipconfig参数
//        System.out.println(process);
        InputStream inputStream = process.getInputStream();    //获取输出的数据
        String ipconfig = IOUtils.toString(inputStream,"gbk"); //字节输出流转换为字符
        System.out.println(ipconfig);
    }
}

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

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

0x04：参考

https://www.cnblogs.com/nice0e3/p/13494147.html#0x02-java%E5%8F%8D%E5%B0%84

发表回复

您的电子邮箱地址不会被公开。 必填项已用 * 标注