Anti-Web Scraping Ninja: Como Blindar Seu Site

TopCringeTech,

Anti-Web Scraping Ninja: Como Blindar Seu Site Contra os Robozões Ladrões de Dados!

Introdução: Quem Nunca Foi Roubado Que Atire a Primeira Linha de Código
O web scraping — aquela prática "inocente" de arrancar tudo do seu site igual mão boba em Black Friday — é o terror dos devs modernos.
Se não tomar cuidado, além de perder dados valiosos, você ainda entope o servidor e dá de bandeja a experiência do usuário real pra bots folgados.
Spoiler: vamos usar o caso real do meu chapa fsimobiliaria.com, onde o scraper tomou uma surra bonita e foi pra casa chorando.

Testado e aprovado com Manus.im e Perplexity.ai, porque a gente aqui é tech raiz, mas com pezinho no futuro.

Seguinte: se seu site já teve aquele tráfego esquisito às 3 da manhã, tipo ex stalkeando no Zap, pode apostar que era bot tentando surrupiar seus dados.

Hoje, meu chapa, vamos aprender a meter umas armadilhas ninjas no seu site, igual aqueles chefes de fase difícil que o pessoal rage quitava nos jogos antigos.

Origem:

Anti-Web Scraping Ninja: Como Blindar Seu Site

sim o resultado esta aqui...

Sério???

🕵️‍♂️ O Que É Web Scraping e Por Que Isso É Um Problemão?

vem, coleta informação e vaza — nem bate palma.
Mas na maioria das vezes é treta: cópia de conteúdo, sobrecarga de servidor, quebra de regras... só falta pedir CPF e senha.

Web scraping é tipo aquele vizinho fofoqueiro:

Às vezes é de boas (tipo o Google indexando sua página).

No site fsimobiliaria.com, o robozão teve que encarar:

Falha dramática ao tentar rolar a página 👎
Bloqueio cruel já na segunda navegação 👀
IP tomando chá de banco de dados (sim se voce acha que seu ip nao é registrado fica expert)🍵
Desafios JavaScript que nem os bots hardcore passaram 😵

Tudo isso não foi acidente, foi estratégia de defesa muito bem bolada, fi.

🛡️ Como Jogar Água no Chopp dos Scrapers: Técnicas de Defesa

1. Detectando Bots Com JavaScript: Rápido Demais, Mané!

Resumo da ópera: humanos erram, bots não.

Quer pegar bot? Monitora cliques rápidos demais. Se o cabra clicar 3x em 0,2 segundos... é bot, fi.

Primeirão Basic:

// Detecta mão boba (típicas de bots e abdução alienigina ha)

<script type='text/javascript'>

// Desabilitar o menu de contexto ao clicar com o botão direito do mouse
document.addEventListener('contextmenu', function(e) {
e.preventDefault();
alert("Evite copiar imagens. Entre em contato para obter permissão.");
});
</script>

Trechinho de Código:
(spoiler: seu site vai virar detector de Flash Reverso dos robôs)

javascript

// Detecta interações rápidas demais (típicas de bots)
const clicks = [];
const THRESHOLD_TIME = 150; // milissegundos
const MAX_CLICKS_TO_ANALYZE = 5;

document.addEventListener('click', function(event) {
    const timestamp = new Date().getTime();
    clicks.push(timestamp);
    
    if (clicks.length > MAX_CLICKS_TO_ANALYZE) {
        clicks.shift(); // Mantém apenas os últimos cliques
        
        // Analisa o tempo entre cliques
        let suspiciousClicks = 0;
        for (let i = 1; i < clicks.length; i++) {
            if (clicks[i] - clicks[i-1] < THRESHOLD_TIME) {
                suspiciousClicks++;
            }
        }
        
        if (suspiciousClicks >= 3) {
            // Comportamento suspeito detectado
            document.body.innerHTML = 'Comportamento suspeito detectado.';
            reportSuspiciousActivity();
        }
    }
});

function reportSuspiciousActivity() {
    // Lógica para registrar atividade suspeita
    fetch('/api/security/report', {
        method: 'POST',
        body: JSON.stringify({
            type: 'rapid-clicking',
            timestamp: new Date().toISOString()
        })
    });
}
Este código monitora a velocidade dos cliques e identifica padrões que seriam difíceis para humanos replicarem, como cliques muito rápidos em sequência.

2. Detectando Navegador Headless: Só Olho Vivo, Sem Corpo!

Bot safado ama navegador "fantasma" (headless). A gente detecta e mete o pé na porta!

Trechinho de Código:



<script type="text/javascript" src="./headlessDetect.js"></script>
<script>
    document.addEventListener('DOMContentLoaded', function() {        var headlessDetector = new HeadlessDetect();                if(headlessDetector.getHeadlessScore() > 0.25) {            // Navegador headless detectado            console.log("Navegador headless detectado");                        // Implementa medidas anti-scraping            disruptScrapingAttempt();        }    });        function disruptScrapingAttempt() {        // Modifica o DOM de maneira que afeta apenas scrapers        // Apresenta conteúdo falso ou mensagem de erro        setTimeout(() => {            document.querySelectorAll('.property-card').forEach(card => {                // Substitui informações reais por falsas para scrapers                const originalHTML = card.innerHTML;                card.setAttribute('data-original', btoa(originalHTML));                card.innerHTML = "<p>Conteúdo indisponível temporariamente</p>";            });        }, 100);    }</script>

3. Rolagem de Página: Bot, Vai Rolar Não!

Bot adora descer a página igual adolescente em rede social.

A gente deixa armadilha pra prender o safado num loop infinito de conteúdo falso. 🎣

Trechinho de Código:


// Código armando cilada para scraper mané

javascript
// Monitora comportamento de rolagem
let scrollEvents = 0;
let lastScrollTime = 0;
let isBlockingScroll = false;

window.addEventListener("scroll", function() {
    const currentTime = new Date().getTime();
    scrollEvents++;
    
    // Verifica se chegou ao fim da página
    if (window.innerHeight + window.scrollY >= document.body.offsetHeight) {
        // Detecta rolagem até o fim
        console.log("scrolled to bottom");
        
        // Verifica se foi rápido demais (comportamento de bot)
        if (scrollEvents > 10 && (currentTime - lastScrollTime) < 3000) {
            isBlockingScroll = true;
            implementScrollDefense();
        }
    }
    
    // Verifica padrões suspeitos de rolagem
    if (lastScrollTime > 0 && (currentTime - lastScrollTime) < 50) {
        // Rolagem mais rápida que um humano normal
        scrollSuspicionCounter++;
        if (scrollSuspicionCounter > 5) {
            isBlockingScroll = true;
            implementScrollDefense();
        }
    }
    
    lastScrollTime = currentTime;
});

function implementScrollDefense() {
    // Implementa mecanismos anti-scraping
    if (isBlockingScroll) {
        // Adiciona conteúdo infinito falso para prender o scraper
        setInterval(() => {
            const fakeContent = document.createElement('div');
            fakeContent.className = 'fake-content';
            fakeContent.innerHTML = `<div class="property-item">
                <h3>Propriedade ${Math.floor(Math.random() * 1000)}</h3>
                <p>Conteúdo gerado dinamicamente...</p>
            </div>`;
            document.body.appendChild(fakeContent);
        }, 500);
        
        // Altera o comportamento de rolagem
        window.scrollTo = function() { return false; };
    }
}

4. Honeypot: Docinho de Bot (Só Que Não)

Campo escondido no formulário.
Humano de verdade não vê, bot burro preenche, a gente detecta, ri da cara dele e bloqueia.

Trechinho de Código:

<!-- Honeypot ativado! -->

<form action="/submit" method="post" id="contact-form">
    <div class="form-group">
        <label for="nome">Nome</label>
        <input type="text" id="nome" name="nome" required>
    </div>
    
    <!-- Honeypot: invisível para humanos, atraente para bots -->
    <div class="business">
        <label for="work-email" aria-hidden="true">E-mail de Trabalho</label>
        <input type="email" id="work-email" name="work-email" tabindex="-1">
    </div>
    
    <div class="form-group">
        <label for="email">E-mail</label>
        <input type="email" id="email" name="email" required>
    </div>
    
    <div class="form-group">
        <label for="mensagem">Mensagem</label>
        <textarea id="mensagem" name="mensagem" required></textarea>
    </div>
    
    <button type="submit" id="submit">Enviar</button>
</form>

<style>
.business {
    position: absolute;
    left: 0%;
    top: 0%;
    right: auto;
    bottom: auto;
    z-index: -1;
    overflow: hidden;
    width: 0px;
    height: 0px;
    opacity: 0;
    display: none;
}
</style>

<script>
const submit = document.querySelector("#submit");
const honeypot = document.querySelector("#work-email");

honeypot.oninput = function() {
    if (honeypot.value.length > 0) {
        // Bot detectado - desabilita o botão de envio
        submit.disabled = true;
        
        // Registra a tentativa de bot
        fetch('/api/security/report-bot', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify({
                type: 'honeypot-triggered',
                timestamp: new Date().toISOString()
            })
        });
    }
};
</script>

Quer mais dicas de tecnologia com aquele toque de nostalgia, piadas ruins e sabedoria do interior?
Segue a gente porque aqui a gente ri da tecnologia antes que ela ria da gente! 🤠
sim aqui tem um codigo aqui nao ta vendo???

5. Exemplo de Código: Ofuscação de Conteúdo Crítico


javascript

// ativar poeira nos bots!
(function() {
    // Ofuscação com Base64
    const encodedContent = "SGlkZGVuIGNvbnRlbnQgdGhhdCBzaG91bGQgbm90IGJlIHNjcmFwZWQ=";
    
    // Função para decodificar apenas para usuários legítimos
    function showRealContent() {
        if (isLegitimateUser()) {
            const realContent = atob(encodedContent);
            document.getElementById('protected-content').innerHTML = realContent;
        }
    }
    
    // Função para verificar legitimidade do usuário
    function isLegitimateUser() {
        // Implementa várias verificações
        let legitimacyScore = 0;
        
        // Verifica interações prévias na página
        if (window.userInteractions && window.userInteractions > 3) {
            legitimacyScore += 2;
        }
        
        // Verifica tempo na página
        if (window.pageLoadTime && ((new Date().getTime() - window.pageLoadTime) > 15000)) {
            legitimacyScore += 2;
        }
        
        // Verifica comportamento de mouse
        if (window.mouseMovements && window.mouseMovements > 10) {
            legitimacyScore += 1;
        }
        
        return legitimacyScore >= 3;
    }
    
    // Inicia monitoramento de interações
    window.userInteractions = 0;
    window.pageLoadTime = new Date().getTime();
    window.mouseMovements = 0;
    
    document.addEventListener('click', function() { window.userInteractions++; });
    document.addEventListener('mousemove', function() { window.mouseMovements++; });
    
    // Revela conteúdo após verificações
    setTimeout(showRealContent, 1000);

🎯 Conclusão: Ou Você Defende Seu Site, Ou Vira Piquenique de Bot

Hoje em dia, deixar seu site sem proteção é tipo jogar PS5 no meio da praça e esperar ninguém levar.
Implementa essas técnicas, revisa seus logs e mantém o site filé, porque scraper bom é scraper chorando no suporte técnico.

Ah, e lembra: proteger site também é proteger o meio ambiente, viu? Cada servidor que você salva de sobrecarga, é menos energia jogada fora. 🌎✨

🧠 Bônus TopCringeTech

Quer mais dicas de tecnologia com aquele toque de nostalgia, piadas ruins e sabedoria do interior?
Segue a gente porque aqui a gente ri da tecnologia antes que ela ria da gente! 🤠
sim aqui tem um codigo aqui nao ta vendo???

Esta implementação de honeypot, baseada no exemplo dos resultados de pesquisa 5, cria um campo invisível para usuários humanos. Se um bot preencher este campo, ele é identificado como não-humano e o envio do formulário é bloqueado.

Implementando Bloqueios de IP e Rate Limiting

O relatório menciona possíveis bloqueios por IP e rate limiting como barreiras efetivas contra scrapers.

Exemplo de Código: Implementação de Verificações no Front-end


javascript
// Sistema de verificação de acesso
document.addEventListener('DOMContentLoaded', function() {
    // Faz verificação inicial do acesso
    fetch('/api/access/verify', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        credentials: 'include' // Importante para autenticação
    })
    .then(response => response.json())
    .then(data => {
        if (data.status === 'blocked' || data.rateLimit === 'exceeded') {
            // Implementa medidas contra acesso bloqueado
            document.body.innerHTML = '<h1>Acesso temporariamente indisponível</h1>';
            return;
        }
        
        // Inicia monitoramento contínuo
        initAccessMonitoring();
    })
    .catch(error => {
        console.error('Erro na verificação de acesso:', error);
    });
    
    function initAccessMonitoring() {
        // Monitora padrões de requisição
        let requestCount = 0;
        const originalFetch = window.fetch;
        
        // Sobrescreve o método fetch
        window.fetch = function() {
            requestCount++;
            
            // Verifica se há muitas requisições em sequência
            if (requestCount > 15 && (requestCount / ((new Date().getTime() - window.pageLoadTime) / 1000)) > 2) {
                // Taxa de requisição suspeita (mais de 2 por segundo)
                reportSuspiciousActivity('excessive-requests');
            }
            
            return originalFetch.apply(this, arguments);
        };
    }
});

function reportSuspiciousActivity(type) {
    // Implementa relatório de atividade suspeita
    const reportData = {
        type: type,
        timestamp: new Date().toISOString(),
        userAgent: navigator.userAgent,
        page: window.location.href
    };
    
    // Envia relatório para o backend
    navigator.sendBeacon('/api/security/report-activity', JSON.stringify(reportData));
}

Esta implementação monitora padrões de requisição e comportamentos suspeitos, enviando relatórios para o backend que pode implementar bloqueios de IP ou rate limiting1.

Desafios de JavaScript e CAPTCHAs

Implementar desafios baseados em JavaScript e CAPTCHAs é uma estratégia eficaz mencionada no relatório.

Exemplo de Código: Desafio JavaScript Personalizado


javascript
// Implementa desafio JavaScript
function implementJavaScriptChallenge() {
    // Gera valores aleatórios para o desafio
    const a = Math.floor(Math.random() * 10) + 1;
    const b = Math.floor(Math.random() * 10) + 1;
    const operation = Math.random() > 0.5 ? 'soma' : 'multiplicação';
    
    // Cria desafio dinâmico
    const expectedResult = operation === 'soma' ? a + b : a * b;
    
    // Cria overlay na página
    const overlay = document.createElement('div');
    overlay.style.position = 'fixed';
    overlay.style.top = '0';
    overlay.style.left = '0';
    overlay.style.width = '100%';
    overlay.style.height = '100%';
    overlay.style.backgroundColor = 'rgba(0,0,0,0.8)';
    overlay.style.zIndex = '9999';
    overlay.style.display = 'flex';
    overlay.style.justifyContent = 'center';
    overlay.style.alignItems = 'center';
    
    // Cria conteúdo do desafio
    overlay.innerHTML = `
        <div style="background: white; padding: 20px; border-radius: 5px; max-width: 400px;">
            <h2>Verificação de Segurança</h2>
            <p>Para continuar navegando, por favor resolva o seguinte desafio:</p>
            <p>Qual é o resultado da ${operation} de ${a} e ${b}?</p>
            <input type="number" id="challenge-answer" placeholder="Digite sua resposta">
            <button id="challenge-submit">Verificar</button>
        </div>
    `;
    
    document.body.appendChild(overlay);
    
    // Monitora resposta
    document.getElementById('challenge-submit').addEventListener('click', function() {
        const userAnswer = parseInt(document.getElementById('challenge-answer').value);
        
        if (userAnswer === expectedResult) {
            // Resposta correta
            overlay.remove();
            // Armazena sucesso do desafio
            localStorage.setItem('challenge_passed', new Date().getTime());
        } else {
            // Resposta incorreta
            document.querySelector('#challenge-submit').insertAdjacentHTML('afterend', 
                '<p style="color: red;">Resposta incorreta. Tente novamente.</p>');
            
            // Incrementa contador de falhas
            const failCount = parseInt(localStorage.getItem('challenge_fails') || '0') + 1;
            localStorage.setItem('challenge_fails', failCount);
            
            // Se falhar muitas vezes, implementa bloqueio temporário
            if (failCount >= 3) {
                overlay.innerHTML = `
                    <div style="background: white; padding: 20px; border-radius: 5px;">
                        <h2>Acesso Temporariamente Bloqueado</h2>
                        <p>Muitas tentativas incorretas foram detectadas.</p>
                        <p>Por favor, tente novamente em 5 minutos.</p>
                    </div>
                `;
                
                // Reporta atividade suspeita
                reportSuspiciousActivity('challenge-failed-multiple');
            }
        }
    });
}

// Verifica se precisa implementar o desafio
if (!localStorage.getItem('challenge_passed') || 
    (new Date().getTime() - parseInt(localStorage.getItem('challenge_passed'))) > 3600000) {
    // Implementa desafio se nunca passou ou se passou há mais de 1 hora
    implementJavaScriptChallenge();
}

Este código implementa um desafio matemático simples que bots teriam dificuldade em resolver automaticamente, especialmente quando combinado com alterações dinâmicas e aleatórias13.

Conclusão: Estratégia de Defesa em Profundidade

As técnicas apresentadas neste artigo demonstram como o site fsimobiliaria.com conseguiu frustrar tentativas de web scraping através de múltiplas camadas de proteção. Para uma defesa eficaz, recomenda-se implementar várias dessas técnicas simultaneamente, criando uma "defesa em profundidade".

As implementações descritas são particularmente eficazes porque não dependem de uma única barreira, mas sim de uma combinação de:

Detecção de comportamentos não-humanos
Identificação de navegadores headless
Interferência em padrões de rolagem
Técnicas de honeypot
Ofuscação de código JavaScript
Bloqueios de IP e rate limiting
Desafios de JavaScript

Para sites que precisam proteger seu conteúdo contra scraping, a implementação dessas técnicas pode significar a diferença entre ter seu conteúdo extraído facilmente ou manter o controle sobre como suas informações são acessadas e utilizadas.

É importante ressaltar que estas técnicas devem ser implementadas com cuidado para não afetar a experiência de usuários legítimos, encontrando o equilíbrio entre segurança e usabilidade. O objetivo final é proteger seu conteúdo sem prejudicar a navegação de visitantes reais.

Agora se o seu intuito é que uma pagina seja encontrada pelo Perplexity.ai por que você quer relevância, combinamos para outra hora, tem uns bizu que nem com carteirinha da area 51 voce tera acesso.

Citações em:

Marcadores

A.I.Cracia: Como a Inteligência Artificial Vai Substituir

Segurança Digital em 2024: Como Não Cair em Golpes de 'Príncipes Nigerianos'