Relatório Técnico: Avaliação de Metodologias para Automação de Navegação Web e Análise de Mitigação Anti-Bot

Relatório Técnico: Avaliação de Metodologias para Automação de Navegação Web e Análise de Mitigação Anti-Bot

Mecanismos de proteção contra força bruta (brute force) e automação abusiva, como o Google reCAPTCHA, tornaram-se uma camada padrão de defesa em formulários de autenticação na web. No entanto, a eficácia dessas ferramentas depende diretamente de como a aplicação valida a resposta retornada pela API do provedor no lado do servidor (backend). Quando essa validação é implementada com premissas permissivas, a camada de proteção pode ser completamente anulada sem que o usuário final perceba.

Durante uma revisão estática de código em ambiente controlado no plugin Hide My WP Ghost (hide-my-wp, versão 7.0.19) — uma solução de segurança e firewall para WordPress com mais de 100 mil instalações ativas —, foram identificadas duas fragilidades lógicas críticas na integração com o reCAPTCHA v2: um comportamento de falha aberta (Fail-Open) diante de erros de rede ou respostas malformadas e a omissão da verificação de contexto de domínio (hostname).

Neste artigo, detalho a anatomia dessas falhas nos arquivos Abstract.php e GoogleV2.php, demonstro o impacto arquitetural de confiar em validações frouxas no backend e apresento o patch recomendado em modelo Fail-Closed para mitigar o problema.


1. Ambientes de Execução e Arquiteturas de Automação Web

A evolução dos ambientes de automação de testes e navegação web reflete a constante busca por maior precisão, velocidade e resiliência operacional. Historicamente, a automação baseava-se em interações diretas e exclusivamente locais com a interface gráfica, orientadas por coordenadas fixas de tela através do ponteiro do sistema operacional. Com a complexidade crescente das aplicações web e a necessidade de execução em alta escala em infraestruturas de nuvem, esse modelo legado migrou progressivamente para a execução gerenciada em ambientes headless e a integração direta com motores de navegação. A escolha estratégica da infraestrutura adequada é decisiva: enquanto abordagens locais dependem estritamente do servidor de exibição gráfica, arquiteturas modernas desacoplam a renderização visual do suporte de hardware físico, garantindo escalabilidade e reprodutibilidade em pipelines de integração contínua (CI/CD).
Abaixo, apresenta-se uma análise comparativa das principais abordagens de execução de automação web observadas em ambientes Linux:
Abordagem de Execução
Arquitetura / Mecanismo
Dependência de Display Físico
Desempenho / I/O
Nível de Confiabilidade em Servidores
Automação de Display Nativo (xdotool / PyAutoGUI em X11)
Interação direta com o servidor gráfico X11 simulando eventos de entrada física de mouse e teclado em janelas visíveis. Sob o gerenciador Wayland, exige migração obrigatória para a ferramenta ydotool.
Alta (Exige monitor ativo ou sessão de desktop renderizada via X11).
Baixo a Médio (Sujeito a custos de renderização gráfica e dependência de I/O de tela local).
Baixo (Instável em servidores sem interface gráfica ou sob o gerenciador Wayland sem ydotool).
Virtual Framebuffer (Xvfb em Linux Headless)
Criação de uma tela virtual em memória RAM no servidor Linux (xvfb-run), permitindo que ferramentas baseadas em GUI operem sem monitor físico.
Nula (Simula um display em memória sem necessidade de hardware gráfico).
Médio (Elimina dependência de monitor físico, mas mantém a sobrecarga de renderização visual completa).
Médio a Alto (Amplamente utilizado para compatibilizar ferramentas legadas em servidores e contêineres).
Navegação Headless Nativa (Motor de Navegador via Playwright / Chromium)
Integração direta via protocolo de desenvolvimento (CDP) com o motor interno do navegador Chromium em segundo plano, capturando o estado interno da página.
Nula (Opera nativamente sem servidor de vídeo ou interface gráfica).
Elevado (Processamento otimizado direto em memória, sem emulação de eventos de sistema operacional).
Altíssimo (Padrão corporativo para servidores Linux, contêineres Docker e ambientes integrados de CI/CD).

Apesar de funcionais para tarefas locais simples, as soluções baseadas estritamente em manipulação de pixels de tela enfrentam gargalos operacionais críticos. Alterações sutis na resolução do sistema, variações de dimensionamento de DPI (scaling) em notebooks ou a simples alternância entre gerenciadores de janela inviabilizam a precisão dos cliques por coordenadas fixas. Além disso, o uso impróprio do modo tela cheia através da tecla F11 oculta barras de endereço e abas, alterando a área útil de exibição (viewport) e deslocando a grade cartesiana original. Para preservar a estabilidade da resolução sem deformar a área útil da página, exige-se o uso de comandos específicos de maximização como alt+F10, o dimensionamento dinâmico via windowsize ou o gerenciamento de propriedades de janelas com wmctrl. Ademais, o avanço do gerenciador de display Wayland em substituição ao X11 limita significativamente utilitários legados como o xdotool, exigindo transições para alternativas de nível de kernel como o ydotool.
A superação dessas restrições físicas de display exige uma evolução fundamental no design dos sistemas automatizados, migrando do mapeamento por coordenadas cartesianas estáticas de tela para métodos de localização visual dinâmica operados diretamente em memória.

2. Reconhecimento e Localização Visual por Pixels (Template Matching)

Quando seletores tradicionais do Modelo de Objeto do Documento (DOM) — tais como identificadores (id), classes CSS ou seletores XPath — tornam-se inacessíveis, são alterados dinamente por ofuscação ou se mostram instáveis em interfaces complexas, a visão computacional assume papel central na automação web. Ao tratar a interface gráfica como uma matriz bidimensional de dados visuais, a localização por reconhecimento de imagem permite identificar componentes (como botões, ícones ou sinalizadores) a partir do processamento de seus padrões de cores e pixels, independentemente da estrutura do código-fonte subjacente.
No ambiente de automação headless nativa, o processo de localização visual integra o motor do Playwright às rotinas da biblioteca OpenCV, executando a busca por correspondência de modelo (Template Matching) por meio da função cv2.matchTemplate respaldada pela métrica de pontuação padronizada TM_CCOEFF_NORMED:
  • Processamento e Conversão Direta em Memória: Para evitar a degradação de desempenho associada à gravação de arquivos temporários em disco, a captura da tela é realizada diretamente em bytes (screenshot_bytes = page.screenshot()). Esses dados brutos são convertidos em um array numérico estruturado via numpy.frombuffer(screenshot_bytes, np.uint8) e decodificados com cv2.imdecode(..., cv2.IMREAD_COLOR). Em seguida, ajusta-se a matriz do espaço de cor RGB (padrão de captura do navegador) para o espaço BGR (padrão nativo do OpenCV) através de cv2.cvtColor(..., cv2.COLOR_RGB2BGR).
  • Cálculo do Centro Geométrico e Disparo: A função cv2.minMaxLoc varre a matriz da imagem da página e retorna o ponto de maior similaridade visual (max_loc), acompanhado da pontuação máxima (max_val). A partir das dimensões da imagem de referência (template) — especificamente sua largura ($w$) e altura ($h$) —, calcula-se o centro geométrico exato do elemento encontrado pelas equações:



$$X_{\text{centro}} = X_{\text{max\_loc}} + \left(\frac{w}{2}\right)$$
$$Y_{\text{centro}} = Y_{\text{max\_loc}} + \left(\frac{h}{2}\right)$$

Com as coordenadas $(X_{\text{centro}}, Y_{\text{centro}})$ identificadas no espaço bidimensional da página, o motor de automação dispara o evento de clique diretamente no contexto interno do navegador (page.mouse.click(X_centro, Y_centro)).
       Matriz de Pixels da Tela (RGB -> BGR em Memória RAM)
+---------------------------------------------------------+
|                                                         |
|         +-------------------+                           |
|         | Imagem Alvo       |                           |
|         | (Template)        |                           |
|         |       (X,Y)       |                           |
|         |         +  <------+--- Centro Geométrico      |
|         |                   |    (X_centro, Y_centro)   |
|         +-------------------+                           |
|                                                         |
+---------------------------------------------------------+
A confiabilidade e a eficiência dessa abordagem dependem do ajuste rigoroso de parâmetros operacionais cruciais:
  1. Limiar de Confiança (Threshold): O nível mínimo aceitável de similaridade matemática (tipicamente configurado na faixa estrita entre 0.82 e 0.85). Valores excessivamente altos (ex: 0.99) podem gerar falhas perante variações imperceptíveis de renderização, enquanto limiares baixos aumentam a ocorrência de falsos positivos em áreas ruidosas da página.
  2. Desempenho de I/O de Entrada e Saída: A manipulação de screenshots diretamente no buffer da memória RAM elimina chamadas de leitura e escrita no disco rígido, otimizando o ciclo de execução do loop de busca e viabilizando múltiplas tentativas seguidas com menor consumo de recursos computacionais.
  3. Restrições de Mudança de Layout: O Template Matching estático baseia-se na sobreposição rígida de matrizes. Variações na escala de exibição, alterações nas bordas, sombras dinâmicas, distorções de renderização ou mudanças sutis nas tonalidades de cor dos elementos visuais reduzem a similaridade máxima calculada, podendo levar a falhas de localização se não houver imagens de referência adaptativas.
A localização precisa do alvo visual na tela precisa, contudo, ser acompanhada por trajetórias de movimento biomiméticas, evitando que o deslocamento do ponteiro apresente padrões robóticos facilmente identificáveis por sistemas de análise comportamental.

3. Engenharia de Trajetória Biomimética e Simulação Comportamental
Sistemas modernos de detecção comportamental analisam continuamente os eventos de entrada de hardware disparados no navegador, focando especialmente na telemetria temporal do evento mousemove. A verificação busca diferenciar movimentos mecânicos e perfeitamente lineares — característicos de scripts de automação ingênuos — de padrões motores humanos orgânicos, os quais apresentam aceleração gradual, arcos parabólicos e micro-instabilidades motoras imprevisíveis.
Para neutralizar a identificação por heurísticas comportamentais, aplica-se a modelagem matemática baseada em Curvas de Bézier Quadráticas combinada à variação estocástica de parâmetros tempo-espaciais:
  • Pontos de Partida ($P_0$) e Destino ($P_2$): O algoritmo lê a posição inicial corrente do cursor no espaço de coordenadas cartesianas ($P_0 = (X_0, Y_0)$) e define o ponto final de destino retornado pela etapa de localização visual ($P_2 = (X_2, Y_2)$).
  • Ponto de Controle Intermediário ($P_1$): Para evitar a linha reta contínua, calcula-se o ponto médio da trajetória e aplica-se um desvio angular estocástico gerado aleatoriamente (random.randint(-50, 50)). Isso desloca o ponto de controle intermediário ($P_1 = (X_1, Y_1)$), forçando o traçado a assumir a forma de um arco parabólico natural.
  • Fórmula da Curva de Bézier Quadrática: A trajetória contínua é calculada para um parâmetro $t$ variando de $0$ a $1$ ao longo de um número determinado de passos (geralmente entre 25 e 45 intervalos), aplicando-se a equação:


$$B(t) = (1-t)^2 P_0 + 2(1-t)t P_1 + t^2 P_2 \quad \text{para } t \in [0, 1]$$
  • Micro-ruído (Jitter) e Micro-pausas Fisiológicas: Em cada passo iterativo da curva, adiciona-se uma variação aleatória de fração de pixel (random.uniform(-0.5, 0.5)) para simular o tremor fisiológico da mão humana. Além disso, a velocidade de transição é ajustada dividindo o tempo total por intervalos dinâmicos, culminando em uma micro-pausa deliberada (entre 0.08 e 0.18 segundos) logo antes do disparo do clique, reproduzindo o tempo de foco neurológico do olho humano.
A combinação entre aceleração e desaceleração gradual, traçado em arcos não lineares e imperfeições motoras de sub-pixels invalida as regras estáticas de detecção baseadas na velocidade constante ou em desvios nulos de trajetória. Os motores de análise de risco tentam identificar assinaturas mecanicistas verificando a derivada da velocidade e a linearidade espacial; ao introduzir estocasticidade biomimética, a assinatura visual do movimento passa a correlacionar-se com perfis de uso humano legítimo.
Contudo, além do movimento orgânico do ponteiro na camada de interface gráfica, a preservação da integridade da identidade do navegador no nível de script é indispensável para evitar o bloqueio inicial durante a fase de handshake da sessão.

4. Preservação de Contexto de Sessão e Ocultação de Parâmetros de Identificação

O Browser Fingerprinting (Impressão Digital do Navegador) consiste na coleta e cruzamento sistemático de centenas de variáveis de configuração do ambiente cliente executadas em segundo plano via JavaScript. Sistemas de proteção e mitigação utilizam essa técnica para mapear inconsistências que revelem que o navegador está sendo operado por motores de automação em vez de um usuário comum em um ambiente desktop convencional.
Para mitigar a identificação superficial do cliente, adota-se uma matriz de blindagem baseada em quatro pilares principais de ocultação de identidade:
  1. Remoção da Flag navigator.webdriver: Por padrão, ferramentas de automação definem a propriedade nativa navigator.webdriver como true. A blindagem sobrescreve a propriedade no momento da inicialização da página via scripts de injeção primária (add_init_script), definindo o atributo como undefined.
  2. Mascaramento de Propriedades de Hardware e Ambiente: Falsificação estrita das coleções de sistema para refletir um ambiente de uso real. Inclui a definição de listas simuladas de plugins (navigator.plugins), idiomas preferenciais (navigator.languages contendo ['pt-BR', 'pt', 'en-US']), bem como a sincronização entre o cabeçalho User-Agent, a localidade (locale="pt-BR") e o fuso horário (timezone_id="America/Sao_Paulo").
  3. Desativação de Flags de Compilação no Chromium: Injeção de argumentos de inicialização no motor do navegador no momento da abertura do processo, destacados pela flag --disable-blink-features=AutomationControlled, acompanhada da desativação de barras de informação de controle automatizado e ajustes de tamanho de janela fixa (ex: --window-size=1366,768).
  4. Uso de Contextos Persistentes (launch_persistent_context): Em vez de instanciar contextos temporários que nascem sem histórico, cookies ou cache prévio — padrão altamente suspeito para heurísticas de risco —, utiliza-se a inicialização com diretório de dados do usuário salvo em disco, especificando explicitamente o caminho de perfil:
user_data_dir = os.path.expanduser("~/.config/playwright_profile_seguro")
Isso permite que a sessão acumule dados de navegação legítimos, mantendo o estado de cookies, armazenamento local e ativos pré-existentes.
Apesar da eficácia substancial dessa blindagem no lado do cliente em reduzir a fricção superficial e impedir o bloqueio imediato durante a renderização inicial do DOM, ela não garante a aprovação absoluta da sessão. Se os sistemas de backend realizarem uma auditoria profunda de sinais e redes — como a verificação da origem do endereço IP —, os parâmetros do cliente tornam-se secundários. O tráfego originado de blocos de endereços pertencentes a datacenters comerciais ou provedores de hospedagem em nuvem (como AWS ou GCP) é marcado com alto nível de risco por redes de reputação de IP, independentemente de quão perfeita seja a falsificação do fingerprint no navegador.
Consequentemente, a avaliação de segurança de um sistema de informação deve migrar da simples tentativa de contorno da camada do cliente para a verificação rigorosa da arquitetura de validação implementada no servidor.

5. Arquitetura de Validação de Tokens de Segurança no Backend

Existe uma distinção fundamental entre as ferramentas de execução operadas no cliente — cuja função limita-se a completar desafios visuais ou obter tokens de verificação — e a lógica de verificação executada no backend da aplicação. Enquanto a camada do cliente apenas transporta a string de verificação gerada pelo provedor de segurança, cabe ao servidor da aplicação consultar o endpoint de validação do provedor (como a API siteverify do Google reCAPTCHA) para atestar a conformidade, a integridade da sessão e o contexto do envio.
Abaixo é apresentado o modelo representativo da estrutura em formato JSON retornada por endpoints oficiais de verificação (ex: https://www.google.com/recaptcha/api/siteverify) após a consulta do backend:
{
  "success": true,
  "challenge_ts": "2026-03-30T12:00:00Z",
  "hostname": "empresa-oficial.com.br",
  "apk_package_name": null,
  "error-codes": []
}
A avaliação de segurança no backend revela lacunas críticas de validação que determinam se o sistema opera sob modos de falha permissivos ou seguros:
  • Validação Incompleta (Fail-Open / Comparações Permissivas): Padrão vulnerável em que a lógica do backend verifica unicamente se a chave booleana success é avaliada como verdadeira (success == true ou simples existência do objeto de resposta). Esse modelo ignora a verificação do domínio de origem (hostname), desconsidera o tempo de emissão (challenge_ts) e não valida o escopo da ação (action). Adicionalmente, linguagens com comparações frouxas podem falhar na validação de tipo, permitindo a aceitação de tokens nulos ou reaproveitados.
  • Validação Criptográfica e Contextual Estrita (Fail-Closed): Padrão seguro em que o backend condiciona a liberação do fluxo de negócios à checagem mandatória e cumulativa de múltiplos fatores. Exige-se estritamente que success === true, que o hostname retornado seja idêntico ao domínio oficial do servidor, que o parâmetro action corresponda exatamente ao escopo esperado e que haja a revogação imediata da chave após o primeiro uso, impedindo ataques de reutilização de token (Token Replay).
Abaixo, estabelece-se a comparação direta entre as implementações de backend vulnerável (Fail-Open) e resiliente (Fail-Closed):
// ============================================================================
// PADRÃO VULNERÁVEL (Fail-Open / Comparações Frouxas)
// ============================================================================
async function validarTokenVulneravel(req, res) {
    const { token } = req.body;
    const respostaApi = await consultarApiSiteverify(token);

    // FALHA CRÍTICA: Valida apenas se a propriedade success existe/é verdadeira.
    // Ignora hostname, action, idade do token e reutilização.
    if (respostaApi && respostaApi.success) {
        liberarAcessoOperacaoCritica();
        return res.json({ status: "sucesso" });
    }
    return res.status(400).json({ error: "Token inválido" });
}

// ============================================================================
// PADRÃO RESILIENTE (Fail-Closed / Validação Estrita de Contexto)
// ============================================================================
async function validarTokenSeguro(req, res) {
    const { token } = req.body;
    const DOMINIO_OFICIAL = "empresa-oficial.com.br";
    const ACAO_ESPERADA = "formulario_contato";
    
    const respostaApi = await consultarApiSiteverify(token);

    // VALIDAÇÃO ESTRITA: Exige sucesso booleano estrito, match de domínio, 
    // escopo da ação e ausência de reutilização prévia.
    const isValido = respostaApi &&
                     respostaApi.success === true &&
                     respostaApi.hostname === DOMINIO_OFICIAL &&
                     respostaApi.action === ACAO_ESPERADA &&
                     await tokenNaoFoiConsumidoAnteriormente(token);

    if (isValido) {
        await registrarConsumoDoToken(token);
        liberarAcessoOperacaoCritica();
        return res.json({ status: "sucesso" });
    }

    // BLOQUEIO PADRÃO: Tranca o fluxo no primeiro critério divergente
    registrarAlertaDeSeguranca(respostaApi);
    return res.status(403).json({ error: "Acesso negado: Falha na validação contextual" });
}
                      FLUXO DE VALIDAÇÃO NO BACKEND
                      
    Requisição do Cliente com Token
                 |
                 v
   +---------------------------+
   |  Consulta à API Externa   |
   |   (siteverify endpoint)   |
   +-------------+-------------+
                 |
                 v
   +---------------------------+
   | Resposta JSON Recebida    |
   +-------------+-------------+
                 |
        +--------+--------+
        |                 |
        v                 v
 [ Modos de Validação no Backend ]
        |                 |
        | (Fail-Open)     | (Fail-Closed)
        v                 v
+------------------+  +----------------------------------+
| Checa apenas:    |  | Checa cumulativamente:           |
| success == true  |  | 1. success === true              |
|                  |  | 2. hostname == dominioOficial     |
| (INSEGURO:       |  | 3. action == acaoEsperada (v3)   |
| Permite Replay e |  | 4. Token não reutilizado         |
| Cross-Domain)    |  | 5. Validação dentro do timeout   |
|                  |  | (SEGURO: Tranca no primeiro erro)|
+------------------+  +----------------------------------+
Para garantir a conformidade dos mecanismos de autenticação e proteção baseados em tokens, os auditores e desenvolvedores devem aplicar o seguinte checklist de verificação no backend:
  • Identidade e Origem:
    • [ ] O servidor valida se o emissor (iss) pertence ao provedor confiável?
    • [ ] O domínio retornado no parâmetro hostname (ou aud/audience) corresponde estritamente ao FQDN oficial da aplicação em produção?
    • [ ] O parâmetro de escopo action (em implementações como reCAPTCHA v3 / Turnstile) é verificado estritamente contra a ação esperada para aquele endpoint específico?
    • [ ] Tokens gerados em ambientes secundários, de teste ou domínios colaterais são terminantemente rejeitados pelo servidor?
  • Estado e Ciclo de Vida:
    • [ ] O sistema possui controle de revogação de uso único, impedindo que o mesmo token seja reutilizado em requisições subsequentes (Replay Protection)?
    • [ ] O timestamp de geração (challenge_ts / exp) é auditado para garantir que tokens antigos ou expirados sejam descartados?
    • [ ] O token está devidamente vinculado à sessão ativa do usuário ou ao seu endereço IP?
  • Integridade da Assinatura:
    • [ ] O backend rejeita a requisição se o token estiver malformado, for nulo, contiver strings vazias ou arrays ausentes?
    • [ ] A validação booleana emprega operadores de igualdade estrita (===), prevenindo ambiguidades de conversão de tipos (Loose Comparison)?
A identificação analítica dessas falhas de validação exige a formalização dos achados de forma ética, profissional e padronizada, reportando as lacunas de arquitetura sem a necessidade de promover invasões ou testes destrutivos em sistemas de produção.

6. Metodologia de Auditoria e Estruturação de Relatórios Técnicos

A formalização de achados de segurança em programas de divulgação responsável de vulnerabilidades (Vulnerability Disclosure Programs - VDP / Vulnerability Reward Programs - VRP) e em revisões estáticas de código (Code Review) exige estrita observância a padrões éticos, regulatórios e normativos (tais como alinhamento a classificações CWE/CVSS e diretrizes de Safe Harbor). Relatórios qualificados não dependem de ferramentas de exploração maliciosa, da injeção de trojans ou de provas de conceito baseadas em força bruta em ambientes de produção; pelo contrário, fundamentam-se na demonstração clara de inconsistências lógicas de código, divergências de documentação e falhas de arquitetura de validação no backend.
Para que um relatório técnico atingir o padrão exigido pelas equipes de triagem de segurança corporativa, o auditor sênior deve seguir as diretrizes explícitas de preenchimento descritas no modelo abaixo:
Estrutura Padrão de Relatório de Segurança
  1. Título: Identificação limpa, direta e descritiva da falha de lógica de negócio ou de validação de parâmetros, utilizando a taxonomia padrão de segurança (ex: [Lógica de Negócio / Validação de Servidor] Ausência de Validação Contextual de Hostname e Action em Tokens de Segurança).
  2. Resumo Executivo: Descrição sucinta e de alto nível sobre a vulnerabilidade identificada, detalhando a inconsistência de conformidade do backend sem recorrer ao uso de jargões operacionais sensacionalistas.
  3. Descrição Detalhada e Snippet de Código Vulnerável: Explicação aprofundada da lógica subjacente à fragilidade. Deve-se incluir a demonstração estática do bloco de código com falha (explicitando comparativos entre avaliações permissivas == e a ausência de checagens de metadados colaterais).
  4. Avaliação de Impacto de Negócio: Análise objetiva baseada em risco operacional real (mapeada por severidade CVSS). Explicita as consequências de uma exploração em escala, tais como a automatização desmitigada de requisições críticas, bypass de fricção e reutilização de tokens (Token Replay).
  5. Prova de Conceito em Ambiente Controlado (PoC Local): Demonstração da reprodutibilidade da falha restrita exclusivamente a um ambiente de desenvolvimento local autorizado (localhost ou contêiner Docker controlado). Declara-se explicitamente a conformidade ética e a ausência de testes não autorizados contra a infraestrutura de produção.
  6. Sugestão de Remediação (Fail-Closed): Apresentação do trecho de código corrigido contendo a lógica recomendada para a validação estrita dos metadados e adotando o princípio de bloqueio padrão (Fail-Closed) perante qualquer inconsistência de contexto.
Para garantir a reprodutibilidade, o versionamento e a padronização dos modelos de auditoria, orienta-se a organização local dos arquivos em uma estrutura de diretórios bem definida, separando os modelos mestres da documentação de projetos específicos:
/Auditorias/
  ├── Templates/
  │   └── modelo_relatorio_vrp.md       <-- Modelo mestre estruturado (Template)
  └── Projetos/
      └── auditoria-backend-v1/
          ├── analise_codigo.txt
          └── relatorio_tecnico_final.md  <-- Relatório preenchido do projeto específico

Adotando essa estrutura, garante-se que os estudos de automação, a análise de sinalização de interfaces e a auditoria de validação no backend sejam documentados de forma rigorosa, ética e tecnicamente irrepreensível.

Relatório de Vulnerabilidade: Validação Incompleta de reCAPTCHA e Comportamento Fail-Open no Plugin Hide My WP Ghost

1. Metadados do Alvo e Escopo

  • Plugin: Hide My WP Ghost – Security & Firewall
  • Slug: hide-my-wp
  • Versão Analisada: 7.0.19 (confirmada no diretório oficial do WordPress)
  • Instalações Ativas: 100.000+
  • Repositório Oficial: [https://wordpress.org/plugins/hide-my-wp/](https://wordpress.org/plugins/hide-my-wp/)
  • Arquivos Afetados: models/bruteforce/Abstract.php e models/bruteforce/GoogleV2.php

 

2. Resumo Executivo

Durante a análise estática do mecanismo de proteção contra força bruta via Google reCAPTCHA v2 no plugin Hide My WP Ghost (versão 7.0.19), foram identificadas duas falhas lógicas na validação do token retornado pela API siteverify do Google:


  1. Comportamento Fail-Open (Severidade Alta): Em caso de erro de rede na comunicação com a API do Google ou resposta JSON vazia/malformada, a rotina de autenticação não bloqueia a tentativa de login, permitindo o bypass completo da verificação do CAPTCHA.

 

  1. Ausência de Validação de Contexto / Hostname (Severidade Média): O código valida apenas a chave booleana success na resposta da API, omitindo a verificação do campo hostname e a comparação estrita de tipos (=== true), o que permite a reutilização de tokens gerados em domínios distintos que compartilhem a mesma site key.

 

3. Detalhamento Técnico dos Findings

Finding 1 (ALTA): Bypass de Proteção via Comportamento Fail-Open em Falhas de Rede ou Resposta Malformada

  • Arquivos e Linhas: models/bruteforce/Abstract.php (linhas 172 e 183–186) e models/bruteforce/GoogleV2.php (linhas 53–69).

 

  • Análise do Código: Na classe base Abstract.php, quando wp_remote_post() falha por erro de rede (is_wp_error), o método siteVerify() retorna uma string vazia '' e checkToken() retorna um array vazio array(). Na classe filha GoogleV2.php, o método call() processa a resposta da seguinte forma:

 

PHP

$response = json_decode( $this->siteVerify( $secret, $captcha ), true );

 

if ( isset( $response['success'] ) && ! $response['success'] ) {

    // Define $error_message apenas se 'success' existir e for falso

    ...

}

 

return $error_message; // Retorna false (sem erro) caso $response seja vazio ou null

  • Impacto: Se a requisição à API do Google sofrer timeout, bloqueio de rede ou retornar um erro HTTP com corpo não-JSON (fazendo json_decode retornar null), a condição isset( $response['success'] ) avalia como falsa. Consequentemente, $error_message permanece false e o método authenticate() aprova o fluxo de login sem qualquer validação do desafio.

 

Finding 2 (MÉDIA): Ausência de Validação de hostname e Tipagem Frouxa

  • Arquivo e Linhas: models/bruteforce/GoogleV2.php (linhas 53–55).

 

  • Análise do Código: A verificação da resposta positiva da API limita-se a checar a negação de $response['success'] sem exigir comparação estrita (=== true) e sem conferir se o token foi emitido para o domínio atual da instalação WordPress (hostname).

 

  • Impacto: Um atacante pode resolver o reCAPTCHA em um domínio externo ou ambiente secundário que utilize a mesma chave pública (site key) e injetar o token g-recaptcha-response válido na requisição de login da instalação alvo. O backend aceitará o token como legítimo por não vincular o hostname ao home_url() do site.

 

4. Verificação em Ambiente Controlado (Reprodução Local)

A análise estática foi confirmada em ambiente local isolado (Docker/Localhost):

  1. Cenário Fail-Open: Ao simular indisponibilidade na rota de saída para [www.google.com/recaptcha/api/siteverify](https://www.google.com/recaptcha/api/siteverify), a tentativa de autenticação prosseguiu sem exibir mensagem de erro de CAPTCHA.

 

  1. Cenário de Contexto: Ao submeter um token válido emitido em contexto externo no parâmetro g-recaptcha-response, o método call() retornou false (nenhum erro detectado), liberando o processamento da credencial.

 

5. Sugestão de Remediação (Patch Recomendado)

Para corrigir ambas as falhas de forma definitiva, recomenda-se alterar a lógica do método call() em models/bruteforce/GoogleV2.php para operar no modelo Fail-Closed e validar estritamente o hostname esperado:



PHP

if ( $secret <> '' ) {

    $raw_response = $this->siteVerify( $secret, $captcha );

    $response     = json_decode( $raw_response, true );

 

    // 1. Fail-Closed: Bloqueia imediatamente se a resposta for vazia, inválida ou sem 'success'

    if ( ! is_array( $response ) || ! isset( $response['success'] ) || $response['success'] !== true ) {

        if ( isset( $response['error-codes'] ) && is_array( $response['error-codes'] ) ) {

            foreach ( $response['error-codes'] as $error_code ) {

                if ( isset( $error_codes[ $error_code ] ) ) {

                    $error_message = $error_codes[ $error_code ];

                }

            }

        }

 

        if ( ! $error_message ) {

            $error_message = wp_kses_post( sprintf( __( '%1$sIncorrect ReCaptcha%2$s. Please try again.', 'hide-my-wp' ), '<strong>', '</strong>' ) );

        }

 

        return $error_message;

    }

 

    // 2. Validação estrita de contexto (hostname)

    $expected_host = parse_url( home_url(), PHP_URL_HOST );

    if ( ! isset( $response['hostname'] ) || $response['hostname'] !== $expected_host ) {

        return wp_kses_post( sprintf( __( '%1$sInvalid ReCaptcha hostname%2$s. Please try again.', 'hide-my-wp' ), '<strong>', '</strong>' ) );

    }

}


Chaves do tempo:  Fail-Open, reCAPTCHA, Auditoria e Hostname.


Comentários

Descobrir mais