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:
* Exigir grande cuidado para corresponder perfeitamente ao comportamento da implementação do navegador "real". Como resultado, *quaisquer* peculiaridades ou discrepâncias podem ser usadas para diferenciar esses clientes da implementação do navegador "real".
* Tentar resolver o problema apenas em uma camada da pilha. O Chrome utiliza vários protocolos para proporcionar uma experiência de navegação web. Como resultado, mesmo que você tenha criado uma camada TLS perfeitamente correspondente, sua camada HTTP pode denunciá-lo se não for byte a byte perfeita.
* Como os navegadores "reais" mudam regularmente seu comportamento, seus fingerprints mudam e, como resultado, essas ferramentas exigem constantemente um trabalho de desenvolvimento mais intensivo para compensar.
Em contraste, como o `thermoptic` usa o próprio navegador para realizar requisições HTTP:
* Cada camada da pilha, como TCP, TLS, HTTP, é indistinguível do navegador real porque a requisição é feita *usando* um navegador real da maneira como *normalmente* ocorreria.
* Mudanças no comportamento do navegador em várias camadas são minimamente disruptivas; o navegador controlado pelo `thermoptic` só precisa ser atualizado para corresponder ao conjunto mais recente de fingerprints.
É claro que nenhuma solução é isenta de desvantagens. Consulte a documentação `DOWNSIDES.md` para obter uma lista detalhada das desvantagens da abordagem do `thermoptic`.
## FAQ
### Por que o nome `thermoptic`?
`Thermoptic` (abreviação de "camuflagem termoóptica") é uma referência à camuflagem fictícia [usada pela Major no anime Ghost in the Shell (1995)](https://ghostintheshell.fandom.com/wiki/Thermoptic_camouflage). No filme, essa camuflagem é mostrada como capaz de esconder quem a usa em múltiplos espectros de detecção, incluindo luz visível e radiação térmica. Da mesma forma, esta ferramenta tenta camuflar o usuário contra fingerprinting em múltiplos canais (HTTP, TLS, etc).
### JA4+ é uma **suíte** de fingerprints! Quais deles ele falsifica?
Esta ferramenta forjará os seguintes fingerprints JA4 para que sejam exatamente como os do navegador Chrome/Chromium ao qual você está conectado:
* JA4 (fingerprint de TLS)
* JA4H (fingerprint de HTTP)
* JA4X (fingerprint de certificado TLS X509)
* JA4T (fingerprint de TCP)
### E se eu quiser usar outro proxy upstream HTTP/SOCKS com isso?
O `thermoptic` agora roteia a instância do Chrome controlada por meio de um serviço `proxyrouter` interno, para que você possa apontar o Chrome para proxies upstream HTTP ou SOCKS (incluindo aqueles que exigem credenciais). Defina o URI do proxy upstream editando o valor `UPSTREAM_PROXY` em `docker-compose.yml` no serviço `proxyrouter`. Quando você o deixa vazio, o Chrome fala diretamente com a internet por meio do proxy não autenticado no cluster.
Exemplo para configurar um proxy upstream SOCKS:```yaml
proxyrouter:
environment:
UPSTREAM_PROXY: "socks5://username:[email protected]:1080"
Esteja ciente de que alguns proxies upstream podem alterar impressões digitais de baixo nível (por exemplo, metadados TCP), o que pode reduzir a paridade com um navegador residencial.
O thermoptic carregará o navegador com os cookies que seu cliente especifica no cabeçalho Cookie. A solicitação incluirá esses cookies assim que for executada no contexto do navegador. Isso é feito para garantir que o servidor não consiga usar a ordem dos cookies como impressão digital, nem qualquer outro truque barato desse tipo.
NOTA: esses cookies também permanecerão após a solicitação. Se você quiser implementar uma lógica de limpeza para os cookies, escreva um hook do thermoptic.
Sim, o thermoptic suporta esse tipo de uso híbrido. Veja esta seção para mais informações.
Você precisa garantir que está definindo cabeçalhos como X-Fetch-*, Origin e Referer corretamente. Se você não informar esses cabeçalhos ao thermoptic, ele não conseguirá executar a solicitação da maneira furtiva adequada.
Sem definir cabeçalhos contextuais, o thermoptic definirá valores padrão que podem não refletir exatamente o que o site de destino espera. Por exemplo, se você não definir um cabeçalho Origin, ele definirá um Origin como null; se você não definir um cabeçalho Referer, ele simplesmente não enviará nenhum Referer.
É do seu interesse incluir esses cabeçalhos contextuais para que sua solicitação seja o mais furtiva possível! O thermoptic não consegue ler sua mente; ele só consegue ler a sua solicitação :).
Geralmente, isso se aplica apenas no caso dos hooks do thermoptic que utilizam temporariamente o navegador web completo para passar nas verificações de JavaScript/nível de navegador. Ao usar temporariamente esses hooks e o modo de navegador completo, você precisará tomar cuidado para não ser identificado como bot por fingerprinting (por exemplo, evite pegadinhas como Runtime.enable).
As considerações éticas e a complexa teoria dos jogos em jogo aqui são maiores do que podem ser respondidas em um README. Sinta-se à vontade para argumentar contra qualquer um desses pontos simplificados quando você me criticar por e-mail/Twitter/Github:
Para mais discussões sobre a corrida armamentista do scraping, peço que você pelo menos me pague uma cerveja antes. Para ser honesto, odeio escrever esses ensaios éticos entediantes nos meus READMEs, então sinta-se à vontade para apenas me imaginar como um nerd malvado que quer dificultar sua vida.
thermopticO thermoptic permite que você configure scripts personalizados para executar ações no navegador quando:
ON_START_HOOK_FILE_PATH)BEFORE_REQUEST_HOOK_FILE_PATH)AFTER_REQUEST_HOOK_FILE_PATH)Isso permite que você use o Chrome Debugging Protocol para clicar e definir os cookies apropriados para sites que exigem um navegador web real para uma etapa de verificação. Você pode então usar o proxy thermoptic para continuar sua sessão de forma camuflada através do mesmo navegador.
Para fazer isso, modifique o arquivo JavaScript do hook apropriado com seu código personalizado para orquestrar o navegador adequadamente por meio da interface chrome-remote-interface fornecida:```
// cdp is an instance of a connected browser, use it to run your browser actions
export async function hook(cdp) {
console.log([STATUS] Browser start hook called successfully!);
}
Para um exemplo de implementação, consulte o arquivo [`./hooks/onstart.js`](https://github.com/mandatoryprogrammer/thermoptic/blob/main/hooks/onstart.js) que [ignora o CAPTCHA turnstile da Cloudflare](https://github.com/mandatoryprogrammer/thermoptic/blob/main/tutorials/turnstile/cloudflare-turnstile-bypass.md) (e outras verificações antibot da Cloudflare).
## Controle o navegador Chrome em Docker via interface web (Xpra)
`thermoptic` vem com uma interface web Xpra disponível em `http://127.0.0.1:14111`. Isso permite que você controle manualmente o navegador Chrome em Docker com facilidade:
<img src="https://assets.kitploit.com/production/public/readmes/49068/0fa1b187f46405dda2b0db5d461619daa6a7bdad2c385cb51994e870d9054d10.png" width="100%">
Isso é útil para coisas como:
* Fazer login na sua conta para que você possa fazer requisições autenticadas por meio do `thermoptic` usando seu cliente HTTP preferido, como `curl`.
* Por exemplo, se você fizer login no `reddit.com` com o navegador, todas as requisições que você fizer ao Reddit por meio do `thermoptic` serão autenticadas automaticamente como sua conta do Reddit!
* Depurar seus hooks personalizados do `thermoptic` e verificar problemas com sites.
## Configuração
Estas variáveis de ambiente especificam como o `thermoptic` deve ser configurado quando executado.
`HTTP_PROXY_PORT`: A porta na qual o proxy do `thermoptic` deve escutar. Se você estiver executando o `thermoptic` no Docker, também precisará alterar o campo de mapeamento `ports` para corresponder.
`CHROME_DEBUGGING_PORT`: A porta na qual o Protocolo de Depuração do Chrome é exposto. Essa porta é especificada quando você inicia o Chrome/Chromium com a flag `--remote-debugging-port` definida para um valor como `9222`.
`CHROME_DEBUGGING_HOST`: O host no qual o Protocolo de Depuração do Chrome é exposto. Geralmente é `127.0.0.1` se o navegador for iniciado localmente e o `thermoptic` não estiver rodando no Docker. Se estiver rodando no Docker, talvez seja necessário usar `host.docker.internal`; consulte a [documentação do Docker](https://docs.docker.com/desktop/features/networking/#i-want-to-connect-from-a-container-to-a-service-on-the-host) para obter informações.
`PORT`: A porta CDP que o contêiner do Chrome publica para o restante da stack. Mantenha-a alinhada com `CHROME_DEBUGGING_PORT` para que a ponte `socat` continue funcionando como esperado.
`CHROME_CONTROL_PORT`: A porta do serviço de controle do Chrome que o thermoptic usa para gerenciar o navegador (por exemplo, enviar solicitações de reinicialização).
`CHROME_CONTROL_COOLDOWN_MS`: Tempo mínimo em milissegundos entre tentativas de reinicialização do Chrome. Use isso para evitar ciclos rápidos de reinicialização quando múltiplas falhas ocorrerem em sequência rápida.
`ENABLE_GUI_CONTROL`: Defina como `true` para iniciar o painel web xpra e poder controlar o Chrome em contêiner visitando `http://127.0.0.1:14111`. Desative-o para execuções somente headless.
`CHROME_SCREEN_WIDTH` / `CHROME_SCREEN_HEIGHT`: As dimensões em pixels da tela do Chrome headful em Docker.
`CHROME_ENABLE_GPU`: Controla se o contêiner Chrome incluído deve tentar usar a aceleração de GPU do host. `auto` (padrão) ativa o caminho NVIDIA/Vulkan quando o runtime e os nós de dispositivo necessários estão presentes; caso contrário, ele volta para a renderização por software. Defina como `false` para forçar o comportamento antigo somente por software.
`CHROME_PROFILE_RECOVERY`: Quando `true` (padrão), o lançador de Chrome incluído fará uma tentativa de recuperação se o Chrome morrer imediatamente com o mesmo código de saída de loop de falha observado em um perfil envenenado (`133`). O conteúdo do perfil ruim é movido para `/tmp/chrome-profile-recovery/` dentro do contêiner antes de tentar novamente com um perfil limpo.
`PROXY_USERNAME`: O nome de usuário usado para autenticar você no proxy; o padrão é `changeme`. Se não for definido, o proxy é executado sem exigir autenticação.
`PROXY_PASSWORD`: A senha usada para autenticar você no proxy; o padrão é `changeme`. Se não for definida, o proxy é executado sem exigir autenticação.
`THERMOPTIC_CONTAINER_RUNTIME`: Indica que o thermoptic está sendo executado dentro do contêiner incluído. Deixe definido como `true`; ele controla comportamentos como as verificações de integridade integradas, que só fazem sentido na configuração completa do Docker.
`HEALTHCHECK_ENDPOINT_PORT`: A porta onde o thermoptic expõe seu endpoint web de verificação de integridade. O worker de integridade chama esse endpoint por meio do proxy; se ele parar de responder, o Chrome é reiniciado automaticamente para destravar sessões congeladas.
`HEALTHCHECK_ENDPOINT_PATH`: O caminho HTTP servido pelo endpoint de verificação de integridade descrito acima. Altere-o se precisar de uma URL diferente.
`ON_START_HOOK_FILE_PATH`: Código Node personalizado para executar na inicialização do proxy. O proxy não começará a escutar até que esse hook seja concluído; veja o exemplo em `./hooks/`. O exemplo demonstra o uso do navegador para passar pela verificação de JavaScript do Cloudflare antes de iniciar o proxy.
`BEFORE_REQUEST_HOOK_FILE_PATH`: Código Node personalizado para executar antes de uma requisição ser encaminhada pelo proxy. Isso é útil se você precisar que o navegador passe em alguma verificação antes que uma requisição HTTP ao site seja feita.
`AFTER_REQUEST_HOOK_FILE_PATH`: Código Node personalizado para executar depois que uma requisição foi encaminhada pelo proxy. Geralmente é útil para fazer coisas como limpar cookies que foram definidos pelo cliente por meio do cabeçalho `Cookie`.
`DEBUG`: Defina como `true` quando encontrar um bug para que o thermoptic imprima diagnósticos detalhados antes de você abrir uma issue; deixe-o como `false` durante a operação normal.
## Segurança
Observe que, neste momento, o `thermoptic` deve ser usado apenas com clientes HTTP em que você confia explicitamente. Ele *não* deve ser exposto a usuários não confiáveis.
Para qualquer vulnerabilidade de segurança, envie um relatório para mim em `mandatory@` Gmail.