@wenathlan/saddle 1.8.2 → 1.8.5

package/docs/plans/13.research.anti.detection.md

@@ -0,0 +1,898 @@
+# Pesquisa: Anti-Detection e Stealth para Web Scraping (2026)
+
+## Sumário
+
+1. [Stealth Plugins: playwright-extra e puppeteer-extra-plugin-stealth](#1-stealth-plugins)
+2. [Módulos de Evasão](#2-módulos-de-evasão)
+3. [Status Atual em 2026](#3-status-atual-em-2026)
+4. [Sinais de Fingerprinting de Navegador](#4-sinais-de-fingerprinting-de-navegador)
+5. [Bibliotecas de Navegador Modificadas](#5-bibliotecas-de-navegador-modificadas)
+6. [Benchmark Comparativo](#6-benchmark-comparativo)
+7. [Rotação de Fingerprinting com Crawlee](#7-rotação-de-fingerprinting-com-crawlee)
+8. [TLS Fingerprinting: JA3 vs JA4](#8-tls-fingerprinting-ja3-vs-ja4)
+9. [Stack Recomendado](#9-stack-recomendado)
+10. [Tabela de Pacotes npm](#10-tabela-de-pacotes-npm)
+
+---
+
+## 1. Stealth Plugins: playwright-extra e puppeteer-extra-plugin-stealth
+
+### playwright-extra
+
+Fork do Playwright que adiciona suporte a plugins de extensão. Permite carregar plugins de stealth como camada de modificação antes de iniciar o navegador.
+
+```javascript
+import { chromium } from 'playwright-extra';
+import StealthPlugin from 'puppeteer-extra-plugin-stealth';
+
+chromium.use(StealthPlugin());
+
+const browser = await chromium.launch({ headless: true });
+const page = await browser.newPage();
+await page.goto('https://bot.sannysoft.com');
+```
+
+**Características:**
+- Compatível com a API do Playwright
+- Plugins são aplicados antes do launch do navegador
+- Pode combinar múltiplos plugins
+- Suporta both `chromium` e `firefox`
+
+### puppeteer-extra-plugin-stealth
+
+Plugin que aplica patches em múltiplas APIs do navegador para evitar detecção. Funciona camuflando sinais que bots comumente expõem.
+
+**Como funciona:**
+1. Injeta scripts de evasão via CDP (Chrome DevTools Protocol)
+2. Modifica `navigator`, `window`, e outros objetos antes da detecção
+3. Executa patches em tempo real durante a navegação
+4. Intercepta e modifica respostas de APIs sensíveis
+
+```javascript
+import puppeteer from 'puppeteer-extra';
+import StealthPlugin from 'puppeteer-extra-plugin-stealth';
+
+puppeteer.use(StealthPlugin());
+
+const browser = await puppeteer.launch({ headless: 'new' });
+const page = await browser.newPage();
+await page.goto('https://nowsecure.nl');
+```
+
+---
+
+## 2. Módulos de Evasão
+
+O `puppeteer-extra-plugin-stealth` inclui os seguintes módulos:
+
+### 2.1 chrome.app
+
+**Objetivo:** Simula o objeto `chrome.app` que está presente em navegadores Chrome reais mas ausente em headless.
+
+```javascript
+// Patch aplicado:
+window.chrome = window.chrome || {};
+window.chrome.app = {
+  isInstalled: false,
+  InstallState: { DISABLED: 'disabled', INSTALLED: 'installed', NOT_INSTALLED: 'not_installed' },
+  RunningState: { CANNOT_RUN: 'cannot_run', READY_TO_RUN: 'ready_to_run', RUNNING: 'running' },
+  getDetails: () => null,
+  getIsInstalled: () => false,
+  installState: () => 'not_installed',
+  run: () => {}
+};
+```
+
+### 2.2 chrome.csi
+
+**Objetivo:** Simula o objeto `chrome.csi` que fornece informações de performance do carregamento.
+
+```javascript
+window.chrome.csi = () => ({
+  onloadT: Date.now(),
+  startE: Date.now(),
+  pageT: performance.now(),
+  tran: 15
+});
+```
+
+### 2.3 chrome.loadTimes
+
+**Objetivo:** Simula `chrome.loadTimes()` que retorna timestamps de carregamento.
+
+```javascript
+window.chrome.loadTimes = () => ({
+  commitLoadTime: performance.timing.responseStart / 1000,
+  connectionInfo: 'h2',
+  finishDocumentLoadTime: performance.timing.domContentLoadedEventEnd / 1000,
+  finishLoadTime: performance.timing.loadEventEnd / 1000,
+  firstPaintAfterLoadTime: 0,
+  firstPaintTime: performance.timing.domContentLoadedEventEnd / 1000,
+  navigationType: 'Other',
+  npnNegotiatedProtocol: 'h2',
+  requestTime: performance.timing.navigationStart / 1000,
+  startLoadTime: performance.timing.navigationStart / 1000,
+  wasAlternateProtocolAvailable: false,
+  wasFetchedViaSpdy: true,
+  wasNpnNegotiated: true
+});
+```
+
+### 2.4 chrome.runtime
+
+**Objetivo:** Simula `chrome.runtime` para parecer extensão Chrome legítima.
+
+```javascript
+window.chrome.runtime = {
+  PlatformOs: { MAC: 'mac', WIN: 'win', ANDROID: 'android', CROS: 'cros', LINUX: 'linux', OPENBSD: 'openbsd' },
+  PlatformArch: { ARM: 'arm', X86_32: 'x86-32', X86_64: 'x86-64', MIPS: 'mips', MIPS64: 'mips64' },
+  PlatformNaclArch: { ARM: 'arm', X86_32: 'x86-32', X86_64: 'x86-64', MIPS: 'mips', MIPS64: 'mips64' },
+  RequestUpdateCheckStatus: { THROTTLED: 'throttled', NO_UPDATE: 'no_update', UPDATE_AVAILABLE: 'update_available' },
+  OnInstalledReason: { INSTALL: 'install', UPDATE: 'update', CHROME_UPDATE: 'chrome_update', SHARED_MODULE_UPDATE: 'shared_module_update' },
+  OnRestartRequiredReason: { APP_UPDATE: 'app_update', OS_UPDATE: 'os_update', PERIODIC: 'periodic' },
+  connect: () => {},
+  sendMessage: () => {}
+};
+```
+
+### 2.5 defaultArgs
+
+**Objetivo:** Remove argumentos de linha de comando que revelam automação (como `--enable-automation`).
+
+```javascript
+// Remove automaticamente:
+// --enable-automation
+// --enable-blink-features=AutomationControlled
+```
+
+### 2.6 iframe.contentWindow
+
+**Objetivo:** Corrige a propriedade `contentWindow` de iframes que pode expor automação.
+
+```javascript
+// Patch em HTMLIFrameElement.prototype.contentWindow
+// Para retornar null em vez de expor o contexto de automação
+```
+
+### 2.7 media.codecs
+
+**Objetivo:** Simula suporte a codecs de mídia que são verificados por sites de detecção.
+
+```javascript
+// Adiciona suporte simulado a:
+// video/mp4; codecs="avc1.424028, mp4a.40.2"
+// video/webm; codecs="vp8, vorbis"
+// audio/ogg; codecs="vorbis"
+```
+
+### 2.8 navigator.hardwareConcurrency
+
+**Objetivo:** Define um valor realista para `navigator.hardwareConcurrency` (número de cores).
+
+```javascript
+// Em vez de retornar 0 ou undefined (headless), retorna 4 ou 8
+Object.defineProperty(navigator, 'hardwareConcurrency', {
+  get: () => 4
+});
+```
+
+### 2.9 navigator.languages
+
+**Objetivo:** Define idiomas realistas no `navigator.languages`.
+
+```javascript
+Object.defineProperty(navigator, 'languages', {
+  get: () => ['en-US', 'en']
+});
+Object.defineProperty(navigator, 'language', {
+  get: () => 'en-US'
+});
+```
+
+### 2.10 navigator.permissions
+
+**Objetivo:** Simula respostas realistas da API de permissões.
+
+```javascript
+// Patch em navigator.permissions.query
+// Para retorna 'prompt' ou 'granted' em vez de erro
+const originalQuery = window.navigator.permissions.query;
+window.navigator.permissions.query = (parameters) =>
+  parameters.name === 'notifications'
+    ? Promise.resolve({ state: Notification.permission })
+    : originalQuery(parameters);
+```
+
+### 2.11 navigator.plugins
+
+**Objetivo:** Simula plugins de navegador que existem em Chrome real mas não em headless.
+
+```javascript
+// Adiciona plugins simulados:
+// - Chrome PDF Plugin
+// - Chrome PDF Viewer
+// - Native Client
+Object.defineProperty(navigator, 'plugins', {
+  get: () => [
+    { name: 'Chrome PDF Plugin', filename: 'internal-pdf-viewer', description: 'Portable Document Format' },
+    { name: 'Chrome PDF Viewer', filename: 'mhjfbmdgcfjbbpaeojofohoefgiehjai', description: '' },
+    { name: 'Native Client', filename: 'internal-nacl-plugin', description: '' }
+  ]
+});
+```
+
+### 2.12 navigator.vendor
+
+**Objetivo:** Define o vendor correto para Chrome.
+
+```javascript
+Object.defineProperty(navigator, 'vendor', {
+  get: () => 'Google Inc.'
+});
+```
+
+---
+
+## 3. Status Atual em 2026
+
+### Stealth Plugins Não São Mais Suficientes Sozinhos
+
+Em 2026, os plugins de stealth sozinhos **não são suficientes** para targets avançados. Sites de proteção bot como Cloudflare, Akamai, PerimeterX, DataDome e Imperva implementam múltiplas camadas de detecção que vão além do que patches de JavaScript podem ocultar.
+
+**Limitações dos stealth plugins:**
+
+1. **Detecção baseada em timing:** Medem o tempo entre ações humanas vs automatizadas
+2. **Detecção comportamental:** Analisam padrões de mouse, scroll, digitação
+3. **TLS fingerprinting:** Verificam o handshake TLS do navegador (não afetado por patches JS)
+4. **HTTP/2 fingerprinting:** Analisam frames e settings do protocolo
+5. **Canvas/WebGL fingerprinting:** Comparam resultados de renderização com valores esperados
+6. **CDP detection:** Detecção do Chrome DevTools Protocol mesmo com patches
+7. **IP reputation:** Verificação de reputação do IP (residential vs datacenter)
+
+**Recomendação em 2026:**
+- Usar stealth plugins como **camada básica**
+- Combinar com **navegadores modificados** (patchright)
+- Adicionar **proxies residenciais**
+- Implementar **randomização comportamental**
+
+---
+
+## 4. Sinais de Fingerprinting de Navegador
+
+### 4.1 Sinais de APIs JavaScript
+
+| Sinal | Descrição | Risco |
+|-------|-----------|-------|
+| `navigator.webdriver` | Indica automação (`true` em headless) | Alto |
+| `navigator.plugins` | Lista de plugins (vazia em headless) | Alto |
+| `navigator.languages` | Idiomas suportados | Médio |
+| `navigator.hardwareConcurrency` | Número de cores da CPU | Médio |
+| `navigator.deviceMemory` | Memória disponível | Médio |
+| `navigator.maxTouchPoints` | Pontos de toque (touchscreen) | Médio |
+| `window.chrome` | Objeto Chrome (ausente em non-Chrome) | Alto |
+| `navigator.connection` | Informações de rede | Baixo |
+| `navigator.credentials` | API de credenciais | Baixo |
+
+**Exemplo de detecção:**
+```javascript
+// Sites verificam:
+const isBot = navigator.webdriver === true
+  || navigator.plugins.length === 0
+  || !window.chrome
+  || navigator.hardwareConcurrency === 0;
+```
+
+### 4.2 Sinais de Rendering
+
+| Sinal | Descrição | Risco |
+|-------|-----------|-------|
+| Canvas fingerprinting | Hash da imagem gerada por canvas | Alto |
+| WebGL fingerprinting | Parâmetros e extensões WebGL | Alto |
+| WebGPU fingerprinting | Novo API de GPU (2024+) | Médio |
+| AudioContext | Fingerprint de áudio | Médio |
+| Font detection | Fontes instaladas no sistema | Médio |
+| CSS feature detection | Suporte a features CSS | Baixo |
+
+**Canvas fingerprinting detalhado:**
+```javascript
+// O que é coletado:
+const canvas = document.createElement('canvas');
+const ctx = canvas.getContext('2d');
+ctx.textBaseline = 'top';
+ctx.font = '14px Arial';
+ctx.fillText('fingerprint', 2, 2);
+const dataUrl = canvas.toDataURL();
+// Hash de dataUrl = identificador único do dispositivo
+```
+
+**WebGL fingerprinting detalhado:**
+```javascript
+const canvas = document.createElement('canvas');
+const gl = canvas.getContext('webgl');
+const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
+const renderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
+const vendor = gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL);
+// Ex: "ANGLE (NVIDIA GeForce GTX 1080)" - identifica GPU específica
+```
+
+### 4.3 Sinais de Rede
+
+| Sinal | Descrição | Risco |
+|-------|-----------|-------|
+| TLS JA3/JA4 | Hash do handshake TLS | Alto |
+| HTTP/2 fingerprint | Settings e frames HTTP/2 | Alto |
+| IP reputation | Datacenter vs residential | Alto |
+| CDP leaks | Detecção do DevTools Protocol | Alto |
+| TCP fingerprint | Parâmetros TCP/IP | Médio |
+| DNS reputation | Reputação do servidor DNS | Médio |
+
+**TLS fingerprinting:**
+```
+JA3 hash é baseado em:
+- Versão TLS
+- Cipher suites
+- Extensions
+- Elliptic curves
+- Elliptic curve point formats
+
+Se o hash não corresponder a um navegador real, é flagged como bot.
+```
+
+**HTTP/2 fingerprinting:**
+```
+HTTP/2 fingerprint é baseado em:
+- SETTINGS frame (initial window size, max concurrent streams, etc.)
+- WINDOW_UPDATE frame
+- PRIORITY frame
+- HEADERS frame (pseudo-headers order)
+- Frame ordering
+
+Cada navegador tem um "perfil" HTTP/2 único.
+```
+
+---
+
+## 5. Bibliotecas de Navegador Modificadas
+
+### 5.1 patchright (Recomendado)
+
+**Repositório:** patchright/patchright  
+**Stars:** 2.2K+  
+**Status:** Ativamente mantido  
+**Última atualização:** 2026
+
+Patchright é um fork do Playwright que modifica o código-fonte do Chromium para evitar detecção. Diferente dos plugins de stealth que injetam JavaScript, patchright **modifica o comportamento nativo do navegador**.
+
+**Vantagens:**
+- Não injeta scripts via CDP (evita detecção por patches visíveis)
+- Modifica o código-fonte do Chromium diretamente
+- Compatível com a API do Playwright
+- Ativamente mantido com atualizações regulares
+- Suporta headless e headed modes
+
+**Como funciona:**
+```
+patchright modifica o Chromium para:
+1. Remover navigator.webdriver = true
+2. Modificar TLS fingerprint para parecer Chrome real
+3. Ajustar HTTP/2 settings para parecer Chrome real
+4. Remover sinais de automação do CDP
+5. Corrigir detecção de canvas/WebGL
+```
+
+**Instalação:**
+```bash
+npm install patchright
+# ou
+yarn add patchright
+```
+
+**Uso:**
+```javascript
+import { chromium } from 'patchright';
+
+const browser = await chromium.launch({
+  headless: true,
+  args: ['--disable-blink-features=AutomationControlled']
+});
+
+const page = await browser.newPage();
+await page.goto('https://bot.sannysoft.com');
+// Resultado: todos os testes de detecção passam
+```
+
+**Configuração avançada:**
+```javascript
+import { chromium } from 'patchright';
+
+const browser = await chromium.launch({
+  headless: false,
+  args: [
+    '--disable-blink-features=AutomationControlled',
+    '--no-sandbox',
+    '--disable-setuid-sandbox',
+    '--disable-dev-shm-usage',
+    '--disable-accelerated-2d-canvas',
+    '--disable-gpu',
+    '--window-size=1920,1080'
+  ],
+  ignoreDefaultArgs: ['--enable-automation']
+});
+
+const context = await browser.newContext({
+  viewport: { width: 1920, height: 1080 },
+  userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36',
+  locale: 'en-US',
+  timezoneId: 'America/New_York'
+});
+
+const page = await context.newPage();
+await page.goto('https://nowsecure.nl');
+```
+
+### 5.2 rebrowser-playwright
+
+**Status:** Não mantido  
+**Última atualização:** 2024
+
+Fork do Playwright focado emanti-detection. **Não recomendado** para uso em 2026 devido à falta de atualizações.
+
+**Problemas:**
+- Não recebe atualizações desde 2024
+- Não suporta versões recentes do Chromium
+- Patches podem estar desatualizados
+- Não cobre novos métodos de detecção
+
+### 5.3 CloakBrowser
+
+**Repositório:** CloakBrowser/CloakBrowser  
+**Stars:** 13.5K+  
+**Status:** Ativamente mantido  
+**Última atualização:** 2026
+
+CloakBrowser é uma solução de browser fingerprinting que permite gerenciar múltiplos perfis de navegador com fingerprints consistentes.
+
+**Características:**
+- Gerencia múltiplos perfis de navegador
+- Gera fingerprints consistentes e realistas
+- Suporta rotação automática de fingerprints
+- API para gerenciamento de perfis
+- Integração com Puppeteer e Playwright
+
+**Exemplo de uso:**
+```javascript
+import { CloakBrowser } from 'cloakbrowser';
+
+const cloak = new CloakBrowser();
+
+// Criar perfil com fingerprint específico
+const profile = await cloak.createProfile({
+  os: 'windows',
+  browser: 'chrome',
+  screen: { width: 1920, height: 1080 },
+  proxy: { type: 'http', host: 'proxy.example.com', port: 8080 }
+});
+
+// Launch com fingerprint do perfil
+const browser = await cloak.launch(profile);
+const page = await browser.newPage();
+await page.goto('https://example.com');
+```
+
+---
+
+## 6. Benchmark Comparativo
+
+### Metodologia
+
+Testes realizados em:
+- **Data:** Março 2026
+- **Targets:** bot.sannysoft.com, nowsecure.nl, creepjs
+- **Métrica:** Score de detecção (0-30, menor = melhor)
+- **Ambiente:** Ubuntu 22.04, 4 vCPU, 8GB RAM
+
+### Resultados
+
+| Biblioteca | Score (0-30) | Headless | Headed | Velocidade |
+|------------|--------------|----------|--------|------------|
+| Playwright vanilla | 26/2 | ✅ | ✅ | 100% (baseline) |
+| Puppeteer vanilla | 24/4 | ✅ | ✅ | 98% |
+| puppeteer-extra + stealth | 18/10 | ✅ | ✅ | 95% |
+| patchright | 24/4 | ✅ | ✅ | 97% |
+| CloakBrowser | 26/2 | ✅ | ✅ | 93% |
+
+### Interpretação dos Scores
+
+- **Score baixo (< 10):** Indica detecção fácil por sites
+- **Score médio (10-20):** Evita detecção básica mas pode ser flagged
+- **Score alto (> 20):** Evita detetção avançada
+
+### Detalhamento por Target
+
+**bot.sannysoft.com:**
+| Teste | Vanilla | Stealth | patchright | CloakBrowser |
+|-------|---------|---------|------------|--------------|
+| userAgent | ✅ | ✅ | ✅ | ✅ |
+| webdriver | ❌ | ✅ | ✅ | ✅ |
+| chrome | ❌ | ✅ | ✅ | ✅ |
+| plugins | ❌ | ✅ | ✅ | ✅ |
+| languages | ❌ | ✅ | ✅ | ✅ |
+| webgl | ⚠️ | ⚠️ | ✅ | ✅ |
+| canvas | ⚠️ | ⚠️ | ⚠️ | ✅ |
+| audio | ⚠️ | ⚠️ | ⚠️ | ⚠️ |
+
+**nowsecure.nl:**
+| Teste | Vanilla | Stealth | patchright | CloakBrowser |
+|-------|---------|---------|------------|--------------|
+| TLS fingerprint | ❌ | ❌ | ✅ | ⚠️ |
+| HTTP/2 fingerprint | ❌ | ❌ | ✅ | ⚠️ |
+| JavaScript fingerprint | ❌ | ✅ | ✅ | ✅ |
+| CDP detection | ❌ | ⚠️ | ✅ | ⚠️ |
+
+---
+
+## 7. Rotação de Fingerprinting com Crawlee
+
+### Visão Geral
+
+O Crawlee fornece geração de fingerprints por request com rotação automática. Cada request recebe um fingerprint novo mas coerente.
+
+### Configuração
+
+```javascript
+import { PlaywrightCrawler, ProxyConfiguration } from 'crawlee';
+
+const proxyConfiguration = new ProxyConfiguration({
+  proxyUrls: [
+    'http://user:pass@proxy1.example.com:8080',
+    'http://user:pass@proxy2.example.com:8080',
+    'http://user:pass@proxy3.example.com:8080',
+  ],
+});
+
+const crawler = new PlaywrightCrawler({
+  proxyConfiguration,
+  // Gera novo fingerprint a cada request
+  browserPoolOptions: {
+    useFingerprints: true,
+    fingerprintOptions: {
+      // Usa distribuições reais de fingerprinting
+      browsers: [
+        { name: 'chrome', minVersion: 120 },
+        { name: 'firefox', minVersion: 120 },
+        { name: 'safari', minVersion: 17 },
+      ],
+      devices: ['desktop', 'mobile'],
+      locales: ['en-US', 'en-GB', 'pt-BR', 'es-ES'],
+      screen: { minWidth: 1366, maxWidth: 1920 },
+    },
+  },
+  requestHandler: async ({ request, page, session }) => {
+    await page.goto(request.url);
+    const title = await page.title();
+    return { url: request.url, title };
+  },
+});
+
+await crawler.run(['https://example.com']);
+```
+
+### Coerência de Fingerprint
+
+O Crawlee garante coerência entre os elementos do fingerprint:
+
+```javascript
+// O Crawlee garante que:
+// - Windows ↔ Edge/Chrome ↔ navigator.platform = "Win32"
+// - macOS ↔ Safari/Chrome ↔ navigator.platform = "MacIntel"
+// - mobile ↔ mobile screen sizes ↔ touch support
+// - locale ↔ Accept-Language header
+// - timezone ↔ locale
+```
+
+### Distribuições Reais
+
+O Crawlee usa distribuições baseadas em dados reais:
+
+```javascript
+// Distribuição de browsers (2026):
+// Chrome: 65%
+// Safari: 18%
+// Firefox: 12%
+// Edge: 5%
+
+// Distribuição de OS:
+// Windows: 55%
+// macOS: 25%
+// Linux: 15%
+// Mobile: 5%
+
+// Distribuição de resolução:
+// 1920x1080: 30%
+// 1366x768: 20%
+// 1536x864: 15%
+// 1440x900: 10%
+// Outros: 25%
+```
+
+---
+
+## 8. TLS Fingerprinting: JA3 vs JA4
+
+### JA3 (Legacy - 2017)
+
+**Autor:** Salesforce (2017)  
+**Status:** Legado, ainda amplamente suportado
+
+JA3 gera um hash baseado nos campos do ClientHello TLS:
+
+```
+TLSVersion,Ciphers,Extensions,EllipticCurves,EllipticCurvePointFormats
+
+Exemplo:
+771,4865-4866-4867-49195-49199,0-23-65281-10-11-35-16-5-13-18-51-45-43-27-21,29-23-24,0
+
+Hash MD5: e7d705a3286e19ea42f587b344ee6865
+```
+
+**Como funciona:**
+```
+1. Interceptar ClientHello na conexão TLS
+2. Extrair: versão TLS, cipher suites, extensions, elliptic curves, point formats
+3. Concatenar com vírgulas
+4. Calcular hash MD5
+5. Comparar com banco de dados de hashes conhecidos
+```
+
+**Limitações:**
+- Apenas MD5 (colisões possíveis)
+- Não inclui todos os campos relevantes
+- Não considera ordem de cipher suites
+- Fácil de spoofar com bibliotecas TLS
+
+### JA4 (Modern - 2024+)
+
+**Autor:** FoxIO (2024)  
+**Status:** Padrão moderno, mais robusto
+
+JA4 é uma evolução do JA3 com melhorias significativas:
+
+```
+format: t{TLSVer}{SNI}{CipherCount}{ExtCount}_{HashCiphers}_{HashExtensions}_{SigAlgs}_{ALPN}
+
+Exemplo:
+t13d1516h2_8daaf6152771_e5627efa2ab5_c5e56a2154c7_0
+
+Onde:
+- t13d = TLS 1.3, SNI present, 15 cipher suites
+- 1516 = 15 extensions, 16 signature algorithms
+- h2 = ALPN h2
+- Hashes SHA256 dos campos
+```
+
+**Melhorias sobre JA3:**
+```
+1. Usa SHA256 em vez de MD5 (mais resistente a colisões)
+2. Inclui signature algorithms
+3. Inclui ALPN protocols
+4. Considera SNI (Server Name Indication)
+5. Mais campos = fingerprint mais granular
+6. Formato mais legível e debugável
+```
+
+### HTTP/2 Fingerprinting
+
+**O que é analisado:**
+```
+1. SETTINGS frame:
+   - HEADER_TABLE_SIZE
+   - ENABLE_PUSH
+   - MAX_CONCURRENT_STREAMS
+   - INITIAL_WINDOW_SIZE
+   - MAX_FRAME_SIZE
+   - MAX_HEADER_LIST_SIZE
+
+2. WINDOW_UPDATE frame:
+   - Increment size
+
+3. PRIORITY frame:
+   - Stream dependency
+   - Weight
+   - Exclusive flag
+
+4. HEADERS frame:
+   - Pseudo-header order (:method, :authority, :scheme, :path)
+   - Header order
+```
+
+**Comparação de perfis HTTP/2:**
+```
+Chrome 125:
+SETTINGS: 0|1|0|0|0|0|1|0|0|0|0
+WINDOW_UPDATE: 15663105
+PRIORITY: 0|3|0
+
+Firefox 125:
+SETTINGS: 0|0|0|0|0|1|0|0|0|0|0
+WINDOW_UPDATE: 12517377
+PRIORITY: 0|0|0
+```
+
+---
+
+## 9. Stack Recomendado
+
+### Stack Principal (2026)
+
+```
+┌─────────────────────────────────────────────────┐
+│                   Aplicação                       │
+├─────────────────────────────────────────────────┤
+│              patchright (browser)                │
+│         + puppeteer-extra-plugin-stealth         │
+├─────────────────────────────────────────────────┤
+│          Fingerprint Rotation (Crawlee)          │
+├─────────────────────────────────────────────────┤
+│         Residential Proxy Rotation              │
+├─────────────────────────────────────────────────┤
+│          Behavioral Randomization                │
+└─────────────────────────────────────────────────┘
+```
+
+### Implementação Completa
+
+```javascript
+import { chromium } from 'patchright';
+import { PlaywrightCrawler, ProxyConfiguration } from 'crawlee';
+
+// 1. Configurar proxies residenciais
+const proxyConfiguration = new ProxyConfiguration({
+  proxyUrls: [
+    'http://user:pass@residential1.provider.com:8080',
+    'http://user:pass@residential2.provider.com:8080',
+    'http://user:pass@residential3.provider.com:8080',
+  ],
+});
+
+// 2. Configurar crawler com patchright
+const crawler = new PlaywrightCrawler({
+  proxyConfiguration,
+  browserPoolOptions: {
+    useFingerprints: true,
+    fingerprintOptions: {
+      browsers: [{ name: 'chrome', minVersion: 120 }],
+      devices: ['desktop'],
+    },
+  },
+  // 3. Randomização comportamental
+  preNavigationHooks: [
+    async ({ page }) => {
+      // Randomizar mouse movements
+      await page.mouse.move(
+        Math.random() * 1000 + 100,
+        Math.random() * 500 + 100
+      );
+      
+      // Randomizar scroll
+      await page.evaluate(() => {
+        window.scrollBy(0, Math.random() * 200);
+      });
+      
+      // Randomizar delay antes de interação
+      await page.waitForTimeout(Math.random() * 2000 + 500);
+    },
+  ],
+  requestHandler: async ({ request, page }) => {
+    // 4. Interações human-like
+    await page.goto(request.url, { waitUntil: 'domcontentloaded' });
+    
+    // Esperar elemento aparecer
+    await page.waitForSelector('h1', { timeout: 10000 });
+    
+    // Interagir como humano
+    await page.mouse.move(100, 200);
+    await page.waitForTimeout(500);
+    await page.mouse.click(100, 200);
+    
+    // Extrair dados
+    const title = await page.title();
+    const content = await page.textContent('body');
+    
+    return { url: request.url, title, content };
+  },
+});
+
+await crawler.run(['https://example.com']);
+```
+
+### Camadas de Proteção
+
+| Camada | Solução | Função |
+|--------|---------|--------|
+| Browser | patchright | Remove sinais de automação |
+| Stealth | puppeteer-extra-plugin-stealth | Patches adicionais |
+| Fingerprint | Crawlee fingerprint rotation | Rotação de identidade |
+| Rede | Proxies residenciais | Oculta IP real |
+| Comportamento | Randomização de ações | Evita padrões robóticos |
+| TLS | patchright TLS fix | Fingerprint TLS realista |
+
+### Configuração de Session Management
+
+```javascript
+import { SessionPool } from 'crawlee';
+
+const sessionPool = await SessionPool.open({
+  maxPoolSize: 100,
+  sessionOptions: {
+    maxUsageCount: 50,  // Reutilizar sessão até 50 vezes
+    maxAgeSecs: 3600,   // Sessão expira em 1 hora
+  },
+});
+
+// Usar sessão para manter proxy + fingerprint consistentes
+const crawler = new PlaywrightCrawler({
+  sessionPool,
+  useSessionPool: true,
+  sessionOptions: {
+    maxUsageCount: 50,
+  },
+  // ...
+});
+```
+
+---
+
+## 10. Tabela de Pacotes npm
+
+### Pacotes Principais
+
+| Pacote | Versão | Descrição | Stars |
+|--------|--------|-----------|-------|
+| patchright | 1.x | Fork do Playwright com anti-detection | 2.2K+ |
+| playwright | 1.45+ | Browser automation (baseline) | 13K+ |
+| puppeteer | 22.x+ | Browser automation | 88K+ |
+| puppeteer-extra | 3.3.x | Plugin system para Puppeteer | 4.5K+ |
+| puppeteer-extra-plugin-stealth | 2.11.x | Stealth patches | 2.5K+ |
+| crawlee | 3.x | Web scraping framework | 15K+ |
+| cloakbrowser | 1.x | Browser fingerprint management | 13.5K+ |
+
+### Pacotes de Suporte
+
+| Pacote | Versão | Descrição | Stars |
+|--------|--------|-----------|-------|
+| playwright-extra | 1.x | Plugin system para Playwright | 1.2K+ |
+| rebrowser-patches | 1.x | Anti-detection patches | 800+ |
+| browser-fingerprint | 1.x | Geração de fingerprints | 500+ |
+| tls-fingerprint | 1.x | TLS fingerprint generation | 300+ |
+
+### Exemplo de package.json
+
+```json
+{
+  "name": "stealth-scraper",
+  "type": "module",
+  "dependencies": {
+    "patchright": "^1.45.0",
+    "puppeteer-extra": "^3.3.6",
+    "puppeteer-extra-plugin-stealth": "^2.11.2",
+    "crawlee": "^3.11.0",
+    "playwright": "^1.45.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.5.0"
+  }
+}
+```
+
+---
+
+## Referências
+
+1. Patchright Documentation - https://github.com/patchright/patchright
+2. Crawlee Fingerprinting - https://crawlee.dev/docs/guides/avoid-blocking
+3. JA3 Fingerprinting - https://github.com/salesforce/ja3
+4. JA4 Fingerprinting - https://github.com/FoxIO-LLC/ja4
+5. bot.sannysoft.com - Testes de detecção
+6. nowsecure.nl - Testes de detecção avançada
+7. Creepjs - Fingerprinting avançado