《Python黑帽子：黑客与渗透测试编程之道》 网络基础

1、创建一个TCP客户端

socket对象包含两个参数，AF_INET表示使用IPv4地址或主机名,SOCK_STREAM表示是一个TCP客户端。请求的URL是百度。

#!/usr/bin/python3
#-*- coding:utf-8 -*-

#编译环境  windows 7 x64 + Python3.7.0
#创建一个TCP客户端

import socket

def main():
    target_host = "www.baidu.com"
    target_port = 80
    
    #建立一个socket对象
    client =socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    
    #连接客户端，(由于TCP三次握手机制，需要先连接)
    client.connect((target_host,target_port))
    
    #发送一些数据
    client.send(bytes("GET / HTTP/1.1
Host: baidu.com

",'UTF-8'))

    #接收一些数据
    response = client.recv(4096)

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

2、创建一个UDP客户端

与TCP客户端相比，将数据包以UDP的格式发出。将套接字的类型改为SOCK_DGRAM,调用sendto()函数发送数据传到想发送的服务器上,因为UDP是无连接状态的传输协议，所以不需要调用connect()函数，最后调用recvfrom()函数接收返回的UDP数据包。就可以接收到回传的数据及远程主机的信息和端口号

#!/usr/bin/python3
#-*- coding:utf-8 -*-

#编译环境  windows 7 x64 + Python3.7.0
#创建一个UDP客户端

import socket

def main():
    
    target_host = "127.0.0.1"
    target_port = 2333
    
    #建立一个socket对象
    client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    
    #发送一些数据
    client.sendto(bytes("AAABBBCCC",'UTF-8'),(target_host, target_port))
    
    #接收一些数据
    data, addr = client.recvfrom(4096)
    print(data)
    print(addr)
    
if __name__ == '__main__':
    main()

（运行nc.exe -ulvp 2333）本地监听2333端口，运行udp_client.py脚本，过一会可以看到有数据传过来了。

-l 表示侦听模式

-u UDP

3、创建一个TCP服务端

先确定服务器需要监听的IP地址和端口。然后，我们启动监听并将最大连接数设为5。

#!/usr/bin/python3
#-*- coding:utf-8 -*-

#编译环境  windows 7 x64 + Python3.7.0
#创建一个TCP服务端

import socket
import threading

#这是客户处理线程
def handle_client(client_socket):
    
    #打印出客户端发送得到内容
    request = client_socket.recv(1024)
    
    print("[*] Received: %s"% request)
    
    #返回一个数据包
    client_socket.send(bytes("ACK!",'UTF-8'))
    
    client_socket.close()
    
    
def main():
    bind_ip = "0.0.0.0"
    bind_port = 1234
    
    #创建一个socket对象
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    
    #调用bind()函数绑定IP和端口
    server.bind((bind_ip, bind_port))
    
    #通过listen()函数启动监听并将最大连接数设为5(默认值),有点类似多线程
    server.listen(5)
    
    print("[*] Listening on %s:%d" % (bind_ip,bind_port))
    
    while True:
        client, addr = server.accept()
    
        print("[*] Accepted connection from: %s:%d" % (addr[0], addr[1]))
    
        #挂起客户端线程，处理传入的数据
        client_handler = threading.Thread(target=handle_client,args=(client,))
        client_handler.start()
    
if __name__ == '__main__':
    main()

将TCP客户端代码参数修改如下，先运行TCP服务端，再执行TCP客户端。

执行结果如下所示：

4、取代netcat

以下程序各个函数的意思如下：

usage()函数用于参数的说明帮助、当用户输入错误的参数时会输出相应的提示；

client_sender()函数用于与目标主机建立连接并交互数据直到没有更多的数据发送回来，然后等待用户下一步的输入并继续发送和接收数据，直到用户结束脚本运行；

server_loop()函数用于建立监听端口并实现多线程处理新的客户端；

run_command()函数用于执行命令，其中subprocess库提供多种与客户端程序交互的方法；

client_handler()函数用于实现文件上传、命令执行和与shell相关的功能，其中wb标识确保是以二进制的格式写入文件、从而确保上传和写入的二进制文件能够成功执行；

主函数main()中是先读取所有的命令行选项从而设置相应的变量，然后从标准输入中读取数据并通过网络发送数据，若需要交互式地发送数据需要发送CTRL-D以避免从标准输入中读取数据，若检测到listen参数为True则调用server_loop()函数准备处理下一步命令。

遇到问题 python3 区分了str 和 bytes

bytes.decode()方法 decode() 方法以指定的编码格式解码 bytes 对象。默认编码为 'utf-8'。 该方法返回解码后的字符串。

str.encode() 方法以指定的编码格式编码字符串。 该方法返回编码后的字符串，它是一个 bytes 对象

#!/usr/bin/python3
#-*- coding:utf-8 -*-

#编译环境  windows 7 x64 + Python3.7.0

import sys
import getopt
import socket
import threading
import subprocess

#定义一些全局变量
listen = False             #若True,可理解为服务器。否则为客户端
command = False            #是否建立shell
upload = False             #上传
execute = ""               #目标机上执行的命令
target = ""                #目标主机   
upload_destination = ""    #数据传送的目标文件。  上传文件，目录路径。
port = 0                   #目标端口号

#使用帮助，相当于help
def usage():
    print("BHP Net Tool")
    print("")
    print("Usage: bhpnet.py -t target_host -p port")
    print("-l --listen              - listen on [host]:[port] for incoming connections")
    print("-e --execute=file_to_run - execute the given file upon receiving a connection")
    print("-c --command             - initialize a command shell")
    print("-u --upload=destination  - upon receiving a connection upload a file and write to [destination]")
    print("")
    print("")
    print("Examples: ")
    print("bhpnet.py -t 192.168.0.1 -p 5555 -l -c")
    print("bhpnet.py -t 192.168.0.1 -p 5555 -l -u=C:\target.exe")
    print("bhpnet.py -t 192.168.0.1 -p 5555 -l -e="cat /etc/passwd"")
    print("echo 'ABCDEFGHI' | ./bhpnet.py -t 192.168.11.12 -p 135")
    sys.exit(0)


#客户端发送信息给服务端，并且接收服务端传回来的信息。会一直等待命令输入和接收数据，直到脚本结束    
def client_sender(buffer):
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    try:
        # 连接到目标主机（服务器）
        client.connect((target,port))
        print("目标主机 %s,%d,连接成功"%(target,port))
        
        if len(buffer):
            client.send(str.encode(buffer))#修改1
            
        while True:
            #现在等待数据回传
            recv_len = 1
            response = ""
            
            while recv_len:
                data = client.recv(4096)   #这时 data 为 bytes类型
                recv_len = len(data)
                data = bytes.decode(data) #修改2  这里需要转换为str类型 否则下面的 response += data 没办法执行
                response += data
            
                if recv_len < 4096:
                    break
            print("response,")
        
            #等待更多的输入
            buffer = input("")#'raw_input'修改为input，Python3没有raw_input函数

            buffer += "
"
        
            #发送出去
            client.send(str.encode(buffer))#修改3   这里需要转换为bytes类型 否则发不出去
    
    except Exception as e:
        print(e)
        print("[*] Exception! Exiting.")
        
        #关闭连接
        client.close()


#用于建立监听端口并实现多线程处理新的客户端 
def server_loop():
    global target
    global port
    
    # 如果没有定义目标，那么我们监听所有接口
    if not len(target):
        target = "0.0.0.0"
    
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.bind((target, port))
    server.listen(5)
    
    while True:
        client_socket, addr = server.accept()
        
        # 分拆一个线程处理新的客户端
        client_thread = threading.Thread(target=client_handler, args=(client_socket,))
        client_thread.start()

 
#函数用于执行命令，其中subprocess库提供多种与客户端程序交互的方法 
def run_command(command):
    # 换行
    command = command.rstrip()
    
    # 运行命令并将输出返回
    try:
        #command = bytes.decode(command)  #修改4
        print(bytes.decode(command))
        output = subprocess.check_output(command,stderr=subprocess.STDOUT,shell=True)
    except Exception as e:
        print(e)
        output = "[-] Failed to execute command
"
        
    # 将输出发送
    return output

#函数用于实现文件上传、命令执行和与shell相关的功能，其中wb标识确保是以二进制的格式写入文件、从而确保上传和写入的二进制文件能够成功执行；
def client_handler(client_socket):
    global upload
    global execute
    global command
    
    # 检测上传文件
    if len(upload_destination):
        
        # 读取所有的字符并写入目标
        
        file_buffer = ""
        
        # 持续读取数据直到没有符合的数据
        while True:
            data = client_socket.recv(1024)
            
            if not data:
                break
            else:
                file_buffer += data
        
        # 现在我们接收这些数据并将他们写出来
        try: 
            file_descriptor = open(upload_destination,"wb")
            file_descriptor.write(file_buffer)
            file_descriptor.close()
            
            # 确认文件已经写出来
            client_socket.send(str.encode("Successfully saved file to %s/r/n" % upload_destination))#修改9
        except:
            client_socket.send(str.encode("Failed to save file to %s/r/n" % upload_destination))#修改10
            
    # 检查命令执行
    if len(execute):
        
        # 运行命令
        output = run_command(execute)
        
        client.socket.send(str.encode(output))#修改5
        
    # 如果需要一个命令行shell,那么我们进入另一个循环
    
    if command:
        while True:
            # 跳出一个窗口
            client_socket.send(str.encode("<BHP:#> "))#修改6
            
            cmd_buffer = ""
            cmd_buffer = str.encode(cmd_buffer)
            while "
" not in bytes.decode(cmd_buffer):#修改7
                cmd_buffer += client_socket.recv(1024)         
            # 返还命令输出
            response = run_command(cmd_buffer)
            print(bytes.decode(response))#修改8
            # 返回响应数据
            client_socket.send(response)

#main()中是先读取所有的命令行选项从而设置相应的变量，然后从标准输入中读取数据并通过网络发送数据，
#若需要交互式地发送数据需要发送CTRL-D以避免从标准输入中读取数据，若检测到listen参数为True则调用server_loop()函数准备处理下一步命令。            
def main():
    
    #定义一些全局变量
    global listen
    global port
    global execute
    global command
    global upload_destination
    global target
    
    if not len(sys.argv[1:]): #如果数组中有多个元素
        usage()
    
    # 读取命令行选项
    try:
        opts, args = getopt.getopt(sys.argv[1:],"hle:t:p:cu",["help","listen","execute","target","port","command","upload"])
    except getopt.GetoptError as err:
        print(str(err))
        usage()

    for o,a in opts:
        if o in ("-h", "--help"):
            usage()
        elif o in ("-l", "--listen"):
            listen = True
        elif o in ("-e", "--execute"):
            execute = a
        elif o in ("-c", "--commandshell"):
            command = True
        elif o in ("-u", "--upload"):
            upload_destination = a
        elif o in ("-t", "--target"):
            target = a
        elif o in ("-p", "--port"):
            port = int(a)
        else:
            assert False, "Unhandled Option"
            
    # 我们是进行监听还是仅从标准输入发送数据？
    if not listen and len(target) and port > 0:
            
        # 从命令行读取内存数据
        # 这里将阻塞，所以不在向标准输入发送数据时发送CTRL-D
            
        buffer = sys.stdin.read()
            
        print("sending data")
        
        #作为客户端，给服务端发送数据
        client_sender(buffer)
            
    # 我们开始监听并准备上传文件、执行命令
    # 放置一个反弹shell
    # 取决于上面的命令行选项
    #
    if listen:
        server_loop()
    

if __name__ == '__main__':
    main()

打开一个终端（服务端）python3 netcat.py -l -p 8888 -c

打开新终端（客户端）python3 netcat.py -t localhost -p 8888

输入ctrl+d