java getRuntime().exec 带符号的命令无法执行解决方法

冷不防 2021-08-30 23:25 1105阅读 0赞

### 0x01 前言 ###

首先Java下的命令执行大家都知道常见的两种方式：

1.使用ProcessBuilder

ProcessBuilder pb=new ProcessBuilder(cmd); 
    pb.start();

2.使用Runtime

Runtime.getRuntime().exec(cmd)

也就是说上面cmd参数可控的情况下，均存在命令执行的问题。但是话题回来，不太清楚大家是否遇到过java命令执行的时候，无论是windows还是linux环境下，带有`|,<,>`等符号的命令没办法正常执行。所以今天就进入底层看看这两个东西。

### 0x02 差别 ###

先选择跟进`Runtime.getRuntime().exec(cmd)`，样例代码如下所示：

import java.io.*;
    
    public class Main {
        public static void main(String[] arg) throws IOException {
            String command="/bin/sh -c echo 111 > 3.txt";
            Process proc = Runtime.getRuntime().exec(command);
            InputStream in = proc.getInputStream();
            BufferedReader br = new BufferedReader(new InputStreamReader(in, "UTF8"));
            String line = null;
            while((line=br.readLine())!=null) {
                System.out.println(line);
            }
        }
    }

跟进 **java.lang.Runtime\#exec** 的构造方法，这里要感谢**@phith0n**提出的疑问，让我补充完整这篇文章，下面话题回来，exec的构造方法有以下几种情况，其实根据传入的变量我们大概可以区分的了，一个是根据**String command**，也就是直接传入一个字符串。另一个是根据**String cmdarray\[\]**，也就是传入一个数组。

public Process exec(String command) throws IOException {
            return exec(command, null, null);
        }
    
    public Process exec(String command, String[] envp) throws IOException {
            return exec(command, envp, null);
        }
    
    public Process exec(String cmdarray[]) throws IOException {
            return exec(cmdarray, null, null);
        }
    
    public Process exec(String[] cmdarray, String[] envp) throws IOException {
            return exec(cmdarray, envp, null);
        }

而根据前面代码中，我们传入的命令是如下所示：

String command="/bin/sh -c echo 111 > 3.txt";

所以会进入`Process exec(String command)`这个构造方法进行处理，跟进这个方法，发现最后返回`exec(command, null, null)`。

public Process exec(String command) throws IOException {
        return exec(command, null, null);
    }

继续跟进这个**exec**方法，看看这个方法的实现。这里代码实例化了**StringTokenizer**类，并且传入了我们要执行的**command**命令，简单翻译一下注释：为指定的字符串构造一个字符串标记器。也就是说**StringTokenizer**这个类会为特殊字符打上tag之类的东西。

![image-20191008093546498][]

我们继续往下看，经过**StringTokenizer**类处理之后会返回一个**cmdarray\[\]**，而这里的处理实际上是根据空格针对命令进行了分割，至于为什么结果要是一个array数组，我们下面会接着说。

![image-20191008094034245][]

我们发现经过一系列的处理，最后又有一个**return exec** 的处理。继续跟进这个**exec**的处理，我们可以看到这里最后实例化**ProcessBuilder**来处理我们传入的**cmdarray**。到这里实际上可以清楚了**Runtime.getRuntime().exec()**的底层实际上也是**ProcessBuilder**。

public Process exec(String[] cmdarray, String[] envp, File dir)
        throws IOException {
        return new ProcessBuilder(cmdarray)
            .environment(envp)
            .directory(dir)
            .start();
    }

我们知道**ProcessBuilder.start**方法是命令执行，那么跟进这个**start**我们发现，首先**prog**获取**cmdarray\[0\]**也就是我们的**/bin/sh**，然后判断**security**是否为**null**，如果不为**null**就会校验**checkExec**。

![image-20191008094452918][]

然后继续往下走，这里调用**java.lang.ProcessImpl.start**。

![image-20191008095329104][]

进入之后我们就可以看到最后是调用**java.lang.UnixProcess**这个类来执行命令，而且我们发现执行命令的时候实际上是根据**cmdarray\[0\]**来判断用什么命令。而在**java.lang.UnixProcess**这个类里面是调用**forkAndExec**来为命令创建环境等操作。我们看到当前断点**pid**是**2653**，而这里确实起了一个sh的进程。

![image-20191008095900899][]

这样看可能还不够明显，因为我们知道`/bin/sh -c echo 111 > 3.txt`在bash命令行下也不会正常执行成功，命令行下需要`/bin/sh -c "echo 111 > 3.txt"`，看这两段代码的命令执行的效果。

String[] command = { "/bin/sh", "-c", "echo 111 > 3.txt" };
    String command="/bin/sh -c \"echo 111 > 3.txt\"";

首先先看`String command="/bin/sh -c \"echo 111 > 3.txt\"";`，按照前面的分析，经过**StringTokenizer**这个类进行拆分之后变成了`{"/bin/sh","-c",""echo","111"、">","3.txt""}`。

![image-20191008102437343][]

而当前内存开辟一个**12473**进程，并且确实**12473**执行**sh**命令。

![image-20191008101638581][]

![image-20191008101629453][]

但是我们发现，经过**StringTokenizer**这类拆分之后，命令完全变了一个味道，语义完全变了，并不是我们想要的结果，那我们再看看`String[] command = { "/bin/sh", "-c", "echo 111 > 3.txt" };`的结果。因为我们传入的是**array**数组类型，这里直接将命令直接带入了**ProcessBuilder**进行处理，前面完全没有经过**StringTokenizer**这个类的拆分。也就是他完整的保存了我想要的语义。

![image-20191008101848421][]

![image-20191008101932196][]

也就是说**getRuntime().exec()**如果直接传入字符串会经过**StringTokenizer的**分割，进而破坏其原本想要表达的意思。

下面这段代码是否存在命令执行的问题，要是在PHP下，我会斩钉截铁的说是，但是回到java环境下，我们发现`|`等一些特殊符号没办法使用，而且传入的是字符串，遇到空格会被**StringTokenizer**进行切割，所以实际上下面这段代码是没办法使用的。

String str = request.getParameter("url");
    String cmdstr = "ping "+ url;
    Runtime.getRuntime().exec(cmdstr)

再来一段代码，能够执行命令，但是很受限，我们知道命令根据**cmdarray\[0\]**来确认以什么命令环境启动，这里确实以**/bin/sh**启动了，但是后面的命令执行的时候存在问题，它仅能执行单条命令，拼接不了相关参数。

String str = request.getParameter("cmd");
    String cmdstr = "/bin/sh -c "+ cmd;
    Runtime.getRuntime().exec(cmdstr)

![image-20191008103853367][]

最后再来一段代码，下面这段代码才会是java下命令执行的完全体。

String str = request.getParameter("cmd");
    String[] cmdstr = { "/bin/sh", "-c", str };
    Runtime.getRuntime().exec(cmdstr)

后面我翻到一篇文章，实际上也是差不多这个情况，实际上也是这个**StringTokenizer**这个类针对命令进行处理可能会造成非预期的结果。

![image-20191006105729560][]

最后还有一个问题，为什么一定要将命令切割成为数组，原因是因为**ProcessBuilder**，看看他的构造方法。

public ProcessBuilder(String... command) {
        this.command = new ArrayList<>(command.length);
        for (String arg : command)
            this.command.add(arg);
    }
    
    public ProcessBuilder(List<String> command) {
        if (command == null)
            throw new NullPointerException();
        this.command = command;
    }

实际上它是要求 **Array** 类型或者 **List** 类型，如果我们要执行下图中的代码是不行的。

![image-20191008104432564][]

原因在于我们传入的类型不对，我们前面说过命令执行是根据**cmdarray\[0\]**，确认命令启动环境，这里自然找不到我们要启动的命令。

![image-20191008104655016][]

所以Java下的命令稍微改造一下代码就好。

![image-20191005215432368][]

还有一种方式就是用编码，linux下可以用bash的base64编码来解决这个特殊字符的问题。

![image-20191008113959749][]

这里在小提一下如果遇到命令执行过滤了**ProcessBuilder**和**getRuntime**，可以考虑一下**java.lang.ProcessImpl.start**

### 0x03 小结 ###

其实java已经尽量规避命令执行的安全问题，JDK沙盒机制会进行checkExec，执行命令的机制就是仅仅检查并执行命令数组中的第一个，而分隔符后面的所有东西都是默认为被执行程序的参数。

所以在java下如果遇到复杂的命令执行，且参数只能如下所示，且只有一个位置可以控制的话，建议使用base64的编码方式，windows下可以使用**powershel**l的**base64**。

java的反序列化框架利用框架yso，以及一些shiro这类反序列化导致的命令执行实际上很多是用了**getRuntime**来达到命令执行的目的，且就像我们上面说的，可控位置比较固定，执行复杂命令会出现执行不了，以上只是复习一下之前和人聊的一个问题。

命令在线转换：

[http://www.jackson-t.ca/runtime-exec-payloads.html][http_www.jackson-t.ca_runtime-exec-payloads.html]

转换工具源码：

<!DOCTYPE html>
    <html lang="en">
     <head> 
      <title>java.lang.Runtime.exec() Payload Workarounds - @Jackson_T</title> 
      <meta charset="utf-8" /> 
      <meta name="viewport" content="width=device-width, initial-scale=1.0" /> 
       
      <style>
    body {
    	margin: 0;
    	padding: 10px 0;
    	text-align: center;
    	font-family: 'Ubuntu Condensed', sans-serif;
    	color: #585858;
      background-color: #fff;
    	font-size: 13px;
    	line-height: 1.4
    }			
    ::selection {
    	background: #fff2a8;
    }
    pre, code {
    	font-family: 'Ubuntu Mono', 'Consolas', Monospace;
      font-size: 13px;
      background-color: #E5F5E5;
      color: #585858;
      padding-left: 0.25em;
      padding-right: 0.25em;
    	/*display: block;*/
    }		
    #wrap {
    	margin-left: 1em;
    	margin-right: 1em;
    	text-align: left;
    	font-size: 13px;
    	line-height: 1.4
    }
    	#wrap {
    		width: 820px;
    	}
    	#container {
    		float: right;
    		width: 610px;
    	}
    .entry {
    	font-size: 14px;
    	line-height: 20px;
    	hyphens: auto;
    	font-family: 'Roboto', sans-serif, 'Inconsolata', Monospace;
    }
    </style> 
     </head> 
     <body> 
      <div id="wrap"> 
       <div id="container"> 
        <div class="entry"> 
         <article> 
          <p>偶尔有时命令执行有效负载<code>Runtime.getRuntime().exec()</code>失败. 使用 web shells, 反序列化漏洞或其他向量时可能会发生这种情况.</p> 
          <p>有时这是因为重定向和管道字符的使用方式在正在启动的进程的上下文中没有意义. 例如 <code>ls > dir_listing</code> 在shell中执行应该将当前目录的列表输出到名为的文件中 <code>dir_listing</code>. 但是在 <code>exec()</code> 函数的上下文中,该命令将被解释为获取 <code>></code> 和 <code>dir_listing</code> 目录.</p> 
          <p>其他时候,其中包含空格的参数会被StringTokenizer类破坏.该类将空格分割为命令字符串. 那样的东西 <code>ls "My Directory"</code> 会被解释为 <code>ls '"My' 'Directory"'</code>.</p> 
          <p>在Base64编码的帮助下, 下面的转换器可以帮助减少这些问题. 它可以通过调用Bash或PowerShell再次使管道和重定向更好,并且还确保参数中没有空格.</p> 
          <p>Input type: <input type="radio" id="bash" name="option" value="bash" onclick="processInput();" checked="" /><label for="bash">Bash</label> <input type="radio" id="powershell" name="option" value="powershell" onclick="processInput();" /><label for="powershell">PowerShell</label> <input type="radio" id="python" name="option" value="python" onclick="processInput();" /><label for="python">Python</label> <input type="radio" id="perl" name="option" value="perl" onclick="processInput();" /><label for="perl">Perl</label></p> 
          <p><textarea rows="10" style="width: 100%; box-sizing: border-box;" id="input" placeholder="Type input here..."></textarea> <textarea rows="5" style="width: 100%; box-sizing: border-box;" id="output" onclick="this.focus(); this.select();" readonly=""></textarea></p> 
          <script>
      var taInput = document.querySelector('textarea#input');
      var taOutput = document.querySelector('textarea#output');
    
      function processInput() {
        var option = document.querySelector('input[name="option"]:checked').value;
    
        switch (option) {
          case 'bash':
            taInput.placeholder = 'Type Bash here...'
            taOutput.value = 'bash -c {echo,' + btoa(taInput.value) + '}|{base64,-d}|{bash,-i}';
            break;
          case 'powershell':
            taInput.placeholder = 'Type PowerShell here...'
            poshInput = ''
            for (var i = 0; i < taInput.value.length; i++) { poshInput += taInput.value[i] + unescape("%00"); }
            taOutput.value = 'powershell.exe -NonI -W Hidden -NoP -Exec Bypass -Enc ' + btoa(poshInput);
            break;
          case 'python':
            taInput.placeholder = 'Type Python here...'
            taOutput.value = "python -c exec('" + btoa(taInput.value) + "'.decode('base64'))";
            break;
          case 'perl':
            taInput.placeholder = 'Type Perl here...'
            taOutput.value = "perl -MMIME::Base64 -e eval(decode_base64('" + btoa(taInput.value) + "'))";
            break;
          default:
            taOutput.value = ''
        }
    
        if (!taInput.value) taOutput.value = '';
      }
    
      taInput.addEventListener('input', processInput, false);
    </script> 
         </article> 
        </div> 
       </div> 
      </div>  
     </body>
    </html>

[image-20191008093546498]: /images/20210728/9bc9ad06885f4122bec6e0c80fec5805.png
[image-20191008094034245]: /images/20210728/4e023c3f76604ef6a8cfa45c12ea5895.png
[image-20191008094452918]: /images/20210728/aacf39dc489143d3b1a61e5a440c631d.png
[image-20191008095329104]: /images/20210728/2f4f69d29675468192d901a9828470fc.png
[image-20191008095900899]: /images/20210728/85c01c594a104e2bbefd6119b860d254.png
[image-20191008102437343]: /images/20210728/a6019e4abcee4d2f90080ddcd029a98c.png
[image-20191008101638581]: /images/20210728/8477dbf6a85b48118e1bbb2f7819f183.png
[image-20191008101629453]: /images/20210728/409e211f34914e54aa587c84c5f04161.png
[image-20191008101848421]: /images/20210728/6d3ec7e88bf34ba591b80fe61a31a6a6.png
[image-20191008101932196]: /images/20210728/eb3c7708f4cf465897f88c0b6dd9daa6.png
[image-20191008103853367]: /images/20210728/db3aed5e1c424825809204fd2e937a77.png
[image-20191006105729560]: /images/20210728/3ce7dd1c17f24df0bcd483408ac92429.png
[image-20191008104432564]: /images/20210728/22d0cf24426c44e88fee9fe77d78f666.png
[image-20191008104655016]: /images/20210728/7363cffb039b45e1bcf13246f43df86f.png
[image-20191005215432368]: /images/20210728/458c09c7ee1e49c2880c8c5d2bfbb541.png
[image-20191008113959749]: /images/20210728/8358a6a6291541949fce08d2e7a1b7bf.png
[http_www.jackson-t.ca_runtime-exec-payloads.html]: http://www.jackson-t.ca/runtime-exec-payloads.html