AI Scraping e Shadow AI | Treinando seu concorrente?

Bot requests típico: 500-1000 req/min por bot
Custo de banda: $0.08 por GB transferido
CPU overhead: 15-25% adicional de processamento
Resultado: $2000-5000/mês extras em infra

# robots.txt tradicional - INEFICAZ
User-agent: GPTBot
Disallow: /

User-agent: ClaudeBot
Disallow: /

# Exemplo de bot evasivo
headers_pool = [
    {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"},
    {"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)"},
    {"User-Agent": "Mozilla/5.0 (X11; Linux x86_64)"}
]

# Rotação automática de identidade
def scrape_with_rotation(urls):
    for url in urls:
        headers = random.choice(headers_pool)
        proxy = get_residential_proxy()
        response = requests.get(url, headers=headers, proxies=proxy)

graph TD
    A[Funcionário] --> B[Copia dados sensíveis]
    B --> C[Cola no ChatGPT/Claude]
    C --> D[IA processa e memoriza]
    D --> E[Dados aparecem em respostas futuras]
    E --> F[Concorrentes acessam informação]

graph LR
    A[Bot Request] --> B[Azion Edge]
    B --> C[Behavioral Analysis]
    C --> D{Bot Score}
    D -->|High| E[Block/Challenge]
    D -->|Low| F[Forward to Origin]

    G[Origin Server] -.-> H[Zero bot traffic]
    H -.-> I[Reduced costs]

// Análise comportamental no Edge
export default async function botDetection(request) {
    const userAgent = request.headers.get('user-agent') || '';
    const clientIP = request.headers.get('cf-connecting-ip');
    const acceptLanguage = request.headers.get('accept-language');

    // Detectar bots conhecidos de IA
    const aiBotsPattern = /(GPTBot|ClaudeBot|CCBot|ChatGPT-User|Bard|Bing.*Bot)/i;

    if (aiBotsPattern.test(userAgent)) {
        return new Response('Access Denied - AI Scraping Not Allowed', {
            status: 403,
            headers: { 'content-type': 'text/plain' }
        });
    }

    // Continuar para origin se não for bot suspeito
    return fetch(request);
}

Firewall Tradicional:
IP 192.168.1.1 + Porta 80 = Permitir/Bloquear

AI Scraper Avançado:
IP rotativo + Headers humanos + Timing natural = Bypass total

# Configuração básica para bots éticos
User-agent: GPTBot
Disallow: api/
Disallow: admin/
Disallow: private/

User-agent: ClaudeBot
Disallow: /

# Honeypot para detectar violações
User-agent: *
Disallow: trap/

{
  "name": "Block AI Scrapers",
  "criteria": [
    [
      {
        "variable": "${http_user_agent}",
        "operator": "matches",
        "conditional": "if",
        "input_value": "(GPTBot|ClaudeBot|CCBot|ChatGPT-User|Bard|Bing.*Bot)"
      }
    ]
  ],
  "behaviors": [
    {
      "name": "deny",
      "target": {
        "status_code": 403,
        "content_type": "text/plain",
        "content_body": "Access Denied - AI Scraping Not Allowed"
      }
    }
  ]
}

graph TD
    A[Funcionário] --> B[Request IA]
    B --> C[Internal AI Gateway]
    C --> D{Data Classification}
    D -->|Public| E[Allow ChatGPT]
    D -->|Sensitive| F[Internal LLM]
    D -->|Confidential| G[Block + Alert]

// Internal AI gateway na Azion Edge Functions
export default async function aiGateway(request) {
    try {
        const body = await request.json();
        const { prompt, classification } = body;

        // Verificar dados sensíveis usando patterns
        const sensitivePatterns = [
            /\b\d{3}\.\d{3}\.\d{3}-\d{2}\b/, // CPF
            /\b\d{2}\.\d{3}\.\d{3}\/\d{4}-\d{2}\b/, // CNPJ
            /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/ // Email
        ];

        const hasSensitiveData = sensitivePatterns.some(pattern =>
            pattern.test(prompt)
        );

        if (hasSensitiveData) {
            return new Response(JSON.stringify({
                error: "Dados sensíveis detectados",
                suggestion: "Use modelo interno ou remova informações pessoais"
            }), {
                status: 403,
                headers: { 'content-type': 'application/json' }
            });
        }

        // Roteamento baseado na classificação
        if (classification === 'public') {
            // Permitir uso de IA externa
            return new Response(JSON.stringify({
                status: "allowed",
                message: "Request aprovado para IA externa"
            }), {
                headers: { 'content-type': 'application/json' }
            });
        } else {
            // Redirecionar para modelo interno
            return new Response(JSON.stringify({
                status: "redirect",
                message: "Use modelo interno da empresa"
            }), {
                headers: { 'content-type': 'application/json' }
            });
        }
    } catch (error) {
        return new Response('Invalid request', { status: 400 });
    }
}

// Bot Detection avançado na Azion Edge
export default async function advancedBotDetection(request) {
    const userAgent = request.headers.get('user-agent') || '';
    const clientIP = request.headers.get('cf-connecting-ip');
    const referer = request.headers.get('referer') || '';
    const acceptHeader = request.headers.get('accept') || '';

    // Score baseado em múltiplos fatores
    let suspicionScore = 0;

    // Verificar User-Agent suspeito
    const botPatterns = [
        new RegExp('GPTBot|ClaudeBot|CCBot|ChatGPT-User', 'i'),
        new RegExp('python-requests|curl|wget', 'i'),
        new RegExp('bot|crawler|spider|scraper', 'i')
    ];

    if (botPatterns.some(pattern => pattern.test(userAgent))) {
        suspicionScore += 0.4;
    }

    // Verificar ausência de headers comuns de browser
    if (!acceptHeader.includes('text/html')) {
        suspicionScore += 0.3;
    }

    // Verificar padrões de navegação
    if (!referer && request.method === 'GET') {
        suspicionScore += 0.2;
    }

    // Ação baseada no score
    if (suspicionScore >= 0.7) {
        // Log do evento suspeito
        console.log(JSON.stringify({
            timestamp: new Date().toISOString(),
            type: 'ai_scraper_blocked',
            ip: clientIP,
            userAgent: userAgent,
            score: suspicionScore,
            url: request.url
        }));

        return new Response('Access Denied - Automated Access Detected', {
            status: 403,
            headers: {
                'content-type': 'text/plain',
                'x-blocked-reason': 'ai-scraper-detection'
            }
        });
    }

    // Permitir request legítimo
    return fetch(request);
}

export default {
  build: {
    entry: 'functions/bot-detection.js',
    preset: {
      name: 'javascript'
    }
  },
  rules: {
    request: [
      {
        name: 'Bot Detection',
        match: '.*',
        behavior: {
          runFunction: {
            path: './functions/bot-detection.js'
          }
        }
      }
    ]
  }
};

{
  "security_metrics": {
    "ai_threats_blocked": 15420,
    "shadow_ai_prevented": 89,
    "cost_savings": "$8,450/month",
    "false_positive_rate": "0.02%"
  }
}