User & Pass Auth - 360Proxy

Cân bằng lưu lượng proxy dân cư

Cân bằng giao thông Sau ngày hết hạn, số dư trong tài khoản sẽ bị đóng băng;
Sau khi mua lại, lưu lượng đông lạnh chưa được sử dụng trước đó sẽ được tự động bỏ chặn và hợp nhất với lưu lượng truy cập mới được mua cho đến thời hạn mới nhất.

0MBGiao thông sẽ tự động được bỏ chặn sau khi sạc lại

Hồ sơ sử dụng Nạp điện

CHỌN QUỐC GIA

Xem mã quốc gia

LỰA CHỌN THÀNH PHỐ

Tài khoản xác thực

tên máy chủ: cổng

Chế độ IP

Sticky IP

Sticky IP
Randomize IP

Thời lượng IP

一

lỗi đầu vào

(1-60 phút)

tên tài khoản

mật khẩu

Các lệnh kiểm tra:

SAO CHÉP

Các lệnh kiểm tra:

*Chỉ hỗ trợ sử dụng trong môi trường không thuộc Trung Quốc đại lục.

hostname:port:username:password

hostname:port:username:password
username:password:hostname:port
username:password@hostname:port

Phát ra

Các lệnh kiểm tra:

SAO CHÉP

Các lệnh kiểm tra:

Bắt đầu nhanh

ParameterDescribe

CountryFilter the country where the required IP is located

StateScreen the state or province where the required IP is located

CityFilter the city where the required IP is located

Hostname:portHost name and port, assigned by default

UsernameAssigned by default according to the user's login account

PasswordBy default, a password composed of letters and numbers is generated, which supports user modification

Ví dụ

C/C++
Go
Node.js
Php
JAVA
Python

                #include iostream
#include stdio.h
#include string
#include Windows.h
#include "curl/curl.h"
#pragma comment(lib, "libcurl.lib")
using namespace std;

static size_t write_buff_data(char* buffer, size_t size, size_t nitems, void* outstream)
{//Copy the received data to the cache
memcpy(outstream, buffer, nitems * size);
return nitems * size;
}
/*
Use HTTP proxy
*/
int GetUrlHTTP(char* url, char* buff)
{
CURL* curl;
CURLcode res;
curl = curl_easy_init();
if (curl)
{
    curl_easy_setopt(curl, CURLOPT_PROXY, "http://ip:port");//Set HTTP proxy address
    curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, "User name: password");//Proxy username password
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)buff);//Set Read-Write Cache
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_buff_data);//Set Callback Function
    curl_easy_setopt(curl, CURLOPT_URL, url);//Set URL address
    curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, 10L);//Sets a long integer to control how many seconds CURLOPT_LOW_SPEED_LIMIT bytes are passed
    curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, 50L);//Set a long integer to control how many bytes are transferred
    curl_easy_setopt(curl, CURLOPT_MAX_RECV_SPEED_LARGE, 2000000L);//Maximum download speed

    res = curl_easy_perform(curl);
    curl_easy_cleanup(curl);
    if (res == CURLE_OK) {
        return res;
    }
    else {
        printf("error code:%d\n", res);
        MessageBox(NULL, TEXT("Get IP Error"), TEXT("assistant"), MB_ICONINFORMATION | MB_YESNO);
    }
}
return res;
}

              

                package main
                  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 = "asg.360s5.com:3500"
                      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))
                      }
                  }

              

                const SocksProxyAgent = require("socks-proxy-agent");
const net = require("net");
const proxyHost = "proxy-server-hostname";
const proxyPort = 1080;
const proxyUsername = "your-username";
const proxyPassword = "your-password";
const agent = new SocksProxyAgent({
host: proxyHost,
port: proxyPort,
auth: `${proxyUsername}:${proxyPassword}`
});
const socket = net.connect({
host: "destination-hostname",
port: 80,
agent
});
socket.on("connect", () => {
console.log("Connected to destination server through SOCKS5 proxy.");
});
socket.on("error", err => {
console.error("Error:", err);
});
              

                <?php
$targetUrl = "https://www.google.com/";
$proxyServer = "http://asg.360s5.com:3500";
$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("asg.360s5.com", 3600));
    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("asg.360s5.com", 3600));
    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 = "asg.360s5.com"
port = 3600
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)
              