精华内容
下载资源
问答
  • python 实现代理服务器

    2019-10-04 13:57:37
    # encoding:utf-8 ...代理服务器异常 ' ,e print ' server end!!! ' http 代理服务器。 无需指定目的服务器,自动读取地址并连接。 转载于:https://www.cnblogs.com/dzqdzq/p/9822187.html
    # encoding:utf-8
    import socket
    import thread
    import re
    
    def getAddr(d):
     a = re.search("Host: (.*)\r\n", d)
     host = a.group(1)
     a = host.split(":")
     if len(a) == 1:
      return (a[0], 80)
     else:
      return (a[0], int(a[1]))
    
    def client(conn, caddr):
        while 1:
            try:
                data = conn.recv(4096)
    
                s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                addr = getAddr(data)
                print "目的服务器:",addr
                s.connect(addr)
                print '发给目的服务器数据:',data
                s.sendall(data)#将请求数据发给目的服务器
                d = s.recv(40960)#接收目的服务器发过来的数据
                s.close()#断开与目的服务器的连接
                print '接收目的服务器数据:',d
                conn.sendall(d)#发送给代理的客户端
            except Exception, e:
                print '代理的客户端异常:%s, ERROR:%s'%(caddr,e)
                conn.close()
                break
    
    def serve(PORT = 10086):
     # 创建
     IP = "0.0.0.0"
     s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     s.bind((IP, PORT))
     s.listen(10)
     print 'proxy start...'
     while True:
      conn, addr = s.accept()
      print 'conn:', conn
      print "addr:", addr
      thread.start_new_thread(client, (conn, addr))
    
    try:
     serve()
    except Exception as e:
     print '代理服务器异常',e
    
    print 'server end!!!'

    http 代理服务器。 无需指定目的服务器,自动读取地址并连接。

    转载于:https://www.cnblogs.com/dzqdzq/p/9822187.html

    展开全文
  • python实现代理服务器端口映射功能

    千次阅读 2017-11-22 11:24:29
    从结果可以看出,代理服务器代码能够对客户端和服务器之间的内容进行记录,也能够修改双方通信内容,这样实际存在潜在危险。只要代理服务想这样做,客户在网络上的通信就没有什么隐私可言了,因此如果涉及金钱交易,...

    一 代码

    1、模拟服务端代码
    import sys
    import socket
    import threading
    #回复消息,原样返回
    def replyMessage(conn):
        while True:
            data = conn.recv(1024)
            conn.send(data)
            if data.decode().lower() == 'bye':
                break
        conn.close()
    def main():
        sockScr = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sockScr.bind(('', port))
        sockScr.listen(200)
        while True:
            try:
                conn, addr = sockScr.accept()
                #只允许特定主机访问本服务器
                if addr[0] != onlyYou:
                    conn.close()
                    continue
                #创建并启动线程
                t = threading.Thread(target=replyMessage, args=(conn,))
                t.start()        
            except:
                print('error')
    if __name__ == '__main__':
        try:
            #获取命令行参数
            port = int(sys.argv[1])
            onlyYou = sys.argv[2]
            main()
        except:
            print('Must give me a number as port')
            
     
    2、模拟代理服务器代码
    import sys
    import socket
    import threading
    def middle(conn, addr):
        #面向服务器的Socket
        sockDst = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sockDst.connect((ipServer,portServer))
        while True:
            data = conn.recv(1024).decode()
            print('收到客户端消息:'+data)
            if data == '不要发给服务器':
                conn.send('该消息已被代理服务器过滤'.encode())
                print('该消息已过滤')
            elif data.lower() == 'bye':
                print(str(addr)+'客户端关闭连接')
                break
            else:
                sockDst.send(data.encode())
                print('已转发服务器')
                data_fromServer = sockDst.recv(1024).decode()
                print('收到服务器回复的消息:'+data_fromServer)
                if data_fromServer == '不要发给客户端':
                    conn.send('该消息已被代理服务器修改'.encode())
                    print('消息已被篡改')
                else:
                    conn.send(b'Server reply:'+data_fromServer.encode())
                    print('已转发服务器消息给客户端')
            
        conn.close()
        sockDst.close()
    def main():
        sockScr = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sockScr.bind(('', portScr))
        sockScr.listen(200)
        print('代理已启动')
        while True:
            try:
                conn, addr = sockScr.accept()
                t = threading.Thread(target=middle, args=(conn, addr))
                t.start()
                print('新客户:'+str(addr))
            except:
                pass
            
    if __name__ == '__main__':
        try:
            #(本机IP地址,portScr)<==>(ipServer,portServer)
            #代理服务器监听端口
            portScr = int(sys.argv[1])
            #服务器IP地址与端口号
            ipServer = sys.argv[2]
            portServer = int(sys.argv[3])
            main()
        except:
            print('Sth error')
     
    3、模拟客户端代码
    import sys
    import socket
    def main():
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.connect((ip, port))
        while True:
            data = input('What do you want to ask:')
            sock.send(data.encode())
            print(sock.recv(1024).decode())
            if data.lower() == 'bye':
                break
        sock.close()
    if __name__ == '__main__':
        try:
            #代理服务器的IP地址和端口号
            ip = sys.argv[1]
            port = int(sys.argv[2])
            main()
        except:
            print('Sth error')
     
    二 运行结果

     
    三 运行说明
    从结果可以看出,代理服务器代码能够对客户端和服务器之间的内容进行记录,也能够修改双方通信内容,这样实际存在潜在危险。只要代理服务想这样做,客户在网络上的通信就没有什么隐私可言了,因此如果涉及金钱交易,最好不要使用代理服务器。
    • 27c1341d-8081-3afb-bd62-f2b16e005c3c-thumb.png
    • 大小: 30.7 KB
    展开全文
  • 这里的代理服务器,是指二级代理服务器。比如:A可以访问B,B可以访问C,A不能直接访问C。这时,如果在B开一个二级代理,就可实现A访问C。现有的工具有CCProxy。 这里就是使用Python简单的实现一个二级代理。
  • [Python]pythonProxy 实现代理服务器详解

    千次阅读 2016-06-02 17:23:16
    python代理服务器实现 Python IDE 网络上有很多关于python IDE的选择,个人比较偏向Anaconda,里面的界面比较友好。缺点是库太大,大概有380M,下载时间太长,在测试中的网络环境太恶劣,希望能用apt-get install...

    python代理服务器的实现

    1. Python IDE
      网络上有很多关于python IDE的选择,个人比较偏向Anaconda,里面的界面比较友好。缺点是库太大,大概有380M,下载时间太长,在测试中的网络环境太恶劣,希望能用apt-get install来安装。最后发现了这个IDLE比较方便,安装如下:
    sudo apt-get install idle-python2.7
    //上面可以不输入2.7然后使用tab联想,可以看到还有3.4的版本,这里使用了2.7的版本
    1. 具体的代理实现。
      参考文献
      上面的参考文献是代理的具体实现,主要实现了A–>B—>C—->Internet中的B的代码,B通过C的代理上网,然后通过这段代码给A开代理,这里仅对这段代码进行分析。

    2.1 创建日志即日志目录,判断是否有logs这个目录,无则进行创建。然后对这个logging的基本信息进行配置。

    logsDir = "logs"
    if not os.path.isdir(logsDir);
        os.mkdir(logsDir)
    logging.basicConfig(level=logging.DEBUG,
     format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
                        datefmt='%a,%d %b %Y %H:%M:%S ',
                        filename='logs/logs.log',
                        filemode='a')

    2.2 设置代理的ip和限制最大代理的数目:

    to_addr=('10.13.20.3',3128)
    maxConnections = 32

    2.3 将所有的代理操作封装成类
    2.3.1 首先写这个初始化函数,传入addr,这个是在调用的时候创建。

    class Proxy:
            def __init__(self,addr):
                self.proxy = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
                self.proxy.bind(addr)
                self.proxy.listen(maxConnections)
                self.inputs = {self.proxy:None}
                self.route = {}

    2.3.1.1 self指的是类实例对象本身,基础知识见self解释

    这个类有成员变量 proxy/inputs/route。
    2.3.1.2 其中proxy是socket对象,这个socket是流对象,基础知识见python中的socket
    将这个proxy对象绑定到指定的地址,并设置最大的监听数目。
    2.3.1.3 inputs成员是以proxy为key的一个集合,用来记录从A过来的socket(A–>B—>C—->Internet)
    2.3.1.4 route和inputs相反,记录返程socket(A<–B<—C<—-Internet)

    2.3.2 在上面的Proxy类中定义这个主要的方法类serve_forever(self)

    def serve_forever(self):
                logging.info('proxy listen....')
                while 1:
                    readable,_,_=select.select(list(self.inputs.keys()),[],[])
                    for self.sock in readable:
                        if self.sock == self.proxy:
                            self.on_join()
                        else:
                            try:
                                data = self.sock.recv(8192)
                            except Exception, e:
                                logging.error(str(e))
                                self.on_quit()
                                continue
    
                            if not data:
                                self.on_quit()
                            else:
                                try:
                                    self.route[self.sock].send(data)
                                except Exception,e:
                                    logging.error(str(e))
                                    self.on_quit()
                                    continue

    2.3.2.1 这里使用了select模块,基础知识见select解释
    这个select这里是为了承担起服务器和多个客户端通信的作用。select的原型为(rlist,wlist,xlist[,timeout]),rlist是等待读取的对象,wlist是等待写入的对象,xlist是等待异常的对象,最后一个是可选对象,指定等待的时间,单位是s,将要返回对象三元组,所以这里只接收等待读取的对象。
    2.3.2.2 如果这个key是proxy对象,执行这个Proxy类的on_join()方法,这个方法具体实现见2.3.3,主要记录从C到A的返程socket(A<–B<—C<—-Internet)
    2.3.2.3 如果不是sock.proxy成员,这里主要是看addr是否一致。不一致需要接收数据。接收完成数据需要进行判断if not data,即是否为空,如果不为空,则对这个self.sock进行发送数据。这里使用了self.route[self.sock]来确定要送达目的的socket,例如从A到B收到了报文,这个时候self.route[self.sock]确定了要发往C的socket。如果收到从C回应的报文,则反向发的报文为 self.route[forward] = client。
    2.3.2.4 所有有异常的情况下需要执行on_quit()操作,具体见2.3.4。

    2.3.3 on_join(self)方法。

    def on_join(self):
                client,addr = self.proxy.accept()
                logging.info("proxy client "+str(addr)+' connect')
                forward = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
                try:
                    forward.connect(to_addr)
                except Exception, e:
                    logging.error(str(e))
                    client.close()
                    return
                self.inputs[client] = None
                self.inputs[forward] = None
    
                self.route[client] = forward
                self.route[forward] = client

    2.3.3.1 这里proxy类是socket对象,调用它的accept方法,具体使用见上面python中socket的解释。accept方法返回一个含有两个元素的 元组(connection,address)。第一个元素connection是新的socket对象,服务器必须通过它与客户通信;第二个元素 address是客户的Internet地址。
    2.3.3.2 定义这个forward变量,是一个新的socket对象。并使用connect链接到C设备(A–>B–>C–>internet)。
    2.3.3.3 然后在这个route中记录这个返程的报文应该调用的链接。

    2.3.4 on_quit()方法,主要是对各个socket进行关闭。

    def on_quit(self):
                ls = [self.sock]
                if self.sock in self.route:
                    ls.append(self.route[self.sock])
                for s in ls:
                    if s in self.inputs:
                        del self.inputs[s]
                    if s in self.route:
                        del self.route[s]
                    s.close()
    1. 最后在代码中使用下面这段代码初始话Proxy类,使用了8192为代理端口,然后其他设备例如A就可以使用这个B设备的IP和端口号进行代理上网。
    if __name__ == "__main__":
        try:
            Proxy(('',8192)).serve_forever()
        except KeyboardInterrupt, e:
            logging.error("KeyboardInterrupt"+str(e))
    展开全文
  • 本文实例讲述了python实现简单的TCP代理服务器的方法,分享给大家供大家参考。 具体实现代码如下: # -*- coding: utf-8 -*- ''' filename:rtcp.py @desc: 利用python的socket端口转发,用于远程维护 如果连接不到...
  • Python实现的简易HTTP代理服务器

    万次阅读 热门讨论 2019-03-14 16:05:32
    使用socket编程实现代理服务器,首先它得是一个服务器 至此,http代理服务器的核心代码已经完成 于是一个非常令人尴尬的问题就出现了,在某一次读取完毕之后,我怎么知道我读完了呢? 一旦如此,就会陷入读阻塞。 ...

     

    本篇源码及Ctrl+C+V的来源参考这个

    使用socket编程实现代理服务器,首先它得是一个服务器,因此我们有第一篇参考代码:

    server = socket.socket()
    server.bind(('127.0.0.1',8000))
    server.listen(3)
    conn, addr = server.accept()
    data = True
    while data :
        data = conn.recv(1024)
        msg = raw_input()
        if msq=="any code you mean to exit": break
        conn.sendall(msg)
    conn.close()
    server.close()

    它做了这几件事:

    1.启动服务,监听端口8000,并设置为允许3个客户端排队(虽然实际上只支持一个客户端进行访问)

    2.接受请求,在连接中接收和返回数据

    3.当客户端关闭时,recv会得到空字符串,因此退出循环、结束程序

    不妨就用上面的这个程序接收请求,看一看我们的代理服务器究竟要处理什么:

    GET http://www.sina.com/ HTTP/1.1
    Host: www.sina.com
    User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:65.0) Gecko/20100101 Firefox/65.0
    Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
    Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
    Accept-Encoding: gzip, deflate
    Connection: keep-alive
    Upgrade-Insecure-Requests: 1


     

    注意到,最下面有两个空行,这是约定,请求头与请求体之间用\r\n\r\n来分割

    为了看的更清楚,我们可以让它以unicode显示

    ['GET http://www.sina.com/ HTTP/1.1\r\nHost: www.sina.com\r\nUser-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:65.0) Gecko/20100101 Firefox/65.0\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8\r\nAccept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2\r\nAccept-Encoding: gzip, deflate\r\nConnection: keep-alive\r\nUpgrade-Insecure-Requests: 1\r\n\r\n']

    其中的第二行Host就是我们要获取的目标服务器地址,当然http的默认端口号是80

    只要得到目标服务器的地址和端口号,我们就可以将这个请求原封不动的丢给目标服务器了,至于怎么获取这个目标地址,反正看起来也不难,我们可以假装它已经实现了。

    与上述服务器代码不同,我们不需要input,也不需要循环处理数据,只需要接受完数据、把它丢给服务器就可以了,然后从目标服务器返回数据的过程恰好相反,需要从target中recv,向conn中sendall,因此:

    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.bind(('127.0.0.1', 8000))
    server.listen(3)
    conn, addr = server.accept()
    data = conn.recv(1024)
    print data
    # 假装已经实现了getHost
    host, port = getHost(data)
    target = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    target.connect((host, port))
    target.sendall(data)
    
    data = target.recv(1024)
    print data
    conn.sendall(data)
    
    target.close()
    conn.close()
    server.close()

    对www.sina.com的测试得到了这样的报文:

    HTTP/1.1 302 Moved Temporarily
    Server: nginx
    Date: Thu, 14 Mar 2019 11:25:58 GMT
    Content-Type: text/html
    Content-Length: 154
    Connection: keep-alive
    Location: https://www.sina.com.cn/
    X-Via-CDN: f=edge,s=cmcc.shandong.ha2ts4.82.nb.sinaedge.com,c=223.72.94.28;
    X-Via-Edge: 15525627584351c5e48df7d53c0784e9a7612

    <html>
    <head><title>302 Found</title></head>
    <body bgcolor="white">
    <center><h1>302 Found</h1></center>
    <hr><center>nginx</center>
    </body>
    </html>

    报文称,这个网站已经搬家了,不再使用http协议进行访问了,以后要上新浪网应该使用https://www.sina.com.cn/这个网址

    显然,这是因为我太落伍了,在https大行其道的年代连传统的http代理都没学会

    无论如何,这样的结果至少表明我们正常的接收了客户端与服务器端的响应,并且测试会发现,浏览器可以正常访问到新浪网(因为它跳转到https协议上不再经过http代理)


    至此,http代理服务器的核心代码已经完成,接下来的任务是对这部分代码进行优化。

    首先我们假装这个服务器启动命令中可以接收一个整数作为端口号,然后假装我们的服务器可以服务于多个不同的客户端,这意味着对于每个客户端需要分别启动新线程,因此:

    def main(_, port=8000):
        myserver = socket.socket()
        myserver.bind(('127.0.0.1', port))
        myserver.listen(1024)
        while True:
            conn, addr = myserver.accept()
            thread_p = threading.Thread(target=thread_proxy, args=(conn, addr))
            thread_p.setDaemon(True)
            thread_p.start()
    
    if __name__ == '__main__':
        main(*sys.argv)
        sys.exit(0)

    当然了,我们的服务器很流氓,不提供退出方法,所以这是一个死循环

    对每一个thread_proxy,我们需要完成三件事:1.找到目标服务器。2.转发请求报文。3.转发响应报文。

    注意到我们在之前的简易服务器代码中写的recv参数固定为1024,这是不是意味着我们只能对请求长度小于1024的请求进行代理,超出长度概不负责?这当然是不合适的!因此我们需要将它设置的非常大循环读取直到读完。

    于是一个非常令人尴尬的问题就出现了,在某一次读取完毕之后,我怎么知道我读完了呢?

    一个非常直观的想法是:如果我读到的长度等于预设的长度,那就是没有读完,否则就是读完了。然而无论是客户端还是浏览器,都不知道你预设的长度是多少,因此总是存在“整倍数”的概率,而且这个概率并不太低。一旦如此,就会陷入读阻塞。

    请求头中有一个字段【content-length】被用于描述请求体的长度,如果没有这样的字段,那么约定\r\n0\r\n\r\n为休止符

    虽然网上查到的结论有些深奥,但简单来说就是上面这句话。再加上我们之前就掌握了的\r\n\r\n分割符,形成这样一组手段:

    1. 切取请求头
      def splitHeader(string):
          i, l = 3, len(string)
          while i<l and (string[i] != "\n" or string[i-3:i+1] !="\r\n\r\n") : i+=1
          return string[:i-3]
    2. 从请求头中寻找信息(host、content-length)
      def getHeader(header, name):
          name = name.upper()
          base, i, l = 0, 0, len(header)
      
          while i<l:
              # 行入口,寻找冒号
              while i<l and header[i] != ":" : i+=1
              # 判断信息头
              if i<l and header[base:i].strip().upper() == name:
                  # 此行即为所求,从冒号后截断
                  base = i+1
                  while i<l and not(header[i] == "\n" and header[i-1] == "\r") : i+=1
                  return header[base:i-1]
              else:
                  # 此行非所求,跳过此行
                  while i<l and not(header[i] == "\n" and header[i-1] == "\r") : i+=1
                  base, i = i+1, i+1
          # 所求不存在
          return None
    3. 根据约定获取全部报文
      def recvBody(conn, base, size):
          if size==-1:
              while base[-5:] != "\r\n0\r\n\r\n" : base += conn.recv(RECV_SIZE)
          else:
              while len(base)<size:base += conn.recv(RECV_SIZE)
          return base

    有了这些给力的手段做支撑,现在可以写thread_proxy了,为了便捷起见,事实上很多服务器也约定,报文的头信息不能太长,这给了我们一个保障:在指定的长度内一定能够获取完整的头信息,将这个长度设置为MAX_HEADER_SIZE,有:

    def thread_proxy(client, addr):
    
        request = client.recv(MAX_HEADER_SIZE)
        requestHeader = splitHeader(request)
        raw_host = getHeader(requestHeader, "Host")
        host, port = transHost(raw_host)
        # body也可能是空字符串,若如此则不必处理
        if len(requestHeader) < len(request)-4:
            content_size = getHeader(requestHeader, "content-length")
            size = len(requestHeader) + 4 + int(content_size) if content_size else -1
            request = recvBody(client, request, size)
    
        server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        server.connect((host, port))
        server.sendall(request)
    
        response = server.recv(MAX_HEADER_SIZE)
        responseHeader = splitHeader(response)
        if len(responseHeader) < len(response)-4:
            content_size = getHeader(responseHeader , "content-length")
            size = len(responseHeader) + 4 + int(content_size) if content_size else -1
            response = recvBody(server, response , size)
    
        client.sendall(response)
        server.close()
        client.close()

    其中transHost是一个异常简单的小方法,只是处于处理默认值的方便,单独提炼出来:

    def transHost(raw_host):
        for i in range(len(raw_host)): 
            if raw_host[i] == ":" : return raw_host[:i].strip(), int(raw_host[i+1:])
        else : return raw_host.strip(), 80

    len(responseHeader)+4+int(content_size)是技术不足技巧来补的解决方案,目的是实现对报文长度的控制

    至此,一个基本的http代理服务器就实现了,当然,出于健壮性考虑、debug方便和其它因素,实用化的代码会更长一点,完整的代码点击这里

    然而https据说会更复杂,截至目前,我连示意图都还没看懂。真希望有个大佬教我SSL协议?

    展开全文
  • python3实现基本的TCP代理功能,这次只对http请求做了相应处理,如果要用于其他协议需要做一些适配。 1.确定原始网页:http://202.123.107.21:80 2.程序执行:python ‘.\proxy server.py’ 0.0.0.0 50006 202...
  • 本文实例讲述了Python简单实现代理服务器端口映射功能。分享给大家供大家参考,具体如下: 一 代码 1、模拟服务端代码 import sys import socket import threading #回复消息,原样返回 def replyMessage(conn): ...
  • python实现http/https代理服务器

    万次阅读 2019-11-24 19:17:23
    代理服务 :param ip: :param port: :return: """ s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) s.bind((ip, port)) s.listen(10) ...
  • Python拥有这种单独起一个服务器监听端口的能力,用标准库的wsgiref就行。 from wsgiref.simple_server import make_server def simple_app(environ, start_response): status = '200 OK' response_headers = [...
  • 代理服务器是在client和server之间的一个服务器,一般起到缓存的作用,所以也叫缓存服务器。比如: A ----(HTTP)----》 B ----(HTTP)----》 C 其中A是客户端,C是服务器端,那么B就是proxy server了,是代理...
  • Python 50行代码实现代理服务器(加强版)
  • 代理服务原理很简单,就拿浏览器与web服务器来说。无非是A浏览器发request给B代理,B代理再把request把送给C web服务,然后C的reponse->B->A。要写web代理服务就要先了解下http协议,当然并不要多深入,除非要实现...
  • 多次重复获取网页时,很容易被网站的反扒封掉ip,这时可以使用代理python使用代理非常简单,三行代码即可实现。 #使用urllib库的ProxyHandler添加代理ip地址。proxy_add为要添加的ip地址,:端口即可 proxy = ...
  • 代理服务器代码实现【同nginx内部实现原理】 ##### 1.1 目的 ​ 代理服务器,是指二级代理服务器。比如:A可以访问B,B可以访问C,A不能直接访问C。这时,如果在B开一个二级代理,就可实现A访问C。现有的工具有...
  • 刚刚接触Py,想写一个http代理服务器 最简单的那种 流量转发。 [color=#FF0000]浏览器->Python程序->Web服务器 | 浏览器 -------------- Python程序[/color] 但是遇到了一些问题,我自己的程序,开启...
  • https://www.baidu.com 收到客户端请求为: b'CONNECT www.baidu.com:443 HTTP/1.0\r\nProxy-Authorization: Basic YWJjOnNhZA==\r\n\r\n' 请求可以分成以下内容 #代表是https的http代理 CONNECT #HOST如果没写默认...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 507
精华内容 202
关键字:

python实现代理服务器

python 订阅