ToB企服应用市场:ToB评测及商务社交产业平台

标题: 使用Python实现简易版Netcat [打印本页]
作者: 尚未崩坏    时间: 2023-3-9 21:42
标题: 使用Python实现简易版Netcat
Netcat

Netcat是一种网络工具，也称为“nc”，可用于在计算机网络之间进行TCP/IP或UDP连接。它可以用于连接到其他计算机上的端口，发送和接收数据，扫描端口以及创建服务器等。
使用Python实现简易版

整体功能规划
  1. if __name__ == "__main__":
  2.     # argparse库是python标准库里面用来处理命令行参数的库
  3.     # 传递不同的参数，就能控制这个程序执行不同的操作
  4.     parser = argparse.ArgumentParser(       # 创建一个解析对象
  5.         description="ReverseShell",
  6.         formatter_class=argparse.RawDescriptionHelpFormatter,
  7.         # 帮助信息,程序启动的时候如果使用--help参数，就会显示这段信息
  8.         epilog=textwrap.dedent(
  9.             """
  10.                 python Simple_Netcat.py -t <IP> -p 5555 -l -c   # command shell
  11.                 python Simple_Netcat.py -t <IP> -p 5555         # connect to server
  12.                 get <file>                                      # download file
  13.                 upload <file>                                   # upload file
  14.             """
  15.         ),
  16.     )
  18.     # -c参数,打开一个交互式的命令行shell；
  19.     parser.add_argument("-c", "--command", action="store_true", help="command shell")
  20.     # -l参数,创建一个监听器
  21.     parser.add_argument("-l", "--listen", action="store_true", help="listen ")
  22.     # -p参数,指定要通信的端口
  23.     parser.add_argument("-p", "--port", type=int, default=5555, help="specified port ")
  24.     # -t参数,指定要通信的目标IP地址
  25.     parser.add_argument("-t", "--target", default="127.0.0.1", help="specified IP")
  27.     args = parser.parse_args()
  29.     nc = SimpleNetcat(args)
  30.     nc.run()
复制代码
创建NetCat类：
  1. class SimpleNetcat:
  2.     def __init__(self, args):
  3.         # 我们用main代码块传进来的命令行参数，初始化一个NetCat对象，然后创建一个socket对象
  4.         self.args = args
  5.         self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  6.         self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
  8.     # 如果NetCat对象是接收方，run就执行listen函数
  9.     # 如果是发送方，run就执行send函数
  10.     def run(self):
  11.         if self.args.listen:
  12.             self.listen()
  13.         else:
  14.             # 用于启动时输出
  15.             print('Enter the first command >',end='')
  16.             self.send()
复制代码
实现listen功能:
  1. # 监听数据
  2. def listen(self):
  3.     self.socket.bind((self.args.target, self.args.port))
  4.     # listen(n)传入的值, n表示的是服务器拒绝(超过限制数量的)连接之前，操作系统可以挂起的最大连接数量。
  5.     self.socket.listen(5)
  7.     # 用一个循环监听新连接,并把已连接的socket对象传递给handle函数执行任务
  8.     while True:
  9.         # accept()等待传入连接。,返回代表连接的新套接字以及客户端的地址。
  10.         client_socket, _ = self.socket.accept()
  11.         # 给每个客户端创建一个独立的线程进行管理
  12.         client_thread = threading.Thread(target=self.handle, args=(client_socket,))
  13.         client_thread.start()
复制代码
当程序监听到指令之后，就可以执行相应的任务：
  1. # 执行传入的任务
  2. def handle(self, client_socket):
  3.     # 如果要执行命令，handle函数就会把该命令传递给execute函数
  4.     # 然后把输出结果通过socket发回去
  5.     if self.args.command:
  6.         # 创建shell，先创建一个循环，向发送方发一个提示符，
  7.         # 然后等待其发回命令。每收到一条命令，就用execute函数执行它，然后把结果发回发送方
  8.         while True:
  9.             try:
  10.                 cmd_buffer = b''
  11.                 # 循环接收发送端命令
  12.                 while '\n' not in cmd_buffer.decode():
  13.                     cmd_buffer += client_socket.recv(64)
  14.                 cmd = cmd_buffer.strip().decode()
  15.                 if cmd.startswith("get"):
  16.                     send_file(cmd, client_socket)
  17.                 elif cmd.startswith("upload"):
  18.                     get_file(cmd, client_socket)
  19.                 else:
  20.                     response = execute(cmd_buffer.decode())
  21.                     if response:
  22.                         client_socket.send(response.encode())
  23.             except Exception as e:
  24.                 print(f'Server killed {e}')
  25.                 self.socket.close()
  26.                 sys.exit()
复制代码
实现execute函数
  1. # execute函数用于接受一条命令并执行，然后将结果作为一段字符串返回
  2. def execute(cmd):
  3.     if cmd.startswith('cd '):
  4.         # 切换目录
  5.         os.chdir(cmd[3:].strip())
  6.         return os.getcwd() + '>'
  7.     else:
  8.         cmd = cmd.strip()
  9.         if not cmd:
  10.             return
  11.         # subprocess库提供了一组强大的进程创建接口，可以通过多种方式调用其他程序。
  12.         # check_output函数会在本机运行一条命令，并返回该命令的输出
  13.         output = subprocess.check_output(shlex.split(cmd), stderr=subprocess.STDOUT)
  14.         return output.decode() + os.getcwd() + '>'
复制代码
实现send函数
  1. def send(self):
  2.     # 连接到target:port
  3.     self.socket.connect((self.args.target, self.args.port))
  4.     # 创建个try/catch块，这样就能直接用Ctrl+C组合键手动关闭连接
  5.     try:
  6.         # 创建一个大循环，接收target返回的数据
  7.         while True:
  8.             # 等待用户输入新的内容，再把新的内容发给target
  9.             buffer = input() + '\n'
  10.             self.socket.send(buffer.encode())
  11.             if buffer.startswith("get"):
  12.                 get_file(buffer, self.socket)
  13.             elif buffer.startswith("upload"):
  14.                 send_file(buffer, self.socket)
  15.             else:
  16.                 recv_len = 4096
  17.                 response = ''
  18.                 # 读取socket本轮返回的数据,如果socket里的数据目前已经读到头，就退出小循环
  19.                 while recv_len:
  20.                     data = self.socket.recv(4096)
  21.                     recv_len = len(data)
  22.                     response += data.decode('utf-8', errors='ignore')
  23.                     if recv_len < 4096:
  24.                         break
  25.                 # 检查刚才有没有实际读出什么东西来，如果读出了什么，就输出到屏幕上
  26.                 if response:
  27.                     print(response, end='')
  28.     except KeyboardInterrupt:
  29.         print("User Terminated.")
  30.         self.socket.close()
  31.         sys.exit()
复制代码
实现文件上传功能
  1. def send_file(cmd, client_socket):
  2.     filename = cmd.split()[1]
  3.     if os.path.isfile(filename):  # 判断文件是否存在
  4.         size = os.path.getsize(filename)  # 获取文件大小
  5.         client_socket.send(str(size).encode() + b'\n')  # 发送数据长度
  7.         with open(filename, "rb") as f:
  8.             client_socket.send(f.read())
  9.     else:
  10.         client_socket.send("File Not Exist".encode())
复制代码
实现文件下载功能
  1. def get_file(buffer, socket):
  2.     cmd, filename = buffer.split(" ")
  3.     filename = filename.replace("\n", "")
  4.     file_size = int(socket.recv(64).decode().strip('\n'))
  5.     print("File Size:%s" % (file_size))
  7.     with open(filename, "wb") as f:
  8.         received_size = 0
  9.         while received_size < file_size:
  10.             size = min(4096, file_size - received_size)
  11.             data = socket.recv(size)
  12.             f.write(data)
  13.             received_size += len(data)
  14.             print("Download: {:.2f}%".format(received_size / file_size * 100))
  15.     print("File '{}' downloaded successfully.".format(filename))
  16.     print('Enter Command >', end="")
复制代码
整体代码

Github
代码测试

shell：


上传文件：


下载文件：



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



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4