jdk17绕过反射限制

Java安全

今天看文章的时候看到一篇是在jdk17版本下的反射绕过，自己之前没了解过，细细读了一下觉得有必要记录一下。

JDK9 模块化

Java模块化主要是用来解决依赖的问题，以及给原生JDK瘦身这两个作用。

在此之前，java项目一般都是由一堆class文件组成，管理这一堆class文件东西叫jar。但是这些class的有分两类，一类是我们自己项目的class，一类是各种依赖的class。jar可不会管他们之前的关系，他只是用来存放这些class的。所以一旦出现漏写某个依赖class所对应的jar，程序就会报”ClassNotFoundException”的异常了。

也正是为了避免这种问题，JDK9之后开始推行模块化，具体体现在：如果a.jar依赖于b.jar，那么对于a这个jar就需要写一份依赖说明，让a程序编译运行的时候能够直接定位到b.jar。这个功能主要就是通过module-info.class​中的定义的。

了解上述定义即可，现在主要是探究模块化关于漏洞利用这一块的限制。首先就是class的访问权限，一般就分为public protected private和默认的包访问限制，但是到了模块化之后折现访问权限就仅限于当前模块了，除非目标类所在模块明确在module-info中指出了该类可被外部调用，不然依然无法获取到。

JDK17 强封装

https://docs.oracle.com/en/java/javase/17/migrate/migrating-jdk-8-later-jdk-releases.html#GUID-7BB28E4D-99B3-4078-BDC4-FC24180CE82B

Oracle官方上述文档中提到了Strong Encapsulation​，这个主要就是针对java*​包下的所有非public字段的如果我们在JDK17的时候对java*​下的非公共字段进行反射调用的话就会直接报错。

其实这个东西在JDK9之后就开始被标记为了不安全选项,但是由于很多大型项目之前都会直接使用反射这个功能，所以直到JDK17才将其强制化。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package org.example;

import java.lang.reflect.Method;
import java.util.Base64;

public class Test
{
    public static void main( String[] args ) throws Exception {
        String payload="yv66vgAAAD0AIAoAAgADBwAEDAAFAAYBABBqYXZhL2xhbmcvT2JqZWN0AQAGPGluaXQ+AQADKClWCgAIAAkHAAoMAAsADAEAEWphdmEvbGFuZy9SdW50aW1lAQAKZ2V0UnVudGltZQEAFSgpTGphdmEvbGFuZy9SdW50aW1lOwgADgEABGNhbGMKAAgAEAwAEQASAQAEZXhlYwEAJyhMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9Qcm9jZXNzOwcAFAEAE2phdmEvbGFuZy9FeGNlcHRpb24HABYBABBvcmcvZXhhbXBsZS9FdmlsAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEABHRoaXMBABJMb3JnL2V4YW1wbGUvRXZpbDsBAAg8Y2xpbml0PgEADVN0YWNrTWFwVGFibGUBAApTb3VyY2VGaWxlAQAJRXZpbC5qYXZhACEAFQACAAAAAAACAAEABQAGAAEAFwAAAC8AAQABAAAABSq3AAGxAAAAAgAYAAAABgABAAAAAwAZAAAADAABAAAABQAaABsAAAAIABwABgABABcAAABPAAIAAQAAAA64AAcSDbYAD1enAARLsQABAAAACQAMABMAAwAYAAAAEgAEAAAABgAJAAgADAAHAA0ACQAZAAAAAgAAAB0AAAAHAAJMBwATAAABAB4AAAACAB8=";
        byte[] bytes= Base64.getDecoder().decode(payload);
        Method defineClass= ClassLoader.class.getDeclaredMethod("defineClass", String.class, byte[].class, int.class, int.class);
        defineClass.setAccessible(true);
        defineClass.invoke(ClassLoader.getSystemClassLoader(), "attack", bytes, 0, bytes.length);
    }
}

这里面的字节码

1
2
3
4
5
6
7
8
public class Evil {
    static {
        try{
            Runtime.getRuntime().exec("calc");
        }catch(Exception e){
        }
    }
}

正常来说会直接弹出计算器但是运行确报错了

下面来介绍下如何使用 Unsafe来打破这个限制,定位到setAccessible

1
2
3
4
5
6
7
@Override
@CallerSensitive
public void setAccessible(boolean flag) {
    AccessibleObject.checkPermission();
    if (flag) checkCanSetAccessible(Reflection.getCallerClass());
    setAccessible0(flag);
}

我们给非public字段或方法设置访问权限为 true 时会调用checkCanSetAccessible 去检查对应的类。执行 checkCanSetAccessible 方法后会调用到 java.lang.reflect.AccessibleObject#checkCanSetAccessible(java.lang.Class<?>, java.lang.Class<?>, boolean)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
private boolean checkCanSetAccessible(Class&lt;?&gt; caller,
                                          Class&lt;?&gt; declaringClass,
                                          boolean throwExceptionIfDenied) {
        if (caller == MethodHandle.class) {
            throw new IllegalCallerException();   // should not happen
        }

        Module callerModule = caller.getModule();
        Module declaringModule = declaringClass.getModule();
        //如果被调用的变量所在模块和调用者所在模块相同，返回true
        if (callerModule == declaringModule) return true;
        //如果调用者所在模块跟Object所在模块相同，则返回true
        if (callerModule == Object.class.getModule()) return true;
        //如果被调用模块没有定义，则返回true
        if (!declaringModule.isNamed()) return true;

        String pn = declaringClass.getPackageName();
        int modifiers;
        if (this instanceof Executable) {
            modifiers = ((Executable) this).getModifiers();
        } else {
            modifiers = ((Field) this).getModifiers();
        }

        //如果当前被调用属性值是public，那就直接返回true
        // class is public and package is exported to caller
        boolean isClassPublic = Modifier.isPublic(declaringClass.getModifiers());
        if (isClassPublic &amp;&amp; declaringModule.isExported(pn, callerModule)) {
            // member is public
            if (Modifier.isPublic(modifiers)) {
                return true;
            }

            //如果被调用属性是protected并且是static，返回true
            // member is protected-static
            if (Modifier.isProtected(modifiers)
                &amp;&amp; Modifier.isStatic(modifiers)
                &amp;&amp; isSubclassOf(caller, declaringClass)) {
                return true;
            }
        }

        //如果在模块define中，定义了该属性值是open的，返回true
        // package is open to caller
        if (declaringModule.isOpen(pn, callerModule)) {
            return true;
        }

        if (throwExceptionIfDenied) {
            // not accessible
            String msg = "Unable to make ";
            if (this instanceof Field)
                msg += "field ";
            msg += this + " accessible: " + declaringModule + " does not \"";
            if (isClassPublic &amp;&amp; Modifier.isPublic(modifiers))
                msg += "exports";
            else
                msg += "opens";
            msg += " " + pn + "\" to " + callerModule;
            InaccessibleObjectException e = new InaccessibleObjectException(msg);
            if (printStackTraceWhenAccessFails()) {
                e.printStackTrace(System.err);
            }
            throw e;
        }
        return false;
    }

总结几个返回true的可能性：

  • 调用者所在模块和被调用者所在模块相同
  • 调用者模块与Object类所在模块相同

后续以及其他的还有的返回true的情况是该属性值本身的定义所决定的，我们无法改变。针对上面三种情况，我们可以通过unsafe模块来达成目的。

Unsafe模块的作用还有很多，属于是积累起来很不错的一块知识点，这里我们只记录如何通过Unsafe模块进行目标类所在moule进行修改，整体的思路为：获取Object中module属性的内存偏移量，之后再通过unsafe中方法，将Object的module属性set进我们当前操作类的module属性中。

Unsafe修改类所属module

Unsafe模块中有几个方法相关：

1.objectFieldOffset

用于获取给定类属性值的内存偏移量，用来找到module属性值的地方

2.getAndSetObject

用来根据内存偏移量以及具体值，来给指定对象的内存空间进行变量设置，跟反射的功能差不多。

其实具体的操作有上述两个方法已经足够了，但unsafe中能够根据内存偏移量和具体值进行set操作的方法可不止这一个，比如putObject也可以实现这个功能，并且方法调用的给值都是相同的。

落实到代码上如何写

1
2
3
4
5
6
7
8
Class unsafeClass = Class.forName("sun.misc.Unsafe");  
Field field = unsafeClass.getDeclaredField("theUnsafe");  
field.setAccessible(true);  
Unsafe unsafe = (Unsafe) field.get(null);  
Module baseModule = Object.class.getModule();  
Class currentClass = OracleSink.class;  
long addr = unsafe.objectFieldOffset(Class.class.getDeclaredField("module"));  
unsafe.getAndSetObject(currentClass, addr, baseModule);

可能会有一个疑问：为什么我们获取到了Class的module内存偏移，就一定能够笃定当前类的内存偏移量与其相同呢？这个其实很好理解，因为所有的类都是继承自Class类的，并且module属性值不是某一个特定类的特定属性值，而是Class类中定义的，用于给所有类都设置的一段属性值，其他类是没有对其进行修改的，所以每一个类的module内存偏移量都是相同的48 然后就可以继续运行了。

踩坑

在运行代码的时候会报错 sum.misc包不存在

1
2
--add-modules=jdk.unsupported
--add-opens=java.base/sun.nio.ch=ALL-UNNAMED

参考文章：
https://forum.butian.net/share/3748
https://pankas.top/2023/12/05/jdk17-%E5%8F%8D%E5%B0%84%E9%99%90%E5%88%B6%E7%BB%95%E8%BF%87/
https://aiwin.fun/index.php/archives/4389/