python渗透测试入门——取代netcat

1.代码及代码讲解。
实验环境：windows10下的linux子系统+kali虚拟机

1. import argparse
2. import socket
3. import shlex
4. import subprocess
5. import sys
6. import textwrap
7. import threading
9. def execute(cmd):
10.     cmd = cmd.strip()
11.     if not cmd:
12.         return
13.     output = subprocess.check_output(shlex.split(cmd),stderr=subprocess.STDOUT)

复制代码

1. #subprocess。这个库提供了一组强大的进程创建接口，让你可以通过多种方式调用其他程序<br><br>return output.decode()

复制代码

1. <em id="__mceDel">class Netcat:
2.     def __init__(self,args,buffer=None):
3.         self.args = args
4.         self.buffer = buffer
5.         self.socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
6.         self.socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
7. #利用传进来的参数，初始化一个NetCat对象，然后创建一个socket对象
8.     def run(self):
9.         if self.args.listen:
10.             self.listen()
11.         else:
12.             self.send()<br></em>#run函数作为NetCat对象的执行入口，它的逻辑其实相当简单：直接把后续的执行移交给其他两个函数。如果我们的NetCat对象是接收方，run就执行listen函数；如果是发送方，run就执行send函数
14.     def send(self):
15.         self.socket.connect((self.args.target,self.args.port))
16.         if self.buffer:
17.             self.socket.send(self.buffer)
18.         try:
19.             while True:
20.                 recv_len = 1
21.                 response = ''
22.                 while recv_len:
23.                     data = self.socket.recv(4096)
24.                     recv_len = len(data)
25.                     response += data.decode()
26.                     if recv_len < 4096:
27.                         break
28.                 if response:
29.                     print(response)
30.                     buffer = input('>')
31.                     buffer += '\n'
32.                     self.socket.send(buffer.encode())
33.         except KeyboardInterrupt:
34.             print('User terminated')
35.             self.socket.close()
36.             sys.exit()
37. #先连接到target和port，之后利用try/catch块，这样就能直接用Ctrl+C组合键手动关闭连接，再通过通过循环接收数据
38.     def listen(self):
39.         self.socket.bind((self.args.target,self.args.port))
40.         self.socket.listen(5)
41.         while True:
42.             client_socket,_ = self.socket.accept()
43.             client_thread = threading.Thread(target=self.handle,args=(client_socket,))
44.             client_thread.start()
45. #listen函数把socket对象绑定到target和port上，然后开始用一个循环监听新连接，并把已连接的socket对象传递给handle函数。
46.     def handle(self,client_socket):
47.         if self.args.execute:
48.             output = execute(self.args.execute)
49.             client_socket.send(output.encode())
50.         elif self.args.upload:
51.             file_buffer = b''
52.             while True:
53.                 data = client_socket.recv(4096)
54.                 print(data.decode)
55.                 if data:
56.                     file_buffer += data
57.                 else:
58.                     break
59.             with open(self.args.upload,'wb') as f:
60.                 f.write(file_buffer)
61.             message = f'Saved file {self.args.upload}'
62.             client_socket.send(message.encode())
63.         elif self.args.command:
64.             cmd_buffer = b''
65.             while True:
66.                 try:
67.                     client_socket.send(b'ailx10:#>')
68.                     while '\n' not in cmd_buffer.decode():
69.                         cmd_buffer += client_socket.recv(64)
70.                     response = execute(cmd_buffer.decode())
71.                     if response:
72.                         client_socket.send(response.encode())
73.                     cmd_buffer = b''
74.                 except Exception as e:
75.                     print(f'server killed {e}')
76.                     self.socket.close()
77.                     sys.exit()<br>#handle函数会根据它收到的命令行参数来执行相应的任务：执行命令、上传文件，或是打开一个shell。<br>#如果要执行命令，handle函数就会把该命令传递给execute函数，然后把输出结果通过socket发回去<br>#如果要执行命令，handle函数就会把该命令传递给execute函数，然后把输出结果通过socket发回去<br>#最后，如果要创建一个shell，我们还是创建一个循环，向发送方发一个提示符，然后等待其发回命令<br>
78. if __name__ == "__main__":
79.     parser = argparse.ArgumentParser(description="simple netcat tool",
80.                                      formatter_class=argparse.RawDescriptionHelpFormatter,
81.                                      epilog=textwrap.dedent("""Example:
82.                                      netcat.py -t 192.168.0.108 -p 5555 -l -c # command shell
83.                                      netcat.py -t 192.168.0.108 -p 5555 -l -u=mytest.txt # upload file
84.                                      netcat.py -t 192.168.0.108 -p 5555 -l -e="cat /etc/passwd" # execute command
85.                                      echo 'ABC' | ./netcat.py -t 192.168.0.108 -p 135 # echo text to server port 135
86.                                      netcat.py -t 192.168.0.108 -p 5555 # connect to server
87.                                      """))
88.     parser.add_argument('-c','--command',action='store_true',help='command shell')
89.     parser.add_argument('-e','--execute',help='execute specified command')
90.     parser.add_argument('-l','--listen',action='store_true',help='listen')
91.     parser.add_argument('-p','--port',type=int,default=5555,help='specified port')
92.     parser.add_argument('-t','--target',default='192.168.0.108',help='specified ip')
93.     parser.add_argument('-u','--upload',help='upload file')
95.     args = parser.parse_args()
96.     if args.listen:
97.         buffer = ''
98.     else:
99.         buffer = sys.stdin.read()
101.     nc = Netcat(args,buffer.encode())
102.     nc.run()

复制代码

　　2.小试牛刀。
1）测试命令控制：
首先在Kali虚拟机上，启动一个接收方，让它在虚拟机IP地址的5555端口提供一个命令行shell。

 
 之后在本地端以客户端的模式打开脚本运行

 
 可以看到，我们得到了一个典型的命令行shell

 2）测试命令执行：
先在服务端运行

 
 在客户端可直接看到命令执行结果

 
 3）在本机上用原版netcat来连接Kali虚拟机

 
 4)发送http请求

 
这次的分享就到这里， 下一次将开发一个TCP代理。
 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！