Java代码审计--反射

admin 2024年5月25日02:31:41评论14 views字数 6554阅读21分50秒阅读模式

简介

java的反射就是在程序运行中动态的创建对象,并且和new不同的是,反射创建对象不需要考虑访问权限,可以直接查看类的私有属性以及调用私有方法,并且new创建对象时在编译时期将对象的.class加载进内存,而反射创建对象则时在运行时期加载进内存。

加载过程

在进行反射时,我们首先需要创建对应类的Class对象,然后再通过Class对象的newInstance方法或者Constructor对象的 newInstance() 方法来创建对象,这种方式下,对象的加载是在程序执行过程中动态进行的,而不是在编译时确定的。

主要使用方法

获取对应的Class对象

Class.forName()
实例对象.getClass()
类名.class

Class.forName()只需要知道某个类的名字或者类的全限命名,就可以获取到这个类的class对象,并且这种方法会默认加载该类的static代码块,其他两种并不会。实例对象.getClass()如果上文已经存在一个实例化的类,那么可以直接使用getClass()方法获取Class对象类名.class如果已经加载了一个类,只需要直接调用class属性即可后去对应的class对象 首先我们创建一个类

package org.Reflex.entity;  
  
public class User {  
    class Userinternal{  
        public void PrintC(){  
            System.out.println("执行了内部类的PrintC方法");  
        }  
    }  
    static {  
//        System.out.println("aaa");  
    }  
  
    public User() {  
        System.out.println("调用了无参构造方法");  
    }  
  
    public User(String user_name, String user_phone) {  
        this.user_name = user_name;  
        this.user_phone = user_phone;  
        System.out.println(user_name+" "+user_phone);  
    }  
  
    public String user_name;  
    private String user_phone;  
  
    public String getUser_name() {  
        return user_name;  
    }  
  
    public void setUser_name(String user_name) {  
        this.user_name = user_name;  
    }  
  
    public String getUser_phone() {  
        return user_phone;  
    }  
  
    public void setUser_phone(String user_phone) {  
        this.user_phone = user_phone;  
    }  
  
    private void PrintAll(){  
        System.out.println("调用了私有化方法");  
    }  
    public String Print(String connect){  
        return connect;  
    }  
    public void PrintA(){  
        System.out.println("调用了PrintA方法");  
    }  
  
    public static void PringB(){  
        System.out.println("调用了static PrintB方法");  
    }  
}

下面是一个测试demo

@Test  
public void testStart() throws ClassNotFoundException {  
    User user = new User();  
    //第一种方法  
    Class<?> aClass = Class.forName("com.entity.User");  
    //第二种方法  
    Class<? extends User> aClass1 = user.getClass();  
    //第三种方法  
    Class<User> userClass = User.class;  
}

Class对象和new创建对象的区别

  • 使用new关键字创建对象返回的是该类的实例对象。
  • Class.forName()返回的是对应类的Class对象,可以通过这个Class对象来创建实例对象、访问类的静态成员和方法,但不会直接创建实例对象。

通过Class对象获取实例化对象

Class<?> aClass = Class.forName("org.Reflex.entity.User");
Object o = aClass.newInstance();

setAccessible 方法

在反射中,这个方法会经常用到,如:

Field userPhone = aClass.getDeclaredField("user_phone");  
userPhone.setAccessible(true);

这个方法可以启用或禁用安全访问检查,如果为true表示禁用,以此来给私有属性赋值,以及调用私有方法等操作。

反射获取类的成员变量

 Field getField(String name)          获取指定的public变量
 Field[] getFields()                  获取所有的public变量 
 Field getDeclaredField(String name)  获取指定的变量,不论是不是public
 Field[] getDeclaredFields()          获取所有的变量,不论是不是public

还是使用上面的User类,这次就删除里面的static代码块,当我们获取到一个属性的时候,还可以使用下面方法进行操作。

String getName()   //获取变量的名字
int getModifiers()  //获取变量的修饰符,返回的是一个数字,需要配合Modifier.tostring使用
Class<?> getType()   //返回属性的类型,一般配合getSimpleName()方法一起使用
void set(Object obj, Object value)   //设置属性的值
Object get(Object obj)  //读取属性的值

使用示例

Class<?> aClass = Class.forName("org.Reflex.entity.User");  
//获取所有的属性  
Field[] declaredFields = aClass.getDeclaredFields();  
for (Field f:declaredFields){  
    System.out.println("属性名:"+f.getName()); //依次打印属性名  
    System.out.println("修饰符:"+ Modifier.toString(f.getModifiers()));   //获取权限修饰符  
    System.out.println("Type:"+f.getType().getSimpleName());  
}
//获取指定属性  
Field userPhone = aClass.getDeclaredField("user_phone");  
userPhone.setAccessible(true);  
//实例化class类  
Object o = aClass.newInstance();  
//为指定实例化对象的指定属性赋值  
userPhone.set(o,"12356456");  
//通过get方法获取属性的值  
System.out.println(userPhone.get(o));

反射调用类的方法

 getMethods()   //获取当前类的所有public方法
 getDeclaredMethods()  //获取当前类的所有方法
 getMethod(String name, Class[] parameterTypes)    //获取类的指定方法,第一个参数是方法名,第二个参数是不定长参数,输入当前方法的所有参数类型

当我们获取到一个方法是,可以使用下面函数进行操作

getName() //获取方法的名字
getModifiers() //获取方法的访问权限,需要配合Modifier.toString使用
getParameterTypes()  //获取方法的参数类型
getDeclaringClass()   //返回声明该方法的类或接口的Class对象
invoke() //使用指定的参数在具有指定参数的指定对象上调用此方法
//参数 `obj` 是调用方法的对象实例,如果是静态方法,则可以为 null ,参数 args 是方法调用的参数。

下面是一些使用的示例

@Test  
public void testMethods() throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {  
    Class<?> aClass = Class.forName("org.Reflex.entity.User");  
    //查看所有的方法  
    Method[] methods = aClass.getDeclaredMethods();  
    for (Method m:methods){  
        System.out.print(Modifier.toString(m.getModifiers())+" ");   //获取方法的权限  
        System.out.print(m.getName()+"  ");   //获取方法的名字  
        System.out.print(Arrays.toString(m.getParameterTypes())+" ");   //获取方法的参数类型  
        System.out.print(m.getDeclaringClass());  
        System.out.println();  
    }  
    //获取指定方法  
    Method pring = aClass.getDeclaredMethod("Print",String.class);  
    //实例化User类  
    Object o = aClass.newInstance();  
    //调用实例化User类的Print方法  
    Object invoke = pring.invoke(o, "测试指定方法调用");  
    //输出方法调用的返回值  
    System.out.println(invoke.toString());  
    
    //获取指定的私有化方法  
    Method printAll = aClass.getDeclaredMethod("PrintAll");  
    //禁用安全检查  
    printAll.setAccessible(true);  
    //调用方法  
    Object invoke1 = printAll.invoke(o);  
  
    //调用静态方法  
    Method pringB = aClass.getDeclaredMethod("PringB");  
    //因为为静态方法,所以不需要传入实例化的类,直接调用就可以  
    Object invoke2 = pringB.invoke(null);  
}

反射类的构造方法

构造方法和普通方法基本基本上差不多,但是也有所不同

  • 构造方法命名要和类名一致
  • 构造方法不能有返回值,但是普通方法有
getConstructors()   //获取所有的public 构造方法
getDeclaredConstructors()   //获取所有的构造方法
getConstructor()   //获取一个指定的public 构造方法
getDeclaredConstructor()   //获取一个指定的构造方法,不限于public

基本上获取到的构造方法都和上面的方法函数差不多

@Test  
public void testConstructor() throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {  
    Class<?> aClass = Class.forName("org.Reflex.entity.User");  
    //获取当前类的所有构造方法  
    Constructor<?>[] constructors = aClass.getConstructors();  
   for (Constructor c:constructors){  
       //打印构造方法的权限  
       System.out.print(Modifier.toString(c.getModifiers())+" ");  
       //打印构造方法的名字  
       System.out.print(c.getName());  
       //打印当前构造方法所有的  
       System.out.print(Arrays.toString(c.getParameterTypes()));  
       //打印当前构造方法的引用  
       System.out.println(c.getDeclaringClass());  
   }  
   //获取类的无参构造方法  
    Constructor<?> constructor = aClass.getConstructor();  
   //调用类的无参构造方法  
    Object o = constructor.newInstance();  
    //调用类的有参构造方法  
    Constructor<?> constructor1 = aClass.getConstructor(String.classString.class);  
    constructor1.newInstance("pwjcw","123456");  
}

调用方法和上面的有所不同,直接调用newInstance函数即可。

相关笔记代码已上传至Github仓库中:github.com


原文始发于微信公众号(剑外思归客):Java代码审计--反射

  • 左青龙
  • 微信扫一扫
  • weinxin
  • 右白虎
  • 微信扫一扫
  • weinxin
admin
  • 本文由 发表于 2024年5月25日02:31:41
  • 转载请保留本文链接(CN-SEC中文网:感谢原作者辛苦付出):
                   Java代码审计--反射http://cn-sec.com/archives/2768480.html

发表评论

匿名网友 填写信息