Ataques Comuns em Cibersegurança: Como Se Proteger

Conheça os ataques comuns em cibersegurança e aprenda a se proteger deles de forma eficaz.

1. Ataques de Injeção SQL

Descrição

Os ataques de injeção SQL exploram vulnerabilidades em aplicações web que utilizam bancos de dados SQL.

Exemplo de Ataque

-- Requête vulnérable
SELECT * FROM users WHERE username = '$username' AND password = '$password'

-- Attaque par injection
' OR '1'='1

Proteção

class SQLInjectionProtection:
    def __init__(self):
        self.patterns = [
            r"'.*'",
            r"--",
            r";.*",
            r"UNION.*SELECT"
        ]
    
    def sanitize_input(self, input_str: str) -> str:
        # Nettoyage des entrées
        for pattern in self.patterns:
            input_str = re.sub(pattern, '', input_str)
        return input_str
    
    def use_parameterized_queries(self, query: str, params: tuple) -> str:
        # Utilisation de requêtes paramétrées
        return cursor.execute(query, params)

2. Ataques XSS (Cross-Site Scripting)

Descrição

Os ataques XSS injetam scripts maliciosos em páginas web legítimas.

Exemplo de Ataque

<script>alert('XSS Attack')</script>

Proteção

class XSSProtection:
    def __init__(self):
        self.escape_chars = {
            '<': '&lt;',
            '>': '&gt;',
            '&': '&amp;',
            '"': '&quot;',
            "'": '&#x27;'
        }
    
    def escape_html(self, input_str: str) -> str:
        # Échappement des caractères HTML
        for char, entity in self.escape_chars.items():
            input_str = input_str.replace(char, entity)
        return input_str
    
    def validate_input(self, input_str: str) -> bool:
        # Validation des entrées
        return not any(char in input_str for char in ['<', '>', 'script'])

3. Ataques de Força Bruta

Descrição

Os ataques de força bruta tentam adivinhar senhas testando todas as combinações possíveis.

Exemplo de Ataque

def brute_force_attack(password_length: int):
    chars = string.ascii_letters + string.digits
    for length in range(1, password_length + 1):
        for guess in itertools.product(chars, repeat=length):
            yield ''.join(guess)

Proteção

class BruteForceProtection:
    def __init__(self):
        self.max_attempts = 5
        self.lockout_time = 30  # minutes
    
    def check_attempts(self, username: str) -> bool:
        # Vérification des tentatives
        attempts = self.get_attempts(username)
        if attempts >= self.max_attempts:
            return False
        return True
    
    def implement_delay(self, username: str):
        # Mise en place d'un délai
        attempts = self.get_attempts(username)
        delay = min(2 ** attempts, 60)  # Délai exponentiel
        time.sleep(delay)

4. Ataques DDoS

Descrição

Os ataques DDoS (Distributed Denial of Service) sobrecarregam um sistema com tráfego excessivo.

Exemplo de Ataque

def ddos_attack(target: str, duration: int):
    while time.time() < duration:
        requests.get(target)

Proteção

class DDoSProtection:
    def __init__(self):
        self.rate_limit = 100  # requêtes par minute
        self.ip_blacklist = set()
    
    def check_rate_limit(self, ip: str) -> bool:
        # Vérification de la limite de taux
        current_rate = self.get_request_rate(ip)
        return current_rate <= self.rate_limit
    
    def implement_rate_limiting(self, ip: str):
        # Mise en place de la limitation de taux
        if not self.check_rate_limit(ip):
            self.ip_blacklist.add(ip)
            return False
        return True

5. Ataques de Phishing

Descrição

Os ataques de phishing tentam obter informações sensíveis se passando por uma entidade legítima.

Exemplo de Ataque

<!-- Email de phishing -->
<div style="color: #000000;">
    <p>Cher utilisateur,</p>
    <p>Veuillez mettre à jour vos informations bancaires en cliquant sur le lien ci-dessous.</p>
    <a href="http://malicious-site.com">Mettre à jour</a>
</div>

Proteção

class PhishingProtection:
    def __init__(self):
        self.suspicious_patterns = [
            r"urgent",
            r"update.*account",
            r"verify.*identity"
        ]
    
    def check_email_content(self, content: str) -> bool:
        # Vérification du contenu de l'email
        for pattern in self.suspicious_patterns:
            if re.search(pattern, content.lower()):
                return False
        return True
    
    def verify_sender(self, email: str) -> bool:
        # Vérification de l'expéditeur
        domain = email.split('@')[1]
        return domain in self.trusted_domains

Boas Práticas de Proteção

1. Atualização regular

   • Manter os sistemas atualizados
   • Aplicar as correções de segurança
   • Atualizar os antivírus

2. Autenticação forte

   • Usar senhas complexas
   • Ativar a autenticação de dois fatores
   • Limitar as tentativas de login

3. Backup dos dados

   • Fazer backups regulares
   • Testar as restaurações
   • Armazenar os backups de forma segura

4. Monitoramento

   • Acompanhar os logs
   • Detectar anomalias
   • Reagir rapidamente aos incidentes

Conclusão

A proteção contra os ataques comuns exige uma abordagem em múltiplas camadas e vigilância constante.

Recursos Complementares

• OWASP Top 10
• Guia de Segurança do NIST
• CERT-FR