Python开发流量代理工具（内网穿透）（内含源码）

Python开发流量代理工具（内网穿透）

C:\out>dnf.exe -h
██████╗ ███╗   ██╗███████╗     ██████╗███████╗
██╔══██╗████╗  ██║██╔════╝    ██╔════╝██╔════╝
██║  ██║██╔██╗ ██║█████╗█████╗██║     ███████╗
██║  ██║██║╚██╗██║██╔══╝╚════╝██║     ╚════██║
██████╔╝██║ ╚████║██║         ╚██████╗███████║
╚═════╝ ╚═╝  ╚═══╝╚═╝          ╚═════╝╚══════╝-h 查看帮助                         by 0x6a0x71
-s 服务端模式
-c 客户端模式
usage: dnf.exe [-h] [-key KEY] [-s] [-c] [-srh SRH] [-srp SRP] [-slh SLH] [-slp SLP] [-crh CRH] [-crp CRP] [-clh CLH][-clp CLP] [-llp1 LLP1] [-llp2 LLP2] [-cm {r,l}]DNF流量代理工具optional arguments:-h, --help  show this help message and exit-key KEY    自定义密钥，可以随机生成，注：服务端必须与客户端一致，密钥为16位【A-Za-z0-9+/=】字符【默认随机】-s          服务端模式-c          客户端模式服务端:通常放置在服务器上，若以下端口都已开启，可直接x.exe -s【例如：代理内网3389，可直接在服务端连接127.0.0.1:8002访问】-srh SRH    远程连接地址【默认：0.0.0.0】-srp SRP    远程连接端口【默认：5050】-slh SLH    本地查看地址【默认：127.0.0.1】-slp SLP    本地查看端口【默认：8002】客户端:通常放置在内网机器上（可出网）【例如：代理3389到服务器，可直接x.exe -c -crh x.x.x.x(服务器地址） -clp 3389】-crh CRH    远程连接地址【默认：127.0.0.1】-crp CRP    远程连接端口【默认：5050】-clh CLH    本地代理地址【默认：127.0.0.1】-clp CLP    本地代理端口【默认：80】-llp1 LLP1  本地代理模式，本地原端口【默认：80】-llp2 LLP2  本地代理模式，映射端口【默认：5050】-cm {r,l}   代理类型，r：远程连接代理，l：本地端口代理【默认r】

这是工具的使用说明
现在的目标是把本地的80服务（http）代理到公网上进行访问
流量路径
127.0.0.1:80 -> xx.xx.xx.xx:5050 -> xx.xx.xx.xx:8002

本地80服务

服务端启动DNF流量代理工具

key值：0r+mS7C4UnH/zhG8

本地开启DNF工具

代理成功后本地访问外网服务端口（8002）

源代码如下

import argparse
import socket
BUFFSIZE = 1024
MAX_LISTEN = 32
CODING = "ISO-8859-1"
import base64
import random
key_num = 16
kill_sokcet_list =[]
max_out_time = 30
key_table = "0123456789QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm"
class My_lock:def OR_key(self):passdef encrypt_random(self,text,key):passdef decrypt_random(self,text,key):passdef _recv_data(socketi):"""接收服务端数据:return: 接收服务端数据-ERROR=None"""global kill_sokcet_listdata = b''while True:try:socketi.settimeout(10)  # 设置超时时间为10s超过10s判定为服务端没有返回状态，未收到数据recv_data = socketi.recv(BUFFSIZE)if len(recv_data) > 0:if len(recv_data) < BUFFSIZE:data += recv_databreakelse:data += recv_dataelse:breakexcept Exception as e:kill_sokcet_list.append(1)print(f"Loading... {str(e)}:{len(kill_sokcet_list)}")if len(kill_sokcet_list) == max_out_time:return None# print(e.__traceback__.tb_frame.f_globals["__file__"])  # 发生异常所在的文件# print(e.__traceback__.tb_lineno)  # 发生异常所在的行数return b""  # 出现异常返回Noneprint(f"DATA::{data}")kill_sokcet_list.clear()if len(data) != 0:return dataelse:return b""  # 非异常无数据，返回空字符串# 远程代理
def tcpServer3(ADDR,ADDR2,KEY):with socket.socket(socket.AF_INET, socket.SOCK_STREAM,proto=0) as rs:   #远程# 绑定服务器地址和端口while True:try:rs.connect(ADDR)print("等待远程请求回复...")rrec = _recv_data(rs)# rrec = rs.recv(BUFFSIZE)print(f"rrec={rrec}")dc_rrec = LOCK.decrypt_random(rrec.decode(),KEY)  # 解密远程回复  2:解密服务器返回的数据print(f"\ndc_rrec={dc_rrec}")with socket.socket(socket.AF_INET, socket.SOCK_STREAM,proto=0) as ls:   #本地while True:ls.connect(ADDR2)ls.sendall(dc_rrec)lrec = _recv_data(ls)# lrec = ls.recv(BUFFSIZE)print(f"lrec={lrec}")# key = LOCK.out_key(lrec.decode(CODING))  # 加密本地回复ec_lrec = LOCK.encrypt_random(lrec, KEY).encode() # 4print(f"\nec_lrec={ec_lrec}")ls.close()rs.sendall(ec_lrec)   # 发送加密后给远程回复except Exception as e:print(e)print(e.__traceback__.tb_frame.f_globals["__file__"])  # 发生异常所在的文件print(e.__traceback__.tb_lineno)  # 发生异常所在的行数breakrs.close()# 本地代理
def tcpServer2(ADDR,ADDR2):with socket.socket(socket.AF_INET, socket.SOCK_STREAM,proto=0) as s:# 绑定服务器地址和端口s.bind(ADDR)# 启动服务监听s.listen(MAX_LISTEN)print('等待用户接入')while True:try:# 等待客户端连接请求,获取connSockconn, addr = s.accept()print('远端客户:{} 接入系统！！！'.format(addr))with conn:while True:print('接收请求信息')# 接收请求信息data = conn.recv(BUFFSIZE)print('data=%s' % data)with socket.socket(socket.AF_INET, socket.SOCK_STREAM,proto=0) as rs:rs.connect(ADDR2)rs.send(data)rec = rs.recv(BUFFSIZE)print(rec)rs.close()conn.send(rec)# 发送请求数据except Exception as e:print(e)print(e.__traceback__.tb_frame.f_globals["__file__"])  # 发生异常所在的文件print(e.__traceback__.tb_lineno)  # 发生异常所在的行数breaks.close()def tcp1(ADDR2,ADDR,KEY):with socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM,proto=0) as rs:rs.bind(ADDR2)# 启动服务监听rs.listen(MAX_LISTEN)print('远程监听开启')while True:try:# 等待客户端连接请求,获取connSockrconn, raddr = rs.accept()print(f'远程服务接入成功！{raddr}')with rconn:with socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM,proto=0) as ls:ls.bind(ADDR)ls.listen(MAX_LISTEN)print('本地监听开启')while True:lconn, laddr = ls.accept()print(f"本地服务接入成功！{laddr}")with lconn:print("等待本地用户请求...")ldata = _recv_data(lconn)# ldata = lconn.recv(BUFFSIZE)print(f"ldata={ldata}")# key = LOCK.out_key(ldata.decode(CODING))    # 加密本地请求ec_ldata = LOCK.encrypt_random(ldata,KEY).encode() # 1 :服务请求print(f"\nec_ldata={ec_ldata}")rconn.sendall(ec_ldata)    # 加密后发送给远程rdata =_recv_data(rconn)# rdata = rconn.recv(BUFFSIZE)print(f"rdata={rdata}")dc_rdata = LOCK.decrypt_random(rdata.decode(),KEY)  # 解密远程回复 3print(f"\ndc_rdatac={dc_rdata}")lconn.sendall(dc_rdata)lconn.close()ls.close()rconn.close()except Exception as e:print(e)print(e.__traceback__.tb_frame.f_globals["__file__"])  # 发生异常所在的文件print(e.__traceback__.tb_lineno)  # 发生异常所在的行数breakrs.close()def mx_key(key):global key_tableif key == "Random":ikey = LOCK.OR_key()else:okl = Falsefor i in key:if i not in key_table:okl = Trueif len(set(key))!=len(key):okl = Trueif okl or len(key) != key_num:print("密钥不符合规定16位（不同字符） 【A-Za-z0-9】已自动生成KEY")ikey = 'ABCD12345678abcd'else:ikey = args.keyreturn ikeyif __name__ == '__main__':print('''██████╗ ███╗   ██╗███████╗     ██████╗███████╗
██╔══██╗████╗  ██║██╔════╝    ██╔════╝██╔════╝
██║  ██║██╔██╗ ██║█████╗█████╗██║     ███████╗
██║  ██║██║╚██╗██║██╔══╝╚════╝██║     ╚════██║
██████╔╝██║ ╚████║██║         ╚██████╗███████║
╚═════╝ ╚═╝  ╚═══╝╚═╝          ╚═════╝╚══════╝-h 查看帮助                         by 0x6a0x71
-s 服务端模式
-c 客户端模式''')parser = argparse.ArgumentParser(description='DNF流量代理工具')parser.add_argument('-key', type=str, default="Random",help='自定义密钥，可以随机生成，注：服务端必须与客户端一致，密钥为16位（不同字符）【A-Za-z0-9】【默认：随机】')parser.add_argument('-s', action="store_true", help='服务端模式')parser.add_argument('-c', action="store_true", help='客户端模式')parser.add_argument('-tt1', type=str,default="30", help='超时次数（每次10s）【默认：30】')group_s = parser.add_argument_group('服务端', '通常放置在服务器上，若以下端口都已开启，可直接x.exe -s【例如：代理内网3389，可直接在服务端连接127.0.0.1:8002访问】')group_s.add_argument('-srh', type=str, default="0.0.0.0", help='远程连接地址【默认：0.0.0.0】')group_s.add_argument('-srp', type=str, default="5050", help='远程连接端口【默认：5050】')group_s.add_argument('-slh', type=str, default="127.0.0.1", help='本地查看地址【默认：127.0.0.1】')group_s.add_argument('-slp', type=str, default="8002", help='本地查看端口【默认：8002】')group_c = parser.add_argument_group('客户端','通常放置在内网机器上（可出网）【例如：代理3389到服务器，可直接x.exe -c -crh x.x.x.x(服务器地址） -clp 3389】')group_c.add_argument('-crh', type=str, default="127.0.0.1", help='远程连接地址【默认：127.0.0.1】')group_c.add_argument('-crp', type=str, default="5050", help='远程连接端口【默认：5050】')group_c.add_argument('-clh', type=str, default="127.0.0.1", help='本地代理地址【默认：127.0.0.1】')group_c.add_argument('-clp', type=str, default="80", help='本地代理端口【默认：80】')group_c.add_argument('-llp1', type=str, default="80", help='本地代理模式，本地原端口【默认：80】')group_c.add_argument('-llp2', type=str, default="5050", help='本地代理模式，映射端口【默认：5050】')group_c.add_argument('-cm', type=str, choices=["r", "l"], default="r", help='代理类型：（r:远程连接代理）（l:本地端口代理）【默认：r】')args = parser.parse_args()if int(args.tt1)<0:print("设置超时次数无效")else:max_out_time = int(args.tt1)print(f"【TimeOut】：{int(args.tt1)}")LOCK = My_lock()if args.s:args.key = mx_key(args.key)print(f"【KEY】:{args.key}")lADDR = (args.slh, int(args.slp))rADDR = (args.srh, int(args.srp))A = tcp1(rADDR, lADDR, args.key)else:passif args.c:args.key = mx_key(args.key)print(f"【KEY】:{args.key}")if args.cm == "r":lADDR = (args.clh, int(args.clp))rADDR = (args.crh, int(args.crp))A = tcpServer3(rADDR, lADDR, args.key)elif args.cm == "l":ADDR = ("127.0.0.1", int(args.llp1))ADDR2 = ("127.0.0.1", int(args.llp2))B = tcpServer2(ADDR, ADDR)else:pass

分开的程序：客户端：

import argparse
import socket
BUFFSIZE = 262144
MAX_LISTEN = 32
import lock
CODING = "ISO-8859-1"# 远程代理
def tcpServer3(ADDR,ADDR2,KEY):with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as rs:   #远程# 绑定服务器地址和端口rs.connect(ADDR)while True:try:print("等待远程请求回复...")rrec = rs.recv(BUFFSIZE)print(f"rrec={rrec}")dc_rrec = LOCK.decrypt_random(rrec.decode(CODING),KEY).encode(CODING)   # 解密远程回复print(f"\ndc_rrec={dc_rrec}")with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as ls:   #本地ls.connect(ADDR2)ls.send(dc_rrec)lrec = ls.recv(BUFFSIZE)print(f"lrec={lrec}")# key = LOCK.out_key(lrec.decode(CODING))  # 加密本地回复ec_lrec = LOCK.encrypt_random(lrec.decode(CODING), KEY).encode(CODING)print(f"\nec_lrec={ec_lrec}")ls.close()rs.send(ec_lrec)   # 发送加密后给远程回复except Exception as e:print(e)breakrs.close()# 本地代理
def tcpServer2(ADDR,ADDR2,KEY):with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:# 绑定服务器地址和端口s.bind(ADDR)# 启动服务监听s.listen(MAX_LISTEN)print('等待用户接入')while True:# 等待客户端连接请求,获取connSockconn, addr = s.accept()print('远端客户:{} 接入系统！！！'.format(addr))with conn:while True:print('接收请求信息。。。。。')# 接收请求信息data = conn.recv(BUFFSIZE)print('data=%s' % data)with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as rs:rs.connect(ADDR2)rs.send(data)rec = rs.recv(BUFFSIZE)print(rec)rs.close()conn.send(rec)# 发送请求数据s.close()if __name__ == '__main__':# ADDR = ('127.0.0.1', 5000)# ADDR2 = ('127.0.0.1', 80)# a = tcpServer3(ADDR,ADDR2)parser = argparse.ArgumentParser(description='DNF流量代理工具')parser.add_argument('-rh',type=str,default="127.0.0.1", help='远程连接地址，默认：127.0.0.1')parser.add_argument('-rp',type=str,default="5050", help='远程连接端口，默认：5050')parser.add_argument('-lh',type=str,default="127.0.0.1", help='本地代理地址，默认：127.0.0.1')parser.add_argument('-lp',type=str,default="80", help='本地代理端口，默认：80')parser.add_argument('-llp1', type=str, default="80", help='本地代理模式，本地原端口，默认：80')parser.add_argument('-llp2', type=str, default="5050", help='本地代理模式，映射端口，默认：5050')parser.add_argument('-m', type=str,choices=["r","l"],default="r",help='代理类型，r：远程回连代理，l：本地端口代理，默认r')parser.add_argument('-key', type=str, default="Random", help='自定义密钥，可以随机生成，注：服务端必须与客户端一致，密钥为10位，ASCII（48-90）区间字符【默认随机】')args = parser.parse_args()LOCK = lock.My_lock()if args.key == "Random":args.key = LOCK.OR_key()else:okl = Falsefor i in args.key:if ord(i)>90 or ord(i)<48:okl = Trueif okl or len(args.key)<10:print("密钥不符合规定【10位，ASCII（48-90）区间字符")if args.m == "r":lADDR = (args.lh,int(args.lp))rADDR = (args.rh,int(args.rp))A = tcpServer3(rADDR,lADDR,args.key)elif args.m == "l":ADDR = ("127.0.0.1", int(args.llp1))ADDR2 = ("127.0.0.1", int(args.llp2))B = tcpServer3(ADDR, ADDR,args.key)

服务端：

import argparse
import socket
import lock
CODING = "ISO-8859-1"
BUFFSIZE = 262144
MAX_LISTEN = 32def tcp1(ADDR2,ADDR,KEY):with socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM) as rs:rs.bind(ADDR2)# 启动服务监听rs.listen(MAX_LISTEN)print('远程监听开启')while True:try:# 等待客户端连接请求,获取connSockrconn, raddr = rs.accept()print(f'远程服务接入成功！{raddr}')with rconn:while True:# LOCK = lock.My_lock()with socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM) as ls:ls.bind(ADDR)ls.listen(MAX_LISTEN)print('本地监听开启')lconn, laddr = ls.accept()print(f"本地服务接入成功！{laddr}")with lconn:print("等待本地用户请求...")ldata = lconn.recv(BUFFSIZE)print(f"ldata={ldata}")# key = LOCK.out_key(ldata.decode(CODING))    # 加密本地请求ec_ldata = LOCK.encrypt_random(ldata.decode(CODING),KEY).encode(CODING)print(f"\nec_ldata={ec_ldata}")rconn.send(ec_ldata)    # 加密后发送给远程rdata = rconn.recv(BUFFSIZE)print(f"rdata={rdata}")dc_rdata = LOCK.decrypt_random(rdata.decode(CODING),KEY).encode(CODING)  # 解密远程回复print(f"\ndc_rdatac={dc_rdata}")lconn.send(dc_rdata)lconn.close()ls.close()rconn.close()except Exception as e:print(e)breakrs.close()if __name__ == '__main__':parser = argparse.ArgumentParser(description='DNF流量代理工具')parser.add_argument('-rh',type=str,default="0.0.0.0", help='远程回连地址，默认：0.0.0.0')parser.add_argument('-rp',type=str,default="5050", help='远程回连端口，默认：5050')parser.add_argument('-lh',type=str,default="127.0.0.1", help='本地查看地址，默认：127.0.0.1')parser.add_argument('-lp',type=str,default="8002", help='本地查看端口，默认：8002')parser.add_argument('-key', type=str, default="Random", help='自定义密钥，可以随机生成，注：服务端必须与客户端一致，密钥为10位，ASCII（48-90）区间字符【默认随机】')args = parser.parse_args()LOCK = lock.My_lock()if args.key == "Random":args.key = LOCK.OR_key()else:okl = Falsefor i in args.key:if ord(i)>90 or ord(i)<48:okl = Trueif okl or len(args.key)<10:print("密钥不符合规定【10位，ASCII（48-90）区间字符")print(f"【KEY】:{args.key}")lADDR = (args.lh,int(args.lp))rADDR = (args.rh,int(args.rp))A = tcp1(rADDR,lADDR,args.key)

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！