网路基础(python)

    网络是对于骇客来讲像一个充满诱惑力的竞技场。一个hacker可以做任何事物在简单的网络接入中。例如：扫描主机，注入数据，嗅探数据等等。 本章将要讲述一个基本的网络知识python网络工作用socket。我们将要建立客户端、服务器和tcp代理。并运用到我们自己的电脑，编译他们。本章是对后续章节的一个基础。我们自己建立一个host discovery tool，实现一个跨平台的探测器，并且创建一个远程木马框架。

我们可以用python来创建一个服务器和客户端，而这个核心模块是socket，该模块使我们快速开发一个tcp或udp的客户端和服务器，运用原始套接字。我们现在将要创建简单的客户端和服务器，我们将要写两个网络工作脚本。用tcp客户端来测试服务器，发送数据包。

TCP客户端：

import socket
target_host = tuple("www.baidu.com")
target_port = 80
#create the socket object
client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
#connect the client
client.connect(target_host,target_port)
#send some data
client.send("Get / HTTP/1.1\r\nHost:baidu.com\r\n\r\n")
#receive some data
response = client.recv(4096)
print (response)

我们将要开始创建一个AF_INET对象和SOCK_STREAM参数。这个AF_INET参数说明我们将要使用IPv4标准的地址或者主机名，而SOCK_STREAM这是一个TCP客户端，之后我们连接客户端和服务器并且发送一些数据，最后一步是接受一些数据并且打印出来。这是一个简单的TCP客户端形式。但是这是最常写的一种。

在上面的代码段中，我们做一些思考。首先，假设我们的连接总是成功的。第二点，服务器总是期望我们发送数据（相对于服务器期望把数据发送给你，并且等待你的回复）。第三个假设，服务器总是即时回馈数据给我们。做这些假设大多数都是为了简单的原因。程序员有不同的方式来处理阻塞套接字以及套接字异常。对于这些异常的问题，处理方式并不多见。我们将会逐渐探索。

UDP客户端：

import socket

target_host = tuple("127.0.0.1")
target_port = 80
#buffer = ('AABBCC')
#create the socket object
client = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
#send some data
client.sendto(“AABBCC”,(target_host,target_port))
#receive data
data,addr = client.recvfrom(4096)
print (data)

如上代码，我们改变了SOCK的类型当创建SOCKET对象的时候。下一步将要调用sendto，发送你想要发送的数据。因为UDP是一个无连接控制，在这里并不需要调用connect()。最好一步是调用recvfrom().来接受UDP的返回数据以及远程端口和主机。

接下来，我们看下高级网络编程者，我们想要更快，更容易处理我们每日的Hacker任务。接下来我们创建一个服务器吧。

TCP 服务器：

import socket

import threading

bind_ip = "0.0.0.0"

bind_port = 9999

server = socket.socket(socket.AF_INET,socket.AF_STREAM)

server.bind((bind_ip,bind_port))

server.listen(5)

print "[*]listen to %s:%d"%(bind_ip,bind_port)

#our client handle the thread

def handle_client(client_socket)

request = client_socket.recv(1024)

print "[*]receive the client%s"%request

#send some data packet

client_socket.send("ACK!")

client_socket.close()

while True

client ,addr = server.accept()

print "[*]Accept the connection from:%s：%d"&(addr[0],addr[1])

# spin up the client thread to handle incoming data

client_handler = threading.Thread(target=handle_client,arg=(client,))

client_handler.start()

我们通过IP地址和端口进行监听。接下来我们让服务器开始监听。我们让服务器开始循环，等待连入。当一个客户端连接，我们会接受这个客户端的变量，并且远程连接这个add。并且我们建立一个新的线程对象，来指向我们的handle_client功能，并且通过他将客户端socket作为一个参数，我们的线程将要处理来自客户端的连接。我们主线程继续循环来处理来自其他客户端的连接。这个handle_client功能表现在recv()并且然后发送一个简单的信息回馈给客户端。

这是非常简单并且很实用，我们将要继续下一部分当我们建立NetCat来取代TCP代理。

替代NetCat
NetCat像一把网络工具刀。所以精明的系统管理员将要从他们的系统中移除这些东西。在更多的场景中。我们并没有安装netcat在服务器中。在这些例子中，创建一个
netcat工作客户端和服务器，如果你要通过一个web应用，可以用它来推送文件，或者进行监听运用这个命令行。创造这个工具就像是python练习一样。让我们现在开始。
在这里我们要调用库，并且定义几个全局变量。现在让我们创造主要的参数来处理命令行参数并且调用我们余下的功能。
import sys
import socket
import getopt
import threading
import subprocess
listen = False
command = False
upload = False
execute = ""
target = ""
upload_destination = 0
port = 0
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 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 main():
    global listen
    global command
    global upload
    global execute
    global target
    global upload_destination
    global port

    if not len(sys.argv[1:]):
                  usage()

          # read the commandline options
         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"


          # are we going to listen or just send data from stdin?
         if not listen and len(target) and port > 0:

                  # read in the buffer from the commandline
                  # this will block, so send CTRL-D if not sending input
                  # to stdin
                  buffer = sys.stdin.read()

                  # send data off
                  client_sender(buffer)

          # we are going to listen and potentially
          # upload things, execute commands, and drop a shell back
          # depending on our command line options above
          if listen:
                 server_loop()

  main()

我们将要开始读这些命令行,并且设置这个必要的变量来依赖他们。如果命令行变量不能匹配我们的标准。我们将要打印这些信息。在这些代码块中我们尝试模仿netcat来读一些数据来自stdin并且将他将他发送到网络。如果你计划发送这些交互数据。我们将要设置监听socket。使文件进行加载、执行命令，并且开始命令脚本。
def client_sender(buffer)
    client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    try:
        client.connect((target,port))
            if(len(buffer))
        client.send(buffer)
    while True:
        recv_len = 1
        response = ""
          while recv_len:
            data = client.receive(4096)
            recv_len = lent(data)
            response += data
            if recv_len<4096
            break
        print response
        buffer = raw_input()
        buffer +="\n"
        client.send(buffer)
    except:
        print "[*]Exception Exit"
        client.close()
这些代码看起来很熟悉。我们将要设置我们的TCP套接字对象并且我们接受一些输入来测试他们，如果这些都没问题，我们将要发送并且接受来自于远程端的数据，知道全部传送完毕。我们继续等待来自用户的输出并且继续发送和接收数据，直到用户杀死脚本。我们的客户端将要适应我们的命令脚本。现在让我们创造首个服务循环。这个存根函数将要处理我们的命令执行。

def server_loop():
    global target
    #if no target is defined,we listen on all interfaces
    if no 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.accpet()
        client_thread = threading.Thread(target = client_handler,args = (client_socket,))
        client_thread.start()

def run_command(command):

          # trim the newline
          command = command.rstrip()

          # run the command and get the output back
          try:
                 output = subprocess.check_output(command,stderr=subprocess.
                  STDOUT, shell=True)
          except:
                  output = "Failed to execute command.\r\n"

          # send the output back to the client
          return output



现在,你将要处理这个TCP服务器来完成这个线程，所以并不要用这个server_loop功能。这个run_command功能，然而，包括一个新的库并且不会覆盖子流程库.子流程库提供这个
程序借口给你一个数字方式来开始或者接触这个客户端程序，在这个例子中。我们要简单用作他。用他在当地的操作系统中，并且返回这个输出来自命令返回这个客户端来链接
到我们。这个异常处理代码将要捕捉一个总体错误并且返回一个消息让你知道命令有失败。
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("success..........")
    except:
    client_socket.send("failure..........")
    if len(execute)
        output = run_command(execute)
        client_socket.send(output)
    if command:
        while True:
            client_socket.send("<BHP:#>")
        
                                # now we receive until we see a linefeed
                                (enter key)
                          cmd_buffer = ""
                          while "\n" not in cmd_buffer:
                                  cmd_buffer += client_socket.recv(1024)


                          # send back the command output
                          response = run_command(cmd_buffer)

                          # send back the response
                          client_socket.send(response)