lanproxy | lanproxy是一个将局域网个人电脑、服务器代理到公网的内网穿透工具，支持tcp流量转发，可支持任何tcp上层协议（访问内网网站、本地支付接口调试、ssh访问、远程桌面...）。目前市面上提供类似服务的有花生壳、TeamView、GoToMyCloud等等，但要使用第三方的公网服务器就必须为第三方 | Proxy library

from bs4 import BeautifulSoup
import requests
import random
import json

# LIST OF FREE PROXY APIS, THESE PROXIES ARE LAST TIME TESTED 50 MINUTES AGO, PROTOCOLS: HTTP, HTTPS, SOCKS4 AND SOCKS5
list_of_proxy_content = ["https://proxylist.geonode.com/api/proxy-list?limit=150&page=1&sort_by=lastChecked&sort_type=desc&filterLastChecked=50&country=CH&protocols=http%2Chttps%2Csocks4%2Csocks5",
                        "https://proxylist.geonode.com/api/proxy-list?limit=150&page=1&sort_by=lastChecked&sort_type=desc&filterLastChecked=50&country=FR&protocols=http%2Chttps%2Csocks4%2Csocks5",
                        "https://proxylist.geonode.com/api/proxy-list?limit=150&page=1&sort_by=lastChecked&sort_type=desc&filterLastChecked=50&country=DE&protocols=http%2Chttps%2Csocks4%2Csocks5",
                        "https://proxylist.geonode.com/api/proxy-list?limit=1500&page=1&sort_by=lastChecked&sort_type=desc&filterLastChecked=50&country=AT&protocols=http%2Chttps%2Csocks4%2Csocks5",
                        "https://proxylist.geonode.com/api/proxy-list?limit=150&page=1&sort_by=lastChecked&sort_type=desc&filterLastChecked=50&country=IT&protocols=http%2Chttps%2Csocks4%2Csocks5"]


# EXTRACTING JSON DATA FROM THIS LIST OF PROXIES
full_proxy_list = []
for proxy_url in list_of_proxy_content:
    
    proxy_json = requests.get(proxy_url).text
    proxy_json = json.loads(proxy_json)
    proxy_json = proxy_json["data"]

    full_proxy_list.extend(proxy_json)

# CREATING PROXY DICT
final_proxy_list = []
for proxy in full_proxy_list:

    #print(proxy) # JSON VALUE FOR ALL DATA THAT GOES INTO PROXY

    protocol = proxy['protocols'][0]
    ip_ = proxy['ip']
    port = proxy['port']
        
    proxy = {protocol : protocol + '://' + ip_ + ':' + port}

    final_proxy_list.append(proxy)


# TRYING PROXY ON 3 DIFERENT WEBSITES
for proxy in final_proxy_list:

    print(proxy)
    try:
        r0 = requests.get("https://edition.cnn.com/", proxies=proxy, timeout = 15)
        if r0.status_code == 200:
            print("GOOD PROXY")
        else:
            print("BAD PROXY")
    except:
        print("proxy error")
        
    try:        
        r1 = requests.get("https://www.buelach.ch/", proxies=proxy, timeout = 15)
        if r1.status_code == 200:
            print("GOOD PROXY")        
        else:
            print("BAD PROXY")
    except:
        print("proxy error")
        
    try:      
        r2 = requests.get("https://www.blog.police.be.ch/", proxies=proxy, timeout = 15)
        if r2.status_code == 200:
            print("GOOD PROXY")        
        else:
            print("BAD PROXY")
    except:
        print("proxy error")

    print()

{'socks4': 'socks4://185.168.173.35:5678'}
{'http': 'http://62.171.177.80:3128'}
{'https': 'http://159.89.28.169:3128'}

proxies = {"http": "http://10.10.1.10:3128",
           "https": "http://10.10.1.10:1080"}

Mendelson AS2 ➡ mitmproxy ➡ partner AS2 server
                          ↘
                           redis

server {
  listen 80;
  sendfile on;
  default_type application/octet-stream;

  gzip on;
  gzip_http_version 1.1;
  gzip_disable      "MSIE [1-6]\.";
  gzip_min_length   256;
  gzip_vary         on;
  gzip_proxied      expired no-cache no-store private auth;
  gzip_types        text/plain text/css application/json application/javascript application/x-javascript text/xml application/xml application/xml+rss text/javascript;
  gzip_comp_level   9;

  location / {
    root /usr/share/nginx/html;
    try_files $uri $uri/ /index.html =404;
  }
  
  location /api/ {
    proxy_pass http://host.docker.internal:8080/api/;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection 'upgrade';
    proxy_set_header Host $host;
    proxy_cache_bypass $http_upgrade;
  }
}

package main

import (
    "log"
    "net"
)

func Conn(c *net.TCPConn) string {
    return c.RemoteAddr().String() + " (" + c.LocalAddr().String() + ")"
}

func ProxifyConns(recipientConn, donorConn *net.TCPConn) {
    log.Println("Proxying", ConnrecipientConn), "and", Conn(donorConn))
    go func() {
        _, err := io.Copy(recipientConn, donorConn)
        if err != nil {
            utils.StacktraceError(err)
        }
        recipientConn.Close()
    }()
    go func() {
        _, err := io.Copy(donorConn, recipientConn)
        if err != nil {
            utils.StacktraceError(err)
        }
        recipientConn.Close()
    }()
}


func main() {
    // Open the donor listener
    donorsAddr, err := net.ResolveTCPAddr("tcp4", ":11000")
    if err != nil {
        utils.StacktraceErrorAndExit(err)
    }
    listenerDonors, err := net.ListenTCP("tcp", donorsAddr)
    if err != nil {
        utils.StacktraceErrorAndExit(err)
    }
    defer listenerDonors.Close()
    log.Println("Listening for donors on", listenerDonors.Addr())

    // Open the recipient listener
    recipientsAddr, err := net.ResolveTCPAddr("tcp4", ":10000")
    if err != nil {
        utils.StacktraceErrorAndExit(err)
    }
    listenerRecipients, err := net.ListenTCP("tcp", recipientsAddr)
    if err != nil {
        utils.StacktraceErrorAndExit(err)
    }
    defer listenerRecipients.Close()
    log.Println("Listening for recipients on", listenerRecipients.Addr())

    //  Handle donor connections
    donorConns := make(chan *net.TCPConn)
    go func() {
        for {
            donorConn, err := listenerDonors.AcceptTCP()
            donorConn.SetKeepAlive(true)
            if err != nil {
                utils.StacktraceErrorAndExit(err)
                return
            }
            log.Println("New donor connection from", Conn(donorConn))
            donorConns <- donorConn
        }
    }()

    // Handle recipient connections
    for {
        recipientConn, err := listenerRecipients.AcceptTCP()
        recipientConn.SetKeepAlive(true)
        if err != nil {
            utils.StacktraceErrorAndExit(err)
            return
        }
        log.Println("New recipient connection from", Conn(recipientConn))
        donorConn := <-donorConns
        proxy.ProxifyConns(recipientConn, donorConn)
    }
}

import net, { AddressInfo } from 'net';
import http from 'http';
import golgi from 'golgi';

export const startHttpProxy = () => {
  const server = http.createServer();
  let proxyServer: http.Server = golgi(server);
  // Listening to 0 assigns a random OS-assigned port
  proxyServer = proxyServer.listen(0);
  return proxyServer;
};

export const startDonorSocket = () => {
  const proxyServer = startHttpProxy();
  const proxyServerSocket = new net.Socket();
  proxyServerSocket.connect(
    (proxyServer.address() as AddressInfo).port,
    '127.0.0.1'
  );

  const donorSocket = new net.Socket();
  donorSocket.setKeepAlive(true);
  donorSocket.connect(11000, '2.226.102.14', () => {
    proxyServerSocket.pipe(donorSocket);
    donorSocket.pipe(proxyServerSocket);
  });
};

Client ↔ Transparent Proxy ↔ Explicit proxy ↔ Web page

import requests, re
import time


proxies = {
    'http': 'http://:user:pass@proxy_ip:port',
    'https': 'https://:user:pass@proxy_ip:port'
    }

r = requests.get('https://httpbin.org/ip', proxies=proxies)
print(r.text)

<html>
    <video id="video" controls src="out.mp4">
    </video>

    <script>
        const video = document.querySelector('#video');
        const mediaSource = new MediaSource();
        video.src = URL.createObjectURL(mediaSource);
        mediaSource.addEventListener('sourceopen', sourceOpen);
        function sourceOpen() {
            var mime = 'video/mp4; codecs="avc1.42E01E, mp4a.40.2"'
            var sourceBuffer = mediaSource.addSourceBuffer(mime);
            fetchBuffer('out.mp4', buffer => {
                sourceBuffer.appendBuffer(buffer)
            })
        }

        function fetchBuffer (url, callback) {
            var xhr = new XMLHttpRequest;
            xhr.open('get', url);
            xhr.responseType = 'arraybuffer';
            xhr.onload = function () {
                callback(xhr.response);
            };
            xhr.send();
        }
    </script>    
</html>