Scraping de IA y Shadow AI | ¿Entrenas a tu rival?

Solicitudes típicas de bots: 500-1000 req/min por bot
Costo de ancho de banda: $0.08 por GB transferido
Overhead de CPU: 15-25% procesamiento extra
Resultado: $2000-5000/mes extra en infraestructura

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

# Ejemplo 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)"}
]

# Rotación automática de identidad
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[Empleado] --> B[Copia datos sensibles]
    B --> C[Pega en ChatGPT/Claude]
    C --> D[IA procesa y memoriza]
    D --> E[Datos aparecen en respuestas futuras]
    E --> F[Competidores acceden información]

graph LR
    A[Solicitud de bot] --> B[Azion Edge]
    B --> C[Análisis conductual]
    C --> D{Puntaje de bot}
    D -->|Alto| E[Bloquear/Desafiar]
    D -->|Bajo| F[Reenviar a origen]
    G[Servidor origen] -.-> H[Cero tráfico de bots]
    H -.-> I[Costos reducidos]

// Análisis conductual en el 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 de IA conocidos
    const aiBotsPattern = /(GPTBot|ClaudeBot|CCBot|ChatGPT-User|Bard|Bing.*Bot)/i;

    if (aiBotsPattern.test(userAgent)) {
        return new Response('Acceso denegado - Scraping de IA no permitido', {
            status: 403,
            headers: { 'content-type': 'text/plain' }
        });
    }

    // Continuar al origen si no es bot sospechoso
    return fetch(request);
}

Firewall tradicional:
IP 192.168.1.1 + Puerto 80 = Permitir/Bloquear

Scraper de IA avanzado:
IP rotativo + Headers humanos + Timing natural = Bypass total

# Configuración básica para bots éticos
User-agent: GPTBot
Disallow: api/
Disallow: admin/
Disallow: private/

User-agent: ClaudeBot
Disallow: /

# Honeypot para detectar violaciones
User-agent: *
Disallow: trap/

{
  "name": "Bloquear scrapers de IA",
  "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": "Acceso denegado - Scraping de IA no permitido"
      }
    }
  ]
}

graph TD
    A[Empleado] --> B[Solicita IA]
    B --> C[Gateway interno de IA]
    C --> D{Clasificación de datos}
    D -->|Público| E[Permitir ChatGPT]
    D -->|Sensible| F[LLM interno]
    D -->|Confidencial| G[Bloquear + Alertar]

// Gateway interno de IA en Azion Edge Functions
export default async function aiGateway(request) {
    try {
        const body = await request.json();
        const { prompt, classification
        ```javascript
// Gateway interno de IA en Azion Edge Functions
export default async function aiGateway(request) {
    try {
        const body = await request.json();
        const { prompt, classification } = body;

        // Verificar datos sensibles usando patrones
        const sensitivePatterns = [
            /\b\d{3}-\d{2}-\d{4}\b/, // SSN
            /\b\d{2}-\d{7}\b/, // Tax ID
            /\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: "Datos sensibles detectados",
                suggestion: "Usa modelo interno o remueve información personal"
            }), {
                status: 403,
                headers: { 'content-type': 'application/json' }
            });
        }

        // Enrutamiento basado en clasificación
        if (classification === 'public') {
            // Permitir uso de IA externa
            return new Response(JSON.stringify({
                status: "permitido",
                message: "Solicitud aprobada para IA externa"
            }), {
                headers: { 'content-type': 'application/json' }
            });
        } else {
            // Redirigir a modelo interno
            return new Response(JSON.stringify({
                status: "redirect",
                message: "Usa el modelo interno de la empresa"
            }), {
                headers: { 'content-type': 'application/json' }
            });
        }
    } catch (error) {
        return new Response('Solicitud inválida', { status: 400 });
    }
}

// Detección avanzada de bots en 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') || '';

    // Puntaje basado en múltiples factores
    let suspicionScore = 0;

    // Verificar User-Agent sospechoso
    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 ausencia de headers comunes de navegador
    if (!acceptHeader.includes('text/html')) {
        suspicionScore += 0.3;
    }

    // Verificar patrones de navegación
    if (!referer && request.method === 'GET') {
        suspicionScore += 0.2;
    }

    // Acción basada en puntaje
    if (suspicionScore >= 0.7) {
        // Registrar evento sospechoso
        console.log(JSON.stringify({
            timestamp: new Date().toISOString(),
            type: 'ai_scraper_blocked',
            ip: clientIP,
            userAgent: userAgent,
            score: suspicionScore,
            url: request.url
        }));

        return new Response('Acceso denegado - Acceso automatizado detectado', {
            status: 403,
            headers: {
                'content-type': 'text/plain',
                'x-blocked-reason': 'ai-scraper-detection'
            }
        });
    }

    // Permitir solicitud legítima
    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/mes",
    "false_positive_rate": "0.02%"
  }
}