package main

import (
"context"
"fmt"
"golang.org/x/net/proxy"
"io/ioutil"
"net"
"net/http"
"net/url"
"strings"
"time"
)

var testApi = "https://api.ipify.org/?format=json"

func main() {
var proxyIP = "922s5.proxys5.net:6300"
var username = "xxx-zone-isp"
var password = ""
httpProxy(proxyIP, username, password)
time.Sleep(time.Second * 1)
Socks5Proxy(proxyIP, username, password)

}
func httpProxy(proxyUrl, user, pass string) {
defer func() {
    if err := recover(); err != nil {
        fmt.Println(err)
    }
}()
urli := url.URL{}

if !strings.Contains(proxyUrl, "http") {
    proxyUrl = fmt.Sprintf("http://%s", proxyUrl)
}

urlProxy, _ := urli.Parse(proxyUrl)
if user != "" && pass != "" {
    urlProxy.User = url.UserPassword(user, pass)
}

client := &http.Client{
    Transport: &http.Transport{
        Proxy: http.ProxyURL(urlProxy),
    },
}
rqt, err := http.NewRequest("GET", testApi, nil)
if err != nil {
    panic(err)
    return
}
response, err := client.Do(rqt)
if err != nil {
    panic(err)
    return
}

defer response.Body.Close()
body, _ := ioutil.ReadAll(response.Body)
fmt.Println("http result = ", response.Status, string(body))

return
}

func Socks5Proxy(proxyUrl, user, pass string) {

defer func() {
    if err := recover(); err != nil {
        fmt.Println(err)
    }
}()

var userAuth proxy.Auth
if user != "" && pass != "" {
    userAuth.User = user
    userAuth.Password = pass
}
dialer, err := proxy.SOCKS5("tcp", proxyUrl, &userAuth, proxy.Direct)
if err != nil {
    panic(err)
}
httpClient := &http.Client{
    Transport: &http.Transport{
        DialContext: func(ctx context.Context, network, addr string) (conn net.Conn, err error) {
            return dialer.Dial(network, addr)
        },
    },
    Timeout: time.Second * 10,
}

if resp, err := httpClient.Get(testApi); err != nil {
    panic(err)
} else {
    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println("socks5 result = ",string(body))
}
}
                 
                

                 
                
#!/usr/bin/env node
require('request-promise')({
    url: 'https://ipinfo.io',
    proxy: 'http://???-zone-custom:????@  ',
    })
.then(function(data){ console.log(data); },
    function(err){ console.error(err); });
                 
                

                 
<?php

$targetUrl = "https://www.google.com/";
$proxyServer = "http://922s5.proxys5.net:6300";
$proxyUserPwd = "user:psswd";
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $targetUrl);
curl_setopt($ch, CURLOPT_HTTPPROXYTUNNEL, false);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_PROXYTYPE, 0); //http
// curl_setopt($ch, CURLOPT_PROXYTYPE, 5); //sock5
curl_setopt($ch, CURLOPT_PROXY, $proxyServer);
curl_setopt($ch, CURLOPT_PROXYAUTH, CURLAUTH_BASIC);
curl_setopt($ch, CURLOPT_USERAGENT, "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727;)");
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 3);
curl_setopt($ch, CURLOPT_TIMEOUT, 5);
curl_setopt($ch, CURLOPT_HEADER, true);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_PROXYUSERPWD, $proxyUserPwd);
$result = curl_exec($ch);
$err = curl_error($ch);
curl_close($ch);
var_dump($err);
var_dump($result);
                 
                

                 
package demo;
import okhttp3.Credentials;
import okhttp3.OkHttpClient;
import okhttp3.Request;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.PasswordAuthentication;
import java.net.Proxy;

/**
* compile 'com.squareup.okhttp3:okhttp:3.10.0'
*/
class AutProxyJava {
public static void main(String[] args) throws IOException {
    testWithOkHttp();

    testSocks5WithOkHttp();
}

public static void testWithOkHttp() throws IOException {
    String url = "https://api.ipify.org?format=json";
    Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("ip.proxys5.net", 6500));
    OkHttpClient client = new OkHttpClient().newBuilder().proxy(proxy).proxyAuthenticator((route, response) -> {
        String credential = Credentials.basic("username-zone-custom", password);
            return response.request().newBuilder()
        .header("Proxy-Authorization", credential).build();
    }).build();


    Request request = new Request.Builder().url(url).build();
    okhttp3.Response response = client.newCall(request).execute();
    String responseString = response.body().string();
    System.out.println(responseString);
}

public static void testSocks5WithOkHttp() throws IOException {
    String url = "https://api.ipify.org?format=json";
    Proxy proxy = new Proxy(Proxy.Type.SOCKS, new InetSocketAddress("ip.proxys5.net", 6500));
    java.net.Authenticator.setDefault(new java.net.Authenticator() {
        private PasswordAuthentication authentication =
        new PasswordAuthentication("laylay-zone-isp", "123456".toCharArray());

        @Override
        protected PasswordAuthentication getPasswordAuthentication() {
            return authentication;
        }
    });
    OkHttpClient client = new OkHttpClient().newBuilder().proxy(proxy).build();

    Request request = new Request.Builder().url(url).build();
    okhttp3.Response response = client.newCall(request).execute();
    String responseString = response.body().string();
    System.out.println(responseString);
}
}
                    
                 
                

                 
                
import urllib
import socks
import http.client
from urllib.error import URLError
import ssl
from urllib.request import build_opener, HTTPHandler, HTTPSHandler


def merge_dict(a, b):
d = a.copy()
d.update(b)
return d


class SocksiPyConnection(http.client.HTTPConnection):
def __init__(self, proxytype, proxyaddr, proxyport=None, rdns=True, username=None, password=None, *args, **kwargs):
    self.proxyargs = (proxytype, proxyaddr, proxyport, rdns, username, password)
    http.client.HTTPConnection.__init__(self, *args, **kwargs)

def connect(self):
    self.sock = socks.socksocket()
    self.sock.setproxy(*self.proxyargs)
    if type(self.timeout) in (int, float):
        self.sock.settimeout(self.timeout)
    self.sock.connect((self.host, self.port))


class SocksiPyConnectionS(http.client.HTTPSConnection):
def __init__(self, proxytype, proxyaddr, proxyport=None, rdns=True, username=None, password=None, *args, **kwargs):
    self.proxyargs = (proxytype, proxyaddr, proxyport, rdns, username, password)
    http.client.HTTPSConnection.__init__(self, *args, **kwargs)

def connect(self):
    sock = socks.socksocket()
    sock.setproxy(*self.proxyargs)
    if type(self.timeout) in (int, float):
        sock.settimeout(self.timeout)
    sock.connect((self.host, self.port))
    self.sock = ssl.wrap_socket(sock, self.key_file, self.cert_file)


class SocksiPyHandler(HTTPHandler, HTTPSHandler):
def __init__(self, *args, **kwargs):
    self.args = args
    self.kw = kwargs
    HTTPHandler.__init__(self)

def http_open(self, req):
    def build(host, port=None, timeout=0, **kwargs):
        kw = merge_dict(self.kw, kwargs)
        conn = SocksiPyConnection(*self.args, host=host, port=port, timeout=timeout, **kw)
        return conn

    return self.do_open(build, req)

def https_open(self, req):
    def build(host, port=None, timeout=0, **kwargs):
        kw = merge_dict(self.kw, kwargs)
        conn = SocksiPyConnectionS(*self.args, host=host, port=port, timeout=timeout, **kw)
        return conn

    return self.do_open(build, req)


username = ""
password = ""
ip = "ip.proxys5.net"
port = 6500
proxy = "socks5://{username}:{password}@{ip}:{port}".format(username=username, password=password, ip=ip, port=port)
# socks.set_default_proxy(socks.SOCKS5, ip, port,username=username,password=password)
# socket.socket = socks.socksocket

url = 'https://www.google.com/'

try:
req = urllib.request.Request(url=url, headers={'User-Agent':'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36'})
opener = build_opener(SocksiPyHandler(socks.SOCKS5, ip, port, username=username, password=password))
response = opener.open(req)
# response = urllib.request.urlopen(req)
# response = request.urlopen(url)
print(response.read().decode('utf-8'))
except URLError as e:
print(e)