How to Use PrivateProxy.me Backconnect Proxy

如何使用 PrivateProxy.me Backconnect 代理服务器

12 月 12, 2023 / 5 阅读分钟

您知道如何使用 PrivateProxy.me Backconnect 代理服务器？这是 PrivateProxy.me 官方最全面的介绍。

不同语言的用法示例

在 *nix shell 中使用 curlPython 3 + 请求PHP + libcurlNode.js + stdlibRuby + stdlibGolang + stdlibC# + stdlib
curl -x http://login:[email protected]:5432 http://api.privateproxy.me:10738 #1.1.1.1
导入请求
代理服务器 = {
  'http'：http://login:[email protected]:5432'、
  https': 'http://login:[email protected]:5432'.
}
response = requests.get('http://api.privateproxy.me:10738', proxies=proxies)
// response.text = "1.1.1.1\\n"
$ch = curl_init()；
curl_setopt($ch, CURLOPT_URL, "http://api.privateproxy.me:10738")；
curl_setopt($ch, CURLOPT_PROXY, "1.1.1.1:5432")；
curl_setopt($ch, CURLOPT_PROXYUSERPWD, "login:password")；
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1)；
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1)；
curl_setopt($ch, CURLOPT_HEADER, 1)；
$curl_scraped_page = curl_exec($ch)；
curl_close($ch)；

echo $curl_scraped_page; // "1.1.1.1\\n"
const http = require('http');
const https = require('https');

function getWithProxy(url, proxy) {
  const parsedUrl = new URL(url);
  const proxy_ip = proxy['ip']
  const proxy_port = proxy['port']
  const proxy_auth = 'Basic ' + Buffer.from(proxy['login'] + ':' + proxy['password']).toString('base64')

  let host = parsedUrl.hostname;
  if (parsedUrl.port !== '') {
    host += ':' + parsedUrl.port;
  } else {
    if (parsedUrl.protocol == 'http:') {
      host += ':80';
    } else if(parsedUrl.protocol == 'https:') {
      host += ':443';
    }
  }
  const res = new Promise((resolve, reject) => {
    http.request({
      port:   proxy_port,
      host:   proxy_ip,
      method: 'CONNECT',
      path:   host,
      headers: {
        'Host': host,
        'Proxy-Authorization': proxy_auth
      }
    }).on('connect', (res, socket, head) => {
      if (res.statusCode !== 200) {
        reject(new Error(`Non-200 status code returned from proxy: ${res.statusCode} ${res.statusMessage}`));
        return;
      }
      let t, real_opts = {};
      if (parsedUrl.protocol == "http:") {
        real_opts['createConnection'] = () => socket
        t = http;
      } else {
        real_opts['socket'] = socket;
        t = https;
      }
      const real_req = t.request(url, real_opts, (res) => {
        res.setEncoding('utf-8')
        let rawData = []
        res.on('data', (chunk) => rawData.push(chunk));
        res.on('end', () => resolve(rawData.join('')));
      });
      real_req.on('error', (e) => reject(e));
      real_req.end();
    }).end();
  });

  return res;
}

getWithProxy("https://httpbin.org/ip", {
  ip: '1.1.1.1',
  port: 5432,
  login: 'login',
  password: 'password'
}).then(
    (data) => console.log(data.trim()),
    (e) => console.log("Error: " + e.toString())
).then(
  () => getWithProxy("http://api.privateproxy.me:10738", {
    ip: '1.1.1.1',
    port: 5432,
    login: 'login',
    password: 'password'
  })
).then(
  (data) => console.log(data.trim()),
  (e) => console.log("Error: " + e.toString())
)
需要 "net/http

resp = Net::HTTP.start("api.privateproxy.me", 10738, "1.1.1.1", "5432", "login", "password") do |h|
  request = Net::HTTP::Get.new('/')
  h.request(request)
结束

puts resp.body # "1.1.1.1\\n"
主包

导入 (
  "fmt"
  "io/ioutil"
  "net/http"
  "net/url"
  "时间"
)

func main() {
  proxy, err := url.Parse("http://login:[email protected]:5432")
  if err != nil {
    返回
  }
  proxyFunc := http.ProxyURL(proxy)
  tr := &http.Transport{
    MaxIdleConns：       10,
    IdleConnTimeout：    30 * time.Second、
    DisableCompression: true、
    代理：proxyFunc、
  }
  客户端 := &http.Client{
    Transport: tr、
  }
  resp, err := client.Get("http://api.privateproxy.me:10738")
  if err != nil {
    返回
  }
  defer resp.Body.Close()
  bytes, err := ioutil.ReadAll(resp.Body)
  if err != nil {
    返回
  }
  fmt.Print(string(bytes))// "1.1.1.1\\n"
}
var handler = new HttpClientHandler()；
handler.Proxy = new WebProxy("http://login:[email protected]:5432/")；

using (var httpClient = new HttpClient(handler))
{
  using (var request = new HttpRequestMessage(new HttpMethod("GET"), "http://api.privateproxy.me:10738"))
  {
    var response = await httpClient.SendAsync(request)；
    // response.Content - "1.1.1.1\\n"
  }
}

http://api.privateproxy.me:10738 - 以文本模式显示您当前的 IP 地址

使用反向连接代理与使用普通代理没有区别。Backconnect 代理服务器的作用与普通代理服务器相同，只是目标网站看到的 IP 地址不同，具体取决于交换间隔设置/手动交换。

如果您已将自己的 IP 地址添加到授权 IP 列表中，则无需指定证书。授权 IP 并不是强制性的，您可以继续使用证书授权，哪种方式更方便都可以。

如果您要编写自己的软件来访问某个网站，请添加 User-Agent 等标头，以便请求看起来像是来自浏览器。

浏览器使用建议

  • 关闭 WebRTC，因为即使使用代理服务器，它也会破坏你的真实 IP 地址，甚至你的本地内网 IP 地址。这里有一个针对不同浏览器的禁用指南链接： https://www.vpnunlimitedapp.com/blog/how-to-disable-webrtc-in-chrome-and-other-browsers
  • 使用 Chrome 浏览器的 ghostery 等禁用跟踪器插件，网站仍能通过浏览器指纹识别你的身份。
  • 如果可能，将本地计算机时间设置为代理服务器时区。
  • 如果使用 backconnect，最好将交换时间间隔设置为 5 分钟或更长，这样就不会经常出现 IP 变更。

使用 Python-Selenium 代理

python-selenium + Firefox(geckodriver)

要在 firefox 中使用 selenium，你需要安装这些项目：

如果使用凭据认证，还需要

例如，使用代理凭据：

from seleniumwire import webdriver
from selenium.webdriver.firefox.firefox_binary import FirefoxBinary
from selenium.webdriver.firefox.options import Options
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

path_to_firefox_binary = '' # !!! 设置此变量 !!!
path_too_geckodriver_binary = '' # !!! 设置此变量 !!!

wire_options = {
  代理'：{
    'http'：http://login:[email protected]:5432'、
    https': 'http://login:[email protected]:5432'、
    no_proxy'：localhost,127.0.0.1'。
  }
}
binary = FirefoxBinary(path_to_firefox_binary)

options = Options()
options.headless = True
browser = webdriver.Firefox(
  options=options、
  firefox_binary=binary、
  executable_path=path_to_geckodriver_binary、
  seleniumwire_options=wire_options
)

browser.get("http://api.privateproxy.me:10738")
element = WebDriverWait(browser, 10).until(
  EC.visibility_of_element_located((By.CSS_SELECTOR, "pre"))
)
print(element.text)
browser.quit()

使用 IP 授权的示例：

from selenium import webdriver
from selenium.webdriver.firefox.firefox_binary import FirefoxBinary
from selenium.webdriver.firefox.options import Options
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

path_to_firefox_binary = '' # !!! 设置此变量 !!!
path_too_geckodriver_binary = '' # !!! 设置此变量 !!!
proxy_ip = '1.1.1.1'
代理端口 = 5432

profile = webdriver.FirefoxProfile()
profile.set_preference("network.proxy.type", 1)
profile.set_preference("network.proxy.http", proxy_ip)
profile.set_preference("network.proxy.http_port", proxy_port)
profile.set_preference("network.proxy.ssl", proxy_ip)
profile.set_preference("network.proxy.ssl_port", proxy_port)
profile.update_preferences()

binary = FirefoxBinary(path_to_firefox_binary)
options = Options()
options.headless = True
浏览器 = webdriver.Firefox(
  options=options、
  firefox_binary=binary、
  executable_path=path_to_geckodriver_binary、
  firefox_profile=profile
)
browser.get("http://api.privateproxy.me:10738")
element = WebDriverWait(browser, 10).until(
  EC.visibility_of_element_located((By.CSS_SELECTOR, "pre"))
)
print(element.text)
browser.quit()

这两个示例都以无头模式启动 firefox，因此在执行这些示例时浏览器将保持隐藏状态。

python-selenium + Chrome(chromedriver)

要在 Chrome 浏览器中使用硒，你需要安装这些项目：

使用凭证授权的示例：

导入 os
导入 zipfile
导入 hashlib
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

proxy = "1.1.1.1:5432" 代理
凭证 = "login:password"
path_to_chrome_binary = '' !!! 设置此变量 !!!
path_too_chromedriver_binary = '' !!! 设置此变量!!!

def generate_extension(proxy, credentials)：
  IP、端口 = proxy.split(':')
  login, password = credentials.split(':')
  manifest_json = """
  {
      版本"1.0.0",
      "manifest_version"：2,
      "名称"："Chrome 代理"、
      "权限"： [[
          "代理"、
          "选项卡"、
          "unlimitedStorage"、
          "存储"、
          "",
          "网络请求"、
          "网络请求阻塞"
      ],
      "背景"：{
          "脚本"：["background.js"]
      },
      "minimum_chrome_version":"22.0.0"
  }
  """

  background_js = """
  var config = {
          mode："fixed_servers"、
          rules：{
          singleProxy：{
              scheme："http"、
              host: "%s"、
              port: parseInt(%s)
          },
          bypassList：["localhost"]（本地主机
          }
      };

  chrome.proxy.settings.set({value: config, scope："regular"}, function() {})；

  function callbackFn(details) {
      返回 {
          authCredentials：{
              username: "%s"、
              password: "%s".
          }
      };
  }

  chrome.webRequest.onAuthRequired.addListener(
              callbackFn、
              {urls：[""]},
              ['阻塞']
  );
  """% （IP、端口、登录名、密码）

  sha1 = hashlib.sha1()
  sha1.update(("%s:%s" % (proxy, credentials)).encode('utf-8'))
  文件名 = sha1.hexdigest() + ".zip"

  with zipfile.ZipFile(filename, 'w') as zp：
    zp.writestr("manifest.json", manifest_json)
    zp.writestr("background.js", background_js)

  返回文件名

extension_name = generate_extension(proxy, credentials)
options = Options()
options.binary_location = path_to_chrome_binary
options.add_extension(extension_name)
驱动程序 = webdriver.Chrome(
  executable_path = path_to_chromedriver_binary、
  options=options、
)
driver.get('http://api.privateproxy.me:10738/')
element = WebDriverWait(driver, 30).until(
  EC.visibility_of_element_located((By.CSS_SELECTOR, "pre"))
)
print(element.text)
driver.quit()
os.remove(extension_name)

遗憾的是，在使用凭证时存在一些限制：

  • 没有无头模式
  • 必须为每个代理 + 凭据集生成并存储扩展名。我们找不到更简单的方法。

使用 ip 授权的示例：

from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

path_too_chrome_binary = '' # !!! 设置此变量 !!!
path_too_chromedriver_binary = '' # !!! 设置此变量 !!!
代理 = "1.1.1.1:5432"

options = Options()
options.binary_location = path_to_chrome_binary
options.headless = True
options.add_argument("--proxy-server=%s" % proxy)

驱动程序 = webdriver.Chrome(
  executable_path = path_to_chromedriver_binary、
  options=options、
)
driver.get('http://api.privateproxy.me:10738/')
element = WebDriverWait(driver, 30).until(
  EC.visibility_of_element_located((By.CSS_SELECTOR, "pre"))
)
print(element.text)
driver.quit()

使用 Node.JS Puppeteer 代理

Puppeteer + Node.js + chrome 浏览器

目前，我们只有一个如何在 puppeteer 和 Chrome 浏览器中使用代理的示例。

为此，您需要在安装 puppeteer 时使用环境变量 PUPPETEER_PRODUCT=chrome：

PUPPETEER_PRODUCT=chrome npm install puppeteer

您还需要代理链软件包：

npm install proxy-chain

代码示例

const puppeteer = require('puppeteer')；
const proxyChain = require('proxy-chain')；

(async() => {
  const oldProxyUrl = 'http://login:[email protected]:5432'；
  const newProxyUrl = await proxyChain.anonymizeProxy(oldProxyUrl)；

  const browser = await puppeteer.launch({
    args: [`--proxy-server=${newProxyUrl}`]、
  });

  const page = await browser.newPage()；
  await page.goto('https://httpbin.org/ip')；
  const element = await page.$('pre')；
  const text = await page.evaluate(element => element.textContent, element)；
  console.log(text)；
  await browser.close()；

  await proxyChain.closeAnonymizedProxy(newProxyUrl, true)；
})();

最后更新于 2023 年 12 月 12 日

您推荐代理服务吗？

点击奖杯即可颁奖！

平均评分 0 /5.计票： 0

目前没有投票！成为第一个给本帖评分的人。

相关帖子

发表评论

您的电子邮箱地址不会被公开。 必填项已用*标注

zh_CNChinese
en_USEnglish zh_CNChinese
滚动到顶部