import argparse

import socket

import shlex

import subprocess

import sys

import textwrap

import threading

def execute(cmd):

    cmd = cmd.strip()

    if not cmd:

        return

    output = subprocess.check_output(shlex.split(cmd),stderr=subprocess.STDOUT)

#subprocess。这个库提供了一组强大的进程创建接口，让你可以通过多种方式调用其他程序

return output.decode()

class Netcat:

    def __init__(self,args,buffer=None):

        self.args = args

        self.buffer = buffer

        self.socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

        self.socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)

#利用传进来的参数，初始化一个NetCat对象，然后创建一个socket对象

    def run(self):

        if self.args.listen:

            self.listen()

        else:

            self.send()
#run函数作为NetCat对象的执行入口，它的逻辑其实相当简单：直接把后续的执行移交给其他两个函数。如果我们的NetCat对象是接收方，run就执行listen函数；如果是发送方，run就执行send函数

    def send(self):

        self.socket.connect((self.args.target,self.args.port))

        if self.buffer:

            self.socket.send(self.buffer)

        try:

            while True:

                recv_len = 1

                response = ''

                while recv_len:

                    data = self.socket.recv(4096)

                    recv_len = len(data)

                    response += data.decode()

                    if recv_len < 4096:

                        break

                if response:

                    print(response)

                    buffer = input('>')

                    buffer += '\n'

                    self.socket.send(buffer.encode())

        except KeyboardInterrupt:

            print('User terminated')

            self.socket.close()

            sys.exit()

#先连接到target和port，之后利用try/catch块，这样就能直接用Ctrl+C组合键手动关闭连接，再通过通过循环接收数据

    def listen(self):

        self.socket.bind((self.args.target,self.args.port))

        self.socket.listen(5)

        while True:

            client_socket,_ = self.socket.accept()

            client_thread = threading.Thread(target=self.handle,args=(client_socket,))

            client_thread.start()

#listen函数把socket对象绑定到target和port上，然后开始用一个循环监听新连接，并把已连接的socket对象传递给handle函数。

    def handle(self,client_socket):

        if self.args.execute:

            output = execute(self.args.execute)

            client_socket.send(output.encode())

        elif self.args.upload:

            file_buffer = b''

            while True:

                data = client_socket.recv(4096)

                print(data.decode)

                if data:

                    file_buffer += data

                else:

                    break

            with open(self.args.upload,'wb') as f:

                f.write(file_buffer)

            message = f'Saved file {self.args.upload}'

            client_socket.send(message.encode())

        elif self.args.command:

            cmd_buffer = b''

            while True:

                try:

                    client_socket.send(b'ailx10:#>')

                    while '\n' not in cmd_buffer.decode():

                        cmd_buffer += client_socket.recv(64)

                    response = execute(cmd_buffer.decode())

                    if response:

                        client_socket.send(response.encode())

                    cmd_buffer = b''

                except Exception as e:

                    print(f'server killed {e}')

                    self.socket.close()

                    sys.exit()
#handle函数会根据它收到的命令行参数来执行相应的任务：执行命令、上传文件，或是打开一个shell。
#如果要执行命令，handle函数就会把该命令传递给execute函数，然后把输出结果通过socket发回去
#如果要执行命令，handle函数就会把该命令传递给execute函数，然后把输出结果通过socket发回去
#最后，如果要创建一个shell，我们还是创建一个循环，向发送方发一个提示符，然后等待其发回命令


if __name__ == "__main__":

    parser = argparse.ArgumentParser(description="simple netcat tool",

                                     formatter_class=argparse.RawDescriptionHelpFormatter,

                                     epilog=textwrap.dedent("""Example:

                                     netcat.py -t 192.168.0.108 -p 5555 -l -c # command shell

                                     netcat.py -t 192.168.0.108 -p 5555 -l -u=mytest.txt # upload file

                                     netcat.py -t 192.168.0.108 -p 5555 -l -e=\"cat /etc/passwd\" # execute command

                                     echo 'ABC' | ./netcat.py -t 192.168.0.108 -p 135 # echo text to server port 135

                                     netcat.py -t 192.168.0.108 -p 5555 # connect to server

                                     """))

    parser.add_argument('-c','--command',action='store_true',help='command shell')

    parser.add_argument('-e','--execute',help='execute specified command')

    parser.add_argument('-l','--listen',action='store_true',help='listen')

    parser.add_argument('-p','--port',type=int,default=5555,help='specified port')

    parser.add_argument('-t','--target',default='192.168.0.108',help='specified ip')

    parser.add_argument('-u','--upload',help='upload file')

    args = parser.parse_args()

    if args.listen:

        buffer = ''

    else:

        buffer = sys.stdin.read()

    nc = Netcat(args,buffer.encode())

    nc.run()