Common Cybersecurity Attacks: How to Protect Yourself

Learn about common cybersecurity attacks and how to protect yourself against them effectively.

1. SQL Injection Attacks

Description

SQL injection attacks exploit vulnerabilities in web applications that use SQL databases.

Attack Example

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

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

Protection

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. XSS (Cross-Site Scripting) Attacks

Description

XSS attacks inject malicious scripts into legitimate web pages.

Attack Example

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

Protection

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. Brute Force Attacks

Description

Brute force attacks attempt to guess passwords by trying every possible combination.

Attack Example

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)

Protection

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. DDoS Attacks

Description

DDoS (Distributed Denial of Service) attacks overwhelm a system with excessive traffic.

Attack Example

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

Protection

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. Phishing Attacks

Description

Phishing attacks attempt to obtain sensitive information by impersonating a legitimate entity.

Attack Example

<!-- 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>

Protection

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

Protection Best Practices

1. Regular updates

   • Keep systems up to date
   • Apply security patches
   • Update antivirus software

2. Strong authentication

   • Use complex passwords
   • Enable two-factor authentication
   • Limit login attempts

3. Data backups

   • Perform regular backups
   • Test restores
   • Store backups securely

4. Monitoring

   • Monitor logs
   • Detect anomalies
   • Respond quickly to incidents

Conclusion

Protecting against common attacks requires a multi-layered approach and constant vigilance.

Additional Resources

• OWASP Top 10
• NIST Cybersecurity Guide
• CERT-FR