绕过 Turnstile 和 hCaptcha：保护技术和解决方法

Cloudflare Turnstile 和 hCaptcha 已成为保护网络服务免受机器人攻击的标准，取代了传统的 reCAPTCHA。这些系统分析浏览器和网络环境的多个参数，使得使用代理成为自动化的重大挑战。本文将探讨这些技术在技术层面上的工作原理，以及在通过代理工作时哪些绕过方法确实有效。

Cloudflare Turnstile 的工作原理

Cloudflare Turnstile 是一种新一代保护系统，定位为“隐形 CAPTCHA 替代品”。与经典的 reCAPTCHA 不同，Turnstile 不要求用户选择交通信号灯或人行道。相反，该系统在后台分析浏览器的行为和技术特征。

从技术上讲，Turnstile 的工作分为三个阶段。第一阶段是加载 JavaScript 小部件，该小部件通过 iframe 嵌入页面。第二阶段是收集遥测数据：系统收集有关浏览器的数据，包括 WebGL 指纹、Canvas 指纹、字体列表、屏幕分辨率、时区、系统语言和许多其他参数。第三阶段是在 Cloudflare 服务器上进行验证，收集的数据与已知的机器人和代理模式进行匹配。

Turnstile 的关键特性是使用 IP 地址的声誉系统。Cloudflare 拥有庞大的数据库，这些数据来自数百万个使用其 CDN 和 DDoS 保护的网站。如果 IP 地址被发现存在可疑活动，Turnstile 的通过概率将急剧下降。这给代理用户带来了第一个问题——即使是干净的住宅 IP 也可能由于前任所有者而声誉不佳。

hCaptcha 技术和检测方法

hCaptcha 作为 Google reCAPTCHA 的竞争者出现，强调隐私和通过机器学习进行货币化。该系统允许网站所有者支付使用用户数据来训练 AI 模型。从技术角度来看，hCaptcha 在检测自动化方面比 Turnstile 更具侵略性。

hCaptcha 的主要工作机制包括多个保护层。第一层是网络参数检查：系统分析数据包的 TTL、网络延迟、IP 地址的地理位置一致性和浏览器声明的时区。第二层是 JavaScript 调用：hCaptcha 检查 Web API 的存在和正确性，包括 WebRTC、Battery API、Sensor API。第三层是对鼠标移动、滚动速度和点击模式的行为分析。

hCaptcha 的特性是使用基于挑战的检查。如果系统怀疑是机器人，它会显示视觉任务：选择带有特定对象的图像、解决难题、识别扭曲图像上的文本。每次失败尝试时，任务的难度会动态增加。对于代理用户来说，这意味着即使有正确的指纹，也可能会得到无尽的验证码链。

浏览器指纹识别和代理

浏览器指纹识别是一种通过浏览器和设备的独特特征组合来识别用户的技术。即使您使用代理更改 IP 地址，指纹仍然保持不变，并可能暴露出自动化的使用。现代保护系统收集 50 到 200+ 个参数来创建指纹。

指纹的主要组成部分包括：Canvas 指纹（依赖于 GPU 和驱动程序的独特图形渲染）、WebGL 指纹（图形加速器的参数）、音频上下文指纹（音频处理的特征）、已安装字体列表、屏幕参数（分辨率、色深、像素比）、用户代理和浏览器头、语言设置、时区、插件和扩展的存在。

对于代理用户来说，问题在于不一致。例如，如果您的 IP 地址显示在德国的位置，而浏览器的时区设置为莫斯科——这是一个红旗。如果 WebRTC 泄漏揭示了您真实的 IP 地址，与代理不同——系统会立即识别出替换。如果用户代理声明为 Windows，但 Canvas 指纹与 Linux 匹配——检测是必然的。

// 基本指纹收集示例
const fingerprint = {
  canvas: getCanvasFingerprint(),
  webgl: getWebGLFingerprint(),
  fonts: getFonts(),
  screen: {
    width: screen.width,
    height: screen.height,
    colorDepth: screen.colorDepth,
    pixelRatio: window.devicePixelRatio
  },
  timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
  language: navigator.language,
  platform: navigator.platform,
  hardwareConcurrency: navigator.hardwareConcurrency,
  deviceMemory: navigator.deviceMemory,
  webrtc: await getWebRTCIPs()
};

function getCanvasFingerprint() {
  const canvas = document.createElement('canvas');
  const ctx = canvas.getContext('2d');
  ctx.textBaseline = 'top';
  ctx.font = '14px Arial';
  ctx.fillText('浏览器指纹', 2, 2);
  return canvas.toDataURL();
}

代理服务器的检测方法

保护系统使用多种技术来检测代理。第一种方法是检查已知代理和 VPN 的数据库。像 IPHub、IP2Proxy、MaxMind GeoIP2 这样的服务包含数百万个被分类为代理、VPN、托管提供商的 IP 地址。Cloudflare 和 hCaptcha 与这些数据库集成，并自动提高对可疑 IP 的检查级别。

第二种方法是分析 ASN（自治系统编号）。数据中心代理通常属于托管提供商（AWS、DigitalOcean、OVH），这可以通过 ASN 容易识别。住宅代理使用普通互联网服务提供商（Comcast、Verizon、Deutsche Telekom）的 ASN，使其不那么可疑。然而，即使是住宅网络也可能部分被攻破，如果提供商以销售代理而闻名。

第三种方法是网络级行为分析。系统跟踪异常：数据包的 TTL 过低或过高、不典型的延迟、使用非标准端口、地理位置和路由路径不一致。例如，如果 IP 地址地理定位在美国，但 traceroute 显示通过欧洲服务器的路径——这是代理的迹象。

住宅代理作为基本解决方案

住宅代理 是绕过 Turnstile 和 hCaptcha 的基础。与数据中心代理不同，住宅代理使用真实设备的 IP 地址：家庭路由器、手机、物联网设备。这使得它们在网络基础设施的角度上几乎无法与普通用户区分。

绕过验证码的住宅代理的关键优势：属于 ISP（互联网服务提供商），而不是托管提供商；在大多数情况下，IP 地址的声誉良好；正确的地理定位和路由；被列入黑名单的可能性低。然而，并非所有住宅代理都同样有效。有几个关键因素至关重要。

第一个因素是 IP 地址的轮换。静态住宅代理（粘性会话）允许使用一个 IP 从几分钟到几小时。这对于需要保持会话的场景是最佳的：授权、填写表单、多步骤操作。轮换代理在每个请求或定时器上更改 IP，这对解析很有用，但由于频繁更改上下文可能会导致验证码问题。

第二个因素是地理分布。为了绕过验证码，IP 的地理位置必须与网站的目标和浏览器的设置相匹配。如果您在处理德国网站，请使用德国住宅代理，并在浏览器中设置相应的时区（Europe/Berlin）、语言（de-DE）和区域。

第三个因素是代理提供商的质量。便宜的住宅代理通常通过可疑的方法收集（免费 VPN 应用程序、感染的设备），导致 IP 池的声誉低下。专业提供商与合法的 SDK 合作伙伴关系合作，并仔细监控网络质量。在扩展之前，请检查提供商在目标网站上的成功率。

自动化工具：Selenium、Puppeteer、Playwright

自动化工具的选择对绕过验证码的能力有重大影响。Selenium、Puppeteer 和 Playwright 是三种主要解决方案，每种都有其检测特性。保护系统能够通过数十个特征识别这些工具的使用。

Selenium 是最古老且最容易被检测到的工具。由 Selenium 控制的浏览器具有明显的标记：变量 window.navigator.webdriver 被设置为 true，缺少某些特定于自动化的 navigator 对象属性，浏览器窗口的特定大小。即使使用代理，Selenium 通常在没有额外混淆的情况下失败 Turnstile 和 hCaptcha 的检查。

Puppeteer 和 Playwright 是基于 Chrome DevTools 协议的更现代工具。它们也会被检测到，但具有较少的明显特征。主要的检测方法：检查 chrome.runtime，分析 permissions API，通过缺少插件和特定的视口大小检测无头模式，通过时间攻击检查 DevTools 的存在。

// 使用代理和反检测的 Puppeteer 基本设置
const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');

puppeteer.use(StealthPlugin());

const browser = await puppeteer.launch({
  headless: false, // headless: true 容易被检测到
  args: [
    '--proxy-server=http://your-proxy:port',
    '--disable-blink-features=AutomationControlled',
    '--disable-dev-shm-usage',
    '--no-sandbox',
    '--disable-setuid-sandbox',
    '--disable-web-security',
    '--disable-features=IsolateOrigins,site-per-process',
    `--window-size=1920,1080`,
    '--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
  ]
});

const page = await browser.newPage();

// 代理认证
await page.authenticate({
  username: 'proxy_user',
  password: 'proxy_pass'
});

// 重定义 webdriver 属性
await page.evaluateOnNewDocument(() => {
  Object.defineProperty(navigator, 'webdriver', {
    get: () => false
  });
  
  // 为无头模式仿真插件
  Object.defineProperty(navigator, 'plugins', {
    get: () => [1, 2, 3, 4, 5]
  });
});

对于严肃的验证码绕过，建议使用专门的反检测浏览器：Multilogin、GoLogin、AdsPower、Dolphin Anty。这些解决方案创建具有独特指纹的隔离浏览器配置文件，管理 cookies 和会话存储，自动将时区与代理的地理位置同步，仿真真实的 Canvas 和 WebGL 指纹。

验证码解决服务：集成和效率

当技术方法不足时，验证码解决服务提供帮助。它们分为两种类型：人工（众包）和自动（机器学习）。对于 Turnstile 和 hCaptcha，效率有所不同。

人工服务（2Captcha、AntiCaptcha、CapSolver、CapMonster Cloud）按照分布式劳动的原则工作：您的验证码被发送给真实的人，由他们手动解决。优点：高成功率（hCaptcha 为 95-99%，Turnstile 为 85-95%），支持复杂的视觉任务，相对稳定。缺点：解决速度为 10-60 秒，成本为每 1000 个验证码 $1-3，依赖于操作员的可用性。

自动服务使用 AI 模型进行识别。它们更快（1-5 秒）且更便宜，但对于现代验证码的成功率较低——通常 hCaptcha 为 60-80%，Turnstile 为 50-70%。对于简单的基于挑战的任务有效，但在不可见的检查上经常失败。

// 集成 2Captcha 解决 hCaptcha
const axios = require('axios');

async function solveHCaptcha(sitekey, pageUrl, proxyConfig) {
  const API_KEY = 'your_2captcha_api_key';
  
  // 发送任务
  const createTask = await axios.post('https://2captcha.com/in.php', null, {
    params: {
      key: API_KEY,
      method: 'hcaptcha',
      sitekey: sitekey,
      pageurl: pageUrl,
      proxy: `${proxyConfig.type}:${proxyConfig.host}:${proxyConfig.port}:${proxyConfig.user}:${proxyConfig.pass}`,
      json: 1
    }
  });
  
  const taskId = createTask.data.request;
  
  // 等待解决
  let solution = null;
  for (let i = 0; i < 60; i++) {
    await new Promise(resolve => setTimeout(resolve, 3000));
    
    const result = await axios.get('https://2captcha.com/res.php', {
      params: {
        key: API_KEY,
        action: 'get',
        id: taskId,
        json: 1
      }
    });
    
    if (result.data.status === 1) {
      solution = result.data.request;
      break;
    }
  }
  
  return solution; // 用于插入表单的令牌
}

// 在 Puppeteer 中使用
const captchaToken = await solveHCaptcha(
  'site-key-from-page',
  'https://example.com',
  { type: 'http', host: 'proxy.example.com', port: 8080, user: 'user', pass: 'pass' }
);

await page.evaluate((token) => {
  document.querySelector('[name="h-captcha-response"]').value = token;
  document.querySelector('[name="g-recaptcha-response"]').value = token;
}, captchaToken);

在验证码解决服务中传递正确的代理参数至关重要。如果验证码在一个 IP 上解决，然后令牌在另一个 IP 上使用——验证将失败。现代验证码将令牌绑定到 IP 地址、用户代理和其他会话参数。

高级技术：设备仿真和 TLS 指纹识别

绕过最受保护的系统需要超出基本代理和浏览器设置的高级技术。两个关键领域是移动设备仿真和 TLS 指纹管理。

移动代理 与移动浏览器仿真结合，对抗验证码的效率很高。原因：移动流量具有更高的信任评分，移动 IP 地址（尤其是 4G/5G）通常是动态的，并自然变化，移动设备具有不同的指纹参数，许多网站对移动用户简化检查。

为了正确仿真移动设备，需要：使用移动用户代理（准确匹配设备型号），设置正确的视口和 devicePixelRatio，仿真触摸事件而不是鼠标事件，使用移动值的 navigator.platform 和 navigator.maxTouchPoints，调整 WebGL 和 Canvas 指纹以适应特定设备型号。

// 在 Playwright 中仿真 iPhone 13 Pro
const { chromium, devices } = require('playwright');

const iPhone13Pro = devices['iPhone 13 Pro'];

const browser = await chromium.launch({
  proxy: {
    server: 'http://mobile-proxy:port',
    username: 'user',
    password: 'pass'
  }
});

const context = await browser.newContext({
  ...iPhone13Pro,
  locale: 'en-US',
  timezoneId: 'America/New_York',
  geolocation: { latitude: 40.7128, longitude: -74.0060 },
  permissions: ['geolocation']
});

const page = await context.newPage();

// 额外的指纹设置
await page.addInitScript(() => {
  Object.defineProperty(navigator, 'hardwareConcurrency', {
    get: () => 6 // iPhone 13 Pro 具有 6 核心
  });
  
  Object.defineProperty(navigator, 'deviceMemory', {
    get: () => 6 // 6GB RAM
  });
});

TLS 指纹识别是通过 TLS/SSL 连接的参数识别客户端的方法。每个浏览器和操作系统都有独特的密码套件、扩展、椭圆曲线组合，这些组合在建立 HTTPS 连接时传递。保护系统分析 TLS 指纹并将其与声明的用户代理进行比较。

标准自动化工具的问题是，它们使用基础 Chromium 的 TLS 指纹，这与完整的 Chrome 不同。这种不一致会被检测到。解决方案：使用像 curl-impersonate 或 Python 的 tls-client 这样的库，仿真特定浏览器的 TLS 指纹；使用自定义 TLS 的 HTTP 客户端（例如，Node.js 的 cycletls）；使用完整的浏览器而不是无头模式。

代码示例

让我们考虑一个完整的绕过 Turnstile 的示例，使用 Playwright、住宅代理和反检测技术。此代码演示了解决问题的综合方法。

const { chromium } = require('playwright-extra');
const stealth = require('puppeteer-extra-plugin-stealth')();

// 代理配置
const proxyConfig = {
  server: 'http://residential-proxy.proxycove.com:8080',
  username: 'your_username',
  password: 'your_password'
};

// 模拟来自德国的真实用户的设置
const userConfig = {
  viewport: { width: 1920, height: 1080 },
  userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
  locale: 'de-DE',
  timezoneId: 'Europe/Berlin',
  geolocation: { latitude: 52.5200, longitude: 13.4050 }, // 柏林
  permissions: ['geolocation']
};

async function bypassTurnstile(url) {
  const browser = await chromium.launch({
    headless: false, // 对于复杂的验证码很重要
    proxy: proxyConfig,
    args: [
      '--disable-blink-features=AutomationControlled',
      '--no-sandbox',
      '--disable-dev-shm-usage'
    ]
  });

  const context = await browser.newContext({
    ...userConfig,
    // 额外的头部
    extraHTTPHeaders: {
      'Accept-Language': 'de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7',
      'Accept-Encoding': 'gzip, deflate, br',
      'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
      'DNT': '1',
      'Connection': 'keep-alive',
      'Upgrade-Insecure-Requests': '1'
    }
  });

  const page = await context.newPage();

  // 注入反检测脚本
  await page.addInitScript(() => {
    // 隐藏 webdriver
    Object.defineProperty(navigator, 'webdriver', {
      get: () => undefined
    });

    // 模拟 chrome runtime
    window.chrome = {
      runtime: {}
    };

    // 重定义 permissions
    const originalQuery = window.navigator.permissions.query;
    window.navigator.permissions.query = (parameters) => (
      parameters.name === 'notifications' ?
        Promise.resolve({ state: Notification.permission }) :
        originalQuery(parameters)
    );

    // 更真实的 Windows 值
    Object.defineProperty(navigator, 'platform', {
      get: () => 'Win32'
    });

    Object.defineProperty(navigator, 'hardwareConcurrency', {
      get: () => 8
    });

    Object.defineProperty(navigator, 'deviceMemory', {
      get: () => 8
    });
  });

  // 模拟人类行为
  async function humanLikeDelay(min = 1000, max = 3000) {
    const delay = Math.random() * (max - min) + min;
    await page.waitForTimeout(delay);
  }

  async function humanLikeMouseMove() {
    const viewportSize = page.viewportSize();
    const x = Math.random() * viewportSize.width;
    const y = Math.random() * viewportSize.height;
    await page.mouse.move(x, y, { steps: 10 });
  }

  try {
    // 访问页面
    await page.goto(url, { waitUntil: 'networkidle' });
    
    await humanLikeDelay(2000, 4000);
    await humanLikeMouseMove();

    // 等待 Turnstile 加载
    await page.waitForSelector('iframe[src*="turnstile"]', { timeout: 10000 });
    
    console.log('检测到 Turnstile，等待自动解决...');
    
    // Turnstile 在 managed 模式下通常会自动解决
    // 等待令牌出现
    await page.waitForFunction(() => {
      const response = document.querySelector('[name="cf-turnstile-response"]');
      return response && response.value.length > 0;
    }, { timeout: 30000 });

    console.log('成功通过 Turnstile！');
    
    // 在网站上的后续操作
    await humanLikeDelay();
    
    // 示例：填写表单
    await page.fill('#email', 'user@example.com');
    await humanLikeDelay(500, 1500);
    
    await page.fill('#password', 'SecurePassword123');
    await humanLikeDelay(500, 1500);
    
    await humanLikeMouseMove();
    await page.click('button[type="submit"]');
    
    await page.waitForNavigation({ waitUntil: 'networkidle' });
    
    console.log('授权成功');

  } catch (error) {
    console.error('绕过 Turnstile 时出错：', error.message);
    
    // 调试截图
    await page.screenshot({ path: 'turnstile_error.png', fullPage: true });
    
  } finally {
    await browser.close();
  }
}

// 启动
bypassTurnstile('https://example.com/login');

对于具有视觉任务的 hCaptcha，需要集成解决服务。以下是使用 2Captcha 的示例：

const axios = require('axios');

class HCaptchaSolver {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://2captcha.com';
  }

  async solve(sitekey, pageUrl, proxy = null) {
    // 创建任务
    const params = {
      key: this.apiKey,
      method: 'hcaptcha',
      sitekey: sitekey,
      pageurl: pageUrl,
      json: 1
    };

    if (proxy) {
      params.proxy = `${proxy.type}:${proxy.host}:${proxy.port}:${proxy.username}:${proxy.password}`;
      params.proxytype = proxy.type.toUpperCase();
    }

    const createResponse = await axios.post(`${this.baseUrl}/in.php`, null, { params });
    
    if (createResponse.data.status !== 1) {
      throw new Error(`创建任务时出错：${createResponse.data.request}`);
    }

    const taskId = createResponse.data.request;
    console.log(`任务已创建：${taskId}`);

    // 轮询结果
    for (let attempt = 0; attempt < 60; attempt++) {
      await new Promise(resolve => setTimeout(resolve, 5000));

      const resultResponse = await axios.get(`${this.baseUrl}/res.php`, {
        params: {
          key: this.apiKey,
          action: 'get',
          id: taskId,
          json: 1
        }
      });

      if (resultResponse.data.status === 1) {
        console.log('hCaptcha 已解决！');
        return resultResponse.data.request;
      }

      if (resultResponse.data.request !== 'CAPCHA_NOT_READY') {
        throw new Error(`解决时出错：${resultResponse.data.request}`);
      }

      console.log(`尝试 ${attempt + 1}/60：验证码仍在解决中...`);
    }

    throw new Error('超时：验证码在 5 分钟内未解决');
  }
}

// 在 Playwright 中使用
async function bypassHCaptcha(page, proxyConfig) {
  // 从页面获取 sitekey
  const sitekey = await page.getAttribute('[data-sitekey]', 'data-sitekey');
  const pageUrl = page.url();

  const solver = new HCaptchaSolver('your_2captcha_api_key');
  
  const token = await solver.solve(sitekey, pageUrl, {
    type: 'http',
    host: 'residential-proxy.proxycove.com',
    port: 8080,
    username: 'your_username',
    password: 'your_password'
  });

  // 将令牌注入页面
  await page.evaluate((captchaToken) => {
    document.querySelector('[name="h-captcha-response"]').value = captchaToken;
    
    // 对于某些网站，还需要 g-recaptcha-response
    const gRecaptcha = document.querySelector('[name="g-recaptcha-response"]');
    if (gRecaptcha) {
      gRecaptcha.value = captchaToken;
    }
    
    // 触发回调事件
    const event = new Event('change', { bubbles: true });
    document.querySelector('[name="h-captcha-response"]').dispatchEvent(event);
  }, token);

  console.log('hCaptcha 令牌已注入');
}

结论

通过代理绕过 Turnstile 和 hCaptcha 是一项复杂的任务，需要理解保护机制和技术的合理组合。关键结论：使用高质量的 住宅 或 移动代理 而不是数据中心代理；同步所有环境参数（IP 地理位置、时区、语言、区域）；应用反检测技术以隐藏自动化；仿真真实的人类行为；将验证码解决服务作为额外的保护层。

方法的有效性取决于具体网站和保护设置。建议从基本配置开始，逐步复杂化，同时监控成功率。在扩展之前，先在小规模上进行测试，以避免 IP 池被封锁。定期更新指纹参数和用户代理以适应浏览器的最新版本。

对于专业的验证码处理，考虑使用专门的自动化平台，这些平台将代理、反检测浏览器和解决服务整合为一个生态系统。这降低了集成的复杂性，提高了结果的稳定性。开始时 测试高质量的代理 在您的目标网站上——这是成功绕过现代保护系统的基础。