mandatoryprogrammer/thermopticUm proxy HTTP furtivo de próxima geração que camufla perfeitamente as requisições como o navegador Chrome em todas as camadas da pilha.
"Eu não acredito, camuflagem termo-óptica!"
Este é um proxy HTTP projetado para contornar serviços que usam fingerprinting, como JA4+, para bloquear determinados clientes HTTP. Usando este proxy, você pode usar seus clientes HTTP preferidos, como curl, e ainda ter fingerprints magicamente indistinguíveis de um navegador web real (Chrome/Chromium). O thermoptic também vem com alguns recursos divertidos para mitigar fingerprinting baseado em JavaScript. Ele também facilita a raspagem híbrida usando tanto um navegador web quanto clientes HTTP de baixo nível juntos.
Mesmo que você não esteja familiarizado com fingerprinting JA4+, se você já fez scraping, provavelmente já foi bloqueado por isso antes. Serviços populares como Cloudflare usam essas técnicas (e outros truques) para detectar o uso de clientes HTTP "não humanos" e bloquear solicitações. Esses serviços também podem usar esse fingerprinting para detectar se você inicia uma sessão com um navegador real e depois muda para um cliente de baixo nível como curl mais tarde. O thermoptic resolve todos esses problemas apresentando um fingerprint de navegador "real" unificado para todas as solicitações de scraping.
Aqui está um exemplo de fingerprint JA4H (HTTP) do curl sem o proxy:```
$ curl https://ja4db.com/id/ja4h/
ge11nn090000_b6a016211e8a_000000000000_e3b0c44298fc
Isto é bastante diferente da impressão digital que o Chrome produz quando você visita o URL diretamente:```
ge11cn19enus_f2808f0d04cf_9a10d4221160_7068f58def6e
No entanto, quando usamos o proxy para fazer a requisição, nossa impressão digital JA4H é magicamente idêntica:``` $ curl --proxy http://thermoptic:1234 https://ja4db.com/id/ja4h/ ge11cn19enus_f2808f0d04cf_9a10d4221160_7068f58def6e
(O mesmo vale para a nossa impressão digital JA4 TLS também, etc).
## Configuração
Para iniciar um proxy `thermoptic` que camufla o seu tráfego por meio de uma instância do Chrome em contêiner no Ubuntu 22.04:
Configuração padrão do Docker (funciona em hosts sem um runtime de GPU):```
docker compose up --build
Isso é tudo, agora você pode fazer proxy de tráfego através dele:``` curl --proxy http://127.0.0.1:1234 --insecure https://ja4db.com/id/ja4h/
Notas importantes:
* Por padrão, o proxy executa sem autenticação. Se você planeja expor o proxy externamente, certifique-se de definir a autenticação com as variáveis de ambiente `PROXY_USERNAME` e `PROXY_PASSWORD`.
* Se você não quiser usar `---insecure`, precisará usar o arquivo CA gerado localizado em `./ssl/rootCA.crt`. Ele é gerado na primeira vez que você executa `thermoptic`.
* Você pode conectar o `thermoptic` a qualquer instância do Chrome/Chromium iniciada com a flag `--remote-debugging-port`. Isso é essencial, pois você vai querer configurar e fazer proxy por meio de ambientes mais comumente usados para manter seu fingerprint o mais discreto possível (por exemplo, Chrome no Windows).
* A sobreposição de compose para GPU é destinada a hosts NVIDIA que já tenham o runtime/toolkit NVIDIA do Docker instalado. Ela reserva o dispositivo GPU, monta `/dev/dri` e permite que o contêiner Chrome incluído alterne para o caminho de renderização NVIDIA/Vulkan. Para usar isso, execute `docker compose -f docker-compose.yml -f docker-compose.gpu.yml up --build`.
## Features
- 🕵️ [Proxy com paridade de navegador](#how-does-this-cloaking-work-exactly) que reproduz requisições por meio de uma sessão Chrome real para corresponder aos fingerprints JA4 byte por byte.
- 🤝 Pouco ou nenhum código personalizado necessário para integrar seu cliente HTTP (por exemplo, `curl`, `requests`, etc.) com o `thermoptic`; basta [definir o proxy](#setup) e seus fingerprints serão tratados.
- 🪝 [Estrutura de hooks](#handling-browser-javascript-fingerprinting-with-thermoptic-hooks) para automação antes-da-requisição/depois-da-requisição/ao-iniciar, permitindo que você conduza o navegador completo para resolver desafios ou capturar artefatos.
- 📘 Um exemplo de hook para resolver o Cloudflare Turnstile pode ser visto em [`./hooks/onstart.js`](https://github.com/mandatoryprogrammer/thermoptic/blob/main/hooks/onstart.js).
- 🖥️ [UI de controle do navegador web](#control-the-dockerized-chrome-browser-via-web-ui-xpra) (em `http://127.0.0.1:14111`) para controlar a janela do navegador Chrome em Docker. Útil para fazer login manualmente em sites e depois usar o proxy perfeitamente para fazer requisições como sua sessão autenticada (e para depuração).
- 🔌 Defina um URI de proxy upstream HTTP ou SOCKS por meio da variável de ambiente `UPSTREAM_PROXY` em `docker-compose.yml`.
- 🛡️ Verificações de saúde integradas e um loop de controle de reinicialização para detectar navegadores congelados e se recuperar automaticamente sem necessidade de supervisão manual do operador.
- ⚡ Suporta HTTP/1.1 e HTTP/2, permitindo que o tráfego seja enviado por proxy em qualquer um dos protocolos. (_Observe que você pode falar HTTP/1.1 com o proxy, e o Chrome manipulado pode negociar com o site de destino por um protocolo diferente._)
## Como essa camuflagem funciona exatamente?
* Uma requisição HTTP é feita usando um cliente HTTP como `curl` com `thermoptic` definido como proxy.
* O `thermoptic` analisa a requisição para determinar da melhor forma que tipo de requisição de navegador ela *deveria* ser (por exemplo, visita manual a uma URL? Envio de formulário? Uma requisição `fetch()`?).
* O `thermoptic` usa o [Chrome Debugging Protocol (CDP)](https://chromedevtools.github.io/devtools-protocol/) para manipular o navegador e configurar uma página que simula a requisição exatamente como ela normalmente ocorreria em um navegador web real.
* O `thermoptic` dispara a requisição por meio do contexto simulado e captura a resposta HTTP.
* O `thermoptic` envia a resposta HTTP de volta ao cliente.
Devido ao fato de o navegador estar realmente fazendo a requisição usando toda a sua pilha, os fingerprints JA4 resultantes são idênticos.
NOTA: Devido a muitos WAFs empregarem fingerprinting em nível de JavaScript dos navegadores web, o `thermoptic` também expõe hooks para utilizar o navegador em etapas-chave do processo de scraping. Consulte [esta seção](#handling-browser-javascript-fingerprinting-with-thermoptic-hooks) para obter mais informações sobre isso.
## Por que *esta* abordagem em vez de outras soluções?
Para ser direto: outras abordagens têm falhas fundamentais que as impedem de serem uma solução prática de longo prazo para o problema de fingerprinting de navegadores.
Muitas outras tentativas de "vencer" o fingerprinting JA4+ de navegadores fazem isso reimplementando as várias camadas da pilha do navegador. Essa abordagem tem uma série de desvantagens sérias, como: