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
Python开发流量代理工具(内网穿透)(内含源码)_第1张图片
本地80服务

服务端启动DNF流量代理工具
Python开发流量代理工具(内网穿透)(内含源码)_第2张图片

key值:0r+mS7C4UnH/zhG8

本地开启DNF工具
Python开发流量代理工具(内网穿透)(内含源码)_第3张图片

代理成功后本地访问外网服务端口(8002)
Python开发流量代理工具(内网穿透)(内含源码)_第4张图片
源代码如下

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):
		pass
    def encrypt_random(self,text,key):
        pass

    def decrypt_random(self,text,key):
        pass
        

def _recv_data(socketi):
    """
    接收服务端数据
    :return: 接收服务端数据-ERROR=None
    """
    global kill_sokcet_list
    data = 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_data
                    break
                else:
                    data += recv_data
            else:
                break
        except 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""  # 出现异常返回None
    print(f"DATA::{data}")
    kill_sokcet_list.clear()
    if len(data) != 0:

        return data
    else:
        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() # 4
                        print(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)  # 发生异常所在的行数
                break
        rs.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:
                # 等待客户端连接请求,获取connSock
                conn, 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)  # 发生异常所在的行数
                break
        s.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:
                # 等待客户端连接请求,获取connSock
                rconn, 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)  # 解密远程回复 3
                                print(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)  # 发生异常所在的行数
                break
        rs.close()


def mx_key(key):
    global key_table
    if key == "Random":
        ikey = LOCK.OR_key()
    else:
        okl = False
        for i in key:
            if i not in key_table:
                okl = True
        if len(set(key))!=len(key):
            okl = True
        if okl or len(key) != key_num:
            print("密钥不符合规定16位(不同字符) 【A-Za-z0-9】已自动生成KEY")
            ikey = 'ABCD12345678abcd'
        else:
            ikey = args.key
    return ikey


if __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:
        pass
    if 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)
                break
        rs.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:
            # 等待客户端连接请求,获取connSock
            conn, 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 = False
        for i in args.key:
            if ord(i)>90 or ord(i)<48:
                okl = True
        if 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 = 32

def 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:
                # 等待客户端连接请求,获取connSock
                rconn, 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)
                break

        rs.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 = False
        for i in args.key:
            if ord(i)>90 or ord(i)<48:
                okl = True
        if 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)

你可能感兴趣的:(渗透工具编写,奇怪脚本,服务器,代理模式,内网穿透,流量代理,socket编程)