python黑帽子：黑客与渗透测试编程之道（第二版）
1.基础的网络编程工具
TCP客户端
import socket
target_host="127.0.0.1"
target_port=8701
#创建socket对象
client=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
#建立socket链接
client.connect((target_host,target_port))
print("--------")
data="GET / HTTP/1.1\r \n Host: fjdh.com\r\n\r\n"
print(data)
print(b"GET / HTTP/1.1\r \n Host: bilibili.com\r\n\r\n")
#发送数据
client.send("hello")
#接收数据
response=client.recv(4096)
print(response.decode)
print(response)
#关闭链接
client.close()
代码分析： tcp服务端代码由以几个步骤组成：
1.创建socket对象
2.建立socket链接，需要目标对象的ip地址以及端口，这一步就成功的建立好了链接了
3.发送数据
4接收数据
5.关闭连接
TCP服务端
import socket
import threading
ip='0.0.0.0'
port=8701
def main():
server=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server.bind((ip,port))
server.listen(5)
print(f"[*] Listening on {ip}:{port}")
while True:
client,addr=server.accept()
print(f"[*] Accepted connection from {addr[0]}:{addr[1]}")
client_handle=threading.Thread(target=handle_client,args=(client,))
client_handle.start()
def handle_client(client_socket):
with client_socket as sock:
request=sock.recv(1024)
print(f"[*] received:{request.decode('utf-8')}")
sock.send(b"ACK")
if __name__ =='__main__':
main()
tcp服务器代码分析，主要由以下步骤组成：
1.创建socket对象
2.绑定需要主机ip，以及对外开发（监听）的端口
3.不间断监听
4.监听成功，建立会话，得到socket对象，以及发送请求的ip
5.接收数据
6.发送数据
运行结果如下：
udp客户端代码
import socket
target_host="127.0.0.1"
target_port=9997
client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
client.sendto(b"AAABBBCCC",(target_host,target_port))
data,addr=client.recvfrom(4096)
print(data.decode())
client.close()
后续需要编写udp服务器，文章中没有udp服务的代码
编写netcat工具代码，利用自己的工具实现netcat的功能
import argparse
import socket
import shlex
import subprocess
import sys
import textwrap
import threading
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)
def run(self):
if self.args.listen:
self.listen()
else:
self.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()
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()
def handle(self,client_socket):
if self.args.execute:
output=execute(self.args.execute)
client_socket.send(output.encode())
elif self.args.upload:
file_bffer=b""
while True:
data=client_socket.recv(4096)
if data:
file_bffer+=data
else:
break
with open(self.args.upload,'wb') as f:
f.write(file_bffer)
message=f"Save file {self.args.upload}"
client_socket.send(message.encode())
elif self.args.command:
cmd_buffer=b" "
while True:
try:
client_socket.send(b"BHP :#> ")
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()
def execute(cmd):
cmd=cmd.strip()
if not cmd:
return
output=subprocess.check_output(shlex.split(cmd),stderr=subprocess.STDOUT)
return output.decode()
if __name__=='__main__':
parser=argparse.ArgumentParser(
description='BHP Net tool',
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog=textwrap.dedent("""Example:
natcat.py -t 192.168.1.108 -p 5555 -l -c #command shell
netcat.py -t 192.168.1.108 -p 5555 -l -u=mytest.txt #upload to file
netcat.py -t 192.168.1.108 -p 5555 -l -e=\"cat /etc/passwd\" #execute command
echo 'ABC'| ./netcat.py -t 192.168.1.108 -p 135 #echo text to server port 135
netcat.py -t 192.168.1.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.1.203',help='speciified IP')
parser.add_argument('-u','--upload',help='upload file')
args=parser.parse_args()
if args.listen:
buffer=b''
else:
buffer=sys.stdin.read()
nc=NetCat(args,buffer.encode())
nc.run()
代码分析：
1.首先看main函数，使用标准库里的argparse库创建了一个带命令行界面的程序
2.然后就是检查参数，是否存在监听
3.创建NetCat类，并实例化
4.运行该实例化的run函数
5.NetCat类中主要由run（），listen()，handle（）三个数据组成 run()函数依据是否存在listen参数，判断是监听，还是发送数据
备注：这里再敲代码的过程中有一处代码笔误，然后去找很多文章复现代码，没有发现自己的问题，然后利用chatgpt解决了。
代码运行效果：
后续补充
总结：
按照python黑帽子：黑客与渗透测试编程之道（第二版），利用python语言实现了tcp客户端，tcp服务端，udp客户端，以及复现netcat工具。
假如有两台主机，分布为主机1，主机2。主机1创建监听，主机2对主机1发送信息，其中主机2发送的信息为操作系统命令例如whoami，ls. 当主机1和主机2建立完socket连接后，主机2发送的信息，由主机1接收并运行，并将运行的结果发送给主机2.由此完成了通信。
参考资料：
1.python黑帽子：黑客与渗透测试编程之道
2.如何实现反弹shell
3.python实现tcp通信
4.多进程与多线程
5.netcat使用
6.python黑帽子代码实现
7.python黑帽子代码实现
8.python黑帽子代码实现
扫一扫
301
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
