Tutorial de Segurança Web: Mitigação Avançada de XSS e Injeção de SQL em Aplicações Modernas

\' . sanitizeHtml($userInput) . \'

2. Content Security Policy (CSP) Avançado

Implemente CSP com diretivas específicas para bloquear execução de scripts não autorizados:

Content-Security-Policy: default-src \'self\'; script-src \'self\' \'nonce-randomvalue123\'

3. Validação de Entrada com Whitelist

Implemente validação rigorosa baseada em listas de permissões para tipos de dados específicos:

// Validação de entrada avançada
class InputValidator {
    static validateEmail(email) {
        const pattern = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$/;
        return pattern.test(email) && email.length <= 254;
    }
    
    static sanitizeText(input, maxLength = 1000) {
        return input.replace(/[<>"\'&]/g, \'\')
                   .trim()
                   .substring(0, maxLength);
    }
    
    static validateNumeric(input, min = 0, max = Number.MAX_SAFE_INTEGER) {
        const num = parseInt(input, 10);
        return !isNaN(num) && num >= min && num <= max;
    }
}

Prevenção Robusta de Injeção de SQL

Injeção de SQL permite que atacantes executem comandos não autorizados em bancos de dados, comprometendo confidencialidade e integridade dos dados. Estatísticas mostram que 65% das violações de dados envolvem algum tipo de injeção SQL.

1. Prepared Statements com Tipagem Forte

Utilize consultas parametrizadas com validação de tipos para eliminar completamente o risco de injeção:

 PDO::ERRMODE_EXCEPTION,
            PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
            PDO::ATTR_EMULATE_PREPARES => false,
        ];
        $this->pdo = new PDO($dsn, $username, $password, $options);
    }
    
    public function getUserById($userId) {
        // Validação de tipo antes da consulta
        if (!is_int($userId) || $userId <= 0) {
            throw new InvalidArgumentException(\'ID de usuário inválido\');
        }
        
        $stmt = $this->pdo->prepare(\'SELECT * FROM users WHERE id = :id\');
        $stmt->bindParam(\':id\', $userId, PDO::PARAM_INT);
        $stmt->execute();
        
        return $stmt->fetch();
    }
    
    public function searchUsers($searchTerm) {
        // Sanitização e limitação de entrada
        $searchTerm = trim($searchTerm);
        if (strlen($searchTerm) > 50) {
            throw new InvalidArgumentException(\'Termo de busca muito longo\');
        }
        
        $stmt = $this->pdo->prepare(\'SELECT * FROM users WHERE name LIKE :search LIMIT 10\');
        $stmt->bindValue(\':search\', \'%\' . $searchTerm . \'%\', PDO::PARAM_STR);
        $stmt->execute();
        
        return $stmt->fetchAll();
    }
}
?>

2. Stored Procedures com Validação

Implemente stored procedures com validação integrada para adicionar uma camada extra de proteção:

-- Stored procedure segura para autenticação
CREATE PROCEDURE sp_AuthenticateUser(
    IN p_email VARCHAR(255),
    IN p_password_hash VARCHAR(255),
    OUT p_user_id INT,
    OUT p_result VARCHAR(50)
)
BEGIN
    DECLARE v_count INT DEFAULT 0;
    DECLARE v_stored_hash VARCHAR(255);
    
    -- Validação de entrada
    IF LENGTH(p_email) = 0 OR LENGTH(p_email) > 255 THEN
        SET p_result = \'EMAIL_INVALID\';
        LEAVE sp_label;
    END IF;
    
    -- Busca segura com limite
    SELECT COUNT(*), password_hash, user_id
    INTO v_count, v_stored_hash, p_user_id
    FROM users 
    WHERE email = p_email AND status = \'active\'
    LIMIT 1;
    
    -- Verificação de resultado
    IF v_count = 1 AND v_stored_hash = p_password_hash THEN
        SET p_result = \'SUCCESS\';
        UPDATE users SET last_login = NOW() WHERE user_id = p_user_id;
    ELSE
        SET p_result = \'INVALID_CREDENTIALS\';
        SET p_user_id = 0;
    END IF;
END

3. Monitoramento e Auditoria em Tempo Real

Implemente sistemas de detecção proativa para identificar tentativas de ataque:

 Sistema de monitoramento de consultas SQL
import re
import logging
from datetime import datetime

class SQLInjectionDetector:
    def __init__(self):
        self.suspicious_patterns = [
            r"(\'|(\\-\\-)|(;)|(\\|)|(\\*)|(%))",
            r"(union|select|insert|delete|update|drop|create|alter)\\s",
            r"(script|javascript|vbscript|onload|onerror)",
            r"(exec|execute|sp_|xp_)"
        ]
        
    def analyze_query(self, query, user_ip, user_id=None):
        risk_score = 0
        detected_patterns = []
        
        for pattern in self.suspicious_patterns:
            if re.search(pattern, query.lower()):
                risk_score += 25
                detected_patterns.append(pattern)
                
        if risk_score >= 50:
            self.log_suspicious_activity(query, user_ip, user_id, detected_patterns)
            return True
        return False
        
    def log_suspicious_activity(self, query, user_ip, user_id, patterns):
        log_entry = {
            \'timestamp\': datetime.now().isoformat(),
            \'user_ip\': user_ip,
            \'user_id\': user_id,
            \'query\': query[:200],  
 Limitar tamanho do log
            \'patterns_detected\': patterns,
            \'action\': \'BLOCKED\'
        }
        logging.warning(f"Tentativa de injeção SQL detectada: {log_entry}")

Implementação de Camadas de Segurança Adicionais

Além das técnicas específicas contra XSS e SQL injection, implemente medidas complementares para fortalecer a postura de segurança geral.

Web Application Firewall (WAF)

Configure um WAF com regras personalizadas para filtrar requisições maliciosas antes que atinjam a aplicação. Para implementações em servidores VPS, considere soluções como ModSecurity ou Cloudflare WAF.

Rate Limiting e Throttling

Implemente limitação de taxa para prevenir ataques automatizados:

// Rate limiting com Redis
const redis = require(\'redis\');
const client = redis.createClient();

async function rateLimiter(userId, maxRequests = 100, timeWindow = 3600) {
    const key = 
rate_limit:${userId}
;
    const current = await client.get(key);
    
    if (current === null) {
        await client.setex(key, timeWindow, 1);
        return { allowed: true, remaining: maxRequests - 1 };
    }
    
    const currentCount = parseInt(current);
    if (currentCount >= maxRequests) {
        return { allowed: false, remaining: 0 };
    }
    
    await client.incr(key);
    return { allowed: true, remaining: maxRequests - currentCount - 1 };
}

Testes de Segurança e Validação

Implemente testes automatizados para verificar a eficácia das medidas de segurança implementadas. Utilize ferramentas como OWASP ZAP, Burp Suite ou SQLMap para validação contínua.

Para aplicações críticas, considere implementar estratégias de SEO seguro que não comprometam as medidas de proteção implementadas.

A segurança web requer abordagem multicamada e manutenção contínua. As técnicas apresentadas formam uma base sólida para proteger aplicações modernas contra XSS e injeção de SQL. Mantenha-se atualizado com as últimas ameaças e adapte constantemente suas defesas para enfrentar novos vetores de ataque.