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
最后将处理好的参数传给 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());
}
}
标签：lang,java,String,exec,命令,本地,import,Runtime 来源： https://www.cnblogs.com/lalalaxiaoyuren/p/16662567.html