java-本地命令执行

本文主要是介绍java-本地命令执行，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

RunTime类进行exec的流程

源码：Runtime类

public class Runtime，它是一个公有类

构造函数：private Runtime() {}，构造函数为私有，说明不能直接实例化该对象

private static Runtime currentRuntime = new Runtime();，这句话可以看出来currentRuntime这个属性本身是一个Runtime的类

继续看，那么应该就知道了，这个Runtime类是遵循单例模式的，每次运行的对象就只有一个，所以在java程序中不同线程通过调用Runtime.getRuntime()获得的是同一个对象实例，也就是说一个java进程中只有一个Runtime实例

Runtime有个exec的方法，并且对应的重载方法有多个，并且执行完之后返回的是Process类的实例，是一个进程类的实例对象

根据传入的参数大致可以分为两类，exec方法支持传入的命令可以是一个字符串类型，也可以是一个字符串数组类型

//字符串
public Process exec(String command);
public Process exec(String command, String[] envp);
public Process exec(String command, String[] envp, File dir);
//数组
public Process exec(String cmdarray[]); 
public Process exec(String[] cmdarray, String[] envp); 
public Process exec(String[] cmdarray, String[] envp, File dir);

这里得细说exec这个方法，该exec返回的是一个Process类的实例，那么这里就可以知道了它实则是创建了一个进程，让进程来执行我们传入的command命令

这里得跟下exec方法的大概流程，这里执行命令执行测试类，如下：

public class command_cmd {
    public static void main(String[] args) throws IOException {
        String command = "whoami";
        Process p = Runtime.getRuntime().exec(command);
        InputStream in = p.getInputStream();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] b = new byte[1024];
        int a = -1;
        while ((a = in.read(b)) != -1) {
            baos.write(b, 0, a);
        }
        System.out.println(baos.toString());
    }
}

对命令执行语句进行debug操作

 Process p = Runtime.getRuntime().exec(command);

首先跟进exec的方法，发现还是一个exec方法

当传入的参数类型是 String ，会到 Process exec(String command) 这个构造方法进行处理，最后返回了 exec(command, null, null);

它继续跟进exec方法中，继续跟进另一个exec方法

java.lang.Runtime#exec(java.lang.String, java.lang.String[], java.io.File)

第三个exec方法中，如下图所示，可以看到又会继续生成一个ProcessBuilder的实例对象，并且执行start方法

java.lang.Runtime#exec(java.lang.String[], java.lang.String[], java.io.File)

经过处理之后，最后实例化了 ProcessBuilder 来处理传入的 cmdarray。可以证实 Runtime.getRuntime.exec() 的底层实际上也是 ProcessBuilder。

跟进 ProcessBuilder 中的 start 方法

java.lang.ProcessBuilder#start

注意：这里将cmdarray的第一个值赋值给prod参数，其实StringTokenizer对command进行分割后，第一个参数当成系统命令执行

String prog = cmdarray[0];

开始执行ProcessImpl的start方法如下：

ProcessBuilder.start 内部又调用了 ProcessImpl.start

这里标记的for循环，就是将cmdarry[1:])作为命令执行的参数转换成 byte 数组 argBlock。

在 ProcessImpl.start 中将 cmdarry 第一个参数 (cmdarry[0]) 当作要执行的命令，把后面的部分 (cmdarry[1:]) 作为命令执行的参数转换成 byte 数组 argBlock。

最后将处理好的参数传给 UNIXProcess

java.lang.UNIXProcess#UNIXProcess

我们看到当前断点的 pid 是 89827 , 这里确实启动了一个 whoami 进程

RunTime类exec执行流程总结：

Runtime.exec(xxx)
java.lang.ProcessBuilder.start()
new java.lang.UNIXProcess(xxx)
UNIXProcess构造方法中调用了forkAndExec(xxx) native方法。
forkAndExec调用操作系统级别fork->exec(*nix)/CreateProcess(Windows)执行命令并返回fork/CreateProcess的PID。

StringTokenizer 用法

StringTokenizer是一个用来分隔String的应用类，相当于String的split方法。

构造函数

public StringTokenizer(String str)
public StringTokenizer(String str, String delim)
public StringTokenizer(String str, String delim, boolean returnDelims)

第一个参数就是要分隔的String
第二个是分隔字符集合，如果不指定分隔字符，默认的是：”\t\n\r\f”
第三个参数表示分隔符号是否作为标记返回

StringTokenizer(String str)：构造一个用来解析str的StringTokenizer对象。java默认的分隔符是“空格”、“制表符(‘\t’)”、“换行符(‘\n’)”、“回车符(‘\r’)”。

我们本地执行命令，会讲2条命令都显示出来

ifconfig en0;whoami

Java 代码审计当中，关于命令执行，我们主要关注的是函数 Runtime.getRuntime().exec(command) && new ProcessBuilder(command).start()

在参数 command 可控的情况下，一般就会存在命令执行的问题，但是也会存在这种问题，有时候明明参数可控，但是无法成功执行命令，以及复杂的shell 命令，例如带有 | 、<、>、$ 等符号的命令没办法正常执行。

粗略一看，存在命令执行函数，command 获取从外部传入的 cmd ，应该是存在命令注入漏洞的。但是并没有执行成功，并不存在命令执行漏洞。

我们跟进 Runtime.getRuntime().exec() 发现会依据传入的参数类型，而选用不同的函数。

通过StringTokenizer 对command处理，会根据 \t\n\r\f 把传入的 command 分割

空格前面的参数：

cmdarray[0]=ifocnfig

cmdarray[1]=en0;whoami

在 ProcessImpl.start 中将 cmdarry 第一个参数 (cmdarry[0]) 当作要执行的命令，把后面的部分 (cmdarry[1:]) 作为命令执行的参数转换成 byte 数组 argBlock。

最后将处理好的参数传给 UNIXProcess

此时 prog 是要执行的命令 ifconfig , argBlock 都是传给 ifconfig 的参数 en0;whoami

经过 StringTokenizer 对字符串的处理，命令执行的语义发生了改变，并不是最初设定的想法。

Runtime.getRuntime().exec(String cmdarray[])

传入数组

public class command_cmd {
    public static void main(String[] aaa) throws IOException {
        String command = "ifconfig en0;whoami";

        Process p = Runtime.getRuntime().exec(new String[]{"/bin/sh", "-c", command});
        InputStream in = p.getInputStream();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] b = new byte[1024];
        int a = -1;
        while ((a = in.read(b)) != -1) {
            baos.write(b, 0, a);
        }
        System.out.println(baos.toString());

    }
}

我们传入数组，进行分析，因为直接传入的是数组，所以没有经过 StringTokenizer 对字符串的处理

java.lang.Runtime#exec(java.lang.String[])

java.lang.Runtime#exec(java.lang.String[], java.lang.String[], java.io.File)

java.lang.UNIXProcess#UNIXProcess

此时 prog 是要执行的命令 /bin/sh , argBlock 都是传给 /bin/sh 的参数 -c\x00"ifconfig en0;whoami"

同理base64编码也可执行

此时 prog 是要执行的命令 bash , argBlock 都是传给 bash 的参数 -c\x00"{echo,cGluZyAxMjcuMC4wLjE7ZWNobyAxID50ZXN0LnR4dA==}|{base64,-d}|{bash,-i}"

import java.io.IOException;

public class linux_cmd {
    public static void main(String[] args) throws IOException {
        String Command = "bash -c {echo,cGluZyAxMjcuMC4wLjE7ZWNobyAxID50ZXN0LnR4dA==}|{base64,-d}|{bash,-i}";
        Runtime.getRuntime().exec(Command);
    }
}

Runtime反射实现exec的执行

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.*;

public class Test {
    public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {

        String className = "java.lang.Runtime";
        Class  runtimeClass1 = Class.forName(className);

        Constructor runtimeConstructor =  runtimeClass1.getDeclaredConstructor();
        runtimeConstructor.setAccessible(true);
        Runtime runtime = (Runtime) runtimeConstructor.newInstance();
        Method ExecMethod = runtimeClass1.getMethod("exec", String.class);
        String cmd = "ifconfig en0";
        Process p = (Process) ExecMethod.invoke(runtime, cmd);

        InputStream in = p.getInputStream();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] b = new byte[1024];
        int a = -1;

        while ((a = in.read(b)) != -1) {
            baos.write(b, 0, a);
        }

        System.out.println(baos.toString());
    }
}

通过反射ProcessBuilder类来实现命令执行

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.*;
import java.util.ArrayList;
import java.util.List;

public class common_exec {
    public static void main(String args[]) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, IOException {
        Class pClass = ProcessBuilder.class;
        List<String> list = new ArrayList<>();
        list.add("whoami");

        Constructor constructor = pClass.getDeclaredConstructor(new Class[]{List.class});

        Object obj = (ProcessBuilder)constructor.newInstance(list);
        Method startMethod = pClass.getMethod("start");
        Process p = (Process)startMethod.invoke(obj);

        InputStream in = p.getInputStream();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] b = new byte[1024];
        int a = -1;

        while ((a = in.read(b)) != -1) {
            baos.write(b, 0, a);
        }

        System.out.println(baos.toString());

    }
}

通过反射ProcessImpl类来实现命令执行

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class common_exec2 {
    public static void main(String args[]) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, IOException, ClassNotFoundException {
        Class pClass = Class.forName("java.lang.ProcessImpl");
        //Constructor constructor = pClass.getDeclaredConstructor(); //这里是空的构造参数
        //constructor.setAccessible(true);
        //Object obj = constructor.newInstance();
        String[] cmdarray = new String[]{"whoami"};
        Method startMethod = pClass.getDeclaredMethod("start", String[].class, Map.class, String.class, ProcessBuilder.Redirect[].class, boolean.class);
        startMethod.setAccessible(true);
        Process p = (Process)startMethod.invoke(null,cmdarray, null, null, null, false); //这里需要的五个参数，第一个参数为null，因为调用的方法是这个类的静态方法

        // 下面的操作就是正常的读取数据的操作
        InputStream in = p.getInputStream();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] b = new byte[1024];
        int a = -1;

        while ((a = in.read(b)) != -1) {
            baos.write(b, 0, a);
        }

        System.out.println(baos.toString());

    }
}

这篇关于java-本地命令执行的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程

java-本地命令执行

RunTime类进行exec的流程

StringTokenizer 用法

Runtime.getRuntime().exec(String cmdarray[])

同理base64编码也可执行

Runtime反射实现exec的执行

通过反射ProcessBuilder类来实现命令执行

通过反射ProcessImpl类来实现命令执行

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯